Class yii\elasticsearch\Connection

                public function __sleep()
{
    $this->close();
    return array_keys(get_object_vars($this));
}

            

                public function close()
{
    if ($this->activeNode === null) {
        return;
    }
    Yii::trace('Closing connection to Elasticsearch. Active node was: '
        . $this->nodes[$this->activeNode]['http']['publish_address'], __CLASS__);
    $this->activeNode = null;
    if ($this->_curl) {
        curl_close($this->_curl);
        $this->_curl = null;
    }
}

            

                public function createBulkCommand($config = [])
{
    $this->open();
    $config['db'] = $this;
    $command = new BulkCommand($config);
    return $command;
}

            

                public function createCommand($config = [])
{
    $this->open();
    $config['db'] = $this;
    $command = new Command($config);
    return $command;
}

            

                protected function decodeErrorBody($body)
{
    try {
        $decoded = Json::decode($body);
        if (isset($decoded['error']) && !is_array($decoded['error'])) {
            $decoded['error'] = preg_replace('/\b\w+?Exception\[/', "<span style=\"color: red;\">\\0</span>\n               ", $decoded['error']);
        }
        return $decoded;
    } catch(InvalidArgumentException $e) {
        return $body;
    }
}

            

                public function delete($url, $options = [], $body = null, $raw = false)
{
    $this->open();
    return $this->httpRequest('DELETE', $this->createUrl($url, $options), $body, $raw);
}

            

                public function get($url, $options = [], $body = null, $raw = false)
{
    $this->open();
    return $this->httpRequest('GET', $this->createUrl($url, $options), $body, $raw);
}

            

                public function getClusterState()
{
    return $this->get(['_cluster', 'state']);
}

            

                public function getDriverName()
{
    return 'elasticsearch';
}

            

                public function getIsActive()
{
    return $this->activeNode !== null;
}

            

                public function getNodeInfo()
{
    return $this->get([]);
}

            

                public function getQueryBuilder()
{
    return new QueryBuilder($this);
}

            

                public function head($url, $options = [], $body = null)
{
    $this->open();
    return $this->httpRequest('HEAD', $this->createUrl($url, $options), $body);
}

            

                protected function httpRequest($method, $url, $requestBody = null, $raw = false)
{
    $method = strtoupper($method);
    // response body and headers
    $headers = [];
    $headersFinished = false;
    $body = '';
    $options = [
        CURLOPT_USERAGENT      => 'Yii Framework ' . Yii::getVersion() . ' ' . __CLASS__,
        CURLOPT_RETURNTRANSFER => false,
        CURLOPT_HEADER         => false,
        // http://www.php.net/manual/en/function.curl-setopt.php#82418
        CURLOPT_HTTPHEADER     => [
            'Expect:',
            'Content-Type: application/json',
        ],
        CURLOPT_WRITEFUNCTION  => function ($curl, $data) use (&$body) {
            $body .= $data;
            return mb_strlen($data, '8bit');
        },
        CURLOPT_HEADERFUNCTION => function ($curl, $data) use (&$headers, &$headersFinished) {
            if ($data === '') {
                $headersFinished = true;
            } elseif ($headersFinished) {
                $headersFinished = false;
            }
            if (!$headersFinished && ($pos = strpos($data, ':')) !== false) {
                $headers[strtolower(substr($data, 0, $pos))] = trim(substr($data, $pos + 1));
            }
            return mb_strlen($data, '8bit');
        },
        CURLOPT_CUSTOMREQUEST  => $method,
        CURLOPT_FORBID_REUSE   => false,
    ];
    foreach ($this->curlOptions as $key => $value) {
        $options[$key] = $value;
    }
    if (!empty($this->auth) || isset($this->nodes[$this->activeNode]['auth']) && $this->nodes[$this->activeNode]['auth'] !== false) {
        $auth = isset($this->nodes[$this->activeNode]['auth']) ? $this->nodes[$this->activeNode]['auth'] : $this->auth;
        if (empty($auth['username'])) {
            throw new InvalidConfigException('Username is required to use authentication');
        }
        if (empty($auth['password'])) {
            throw new InvalidConfigException('Password is required to use authentication');
        }
        $options[CURLOPT_HTTPAUTH] = CURLAUTH_BASIC;
        $options[CURLOPT_USERPWD] = $auth['username'] . ':' . $auth['password'];
    }
    if ($this->connectionTimeout !== null) {
        $options[CURLOPT_CONNECTTIMEOUT] = $this->connectionTimeout;
    }
    if ($this->dataTimeout !== null) {
        $options[CURLOPT_TIMEOUT] = $this->dataTimeout;
    }
    if ($requestBody !== null) {
        $options[CURLOPT_POSTFIELDS] = $requestBody;
    }
    if ($method == 'HEAD') {
        $options[CURLOPT_NOBODY] = true;
        unset($options[CURLOPT_WRITEFUNCTION]);
    } else {
        $options[CURLOPT_NOBODY] = false;
    }
    if (is_array($url)) {
        list($protocol, $host, $q) = $url;
        if (strncmp($host, 'inet[', 5) == 0) {
            $host = substr($host, 5, -1);
            if (($pos = strpos($host, '/')) !== false) {
                $host = substr($host, $pos + 1);
            }
        }
        $profile = "$method $q#$requestBody";
        $url = "$protocol://$host/$q";
    } else {
        $profile = false;
    }
    Yii::trace("Sending request to Elasticsearch node: $method $url\n$requestBody", __METHOD__);
    if ($profile !== false) {
        Yii::beginProfile($profile, __METHOD__);
    }
    $this->resetCurlHandle();
    curl_setopt($this->_curl, CURLOPT_URL, $url);
    curl_setopt_array($this->_curl, $options);
    if (curl_exec($this->_curl) === false) {
        throw new Exception('Elasticsearch request failed: ' . curl_errno($this->_curl) . ' - ' . curl_error($this->_curl), [
            'requestMethod' => $method,
            'requestUrl' => $url,
            'requestBody' => $requestBody,
            'responseHeaders' => $headers,
            'responseBody' => $this->decodeErrorBody($body),
        ]);
    }
    $responseCode = curl_getinfo($this->_curl, CURLINFO_HTTP_CODE);
    if ($profile !== false) {
        Yii::endProfile($profile, __METHOD__);
    }
    if ($responseCode >= 200 && $responseCode < 300) {
        if ($method === 'HEAD') {
            return true;
        } else {
            if (isset($headers['content-length']) && ($len = mb_strlen($body, '8bit')) < $headers['content-length']) {
                throw new Exception("Incomplete data received from Elasticsearch: $len < {$headers['content-length']}", [
                    'requestMethod' => $method,
                    'requestUrl' => $url,
                    'requestBody' => $requestBody,
                    'responseCode' => $responseCode,
                    'responseHeaders' => $headers,
                    'responseBody' => $body,
                ]);
            }
            if (isset($headers['content-type'])) {
                if (!strncmp($headers['content-type'], 'application/json', 16)) {
                    return $raw ? $body : Json::decode($body);
                }
                if (!strncmp($headers['content-type'], 'text/plain', 10)) {
                    return $raw ? $body : array_filter(explode("\n", $body));
                }
            }
            throw new Exception('Unsupported data received from Elasticsearch: ' . $headers['content-type'], [
                'requestMethod' => $method,
                'requestUrl' => $url,
                'requestBody' => $requestBody,
                'responseCode' => $responseCode,
                'responseHeaders' => $headers,
                'responseBody' => $this->decodeErrorBody($body),
            ]);
        }
    } elseif ($responseCode == 404) {
        return false;
    } else {
        throw new Exception("Elasticsearch request failed with code $responseCode. Response body:\n{$body}", [
            'requestMethod' => $method,
            'requestUrl' => $url,
            'requestBody' => $requestBody,
            'responseCode' => $responseCode,
            'responseHeaders' => $headers,
            'responseBody' => $this->decodeErrorBody($body),
        ]);
    }
}

            

                public function init()
{
    foreach ($this->nodes as &$node) {
        if (!isset($node['http_address'])) {
            throw new InvalidConfigException('Elasticsearch node needs at least a http_address configured.');
        }
        if (!isset($node['protocol'])) {
            $node['protocol'] = $this->defaultProtocol;
        }
        if (!in_array($node['protocol'], ['http', 'https'])) {
            throw new InvalidConfigException('Valid node protocol settings are "http" and "https".');
        }
    }
}

            

                protected function initConnection()
{
    $this->trigger(self::EVENT_AFTER_OPEN);
}

            

                public function open()
{
    if ($this->activeNode !== null) {
        return;
    }
    if (empty($this->nodes)) {
        throw new InvalidConfigException('Elasticsearch needs at least one node to operate.');
    }
    $this->_curl = curl_init();
    if ($this->autodetectCluster) {
        $this->populateNodes();
    }
    $this->selectActiveNode();
    Yii::trace('Opening connection to Elasticsearch. Nodes in cluster: ' . count($this->nodes)
        . ', active node: ' . $this->nodes[$this->activeNode]['http_address'], __CLASS__);
    $this->initConnection();
}

            

                protected function populateNodes()
{
    $node = reset($this->nodes);
    $host = $node['http_address'];
    $protocol = isset($node['protocol']) ? $node['protocol'] : $this->defaultProtocol;
    if (strncmp($host, 'inet[/', 6) === 0) {
        $host = substr($host, 6, -1);
    }
    $response = $this->httpRequest('GET', "$protocol://$host/_nodes/_all/http");
    if (!empty($response['nodes'])) {
        $nodes = $response['nodes'];
    } else {
        $nodes = [];
    }
    foreach ($nodes as $key => &$node) {
        // Make sure that nodes have an 'http_address' property, which is not the case if you're using AWS
        // Elasticsearch service (at least as of Oct., 2015). - TO BE VERIFIED
        // Temporary workaround - simply ignore all invalid nodes
        if (!isset($node['http']['publish_address'])) {
            unset($nodes[$key]);
        }
        $node['http_address'] = $node['http']['publish_address'];
        // Protocol is not a standard ES node property, so we add it manually
        $node['protocol'] = $this->defaultProtocol;
    }
    if (!empty($nodes)) {
        $this->nodes = array_values($nodes);
    } else {
        curl_close($this->_curl);
        throw new Exception('Cluster autodetection did not find any active node. Make sure a GET /_nodes reguest on the hosts defined in the config returns the "http_address" field for each node.');
    }
}

            

                public function post($url, $options = [], $body = null, $raw = false)
{
    $this->open();
    return $this->httpRequest('POST', $this->createUrl($url, $options), $body, $raw);
}

            

                public function put($url, $options = [], $body = null, $raw = false)
{
    $this->open();
    return $this->httpRequest('PUT', $this->createUrl($url, $options), $body, $raw);
}

            

                protected function selectActiveNode()
{
    $keys = array_keys($this->nodes);
    $this->activeNode = $keys[random_int(0, count($keys) - 1)];
}