bool GalaxyFDSClient::doesObjectExist(const string& bucketName, const string& objectName) { string uri = formatUri(_pConfig->getBaseUri(), bucketName + "/" + objectName, _emptySubResources); URI pocoUri(uri); shared_ptr<HTTPClientSession> pSession(_pSessionFacotry->createClientSession( pocoUri)); pSession->setHost(pocoUri.getHost()); pSession->setPort(pocoUri.getPort()); HTTPRequest request(HTTPRequest::HTTP_HEAD, uri, HTTPMessage::HTTP_1_1); prepareRequestHeaders(uri, HTTPRequest::HTTP_HEAD, "", _emptyStream, *_pEmptyMetadata, request); HTTPResponse response; pSession->sendRequest(request); istream& rs = pSession->receiveResponse(response); if (response.getStatus() == HTTPResponse::HTTP_OK) { return true; } else if (response.getStatus() == HTTPResponse::HTTP_NOT_FOUND) { return false; } else { stringstream msg; msg << "Check object existence failed, status=" << response.getStatus() << ", reason="; StreamCopier::copyStream(rs, msg); throw GalaxyFDSClientException(response.getStatus(), msg.str()); } }
void GalaxyFDSClient::refreshObject(const string& bucketName, const string& objectName) { string uri = formatUri(_pConfig->getBaseUri(), bucketName + "/" + objectName, _emptySubResources); uri += "?refresh"; URI pocoUri(uri); shared_ptr<HTTPClientSession> pSession(_pSessionFacotry->createClientSession( pocoUri)); pSession->setHost(pocoUri.getHost()); pSession->setPort(pocoUri.getPort()); HTTPRequest request(HTTPRequest::HTTP_PUT, uri, HTTPMessage::HTTP_1_1); prepareRequestHeaders(uri, HTTPRequest::HTTP_PUT, "", _emptyStream, *_pEmptyMetadata, request); HTTPResponse response; pSession->sendRequest(request); istream& rs = pSession->receiveResponse(response); if (response.getStatus() != HTTPResponse::HTTP_OK) { stringstream msg; msg << "Prefetch object failed, status=" << response.getStatus() << ", reason="; StreamCopier::copyStream(rs, msg); throw GalaxyFDSClientException(response.getStatus(), msg.str()); } }
/** * Calls a web service to get a full path to a file. * Only returns a full path string if the file exists * @param fName :: The file name. * @return The path to the file or an empty string in case of error/non-existing * file. */ std::string ISISDataArchive::getPath(const std::string &fName) const { g_log.debug() << "ISISDataArchive::getPath() - fName=" << fName << "\n"; if (fName.empty()) return ""; // Avoid pointless call to service URI uri(URL_PREFIX + fName); std::string path(uri.getPathAndQuery()); HTTPClientSession session(uri.getHost(), uri.getPort()); HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1); session.sendRequest(req); HTTPResponse res; std::istream &rs = session.receiveResponse(res); const HTTPResponse::HTTPStatus status = res.getStatus(); g_log.debug() << "HTTP response=" << res.getStatus() << "\n"; if (status == HTTPResponse::HTTP_OK) { std::ostringstream os; Poco::StreamCopier::copyStream(rs, os); os << Poco::Path::separator() << fName; try { const std::string expectedPath = os.str(); if (Poco::File(expectedPath).exists()) return expectedPath; } catch (Poco::Exception &) { } } return ""; }
shared_ptr<FDSObjectMetadata> GalaxyFDSClient::getObjectMetadata(const string& bucketName, const string& objectName) { vector<string> subResources; subResources.push_back(SubResource::METADATA); string uri = formatUri(_pConfig->getBaseUri(), bucketName + "/" + objectName, subResources); URI pocoUri(uri); shared_ptr<HTTPClientSession> pSession(_pSessionFacotry->createClientSession( pocoUri)); pSession->setHost(pocoUri.getHost()); pSession->setPort(pocoUri.getPort()); HTTPRequest request(HTTPRequest::HTTP_GET, uri, HTTPMessage::HTTP_1_1); prepareRequestHeaders(uri, HTTPRequest::HTTP_GET, "", _emptyStream, *_pEmptyMetadata, request); HTTPResponse response; pSession->sendRequest(request); istream& rs = pSession->receiveResponse(response); if (response.getStatus() != HTTPResponse::HTTP_OK) { stringstream msg; msg << "Get object metadata failed, status=" << response.getStatus() << ", reason="; StreamCopier::copyStream(rs, msg); throw GalaxyFDSClientException(response.getStatus(), msg.str()); } return parseMetadata(response); }
shared_ptr<FDSObjectListing> GalaxyFDSClient::listObjects(const string& bucketName, const string& prefix, const string& delimiter) { string uri = formatUri(_pConfig->getBaseUri(), bucketName, _emptySubResources); uri += "?prefix=" + prefix + "&delimiter=" + delimiter; URI pocoUri(uri); shared_ptr<HTTPClientSession> pSession(_pSessionFacotry ->createClientSession(pocoUri)); pSession->setHost(pocoUri.getHost()); pSession->setPort(pocoUri.getPort()); HTTPRequest request(HTTPRequest::HTTP_GET, uri, HTTPMessage::HTTP_1_1); prepareRequestHeaders(uri, HTTPRequest::HTTP_GET, "", _emptyStream, *_pEmptyMetadata, request); HTTPResponse response; ostream& os = pSession->sendRequest(request); istream& rs = pSession->receiveResponse(response); if (response.getStatus() != HTTPResponse::HTTP_OK) { stringstream msg; msg << "List objects failed, status=" << response.getStatus() << ", reason="; StreamCopier::copyStream(rs, msg); throw GalaxyFDSClientException(response.getStatus(), msg.str()); } return FDSObjectListing::deserialize(rs); }
void runDelete(){ try{ std::string result; URI uri("http://jsonplaceholder.typicode.com/posts/" + std::to_string(request->getPostID()) ); std::string path(uri.getPathAndQuery()); HTTPClientSession session(uri.getHost(), uri.getPort()); HTTPRequest hrequest(HTTPRequest::HTTP_DELETE, path, HTTPMessage::HTTP_1_1); HTTPResponse response; session.sendRequest(hrequest); std::istream& rs = session.receiveResponse(response); if(response.getStatus() == Poco::Net::HTTPResponse::HTTP_OK){ Response *res = new Response; res->setReqID(reqID); res->setHTTPStatus(HTTPResponse::HTTP_OK); observer.responseQueue.enqueueNotification(new ResponseNotification(res)); { FastMutex::ScopedLock lock(Observer::observerMutex); observer.setResponseAvailable(true); } } else { Response *res = new Response; res->setHTTPStatus(response.getStatus()); res->setReqID(reqID); observer.responseQueue.enqueueNotification(new ResponseNotification(res)); { FastMutex::ScopedLock lock(Observer::observerMutex); observer.setResponseAvailable(true); } } } catch(Exception& exc){ std::cerr<< exc.displayText() << std::endl; } }
void GalaxyFDSClient::setObjectAcl(const string& bucketName, const string& objectName, const AccessControlList& acl) { vector<string> subResources; subResources.push_back(SubResource::ACL); string uri = formatUri(_pConfig->getBaseUri(), bucketName + "/" + objectName, subResources); URI pocoUri(uri); shared_ptr<HTTPClientSession> pSession(_pSessionFacotry->createClientSession( pocoUri)); pSession->setHost(pocoUri.getHost()); pSession->setPort(pocoUri.getPort()); HTTPRequest request(HTTPRequest::HTTP_PUT, uri, HTTPMessage::HTTP_1_1); stringstream ss(AccessControlList::serialize(acl)); prepareRequestHeaders(uri, HTTPRequest::HTTP_PUT, "application/json", ss, *_pEmptyMetadata, request); HTTPResponse response; ostream& os = pSession->sendRequest(request); StreamCopier::copyStream(ss, os); istream& rs = pSession->receiveResponse(response); if (response.getStatus() != HTTPResponse::HTTP_OK) { stringstream msg; msg << "Set Object acl failed, status=" << response.getStatus() << ", reason="; StreamCopier::copyStream(rs, msg); throw GalaxyFDSClientException(response.getStatus(), msg.str()); } }
ofHttpResponse ofURLFileLoader::handleRequest(ofHttpRequest request) { try { URI uri(request.url); std::string path(uri.getPathAndQuery()); if (path.empty()) path = "/"; HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1); HTTPResponse res; ofPtr<HTTPSession> session; istream * rs; if(uri.getScheme()=="https"){ //const Poco::Net::Context::Ptr context( new Poco::Net::Context( Poco::Net::Context::CLIENT_USE, "", "", "rootcert.pem" ) ); HTTPSClientSession * httpsSession = new HTTPSClientSession(uri.getHost(), uri.getPort());//,context); httpsSession->setTimeout(Poco::Timespan(20,0)); httpsSession->sendRequest(req); rs = &httpsSession->receiveResponse(res); session = ofPtr<HTTPSession>(httpsSession); }else{ HTTPClientSession * httpSession = new HTTPClientSession(uri.getHost(), uri.getPort()); httpSession->setTimeout(Poco::Timespan(20,0)); httpSession->sendRequest(req); rs = &httpSession->receiveResponse(res); session = ofPtr<HTTPSession>(httpSession); } if(!request.saveTo){ return ofHttpResponse(request,*rs,res.getStatus(),res.getReason()); }else{ ofFile saveTo(request.name,ofFile::WriteOnly,true); char aux_buffer[1024]; rs->read(aux_buffer, 1024); std::streamsize n = rs->gcount(); while (n > 0){ // we resize to size+1 initialized to 0 to have a 0 at the end for strings saveTo.write(aux_buffer,n); if (rs->good()){ rs->read(aux_buffer, 1024); n = rs->gcount(); } else n = 0; } return ofHttpResponse(request,res.getStatus(),res.getReason()); } } catch (const Exception& exc) { ofLogError("ofURLFileLoader") << "handleRequest(): "+ exc.displayText(); return ofHttpResponse(request,-1,exc.displayText()); } catch (...) { return ofHttpResponse(request,-1,"ofURLFileLoader: fatal error, couldn't catch Exception"); } return ofHttpResponse(request,-1,"ofURLFileLoader: fatal error, couldn't catch Exception"); }
void fetchLoginPage(HTTPSClientSession& clientSession, NameValueCollection& cookies) { HTTPRequest request(HTTPRequest::HTTP_GET, "/royalgreenwich/login?message=borrowerservices_notloggedin&referer=https%3A%2F%2Fcapitadiscovery.co.uk%2Froyalgreenwich%2Faccount", HTTPMessage::HTTP_1_1); request.setCookies(cookies); HTTPResponse response; std::ostream& ostr = clientSession.sendRequest(request); std::istream& rs = clientSession.receiveResponse(response); int statusCode = response.getStatus(); poco_information_f1(logger(), "Status %d", statusCode); std::vector<HTTPCookie> newCookies; response.getCookies(newCookies); for (HTTPCookie cookie : newCookies) { poco_information_f1(logger(), "Cookie %s", cookie.toString()); if (cookies.has(cookie.getName())) { cookies.set(cookie.getName(), cookie.getValue()); } else { cookies.add(cookie.getName(), cookie.getValue()); } } }
void submitLoginPage(HTTPSClientSession& clientSession, NameValueCollection& cookies) { HTTPRequest request(HTTPRequest::HTTP_POST, "/royalgreenwich/sessions", HTTPMessage::HTTP_1_1); request.setCookies(cookies); HTTPResponse response; HTMLForm loginForm; loginForm.add("barcode", "28028005913354"); loginForm.add("pin", "3347"); loginForm.prepareSubmit(request); std::ostream& ostr = clientSession.sendRequest(request); loginForm.write(ostr); std::istream& rs = clientSession.receiveResponse(response); int statusCode = response.getStatus(); poco_information_f1(logger(), "Status %d", statusCode); std::vector<HTTPCookie> newCookies; response.getCookies(newCookies); for (HTTPCookie cookie : newCookies) { poco_information_f1(logger(), "Cookie %s", cookie.toString()); if (cookies.has(cookie.getName())) { cookies.set(cookie.getName(), cookie.getValue()); } else { cookies.add(cookie.getName(), cookie.getValue()); } } }
void fetchAccountPage(HTTPSClientSession& clientSession, NameValueCollection& cookies) { HTTPRequest request(HTTPRequest::HTTP_GET, "/royalgreenwich/account", HTTPMessage::HTTP_1_1); request.setCookies(cookies); HTTPResponse response; std::ostream& ostr = clientSession.sendRequest(request); std::istream& rs = clientSession.receiveResponse(response); int statusCode = response.getStatus(); poco_information_f1(logger(), "Status %d", statusCode); std::vector<HTTPCookie> newCookies; response.getCookies(newCookies); for (HTTPCookie cookie : newCookies) { poco_information_f1(logger(), "Cookie %s", cookie.toString()); if (cookies.has(cookie.getName())) { cookies.set(cookie.getName(), cookie.getValue()); } else { cookies.add(cookie.getName(), cookie.getValue()); } } StreamCopier::copyStream(rs, std::cout); }
int main(int argc, char **argv) { // using `web` as provider URI uri("https://yboss.yahooapis.com/ysearch/web?q=cat"); // init the creds, I think the empty token and token secret are important OAuth10Credentials creds( "dj0yJmk9eGx5RzFQOVAwcDZpJmQ9WVdrOWVVUkhWamhwTkdVbWNHbzlNQS0tJnM9Y29uc3VtZXJzZWNyZXQmeD0wYw--", "2bf8a4682c4948fb4f7add9598eef5f86b57cf93", "", ""); HTTPRequest request(HTTPRequest::HTTP_GET, uri.getPathEtc()); // put the `q` as param HTMLForm params; params.set("q", "cat"); creds.authenticate(request, uri, params); std::string auth = request.get("Authorization"); std::cout << auth << std::endl; const Context::Ptr context = new Context(Context::CLIENT_USE, "", "", "", Context::VERIFY_NONE, 9, false, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH"); HTTPSClientSession session(uri.getHost(), uri.getPort(), context); session.sendRequest(request); HTTPResponse response; std::istream& rs = session.receiveResponse(response); std::cout << response.getStatus() << " " << response.getReason() << std::endl; StreamCopier::copyStream(rs, std::cout); return 0; }
int main(int argc, char** argv) { if (argc != 2) { Path p(argv[0]); std::cout << "usage: " << p.getBaseName() << " <uri>" << std::endl; std::cout << " fetches the resource identified by <uri> and print it to the standard output" << std::endl; return 1; } try { URI uri(argv[1]); std::string path(uri.getPathAndQuery()); if (path.empty()) path = "/"; HTTPClientSession session(uri.getHost(), uri.getPort()); HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1); session.sendRequest(req); HTTPResponse res; std::istream& rs = session.receiveResponse(res); std::cout << res.getStatus() << " " << res.getReason() << std::endl; StreamCopier::copyStream(rs, std::cout); } catch (Exception& exc) { std::cerr << exc.displayText() << std::endl; return 1; } return 0; }
shared_ptr<FDSObject> GalaxyFDSClient::getObject(const string& bucketName, const string& objectName, long pos, long len) { string uri = formatUri(_pConfig->getDownloadBaseUri(), bucketName + "/" + objectName, vector<string>()); URI pocoUri(uri); shared_ptr<HTTPClientSession> pSession(_pSessionFacotry ->createClientSession(pocoUri)); pSession->setHost(pocoUri.getHost()); pSession->setPort(pocoUri.getPort()); HTTPRequest request(HTTPRequest::HTTP_GET, uri, HTTPMessage::HTTP_1_1); FDSObjectMetadata metadata; if (pos >= 0 || len > 0) { std::ostringstream os; os << "bytes=" << pos << "-"; if (len > 0) { os << (pos + len - 1); // inclusive } metadata.add(Constants::RANGE, os.str()); } prepareRequestHeaders(uri, HTTPRequest::HTTP_GET, "", _emptyStream, metadata, request); HTTPResponse response; pSession->sendRequest(request); istream& rs = pSession->receiveResponse(response); if (response.getStatus() != HTTPResponse::HTTP_OK && response.getStatus() != HTTPResponse::HTTP_PARTIAL_CONTENT) { stringstream msg; msg << "Get object failed, status=" << response.getStatus() << ", reason="; StreamCopier::copyStream(rs, msg); throw GalaxyFDSClientException(response.getStatus(), msg.str()); } shared_ptr<FDSObjectSummary> pObjectSummary(new FDSObjectSummary()); pObjectSummary->setBucketName(bucketName); pObjectSummary->setObjectName(objectName); pObjectSummary->setSize(response.getContentLength()); shared_ptr<FDSObject> pObject(new FDSObject()); pObject->setObjectSummary(pObjectSummary); pObject->setObjectMetadata(this->parseMetadata(response)); pObject->setSession(pSession); pObject->setObjectContent(rs); return pObject; }
void runUpdate(){ try{ std::string result; URI uri("http://jsonplaceholder.typicode.com/posts/" + std::to_string(request->getPostID())); std::string path(uri.getPathAndQuery()); HTTPClientSession session(uri.getHost(), uri.getPort()); session.setKeepAlive(true); HTTPRequest hrequest(HTTPRequest::HTTP_PUT, path, HTTPMessage::HTTP_1_1); hrequest.setKeepAlive(true); hrequest.setContentType("application/x-www-form-urlencoded"); std::string requestBody("id="+std::to_string(request->getPostID())+"&title="+request->getPostTitle()+"&body="+request->getPostBody()+"&userID="+std::to_string(request->getPostUserID())); hrequest.setContentLength(requestBody.length()); HTTPResponse response; std::ostream& ostreamSession = session.sendRequest(hrequest); ostreamSession << requestBody; std::istream& rs = session.receiveResponse(response); if(response.getStatus() == Poco::Net::HTTPResponse::HTTP_OK){ StreamCopier::copyToString(rs, result); Response *res = new Response; res->setResponseString(result); res->setReqID(reqID); res->setHTTPStatus(HTTPResponse::HTTP_OK); observer.responseQueue.enqueueNotification(new ResponseNotification(res)); { FastMutex::ScopedLock lock(Observer::observerMutex); observer.setResponseAvailable(true); } } else { Response *res = new Response; res->setHTTPStatus(response.getStatus()); res->setReqID(reqID); observer.responseQueue.enqueueNotification(new ResponseNotification(res)); { FastMutex::ScopedLock lock(Observer::observerMutex); observer.setResponseAvailable(true); } } } catch(Exception& exc){ std::cerr<< exc.displayText() << std::endl; } }
vector<shared_ptr<FDSBucket> > GalaxyFDSClient::listBuckets() { string uri = formatUri(_pConfig->getBaseUri(), "", _emptySubResources); URI pocoUri(uri); shared_ptr<HTTPClientSession> pSession(_pSessionFacotry ->createClientSession(pocoUri)); pSession->setHost(pocoUri.getHost()); pSession->setPort(pocoUri.getPort()); HTTPRequest request(HTTPRequest::HTTP_GET, uri, HTTPMessage::HTTP_1_1); prepareRequestHeaders(uri, HTTPRequest::HTTP_GET, "", _emptyStream, *_pEmptyMetadata, request); HTTPResponse response; ostream& os = pSession->sendRequest(request); istream& rs = pSession->receiveResponse(response); if (response.getStatus() != HTTPResponse::HTTP_OK) { stringstream msg; msg << "List buckets failed, status=" << response.getStatus() << ", reason="; StreamCopier::copyStream(rs, msg); throw GalaxyFDSClientException(response.getStatus(), msg.str()); } vector<shared_ptr<FDSBucket> > res; Parser parser; parser.parse(rs); Var result = parser.result(); Object::Ptr pObject = result.extract<Object::Ptr>(); Object::Ptr pOwnerObject = pObject->getObject("owner"); stringstream ss; pOwnerObject->stringify(ss); shared_ptr<Owner> pOwner = Owner::deserialize(ss); Array::Ptr pBucketsArray = pObject->getArray("buckets"); for (size_t i = 0; i < pBucketsArray->size(); i++) { string bucketName = pBucketsArray->getObject(i)->getValue<string>("name"); shared_ptr<FDSBucket> pBucket(new FDSBucket(bucketName)); pBucket->setOwner(*pOwner); res.push_back(pBucket); } return res; }
ofHttpResponse ofURLFileLoader::handleRequest(ofHttpRequest request) { try { URI uri(request.url); std::string path(uri.getPathAndQuery()); if (path.empty()) path = "/"; HTTPClientSession session(uri.getHost(), uri.getPort()); HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1); session.setTimeout(Poco::Timespan(20,0)); session.sendRequest(req); HTTPResponse res; istream& rs = session.receiveResponse(res); if(!request.saveTo){ return ofHttpResponse(request,rs,res.getStatus(),res.getReason()); }else{ ofFile saveTo(request.name,ofFile::WriteOnly,true); char aux_buffer[1024]; rs.read(aux_buffer, 1024); std::streamsize n = rs.gcount(); while (n > 0){ // we resize to size+1 initialized to 0 to have a 0 at the end for strings saveTo.write(aux_buffer,n); if (rs){ rs.read(aux_buffer, 1024); n = rs.gcount(); } else n = 0; } return ofHttpResponse(request,res.getStatus(),res.getReason()); } } catch (const Exception& exc) { ofLog(OF_LOG_ERROR, "ofURLFileLoader " + exc.displayText()); return ofHttpResponse(request,-1,exc.displayText()); } catch (...) { return ofHttpResponse(request,-1,"ofURLFileLoader fatal error, couldn't catch Exception"); } }
int InternetHelper::processRelocation(const HTTPResponse &response, std::ostream &responseStream) { std::string newLocation = response.get("location", ""); if (!newLocation.empty()) { g_log.information() << "url relocated to " << newLocation; return this->sendRequest(newLocation, responseStream); } else { g_log.warning("Apparent relocation did not give new location\n"); return response.getStatus(); } }
void HTTPResponseTest::testRead1() { std::string s("HTTP/1.1 500 Internal Server Error\r\n\r\n"); std::istringstream istr(s); HTTPResponse response; response.read(istr); assert (response.getStatus() == HTTPResponse::HTTP_INTERNAL_SERVER_ERROR); assert (response.getReason() == "Internal Server Error"); assert (response.getVersion() == HTTPMessage::HTTP_1_1); assert (response.empty()); assert (istr.get() == -1); }
POCO_HttpClient_response POCO_HttpClient::POST_request(string param_uri) { _mutex.lock(); URI uri(param_uri); string path(uri.getPath()); if (path.empty()) path = "/"; string requestBody = uri.getQuery(); HTTPClientSession session(uri.getHost(), uri.getPort()); HTTPRequest request(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1); HTTPResponse response; session.setKeepAlive(true); request.setKeepAlive(true); request.setContentType("application/x-www-form-urlencoded"); request.setContentLength(requestBody.length()); string state = ""; string reason = ""; string received = ""; HTTPResponse::HTTPStatus status = HTTPResponse::HTTPStatus::HTTP_NOT_FOUND; try { session.sendRequest(request) << requestBody; std::istream& rs = session.receiveResponse(response); status = response.getStatus(); reason = response.getReason(); received = ""; string temp; while (getline(rs, temp)) { received += temp + "\n"; } state = "success"; } catch (NetException e) { state = "exception"; received = e.displayText(); } catch (...) { state = "exception"; received = "exception"; } _mutex.unlock(); return POCO_HttpClient_response(state, received, status, reason); }
void runGetID(){ try{ std::string result; URI uri("http://jsonplaceholder.typicode.com/posts/" + std::to_string(request->getPostID())); std::string path(uri.getPathAndQuery()); HTTPClientSession session(uri.getHost(), uri.getPort()); HTTPRequest request(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1); HTTPResponse response; session.sendRequest(request); std::istream& rs = session.receiveResponse(response); if (response.getStatus() == Poco::Net::HTTPResponse::HTTP_OK) { StreamCopier::copyToString(rs, result); Response *res = new Response; res->setResponseString(result); res->setReqID(reqID); res->setHTTPStatus(HTTPResponse::HTTP_OK); observer.responseQueue.enqueueNotification(new ResponseNotification(res)); { /* * Observer object can be common among multiple threads, hence the need for locking while accessing it's variables. */ FastMutex::ScopedLock lock(Observer::observerMutex); observer.setResponseAvailable(true); } } else { Response *res = new Response; res->setHTTPStatus(response.getStatus()); res->setReqID(reqID); observer.responseQueue.enqueueNotification(new ResponseNotification(res)); { FastMutex::ScopedLock lock(Observer::observerMutex); observer.setResponseAvailable(true); } } } catch(Exception& exc){ std::cerr<< exc.displayText() << std::endl; } }
void OAuthPrivate::resourceFile(const std::string method, const std::string url, const std::string & filename, const std::string status){ std::string authStr = buildAuthHeader(method, url, Params()); authStr = "OAuth " + authStr; URI uri(url); std::string path(uri.getPathAndQuery()); if (path.empty()) path = "/"; const Poco::Net::Context::Ptr context( new Poco::Net::Context(Poco::Net::Context::CLIENT_USE, "", "", "cacert.pem")); HTTPSClientSession session(uri.getHost(), uri.getPort(), context); HTTPRequest request(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1); HTTPResponse response; Poco::Net::HTMLForm form; form.setEncoding(Poco::Net::HTMLForm::ENCODING_MULTIPART); form.set("status", status); form.addPart("media[]", new Poco::Net::FilePartSource(filename, filename, "application/octet-stream")); form.prepareSubmit(request); request.set("Authorization", authStr); std::ostream & ostr = session.sendRequest(request); form.write(ostr); std::istream& rs = session.receiveResponse(response); std::cout << response.getStatus() << " " << response.getReason() << std::endl; if (response.getStatus() != Poco::Net::HTTPResponse::HTTP_UNAUTHORIZED) { StreamCopier::copyStream(rs, std::cout); } else { Poco::NullOutputStream null; StreamCopier::copyStream(rs, null); } }
void HTTPResponseTest::testRead3() { std::string s("HTTP/1.1 200 \r\nContent-Length: 0\r\n\r\n"); std::istringstream istr(s); HTTPResponse response; response.read(istr); assert (response.getVersion() == HTTPMessage::HTTP_1_1); assert (response.getStatus() == HTTPResponse::HTTP_OK); assert (response.getReason() == ""); assert (response.size() == 1); assert (response.getContentLength() == 0); assert (istr.get() == -1); }
shared_ptr<PutObjectResult> GalaxyFDSClient::putObject(const string& bucketName, const string& objectName, istream& is, const FDSObjectMetadata& metadata) { PutObjectResult res; string mediaType = "application/octet-stream"; map<string, string>::const_iterator iter = metadata.metadata().find( Constants::CONTENT_TYPE); if (iter != metadata.metadata().end()) { mediaType = iter->second; } string uri = formatUri(_pConfig->getUploadBaseUri(), bucketName + "/" + objectName, _emptySubResources); URI pocoUri(uri); shared_ptr<HTTPClientSession> pSession(_pSessionFacotry->createClientSession( pocoUri)); pSession->setHost(pocoUri.getHost()); pSession->setPort(pocoUri.getPort()); HTTPRequest request(HTTPRequest::HTTP_PUT, uri, HTTPMessage::HTTP_1_1); prepareRequestHeaders(uri, HTTPRequest::HTTP_PUT, mediaType, is, metadata, request); HTTPResponse response; ostream& os = pSession->sendRequest(request); StreamCopier::copyStream(is, os); istream& rs = pSession->receiveResponse(response); if (response.getStatus() != HTTPResponse::HTTP_OK) { stringstream msg; msg << "Put object failed, status=" << response.getStatus() << ", reason="; StreamCopier::copyStream(rs, msg); throw GalaxyFDSClientException(response.getStatus(), msg.str()); } return PutObjectResult::deserialize(rs); }
BOOL SendRequest(std::string addUri) { URI uri(addUri); auto path(uri.getPathAndQuery()); HTTPClientSession session(uri.getHost(), uri.getPort()); HTTPRequest request(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1); HTTPResponse response; session.sendRequest(request); session.receiveResponse(response); return (response.getStatus() == HTTPResponse::HTTP_OK) ? TRUE : FALSE; }
void HTTPResponseTest::testRead2() { std::string s("HTTP/1.0 301 Moved Permanently\r\nLocation: http://www.appinf.com/index.html\r\nServer: Poco/1.0\r\n\r\n"); std::istringstream istr(s); HTTPResponse response; response.read(istr); assert (response.getStatus() == HTTPResponse::HTTP_MOVED_PERMANENTLY); assert (response.getReason() == "Moved Permanently"); assert (response.getVersion() == HTTPMessage::HTTP_1_0); assert (response.size() == 2); assert (response["Location"] == "http://www.appinf.com/index.html"); assert (response["Server"] == "Poco/1.0"); assert (istr.get() == -1); }
shared_ptr<FDSObjectListing> GalaxyFDSClient::listNextBatchOfObjects(const FDSObjectListing& previousObjectListing) { string bucketName = previousObjectListing.bucketName(); string prefix = previousObjectListing.prefix(); string delimiter = previousObjectListing.delimiter(); string marker = previousObjectListing.nextMarker(); int maxKeys = previousObjectListing.maxKeys(); string uri = formatUri(_pConfig->getBaseUri(), bucketName, _emptySubResources); stringstream ss; ss << uri << "?prefix=" << prefix << "&delimiter=" << delimiter; ss << "&marker=" << marker << "&maxKeys=" << maxKeys; uri = ss.str(); URI pocoUri(uri); shared_ptr<HTTPClientSession> pSession(_pSessionFacotry ->createClientSession(pocoUri)); pSession->setHost(pocoUri.getHost()); pSession->setPort(pocoUri.getPort()); HTTPRequest request(HTTPRequest::HTTP_GET, uri, HTTPMessage::HTTP_1_1); prepareRequestHeaders(uri, HTTPRequest::HTTP_GET, "", _emptyStream, *_pEmptyMetadata, request); HTTPResponse response; ostream& os = pSession->sendRequest(request); istream& rs = pSession->receiveResponse(response); if (response.getStatus() != HTTPResponse::HTTP_OK) { stringstream msg; msg << "List objects failed, status=" << response.getStatus() << ", reason="; StreamCopier::copyStream(rs, msg); throw GalaxyFDSClientException(response.getStatus(), msg.str()); } return FDSObjectListing::deserialize(rs); }
std::string doGet(int id){ std::string result; URI uri("http://jsonplaceholder.typicode.com/posts/" + std::to_string(id)); std::string path(uri.getPathAndQuery()); HTTPClientSession session(uri.getHost(), uri.getPort()); HTTPRequest request(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1); HTTPResponse response; session.sendRequest(request); std::istream& rs = session.receiveResponse(response); if(response.getStatus() == Poco::Net::HTTPResponse::HTTP_OK){ StreamCopier::copyToString(rs, result); return result; } else return ""; }
TestResult testIncorrectPassword() { HTTPResponse response; std::string path(_uri.getPathAndQuery()); HTTPRequest request(HTTPRequest::HTTP_GET, path); std::unique_ptr<HTTPClientSession> session(helpers::createSession(_uri)); session->sendRequest(request); session->receiveResponse(response); TestResult res = TestResult::TEST_FAILED; if (response.getStatus() == HTTPResponse::HTTP_UNAUTHORIZED) res = TestResult::TEST_OK; Log::info(std::string("testIncorrectPassword: "******"OK" : "FAIL")); return res; }
StreamSocket HTTPClientSession::proxyConnect() { HTTPClientSession proxySession(getProxyHost(), getProxyPort()); proxySession.setTimeout(getTimeout()); SocketAddress targetAddress(getHost(), getPort()); HTTPRequest proxyRequest(HTTPRequest::HTTP_CONNECT, targetAddress.toString(), HTTPMessage::HTTP_1_1); HTTPResponse proxyResponse; proxyRequest.set("Proxy-Connection", "keep-alive"); proxyRequest.set("Host", getHost()); proxyAuthenticateImpl(proxyRequest); proxySession.setKeepAlive(true); proxySession.sendRequest(proxyRequest); proxySession.receiveResponse(proxyResponse); if (proxyResponse.getStatus() != HTTPResponse::HTTP_OK) throw HTTPException("Cannot establish proxy connection", proxyResponse.getReason()); return proxySession.detachSocket(); }