mirror of https://gitee.com/bigwinds/arangodb
889 lines
29 KiB
C++
889 lines
29 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief simple http client
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2014 ArangoDB GmbH, Cologne, Germany
|
|
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
|
|
///
|
|
/// @author Dr. Frank Celler
|
|
/// @author Achim Brandt
|
|
/// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany
|
|
/// @author Copyright 2009-2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "SimpleHttpClient.h"
|
|
#include "Basics/JsonHelper.h"
|
|
#include "Basics/logging.h"
|
|
#include "Basics/StringUtils.h"
|
|
#include "GeneralClientConnection.h"
|
|
#include "SimpleHttpResult.h"
|
|
|
|
using namespace triagens::basics;
|
|
using namespace triagens::rest;
|
|
using namespace std;
|
|
|
|
namespace triagens {
|
|
namespace httpclient {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief empty map, used for headers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
std::map<std::string, std::string> const SimpleHttpClient::NoHeaders;
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// constructors and destructors
|
|
// -----------------------------------------------------------------------------
|
|
|
|
SimpleHttpClient::SimpleHttpClient (GeneralClientConnection* connection,
|
|
double requestTimeout,
|
|
bool warn)
|
|
: _connection(connection),
|
|
_writeBuffer(TRI_UNKNOWN_MEM_ZONE),
|
|
_readBuffer(TRI_UNKNOWN_MEM_ZONE),
|
|
_readBufferOffset(0),
|
|
_requestTimeout(requestTimeout),
|
|
_state(IN_CONNECT),
|
|
_written(0),
|
|
_errorMessage(""),
|
|
_locationRewriter({nullptr, nullptr}),
|
|
_nextChunkedSize(0),
|
|
_result(nullptr),
|
|
_maxPacketSize(128 * 1024 * 1024),
|
|
_keepConnectionOnDestruction(false),
|
|
_warn(warn),
|
|
_keepAlive(true),
|
|
_exposeArangoDB(true),
|
|
_supportDeflate(true) {
|
|
|
|
TRI_ASSERT(connection != nullptr);
|
|
|
|
if (_connection->isConnected()) {
|
|
_state = FINISHED;
|
|
}
|
|
}
|
|
|
|
SimpleHttpClient::~SimpleHttpClient () {
|
|
// connection may have been invalidated by other objects
|
|
if (_connection != nullptr) {
|
|
if (! _keepConnectionOnDestruction || ! _connection->isConnected()) {
|
|
_connection->disconnect();
|
|
}
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// public methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief close connection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void SimpleHttpClient::close () {
|
|
// ensure connection has not yet been invalidated
|
|
TRI_ASSERT(_connection != nullptr);
|
|
|
|
_connection->disconnect();
|
|
_state = IN_CONNECT;
|
|
|
|
clearReadBuffer();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief send out a request, creating a new HttpResult object
|
|
/// this version does not allow specifying custom headers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
SimpleHttpResult* SimpleHttpClient::request (rest::HttpRequest::HttpRequestType method,
|
|
std::string const& location,
|
|
char const* body,
|
|
size_t bodyLength) {
|
|
return doRequest(method, location, body, bodyLength, NoHeaders);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief send out a request, creating a new HttpResult object
|
|
/// this version allows specifying custom headers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
SimpleHttpResult* SimpleHttpClient::request (rest::HttpRequest::HttpRequestType method,
|
|
std::string const& location,
|
|
char const* body,
|
|
size_t bodyLength,
|
|
std::map<std::string, std::string> const& headers) {
|
|
return doRequest(method, location, body, bodyLength, headers);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief send out a request, worker function
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
SimpleHttpResult* SimpleHttpClient::doRequest (rest::HttpRequest::HttpRequestType method,
|
|
std::string const& location,
|
|
char const* body,
|
|
size_t bodyLength,
|
|
std::map<std::string, std::string> const& headers) {
|
|
|
|
// ensure connection has not yet been invalidated
|
|
TRI_ASSERT(_connection != nullptr);
|
|
|
|
// ensure that result is empty
|
|
TRI_ASSERT(_result == nullptr);
|
|
|
|
// create a new result
|
|
_result = new SimpleHttpResult;
|
|
|
|
// reset error message
|
|
_errorMessage = "";
|
|
|
|
// set body
|
|
setRequest(method, rewriteLocation(location), body, bodyLength, headers);
|
|
|
|
// ensure state
|
|
TRI_ASSERT(_state == IN_CONNECT || _state == IN_WRITE);
|
|
|
|
// respect timeout
|
|
double endTime = TRI_microtime() + _requestTimeout;
|
|
double remainingTime = _requestTimeout;
|
|
|
|
while (_state < FINISHED && remainingTime > 0.0) {
|
|
// Note that this loop can either be left by timeout or because
|
|
// a connect did not work (which sets the _state to DEAD). In all
|
|
// other error conditions we call close() which resets the state
|
|
// to IN_CONNECT and tries a reconnect. This is important because
|
|
// it is always possible that we are called with a connection that
|
|
// has already been closed by the other side. This leads to the
|
|
// strange effect that the write (if it is small enough) proceeds
|
|
// but the following read runs into an error. In that case we try
|
|
// to reconnect one and then give up if this does not work.
|
|
switch (_state) {
|
|
case (IN_CONNECT): {
|
|
handleConnect();
|
|
// If this goes wrong, _state is set to DEAD
|
|
break;
|
|
}
|
|
|
|
case (IN_WRITE): {
|
|
size_t bytesWritten = 0;
|
|
|
|
TRI_ASSERT(_writeBuffer.length() >= _written);
|
|
TRI_set_errno(TRI_ERROR_NO_ERROR);
|
|
|
|
bool res = _connection->handleWrite(
|
|
remainingTime,
|
|
static_cast<void const*>(_writeBuffer.c_str() + _written),
|
|
_writeBuffer.length() - _written,
|
|
&bytesWritten);
|
|
|
|
if (! res) {
|
|
setErrorMessage("Error writing to '" +
|
|
_connection->getEndpoint()->getSpecification() +
|
|
"' '" +
|
|
_connection->getErrorDetails() +
|
|
"'");
|
|
this->close(); // this sets _state to IN_CONNECT for a retry
|
|
}
|
|
else {
|
|
_written += bytesWritten;
|
|
|
|
if (_written == _writeBuffer.length()) {
|
|
_state = IN_READ_HEADER;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case (IN_READ_HEADER):
|
|
case (IN_READ_BODY):
|
|
case (IN_READ_CHUNKED_HEADER):
|
|
case (IN_READ_CHUNKED_BODY): {
|
|
TRI_set_errno(TRI_ERROR_NO_ERROR);
|
|
|
|
// we need to notice if the other side has closed the connection:
|
|
bool connectionClosed;
|
|
|
|
bool res = _connection->handleRead(remainingTime,
|
|
_readBuffer,
|
|
connectionClosed);
|
|
|
|
|
|
// If there was an error, then we are doomed:
|
|
if (! res) {
|
|
setErrorMessage("Error reading from: '" +
|
|
_connection->getEndpoint()->getSpecification() +
|
|
"' '" +
|
|
_connection->getErrorDetails() +
|
|
"'");
|
|
this->close(); // this sets the state to IN_CONNECT for a retry
|
|
break;
|
|
}
|
|
|
|
if (connectionClosed) {
|
|
// write might have succeeded even if the server has closed
|
|
// the connection, this will then show up here with us being
|
|
// in state IN_READ_HEADER but nothing read.
|
|
if (_state == IN_READ_HEADER && 0 == _readBuffer.length()) {
|
|
this->close(); // sets _state to IN_CONNECT again for a retry
|
|
continue;
|
|
}
|
|
|
|
else if (_state == IN_READ_BODY && ! _result->hasContentLength()) {
|
|
// If we are reading the body and no content length was
|
|
// found in the header, then we must read until no more
|
|
// progress is made (but without an error), this then means
|
|
// that the server has closed the connection and we must
|
|
// process the body one more time:
|
|
_result->setContentLength(_readBuffer.length() - _readBufferOffset);
|
|
processBody();
|
|
|
|
if (_state != FINISHED) {
|
|
// If the body was not fully found we give up:
|
|
this->close(); // this sets the state IN_CONNECT to retry
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
else {
|
|
// In all other cases of closed connection, we are doomed:
|
|
this->close(); // this sets the state to IN_CONNECT retry
|
|
break;
|
|
}
|
|
}
|
|
|
|
// the connection is still alive:
|
|
switch (_state) {
|
|
case (IN_READ_HEADER):
|
|
processHeader();
|
|
break;
|
|
|
|
case (IN_READ_BODY):
|
|
processBody();
|
|
break;
|
|
|
|
case (IN_READ_CHUNKED_HEADER):
|
|
processChunkedHeader();
|
|
break;
|
|
|
|
case (IN_READ_CHUNKED_BODY):
|
|
processChunkedBody();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
remainingTime = endTime - TRI_microtime();
|
|
}
|
|
|
|
if (_state < FINISHED && _errorMessage.empty()) {
|
|
setErrorMessage("Request timeout reached");
|
|
}
|
|
|
|
// set result type in getResult()
|
|
SimpleHttpResult* result = getResult();
|
|
|
|
_result = nullptr;
|
|
|
|
return result;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// private methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief initialize the connection
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void SimpleHttpClient::handleConnect () {
|
|
// ensure connection has not yet been invalidated
|
|
TRI_ASSERT(_connection != nullptr);
|
|
|
|
if (! _connection->connect()) {
|
|
setErrorMessage("Could not connect to '" +
|
|
_connection->getEndpoint()->getSpecification() +
|
|
"' '" +
|
|
_connection->getErrorDetails() +
|
|
"'");
|
|
_state = DEAD;
|
|
}
|
|
else {
|
|
// can write now
|
|
_state = IN_WRITE;
|
|
_written = 0;
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief clearReadBuffer, clears the read buffer as well as the result
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void SimpleHttpClient::clearReadBuffer () {
|
|
_readBuffer.clear();
|
|
_readBufferOffset = 0;
|
|
|
|
if (_result) {
|
|
_result->clear();
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sets username and password
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void SimpleHttpClient::setUserNamePassword (const string& prefix,
|
|
const string& username,
|
|
const string& password) {
|
|
|
|
string value = triagens::basics::StringUtils::encodeBase64(username + ":" + password);
|
|
|
|
_pathToBasicAuth.push_back(make_pair(prefix, value));
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief return the result
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
SimpleHttpResult* SimpleHttpClient::getResult () {
|
|
switch (_state) {
|
|
case IN_WRITE:
|
|
_result->setResultType(SimpleHttpResult::WRITE_ERROR);
|
|
break;
|
|
|
|
case IN_READ_HEADER:
|
|
case IN_READ_BODY:
|
|
case IN_READ_CHUNKED_HEADER:
|
|
case IN_READ_CHUNKED_BODY:
|
|
_result->setResultType(SimpleHttpResult::READ_ERROR);
|
|
break;
|
|
|
|
case FINISHED:
|
|
_result->setResultType(SimpleHttpResult::COMPLETE);
|
|
break;
|
|
|
|
case IN_CONNECT:
|
|
default: {
|
|
_result->setResultType(SimpleHttpResult::COULD_NOT_CONNECT);
|
|
if (!haveErrorMessage()) {
|
|
setErrorMessage("Could not connect");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (haveErrorMessage() && (_result->getHttpReturnMessage().length() == 0)) {
|
|
_result->setHttpReturnMessage(_errorMessage);
|
|
}
|
|
|
|
return _result;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief prepare a request
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void SimpleHttpClient::setRequest (rest::HttpRequest::HttpRequestType method,
|
|
std::string const& location,
|
|
char const* body,
|
|
size_t bodyLength,
|
|
std::map<std::string, std::string> const& headers) {
|
|
// clear read-buffer (no pipeling!)
|
|
_readBufferOffset = 0;
|
|
_readBuffer.reset();
|
|
|
|
// set HTTP method
|
|
_method = method;
|
|
|
|
// now fill the write buffer
|
|
_writeBuffer.clear();
|
|
|
|
// append method
|
|
HttpRequest::appendMethod(method, &_writeBuffer);
|
|
|
|
// append location
|
|
string l(location);
|
|
if (location.empty() || location[0] != '/') {
|
|
l = "/" + location;
|
|
}
|
|
|
|
_writeBuffer.appendText(l);
|
|
|
|
// append protocol
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR(" HTTP/1.1\r\n"));
|
|
|
|
// append hostname
|
|
string&& hostname = _connection->getEndpoint()->getHost();
|
|
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("Host: "));
|
|
_writeBuffer.appendText(hostname);
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("\r\n"));
|
|
|
|
if (_keepAlive) {
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("Connection: Keep-Alive\r\n"));
|
|
}
|
|
else {
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("Connection: Close\r\n"));
|
|
}
|
|
|
|
if (_exposeArangoDB) {
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("User-Agent: ArangoDB\r\n"));
|
|
}
|
|
|
|
// do not automatically advertise deflate support
|
|
if (_supportDeflate) {
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("Accept-Encoding: deflate\r\n"));
|
|
}
|
|
|
|
// do basic authorization
|
|
if (! _pathToBasicAuth.empty()) {
|
|
string foundPrefix;
|
|
string foundValue;
|
|
std::vector<std::pair<std::string, std::string>>::iterator i = _pathToBasicAuth.begin();
|
|
|
|
for (; i != _pathToBasicAuth.end(); ++i) {
|
|
string& f = i->first;
|
|
|
|
if (l.find(f) == 0) {
|
|
// f is prefix of l
|
|
if (f.length() > foundPrefix.length()) {
|
|
foundPrefix = f;
|
|
foundValue = i->second;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (! foundValue.empty()) {
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("Authorization: Basic "));
|
|
_writeBuffer.appendText(foundValue);
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("\r\n"));
|
|
}
|
|
}
|
|
|
|
for (auto const& header : headers) {
|
|
_writeBuffer.appendText(header.first);
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR(": "));
|
|
_writeBuffer.appendText(header.second);
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("\r\n"));
|
|
}
|
|
|
|
if (method != HttpRequest::HTTP_REQUEST_GET) {
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("Content-Length: "));
|
|
_writeBuffer.appendInteger(bodyLength);
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("\r\n\r\n"));
|
|
}
|
|
else {
|
|
_writeBuffer.appendText(TRI_CHAR_LENGTH_PAIR("\r\n"));
|
|
}
|
|
|
|
if (body != nullptr) {
|
|
_writeBuffer.appendText(body, bodyLength);
|
|
}
|
|
|
|
LOG_TRACE("Request: %s", _writeBuffer.c_str());
|
|
|
|
if (_state == DEAD) {
|
|
_connection->resetNumConnectRetries();
|
|
}
|
|
|
|
|
|
// close connection to reset all read and write buffers
|
|
if (_state != FINISHED) {
|
|
this->close();
|
|
}
|
|
|
|
// we are connected, start with writing
|
|
if (_connection->isConnected()) {
|
|
_state = IN_WRITE;
|
|
_written = 0;
|
|
}
|
|
|
|
// connect to server
|
|
else {
|
|
_state = IN_CONNECT;
|
|
}
|
|
|
|
TRI_ASSERT(_state == IN_CONNECT || _state == IN_WRITE);
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// private methods
|
|
// -----------------------------------------------------------------------------
|
|
|
|
void SimpleHttpClient::processHeader () {
|
|
TRI_ASSERT(_readBufferOffset <= _readBuffer.length());
|
|
size_t remain = _readBuffer.length() - _readBufferOffset;
|
|
char const* ptr = _readBuffer.c_str() + _readBufferOffset;
|
|
char const* pos = static_cast<char const*>(memchr(ptr, '\n', remain));
|
|
|
|
// We enforce the following invariants:
|
|
// ptr = _readBuffer.c_str() + _readBufferOffset
|
|
// _readBuffer.length() >= _readBufferOffset
|
|
// remain = _readBuffer.length() - _readBufferOffset
|
|
while (pos) {
|
|
TRI_ASSERT(_readBufferOffset <= _readBuffer.length());
|
|
TRI_ASSERT(ptr == _readBuffer.c_str() + _readBufferOffset);
|
|
TRI_ASSERT(remain == _readBuffer.length() - _readBufferOffset);
|
|
|
|
if (pos > ptr && *(pos - 1) == '\r') {
|
|
// adjust eol position
|
|
--pos;
|
|
}
|
|
|
|
// end of header found
|
|
if (*ptr == '\r' || *ptr == '\0') {
|
|
size_t len = pos - ptr;
|
|
_readBufferOffset += len + 1;
|
|
ptr += len + 1;
|
|
remain -= len + 1;
|
|
|
|
if (*pos == '\r') {
|
|
// adjust offset if line ended with \r\n
|
|
++_readBufferOffset;
|
|
ptr++;
|
|
remain--;
|
|
}
|
|
|
|
// handle chunks
|
|
if (_result->isChunked()) {
|
|
_state = IN_READ_CHUNKED_HEADER;
|
|
processChunkedHeader();
|
|
return;
|
|
}
|
|
|
|
// no content-length header in response
|
|
else if (! _result->hasContentLength()) {
|
|
_state = IN_READ_BODY;
|
|
processBody();
|
|
return;
|
|
}
|
|
|
|
// no body
|
|
else if (_result->hasContentLength() && _result->getContentLength() == 0) {
|
|
_result->setResultType(SimpleHttpResult::COMPLETE);
|
|
_state = FINISHED;
|
|
|
|
if (! _keepAlive) {
|
|
_connection->disconnect();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// found content-length header in response
|
|
else if (_result->hasContentLength() && _result->getContentLength() > 0) {
|
|
if (_result->getContentLength() > _maxPacketSize) {
|
|
setErrorMessage("Content-Length > max packet size found", true);
|
|
|
|
// reset connection
|
|
this->close();
|
|
_state = DEAD;
|
|
|
|
return;
|
|
}
|
|
|
|
_state = IN_READ_BODY;
|
|
processBody();
|
|
return;
|
|
}
|
|
else {
|
|
TRI_ASSERT(false);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// we have found more header fields
|
|
else {
|
|
size_t len = pos - ptr;
|
|
_result->addHeaderField(ptr, len);
|
|
|
|
if (*pos == '\r') {
|
|
// adjust length if line ended with \r\n
|
|
// (header was already added so no harm is done)
|
|
++len;
|
|
}
|
|
|
|
ptr += len + 1;
|
|
_readBufferOffset += len + 1;
|
|
remain -= (len + 1);
|
|
|
|
TRI_ASSERT(_readBufferOffset <= _readBuffer.length());
|
|
TRI_ASSERT(ptr == _readBuffer.c_str() + _readBufferOffset);
|
|
TRI_ASSERT(remain == _readBuffer.length() - _readBufferOffset);
|
|
pos = static_cast<char const*>(memchr(ptr, '\n', remain));
|
|
|
|
if (pos == nullptr) {
|
|
_readBufferOffset++;
|
|
ptr++;
|
|
remain--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void SimpleHttpClient::processBody () {
|
|
// HEAD requests may be responded to without a body...
|
|
if (_method == HttpRequest::HTTP_REQUEST_HEAD) {
|
|
_result->setResultType(SimpleHttpResult::COMPLETE);
|
|
_state = FINISHED;
|
|
|
|
if (! _keepAlive) {
|
|
_connection->disconnect();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// we need to wait for a close, if content length is unknown
|
|
if (! _result->hasContentLength()) {
|
|
return;
|
|
}
|
|
|
|
// we need to wait for more data
|
|
if (_readBuffer.length() - _readBufferOffset < _result->getContentLength()) {
|
|
return;
|
|
}
|
|
|
|
// body is compressed using deflate. inflate it
|
|
if (_result->isDeflated()) {
|
|
_readBuffer.inflate(_result->getBody(), 16384, _readBufferOffset);
|
|
}
|
|
|
|
// body is not compressed
|
|
else {
|
|
// Note that if we are here, then
|
|
// _result->getContentLength() <= _readBuffer.length()-_readBufferOffset
|
|
_result->getBody().appendText(_readBuffer.c_str() + _readBufferOffset,
|
|
_result->getContentLength());
|
|
}
|
|
|
|
_readBufferOffset += _result->getContentLength();
|
|
_result->setResultType(SimpleHttpResult::COMPLETE);
|
|
_state = FINISHED;
|
|
|
|
if (! _keepAlive) {
|
|
_connection->disconnect();
|
|
}
|
|
}
|
|
|
|
|
|
void SimpleHttpClient::processChunkedHeader () {
|
|
size_t remain = _readBuffer.length() - _readBufferOffset;
|
|
char const* ptr = _readBuffer.c_str() + _readBufferOffset;
|
|
char const* pos = static_cast<char const*>(memchr(ptr, '\n', remain));
|
|
|
|
// not yet finished, newline is missing
|
|
if (pos == nullptr) {
|
|
return;
|
|
}
|
|
|
|
// adjust eol position
|
|
if (pos > ptr && *(pos - 1) == '\r') {
|
|
--pos;
|
|
}
|
|
|
|
size_t len = pos - (_readBuffer.c_str() + _readBufferOffset);
|
|
string line(_readBuffer.c_str() + _readBufferOffset, len);
|
|
StringUtils::trimInPlace(line);
|
|
|
|
_readBufferOffset += (len + 1);
|
|
|
|
// adjust offset if line ended with \r\n
|
|
if (*pos == '\r') {
|
|
++_readBufferOffset;
|
|
++len;
|
|
}
|
|
|
|
// empty lines are an error
|
|
if (line[0] == '\r' || line.empty()) {
|
|
setErrorMessage("found invalid content-length", true);
|
|
// reset connection
|
|
this->close();
|
|
_state = DEAD;
|
|
|
|
return;
|
|
}
|
|
|
|
uint32_t contentLength;
|
|
|
|
try {
|
|
contentLength = static_cast<uint32_t>(std::stol(line, nullptr, 16)); // C++11
|
|
}
|
|
catch (...) {
|
|
setErrorMessage("found invalid content-length", true);
|
|
// reset connection
|
|
this->close();
|
|
_state = DEAD;
|
|
|
|
return;
|
|
}
|
|
|
|
// failed: too many bytes
|
|
if (contentLength > _maxPacketSize) {
|
|
|
|
setErrorMessage("Content-Length > max packet size found!", true);
|
|
// reset connection
|
|
this->close();
|
|
_state = DEAD;
|
|
|
|
return;
|
|
}
|
|
|
|
_state = IN_READ_CHUNKED_BODY;
|
|
_nextChunkedSize = contentLength;
|
|
|
|
processChunkedBody();
|
|
}
|
|
|
|
|
|
void SimpleHttpClient::processChunkedBody () {
|
|
|
|
// HEAD requests may be responded to without a body...
|
|
if (_method == HttpRequest::HTTP_REQUEST_HEAD) {
|
|
_result->setResultType(SimpleHttpResult::COMPLETE);
|
|
_state = FINISHED;
|
|
|
|
if (! _keepAlive) {
|
|
_connection->disconnect();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (_readBuffer.length() - _readBufferOffset >= _nextChunkedSize + 2) {
|
|
|
|
// last chunk length was 0, therefore we are finished
|
|
if (_nextChunkedSize == 0) {
|
|
_result->setResultType(SimpleHttpResult::COMPLETE);
|
|
|
|
_state = FINISHED;
|
|
|
|
if (! _keepAlive) {
|
|
_connection->disconnect();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (_result->isDeflated()) {
|
|
_readBuffer.inflate(_result->getBody(), 16384, _readBufferOffset);
|
|
}
|
|
else {
|
|
_result->getBody().appendText(_readBuffer.c_str() + _readBufferOffset,
|
|
(size_t) _nextChunkedSize);
|
|
}
|
|
|
|
_readBufferOffset += (size_t) _nextChunkedSize + 2;
|
|
_state = IN_READ_CHUNKED_HEADER;
|
|
processChunkedHeader();
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief extract an error message from a response
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
std::string SimpleHttpClient::getHttpErrorMessage (SimpleHttpResult* result) {
|
|
triagens::basics::StringBuffer const& body = result->getBody();
|
|
std::string details;
|
|
|
|
std::unique_ptr<TRI_json_t> json(triagens::basics::JsonHelper::fromString(body.c_str(), body.length()));
|
|
|
|
if (json != nullptr) {
|
|
std::string const errorMessage = triagens::basics::JsonHelper::getStringValue(json.get(), "errorMessage", "");
|
|
int errorNum = triagens::basics::JsonHelper::getNumericValue<int>(json.get(), "errorNum", 0);
|
|
|
|
if (errorMessage != "" && errorNum > 0) {
|
|
details = ": ArangoError " + StringUtils::itoa(errorNum) + ": " + errorMessage;
|
|
}
|
|
}
|
|
|
|
return "got error from server: HTTP " +
|
|
triagens::basics::StringUtils::itoa(result->getHttpReturnCode()) +
|
|
" (" + result->getHttpReturnMessage() + ")" +
|
|
details;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief fetch the version from the server
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
std::string SimpleHttpClient::getServerVersion () {
|
|
std::unique_ptr<SimpleHttpResult> response(request(HttpRequest::HTTP_REQUEST_GET,
|
|
"/_api/version",
|
|
nullptr,
|
|
0));
|
|
|
|
if (response == nullptr || ! response->isComplete()) {
|
|
return "";
|
|
}
|
|
|
|
std::string version;
|
|
|
|
if (response->getHttpReturnCode() == HttpResponse::OK) {
|
|
// default value
|
|
version = "arango";
|
|
|
|
// convert response body to json
|
|
std::unique_ptr<TRI_json_t> json(TRI_JsonString(TRI_UNKNOWN_MEM_ZONE, response->getBody().c_str()));
|
|
|
|
if (json != nullptr) {
|
|
// look up "server" value
|
|
std::string const server = triagens::basics::JsonHelper::getStringValue(json.get(), "server", "");
|
|
|
|
// "server" value is a string and content is "arango"
|
|
if (server == "arango") {
|
|
// look up "version" value
|
|
version = triagens::basics::JsonHelper::getStringValue(json.get(), "version", "");
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (response->wasHttpError()) {
|
|
setErrorMessage(getHttpErrorMessage(response.get()), false);
|
|
}
|
|
_connection->disconnect();
|
|
}
|
|
|
|
return version;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- END-OF-FILE
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}"
|
|
// End:
|