void HttpAssetTransfer::SendHttpGetAssetRequest(const std::string &resource_uri)
{
    if (http_session_.connected())
    {
        http_session_.abort();
        http_session_.detachSocket();
    }

    received_count_ = 0;

    Poco::URI uri(resource_uri);
    std::string path(uri.getPathAndQuery());
    if (path.empty())
        path = "/";

    http_session_.setHost(uri.getHost());
    http_session_.setPort(uri.getPort());
    Poco::Timespan time_out(HTTP_TIMEOUT_MS*1000);
    http_session_.setTimeout(time_out);

    Poco::Net::HTTPRequest request;
    request.setMethod(Poco::Net::HTTPRequest::HTTP_GET);
    request.setURI(path);
    request.setVersion(Poco::Net::HTTPMessage::HTTP_1_1);

    try
    {
        http_session_.sendRequest(request);
        std::istream &s = http_session_.receiveResponse(http_response_);
        Poco::Net::HTTPResponse::HTTPStatus status = http_response_.getStatus();
        switch (status)
        {
        case Poco::Net::HTTPResponse::HTTP_OK:
            response_stream_ = &s;
            response_size_ = http_response_.getContentLength();
            break;

        default:
            std::string reason = http_response_.getReasonForStatus(status);
            std::stringstream error;
            error << "Http GET failed for: ";
            error << resource_uri << std::endl;
            error << "Reason: " << reason;
            AssetModule::LogError(error.str());
            failed_ = true;
            return;
        }
    }
    catch (Poco::Exception e)
    {
        std::stringstream error;
        error << "Http GET failed for: ";
        error << resource_uri << std::endl;
        error << "Reason: " << e.displayText();
        AssetModule::LogError(error.str());
        failed_ = true;
        return;
    }
}
void HttpAssetTransfer::SendHttpPostAssetRequest(const std::string &host, const std::string &json_data)
{
    std::string ASSET_UPLOADING_CONTENT_TYPE = "application/json";
    int content_length = json_data.length();
    std::istringstream stream(json_data);

    int send_count = 0; //\todo make member var

    Poco::URI uri(host);
    std::string path(uri.getPathAndQuery());
    if (path.empty())
        path = "/";

    http_session_.setHost(uri.getHost());
    http_session_.setPort(uri.getPort());

    Poco::Timespan time_out(HTTP_TIMEOUT_MS*1000);

    Poco::Net::HTTPRequest request;
    request.setMethod(Poco::Net::HTTPRequest::HTTP_POST);
    std::string t = uri.toString();
    request.setURI(uri.getPath());
    request.setVersion(Poco::Net::HTTPMessage::HTTP_1_1);
    request.setContentType(ASSET_UPLOADING_CONTENT_TYPE);
    request.setContentLength(content_length);
    request.setKeepAlive(false);

    try
    {
        std::ostream &request_body = http_session_.sendRequest(request);
        request_body.write(json_data.c_str(), json_data.length());

        std::istream &s = http_session_.receiveResponse(http_response_);

        Poco::Net::HTTPResponse::HTTPStatus status = http_response_.getStatus();
        switch (status)
        {
        case Poco::Net::HTTPResponse::HTTP_OK:
            response_stream_ = &s;
            response_size_ = http_response_.getContentLength();
            break;

        default:
            std::string reason = http_response_.getReasonForStatus(status);
            std::stringstream error;
            error << "Http POST failed for: ";
            error << host << std::endl;
            error << "Reason: " << reason;
            AssetModule::LogError(error.str());
            failed_ = true;
            return;
        }
    }
    catch (Poco::Net::MessageException &e)
    {
        std::string u = request.getURI();
        std::string m = request.getMethod();
        std::string error = e.message();

    }
    catch (Poco::Exception &e)
    {
        std::stringstream error;
        error << "Http POST failed for: ";
        error << host << std::endl;
        error << "Reason: " << e.displayText();
        AssetModule::LogError(error.str());
        failed_ = true;
        return;
    }
}
Exemple #3
-1
void RemoteJobManager::initHTTPRequest(Poco::Net::HTTPRequest &req,
                                       const std::string &method,
                                       std::string extraPath,
                                       std::string queryString) {
  // Set up the session object
  if (m_session) {
    delete m_session;
    m_session = nullptr;
  }

  if (Poco::URI(m_serviceBaseUrl).getScheme() == "https") {
    // Create an HTTPS session
    // TODO: Notice that we've set the context to VERIFY_NONE. I think that
    // means we're not checking the SSL certificate that the server
    // sends to us. That's BAD!!
    Poco::Net::Context::Ptr context =
        new Poco::Net::Context(Poco::Net::Context::CLIENT_USE, "", "", "",
                               Poco::Net::Context::VERIFY_NONE, 9, false,
                               "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
    m_session = new Poco::Net::HTTPSClientSession(
        Poco::URI(m_serviceBaseUrl).getHost(),
        Poco::URI(m_serviceBaseUrl).getPort(), context);
  } else {
    // Create a regular HTTP client session.  (NOTE: Using unencrypted HTTP is a
    // really bad idea! We'll be sending passwords in the clear!)
    m_session =
        new Poco::Net::HTTPClientSession(Poco::URI(m_serviceBaseUrl).getHost(),
                                         Poco::URI(m_serviceBaseUrl).getPort());
  }

  Poco::URI uri(m_serviceBaseUrl);
  std::string path = uri.getPath();
  // Path should be something like "/mws/rest", append extraPath to it.
  path += extraPath;

  uri.setPath(path);
  if (method == Poco::Net::HTTPRequest::HTTP_GET && !queryString.empty()) {
    uri.setQuery(queryString);
  }

  req.setVersion(Poco::Net::HTTPRequest::HTTP_1_1);
  req.setMethod(method);
  req.setURI(uri.toString());

  // Attach any cookies we've got from previous responses
  req.setCookies(getCookies());
}