HttpClient::HttpClient(const std::string& url) throw(JsonRpcException) : AbstractClientConnector(), url(url) { curl = curl_easy_init(); if (!curl) { throw JsonRpcException(Errors::ERROR_CLIENT_CONNECTOR, ": libcurl initialization error"); } curl_easy_setopt(curl, CURLOPT_URL, this->url.c_str()); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writefunc); }
void SocketServer::CreateSocket() throw (JsonRpcException) { int yes = 1; socket_ = socket(host_info_->ai_family, host_info_->ai_socktype, host_info_->ai_protocol); CHECK_SOCKET(socket_); CHECK_STATUS(setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes))); CHECK_STATUS(bind(socket_, host_info_->ai_addr, host_info_->ai_addrlen)); CHECK_STATUS(listen(socket_, poolSize_)); return; error: CloseSocket(); throw JsonRpcException(Errors::ERROR_SERVER_CONNECTOR); }
Json::Value SynchronousCallback::invoke ( JsonRpc * jsonRpc , std::string const & methodName , Json::Value const & params ) { SynchronousCallback callback; // Acquire the mutex. This ensures the response thread is // blocked until this thread has had a chance to start waiting // for a response QMutexLocker locker (& callback.m_mutex); // Send the request jsonRpc->invoke (methodName, params, & callback); // Start waiting for a response Json::Value const response (callback.wait ()); // Handle the response if (isErrorResponse (response)) { Json::Value const error (response["error"]); int const code (error["code"].asInt ()); std::string const message (error["message"].asString ()); Json::Value const data (error["data"]); fprintf(stderr, "Error invoking \"%s\"\n" "This may indicate mismatched " "Conveyor and MakerWare versions,\n" "check your Conveyor and MakerWare " "logs for more information.\n\n", methodName.c_str()); throw JsonRpcException (methodName, params, code, message, data); } else if (not isSuccessResponse (response)) { throw std::runtime_error("Response is not success!"); } else { Json::Value const result (response["result"]); return result; } }
void SpecificationParser::GetFileContent(const std::string &filename, std::string& target) { ifstream config(filename.c_str()); if (config) { config.open(filename.c_str(), ios::in); target.assign((std::istreambuf_iterator<char>(config)), (std::istreambuf_iterator<char>())); } else { throw JsonRpcException(Errors::ERROR_SERVER_PROCEDURE_SPECIFICATION_NOT_FOUND, filename); } }
SocketServer::SocketServer(const std::string& port, const int type, const int pool) throw (JsonRpcException) : AbstractServerConnector(), host_info_(NULL), shutdown_(false), poolSize_(pool) { struct addrinfo hint; memset((char*)&hint, 0, sizeof(hint)); hint.ai_family = AF_INET; hint.ai_socktype = type; hint.ai_flags = AI_PASSIVE; int status = getaddrinfo(NULL, port.c_str(), &hint, &host_info_); CHECK(status); return; error: throw JsonRpcException(Errors::ERROR_SERVER_CONNECTOR); }
procedurelist_t *SpecificationParser::GetProceduresFromString(const string &content) throw(JsonRpcException) { Json::Reader reader; Json::Value val; if(!reader.parse(content,val)) { throw JsonRpcException(Errors::ERROR_RPC_JSON_PARSE_ERROR, " specification file contains syntax errors"); } procedurelist_t* procedures = new procedurelist_t(); Procedure* proc; for (unsigned int i = 0; i < val.size(); i++) { proc = GetProcedure(val[i]); (*procedures)[proc->GetProcedureName()] = proc; } return procedures; }
void HttpClient::SendMessage(const std::string& message, std::string& result) throw (JsonRpcException) { CURLcode res; struct string s; init_string(&s); struct curl_slist * headers = NULL; //Maybe to restrictive //headers = curl_slist_append(headers, "Accept: application/json"); for (std::map<std::string, std::string>::iterator header = this->headers.begin(); header != this->headers.end(); ++header) { headers = curl_slist_append(headers, (header->first + ": " + header->second).c_str()); } headers = curl_slist_append(headers, "Content-Type: application/json"); headers = curl_slist_append(headers, "charsets: utf-8"); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, message.c_str()); curl_easy_setopt(curl, CURLOPT_WRITEDATA, &s); curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); res = curl_easy_perform(curl); result = s.ptr; free(s.ptr); curl_slist_free_all(headers); if (res != CURLE_OK) { stringstream str; if(res == 7) { str << ": Could not connect to " << this->url; } else { str << ": libcurl error: " << res; } throw JsonRpcException(Errors::ERROR_CLIENT_CONNECTOR, str.str()); } }
Procedure* SpecificationParser::GetProcedure(Json::Value &signature) { procedure_t procedureType; std::string name_key; std::string procedureName; Procedure* result; if ((signature.isMember(KEY_METHOD_NAME) || signature.isMember(KEY_NOTIFICATION_NAME)) && signature.isMember(KEY_PROCEDURE_PARAMETERS)) { if (signature.isMember(KEY_METHOD_NAME)) { name_key = KEY_METHOD_NAME; procedureType = RPC_METHOD; } else { name_key = KEY_NOTIFICATION_NAME; procedureType = RPC_NOTIFICATION; } if (signature[name_key].isString() && (signature[KEY_PROCEDURE_PARAMETERS].isObject() || signature[KEY_PROCEDURE_PARAMETERS].isNull())) { procedureName = signature[name_key].asString(); vector<string> parameters = signature[KEY_PROCEDURE_PARAMETERS].getMemberNames(); if(procedureType == RPC_NOTIFICATION) { result = new Procedure(procedureName, NULL); } else { jsontype_t returntype = JSON_OBJECT; if(signature.isMember(KEY_RETURN_TYPE)) { returntype = toJsonType(signature[KEY_RETURN_TYPE]); } result = new Procedure(procedureName, returntype, NULL); } for (unsigned int i = 0; i < parameters.size(); i++) { result->AddParameter(parameters.at(i), toJsonType(signature[KEY_PROCEDURE_PARAMETERS][parameters.at(i)])); } } else { throw JsonRpcException(Errors::ERROR_SERVER_PROCEDURE_SPECIFICATION_SYNTAX, "Invalid signature types in fileds: " + signature.toStyledString()); } } else { throw JsonRpcException(Errors::ERROR_SERVER_PROCEDURE_SPECIFICATION_SYNTAX, "procedure declaration does not contain method/notification name or paramters: " + signature.toStyledString()); } return result; }