char* getRawBlock(int socketFd, int blockHeight)
{
/* Send a request */
char* msg = constructGetBlockHashJSONMsg(blockHeight);
char* req = buildRequest(msg,host,username,password,0);
if (msg!=NULL) free(msg);
/*printf("Sending message : \n%s\n",req);*/
sendMessage(socketFd,req);
/* Receive the response's body */
char* bodyStr = receiveResponse(socketFd);
free(req); /* Clean up */
/* process response */
char* blockHash = extractResultStringFromJSON(bodyStr);
/*printf("Response: \n%s\n",blockHash);*/
if (blockHash==NULL) return NULL;
/* Send a request */
msg = constructGetBlockJSONMsg(blockHash);
if (blockHash!=NULL) free(blockHash);
req = buildRequest(msg,host,username,password,0);
if (msg!=NULL) free(msg);
/*printf("Sending message : \n%s\n",req);*/
sendMessage(socketFd,req);
/* Receive the response's body */
bodyStr = receiveResponse(socketFd);
free(req); /* Clean up */
/* process response */
char* rawBlock = extractResultStringFromJSON(bodyStr);
return rawBlock;
}
void GrooveRequest::post()
{
QString cacheKey = generateCacheKey();
if (cacheKey.length()) {
qDebug() << Q_FUNC_INFO << "Possibly cached request";
QString cachePath = QDesktopServices::storageLocation(QDesktopServices::CacheLocation) + "/libgroove/cache/api/" + cacheKey;
QFile cacheFile(cachePath);
if (cacheFile.open(QIODevice::ReadOnly)) {
qDebug() << Q_FUNC_INFO << "Definitely cached request";
QByteArray response = cacheFile.readAll();
processData(response);
return;
}
}
m_request.setHeader(m_request.ContentTypeHeader, "application/json");
QJson::Serializer serializer;
qDebug() << Q_FUNC_INFO << "Posting to: " << m_request.url();
qDebug() << Q_FUNC_INFO << serializer.serialize(buildRequest());
QNetworkReply *reply = m_client->networkManager()->post(m_request, serializer.serialize(buildRequest()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), SIGNAL(error(QNetworkReply::NetworkError)));
connect(reply, SIGNAL(finished()), SLOT(onFinished()));
}
std::string HTTPSimple::POST(std::string url, std::string &data)
{
splitUrlIntoPageHost(url);
std::string response = buildRequest(std::string("POST"), data);
send(response);
http_code = parseResponse(response);
return response;
}
void OAuthPrivate::accessToken(const QString & url, const QString & verifier){
QNetworkRequest request = buildRequest("POST", url, buildAuthHeader("POST", url, Params(), verifier)).first;
request.setAttribute(QNetworkRequest::User, AccessToken);
QNetworkReply * reply = nam->post(request, QByteArray());
reply->setSslConfiguration(* config);
connect(reply, SIGNAL(finished()), SLOT(reply()));
}
std::string HTTPSimple::GET(std::string url)
{
splitUrlIntoPageHost(url);
std::string data = "";
data = buildRequest(std::string("GET"), data);
send(data);
http_code = parseResponse(data);
return data;
}
/** Delete Key from Bucket Request
**
* Request
* Send the name of the bucket (1), the key name (2), and the num replicas that should confirm deletion (3)
*
* Response
* riak sends Message Code, Only, as confirmation
*/
char *deleteKey(char *key, char *bucket, uint32_t replicas) {
RpbDelReq pb_msg;
pb_msg.set_bucket(bucket);
pb_msg.set_key(key);
if(replicas) pb_msg.set_rw(replicas);
return buildRequest(&pb_msg, MC_DEL_REQUEST);
}
/* Request
* @todo Describe the request
*/
char *req_setClientId(char *client_id, size_t client_id_len) {
if(client_id == NULL) {
return(NULL);
}
RpbSetClientIdReq pb_msg;
pb_msg.set_client_id((void *)client_id, client_id_len);
return buildRequest(&pb_msg, MC_SET_CLIENT_ID_REQUEST);
}
void BullBenchThread::run() {
int succ = 0;
for (;;) {
pthread_mutex_lock(&_settings.mutex);
if (succ > 0) _settings.totalSendSucc ++;
if (succ < 0) _settings.totalSendFail ++;
if (succ > 0 && _settings.totalSendSucc % 1000 == 0) {
uint64_t time = _settings.getTimeCost();
std::cout<<"send request url succ count:" << _settings.totalSendSucc
<<"\tfail count:" << _settings.totalSendFail
<<"\ttime cost: " << time / 1000000 <<" seconds, "
<< time % 1000000 << " microseconds" <<std::endl;
}
succ = 0;
if (_requestQueue.empty()) {
if (_settings.stop) {
pthread_mutex_unlock(&_settings.mutex);
exit(NULL);
}
pthread_cond_broadcast(&_settings.emptyCond);
pthread_cond_wait(&_settings.fullCond, &_settings.mutex);
pthread_mutex_unlock(&_settings.mutex);
continue;
}
std::string url = _requestQueue.front();
_requestQueue.pop();
pthread_mutex_unlock(&_settings.mutex);
char request[REQUEST_SIZE];
buildRequest(request, url);
int rlen = strlen(request);
int sock = _getSocket();
if (sock < 0) {
std::cerr << "Error: sock fail :"
<< _settings.domainName << ':' << _settings.port << std::endl;
succ = -1;
continue;
}
if(rlen!=write(sock,request,rlen)) {
close(sock);
std::cerr<<"Error: write fail :" << std::endl;
succ = -1;
continue;
}
// Read all
char response[8192];
while (read(sock,response,8192) > 0) {
// do nothing;
}
close(sock);
succ = 1;
} // end for
}
ServiceStateMachine::State ServiceStateMachineFixture::runPingTest() {
_tl->setNextMessage(buildRequest(BSON("ping" << 1)));
ASSERT_FALSE(haveClient());
ASSERT_EQ(_ssm->state(), ServiceStateMachine::State::Created);
log() << "run next";
_ssm->runNext();
auto ret = _ssm->state();
ASSERT_FALSE(haveClient());
return ret;
}
/** Get Key from Bucket Request
**
* Request
* Send the name of the bucket (1), the key (2), and the quorum (3)
*
* Response
* riak sends two values: the bucket+key's vclock (1) and content(s) on the key (2)
*/
char *req_getKey(char *key, char *bucket, uint32_t quorum) {
RpbGetReq pb_msg;
pb_msg.set_bucket(bucket);
pb_msg.set_key(key);
if(quorum) {
pb_msg.set_r(quorum);
}
return buildRequest(&pb_msg, MC_GET_REQUEST);
}
void RequestPrivate::followRedirect(const QUrl &redirect) {
Q_Q(Request);
redirects++;
if (reply) {
delete reply;
}
reply = networkAccessManager()->get(buildRequest(redirect));
Request::connect(reply, SIGNAL(finished()), q, SLOT(_q_onReplyFinished()));
}
/** Put Key in Bucket Request
**
* Request
* Send the name of the bucket (1), the key (2), the key's content (3), the quorum (4), and the commits-before-ack (5)
*
* Response
* riak sends either the message code or (optionally) two values: the bucket+key's vclock (1) and content(s) on the key (2)
*/
char *putKey(char *key, char *bucket, char *v_clock, _content *content, uint32_t quorum, uint32_t commit, bool return_body) {
RpbPutReq pb_msg;
pb_msg.set_bucket(bucket);
pb_msg.set_key(key);
if(commit) pb_msg.set_dw(commit);
if(quorum) pb_msg.set_w(quorum);
if(v_clock) pb_msg.set_vclock(v_clock);
packContent(pb_msg.mutable_content(), content);
return buildRequest(&pb_msg, MC_PUT_REQUEST);
}
bool HttpRequest::send()
{
mError = "";
// check that TNL understands the supplied address
if(!mRemoteAddress->isValid())
{
mError = "Address invalid";
return false;
}
S32 connectError = mSocket->connect(*mRemoteAddress);
if(connectError == UnknownError)
{
mError = "Connect error";
return false;
}
if(!mSocket->isWritable(FIVE_SECONDS))
{
mError = "Socket not writable";
return false;
}
buildRequest();
if(!sendRequest(mRequest))
{
mError = "Can't send request";
return false;
}
string response = receiveResponse();
if(response == "")
{
mError = "No response";
return false;
}
parseResponse(response);
if(getResponseCode() == 0)
{
mError = "Invalid response code";
return false;
}
return true;
}
QString GrooveRequest::generateCacheKey() const
{
QVariantMap request = buildRequest();
bool hasKey = false;
QCryptographicHash crypter(QCryptographicHash::Sha1);
if (m_method == QLatin1String("getSearchResults")) {
// hash is:
// parameters/type
// parameters/query
crypter.addData(request["parameters"].toMap()["type"].toByteArray());
crypter.addData(request["parameters"].toMap()["query"].toByteArray());
qDebug() << Q_FUNC_INFO << "Search cache key: " << crypter.result().toHex();
hasKey = true;
}
if (!hasKey)
return QString();
return crypter.result().toHex();
}
void OAuthPrivate::resource(const QString &url, const QString &method, const Params ¶ms, const QByteArray &rawParams)
{
qDebug() << "header";
QPair<QNetworkRequest, QString> r = buildRequest(method, url, buildAuthHeader(method, url, params), params);
QNetworkRequest request = r.first;
request.setAttribute(QNetworkRequest::User, Resource);
oauthReply = 0;
if(method.toUpper() == "POST"){
if(rawParams.length()){
if(rawParams.contains("Content-Disposition")){
request.setRawHeader(QString("Content-Type").toAscii(),QString("multipart/form-data; boundary=" + multipartBound).toAscii());
}
request.setRawHeader(QString("Content-Length").toAscii(), QString::number(rawParams.length()).toAscii());
oauthReply = nam->post(request, rawParams);
}else{
oauthReply = nam->post(request, r.second.toAscii());
}
}else if(method.toUpper() == "PUT"){
oauthReply = nam->put(request, r.second.toAscii());
}else if(method.toUpper() == "DELETE"){
oauthReply = nam->deleteResource(request);
}else{
oauthReply = nam->get(request);
}
if(oauthReply){
oauthReply->setSslConfiguration(* config);
connect(oauthReply, SIGNAL(finished()), SLOT(reply()));
}
}
QNetworkReply* QRestClient::call(
QByteArray method,
QByteArray uri,
QByteArray body,
ContentType cType)
{
#ifdef QRESTCLIENT_DEBUG
qDebug() << __PRETTY_FUNCTION__ << method << uri << body;
#endif
QNetworkRequest req = buildRequest(QUrl(m_rootUrl + uri), cType);
QNetworkReply *rep = nullptr;
if (method == "get") {
rep = m_qnam->get(req);
}else if (method == "post") {
rep = m_qnam->post(req, body);
}else if (method == "put") {
rep = m_qnam->put(req, body);
}else if (method == "delete") {
rep = m_qnam->deleteResource(req);
}
return rep;
}
QNetworkReply* NetworkAccess::simpleGet(QUrl url, int operation) {
return manualGet(buildRequest(url), operation);
}
void PushBullet::sendLinkPush(const String message, const String title, const String url){
String req = buildRequest("/v2/pushes", "{\"body\":\""+message+"\",\"title\":\""+title+"\",\"url\":\""+url+"\",\"type\":\"link\"}");
sendRequest(req);
}
void PushBullet::sendNotePush(const String message, const String title){
String req = buildRequest("/v2/pushes", "{\"body\":\""+message+"\",\"title\":\""+title+"\",\"type\":\"note\"}");
sendRequest(req);
}
void PushBullet::copyToClipboard(const String contents, const String source_device, const String source_user){
String req = buildRequest("/v2/ephemerals", "{\"push\":{\"body\":\""+contents+"\",\"source_device_iden\":\""+source_device+"\",\"source_user_iden\":\""+source_user+"\",\"type\":\"clip\"},\"type\":\"push\"}");
sendRequest(req);
}
void PushBullet::sendSMSPush(const String message, const String phoneNumber, const String source_device, const String source_user){
String req = buildRequest("/v2/ephemerals", "{ \"push\": { \"conversation_iden\": \""+phoneNumber+"\", \"message\": \""+message+"\", \"package_name\": \"com.pushbullet.android\", \"source_user_iden\": \""+source_user+"\", \"target_device_iden\": \""+source_device+"\", \"type\": \"messaging_extension_reply\" }, \"type\": \"push\"} ");
sendRequest(req);
}
std::string HTTPSimple::POSTrequest(std::string url, std::string &data, bool keep_alive)
{
splitUrlIntoPageHost(url);
return buildRequest(std::string("POST"), data, keep_alive);
}
QNetworkRequest RequestPrivate::buildRequest(bool authRequired) {
return buildRequest(url, authRequired);
}
std::string HTTPSimple::GETrequest(std::string url, bool keep_alive)
{
splitUrlIntoPageHost(url);
std::string data = "";
return buildRequest(std::string("GET"), data, keep_alive);
}
int main(int argc, char * argv[]) {
int opt = 0;
int options_index = 0;
char * tmp = NULL;
if (argc == 1) {
usage();
return 2;
}
while((opt = getopt_long(argc, argv, "912Vfrt:p:c:?h", long_options, &options_index)) != EOF ) {
switch(opt) {
case 0 :
break;
case 'f':
force = 1;
break; // don't wait reply
case 'r':
forceReload = 1;
break; // no-cache
case '9':
http10 = 0;
break;
case '1':
http10 = 1;
break;
case '2':
http10 = 2;
break;
case 'V':
printf("%s\n", WEBBENCH_VERSION);
exit(0);
case 't':
benchtime = atoi(optarg);
break;
case 'p': {
/* proxy server parsing server:port */
tmp = strrchr(optarg, ':');
proxyHost = optarg;
if (tmp == NULL) {
break;
}
if (tmp == optarg) { // head - ":80"
fprintf(stderr, "Error in option --proxy %s: Missing hostname.\n", optarg);
return 2;
}
if (tmp == optarg + strlen(optarg) - 1) { // end - "127.0.0.1:"
fprintf(stderr,"Error in option --proxy %s: Port number is missing.\n",optarg);
return 2;
}
* tmp = '\0';
proxyPort = atoi(tmp + 1);
break;
} // case 'p', proxy
case ':':
case 'h':
case '?':
usage();
return 2;
break;
case 'c':
clients = atoi(optarg);
break;
}
}
// optind -> "Index in argv of the next element to be scanned."<getopt.h>
// x -> optind += 1 #1
// x: -> optarg = argv[optind + 1], optind += 2 #2
// x:: -> #1 || #2
if (optind == argc) {
fprintf(stderr, "webbench: Missing URL!\n");
usage();
return 2;
}
if (clients == 0) {
clients = 1;
}
if (benchtime == 0) {
benchtime = 60;
}
/* Copyright */
fprintf(stderr,
"Webbench - Simple Web Benchmark %s\n"
"Copyright (c) Radim Kolar 1997-2004, GPL Open Source Software.\n",
WEBBENCH_VERSION);
buildRequest(argv[optind]);
/* print bench info */
printf("\nBenchmarking: ");
switch(method) {
default:
case METHOD_GET:
printf("GET");
break;
case METHOD_OPTIONS:
printf("OPTIONS");
break;
case METHOD_HEAD:
printf("HEAD");
break;
case METHOD_TRACE:
printf("TRACE");
break;
}
printf(" %s", argv[optind]); // argv[optind] -> url
switch(http10) {
case 0:
printf(" (using HTTP/0.9)");
break;
case 1:
printf(" (using HTTP/1.0)");
break;
case 2:
printf(" (using HTTP/1.1)");
break;
}
printf("\n");
if (clients == 1) {
printf("1 client");
} else {
printf("%d clients", clients);
}
printf(", running %d sec", benchtime);
if (force) {
printf(", early socket close");
}
if (proxyHost != NULL) {
printf(", via proxy server %s:%d", proxyHost, proxyPort);
}
if (forceReload) {
printf(", forcing reload");
}
printf(".\n");
return bench();
}
HttpRequest::HttpRequest(const std::string &req)
{
buildRequest(req);
}
