C++ HttpResponse::getBody方法代码示例

HttpJobRequest * HttpFileRequestHandler::handleHttpRequest(HttpRequest * request, const HttpServerTask *task)
{
	FileUtils::paloifstream file(filename.c_str());

	if (!file) {
		HttpResponse * response = new HttpResponse(HttpResponse::NOT_FOUND);
		response->getBody().appendText("file not found");
		return new DirectHttpResponse(request->getRequestPath(), response);
	}

	HttpResponse * response = new HttpResponse(HttpResponse::OK);
	response->setContentType(contentType);

	int max = 1000;
	char* c = new char[max];

	while (!file.eof()) {
		file.read(c, max);
		response->getBody().appendText(c, (size_t)file.gcount());
	}

	delete[] c;

	return new DirectHttpResponse(request->getRequestPath(), response);
}

bool RPCTestNode::submitBlock(const std::string& block) {
  HttpRequest httpReq;
  httpReq.setUrl("/json_rpc");
  httpReq.addHeader("Host", "127.0.0.1:" + boost::lexical_cast<std::string>(m_rpcPort));
  httpReq.addHeader("Content-Type", "application/json-rpc");
  JsonValue request(cryptonote::JsonValue::OBJECT);
  JsonValue jsonRpc;
  jsonRpc = "2.0";
  request.insert("jsonrpc", jsonRpc);
  JsonValue methodString;
  methodString = "submitblock";
  request.insert("method", methodString);
  JsonValue id;
  id = "sync";
  request.insert("id", id);
  JsonValue params(JsonValue::ARRAY);
  JsonValue blockstr;
  blockstr = block.c_str();
  params.pushBack(blockstr);
  request.insert("params", params);
  std::stringstream jsonOutputStream;
  jsonOutputStream << request;
  httpReq.setBody(jsonOutputStream.str());
  TcpConnector connector(m_dispatcher, "127.0.0.1", m_rpcPort);
  TcpConnection connection = connector.connect();
  TcpStreambuf streambuf(connection);
  std::iostream connectionStream(&streambuf);
  LOG_DEBUG("invoke json-rpc: " + httpReq.getBody());
  connectionStream << httpReq;
  connectionStream.flush();
  HttpResponse httpResp;
  HttpParser parser;
  parser.receiveResponse(connectionStream, httpResp);
  connectionStream.flush();
  if (httpResp.getStatus() != HttpResponse::STATUS_200) return false;

  epee::serialization::portable_storage ps;
  if (!ps.load_from_json(httpResp.getBody())) {
    LOG_ERROR("cannot parse response from daemon: " + httpResp.getBody());
    return false;
  }

  epee::json_rpc::response<COMMAND_RPC_SUBMITBLOCK::response, epee::json_rpc::error> jsonRpcResponse;
  jsonRpcResponse.load(ps);

  if (jsonRpcResponse.error.code || jsonRpcResponse.error.message.size()) {
    LOG_ERROR("RPC call of submit_block returned error: " + TO_STRING(jsonRpcResponse.error.code) + ", message: " + jsonRpcResponse.error.message);
    return false;
  }
   
  if (jsonRpcResponse.result.status != CORE_RPC_STATUS_OK)  return false;
  return true;
}

bool RPCTestNode::startMining(size_t threadsCount, const std::string& address) { 
  LOG_DEBUG("startMining()");
  using namespace cryptonote;
  COMMAND_RPC_START_MINING::request req;
  COMMAND_RPC_START_MINING::response resp;
  req.miner_address = address;
  req.threads_count = threadsCount;
  std::stringstream requestStream;
  JsonOutputStreamSerializer enumerator;
  enumerator(req, "");
  requestStream << enumerator;
  HttpRequest httpReq;
  prepareRequest(httpReq, "/start_mining", requestStream.str());
  HttpResponse httpResp;
  sendRequest(httpReq, httpResp);
  if (httpResp.getStatus() != HttpResponse::STATUS_200) return false;
  std::stringstream responseStream(httpResp.getBody());
  JsonInputStreamSerializer en(responseStream);
  en(resp, "");
  if (resp.status != CORE_RPC_STATUS_OK) {
    std::cout << "startMining() RPC call fail: " << resp.status;
    return false;
  }

  return true;
}

void WebClientApp::onReadComplete()
{
	mText.push_back( "Read complete" );
	
	console() << "HTTP version: ";
	switch ( mHttpResponse.getHttpVersion() ) {
		case HttpVersion::HTTP_0_9:
			console() << "0.9";
			break;
		case HttpVersion::HTTP_1_0:
			console() << "1.0";
			break;
		case HttpVersion::HTTP_1_1:
			console() << "1.1";
			break;
		case HttpVersion::HTTP_2_0:
			console() << "2.0";
			break;
	}
	console() << endl;
	console() << "Status code: " << mHttpResponse.getStatusCode() << endl;
	console() << "Reason: " << mHttpResponse.getReason() << endl;
	
	console() << "Header fields: " << endl;
	for ( const KeyValuePair& kvp : mHttpResponse.getHeaders() ) {
		console() << ">> " << kvp.first << ": " << kvp.second << endl;
	}
	console() << endl;
	
	console() << "Body:" << endl;
	console() << HttpResponse::bufferToString( mHttpResponse.getBody() ) << endl;

	mSession->close();
}

void HttpServerTask::handleDone()
{

	// get response from job request
	HttpResponse* response = httpJobRequest->getResponse();

	if (response == 0) {
		response = new HttpResponse(HttpResponse::NO_RESPONSE);
	}

	// trace
#ifdef ENABLE_TRACE_OPTION
	{
		string requestString = "";

		if (httpRequest != 0) {
			requestString = httpRequest->getHeaderString();

			const string bs = httpRequest->getBodyString();

			if (!bs.empty()) {
				if (requestString.find("?") == string::npos) {
					requestString += "?";
				}

				requestString += bs;
			}
		}

		server->traceRequest(requestString + response->getBody().c_str());
	}
#endif

	// add response to output buffer
	addResponse(response);

	// we can now free the response
	delete response;

	// and the jobe request
	delete httpJobRequest;
	httpJobRequest = 0;

	// and the http request
	if (httpRequest != 0) {
		httpRequest->releaseBuffers();
		delete httpRequest;
		httpRequest = 0;
	}

	httpRequestPending = false;

	// remove body from read buffer and reset read position
	readBuffer.erase_front(bodyPosition + bodyLength);
	readPosition = 0;
	bodyPosition = 0;
	bodyLength = 0;
}

void invokeJsonRpcCommand(HttpClient& httpClient, JsonRpcRequest& jsReq, JsonRpcResponse& jsRes) {
  HttpRequest httpReq;
  HttpResponse httpRes;

  httpReq.setUrl("/json_rpc");
  httpReq.setBody(jsReq.getBody());

  httpClient.request(httpReq, httpRes);

  if (httpRes.getStatus() != HttpResponse::STATUS_200) {
    throw std::runtime_error("JSON-RPC call failed, HTTP status = " + std::to_string(httpRes.getStatus()));
  }

  jsRes.parse(httpRes.getBody());

  JsonRpcError err;
  if (jsRes.getError(err)) {
    throw err;
  }
}

int VersionChecker::retrieveRemoteVersion(const std::string& urlToVersion) {
  Http http(urlToVersion, 0.5);
  HttpResponse response;
  if (this->quiet) {
    http.enableQuiet();
  } else {
    http.disableQuiet();
  }
  if (!this->quiet) {
    fprintf(stderr, "retrieve remote version from [ %s ]\n",
            urlToVersion.c_str());
  }
  // 2: the remote version file has two lines
  int ret = http.read(&response, 2);
  if (ret < 0) {
    if (!this->quiet) {
      fprintf(
          stderr,
          "Failed to retrieve remote version, probably due to wrong http\n");
    }
    return -1;
  }
  this->remoteInformation = response.getBody();
  if (this->remoteInformation.size() < 1) {
    if (!this->quiet) {
      fprintf(stderr,
              "Failed to retrieve remote version due to empty version "
              "information\n");
    }
    return -1;
  }
  this->remoteVersion = this->remoteInformation[0];
  if (!this->quiet) {
    fprintf(stderr, "Retrieved remote version [ %s ]\n",
            this->remoteVersion.c_str());
  }
  return 0;
}

bool RPCTestNode::stopDaemon() {
  LOG_DEBUG("stopDaemon()");
  using namespace cryptonote;
  COMMAND_RPC_STOP_DAEMON::request req;
  COMMAND_RPC_STOP_DAEMON::response resp;
  std::stringstream requestStream;
  JsonOutputStreamSerializer enumerator;
  enumerator(req, "");
  requestStream << enumerator;
  HttpRequest httpReq;
  prepareRequest(httpReq, "/stop_daemon", requestStream.str());
  HttpResponse httpResp;
  sendRequest(httpReq, httpResp);
  if (httpResp.getStatus() != HttpResponse::STATUS_200) return false;
  std::stringstream responseStream(httpResp.getBody());
  JsonInputStreamSerializer en(responseStream);
  en(resp, "");
  if (resp.status != CORE_RPC_STATUS_OK) {
    std::cout << "stopDaemon() RPC call fail: " << resp.status;
    return false;
  }

  return true;
}

void HttpClientApp::onRead( ci::BufferRef buffer )
{
	size_t sz	= buffer->getSize();
	mBytesRead	+= sz;
	mText.push_back( toString( sz ) + " bytes read" );
	
	if ( !mHttpResponse.hasHeader() ) {
		
		// Parse header
		mHttpResponse.parseHeader( HttpResponse::bufferToString( buffer ) );
		buffer = HttpResponse::removeHeader( buffer );
		
		// Get content-length
		for ( const KeyValuePair& kvp : mHttpResponse.getHeaders() ) {
			if ( kvp.first == "Content-Length" ) {
				mContentLength = fromString<size_t>( kvp.second );
				break;
			}
		}
	}
	
	// Append buffer to body
	mHttpResponse.append( buffer );
	
	if ( mBytesRead < mContentLength ) {
		
		// Keep reading until we hit the content length
		mSession->read();
	} else {

		mText.push_back( "Read complete" );
		mText.push_back( toString( mHttpResponse.getStatusCode() ) + " " + mHttpResponse.getReason() );
		
		if ( mHttpResponse.getStatusCode() == 200 ) {
			for ( const KeyValuePair& kvp : mHttpResponse.getHeaders() ) {
				
				// Choose file extension based on MIME type
				if ( kvp.first == "Content-Type" ) {
					string mime = kvp.second;
					
					if ( mime == "audio/mp3" ) {
						mFilename += ".mp3";
					} else if ( mime == "image/jpeg" ) {
						mFilename += ".jpg";
					} else if ( mime == "image/png" ) {
						mFilename += ".png";
					}
				} else if ( kvp.first == "Connection" ) {
					
					// Close connection if requested by server
					if ( kvp.second == "close" ) {
						mSession->close();
					}
				}
			}

			// Save the file
			fs::path path = getAppPath();
#if !defined ( CINDER_MSW )
			path = path.parent_path();
#endif
			path = path / mFilename;
			OStreamFileRef file = writeFileStream( path );
			file->write( mHttpResponse.getBody() );
			
			mText.push_back( mFilename + " downloaded" );
		} else {
			
			// Write error
			mText.push_back( "Response: " +  HttpResponse::bufferToString( mHttpResponse.getBody() ) );
			
			mSession->close();
		}
	}
}