void Strategy::getMore(OperationContext* txn, Request& request) { Timer getMoreTimer; const char* ns = request.getns(); const int ntoreturn = request.d().pullInt(); const long long id = request.d().pullInt64(); // TODO: Handle stale config exceptions here from coll being dropped or sharded during op // for now has same semantics as legacy request const NamespaceString nss(ns); auto statusGetDb = grid.catalogCache()->getDatabase(txn, nss.db().toString()); if (statusGetDb == ErrorCodes::DatabaseNotFound) { cursorCache.remove(id); replyToQuery(ResultFlag_CursorNotFound, request.p(), request.m(), 0, 0, 0); return; } uassertStatusOK(statusGetDb); // Spigot which controls whether OP_QUERY style find on mongos uses the new ClusterClientCursor // code path. // // TODO: Delete the spigot and always use the new code. if (useClusterClientCursor) { boost::optional<long long> batchSize; if (ntoreturn) { batchSize = ntoreturn; } GetMoreRequest getMoreRequest(NamespaceString(ns), id, batchSize, boost::none); auto cursorResponse = ClusterFind::runGetMore(txn, getMoreRequest); if (cursorResponse == ErrorCodes::CursorNotFound) { replyToQuery(ResultFlag_CursorNotFound, request.p(), request.m(), 0, 0, 0); return; } uassertStatusOK(cursorResponse.getStatus()); // Build the response document. // // TODO: this constant should be shared between mongos and mongod, and should not be inside // ShardedClientCursor. BufBuilder buffer(ShardedClientCursor::INIT_REPLY_BUFFER_SIZE); int numResults = 0; for (const auto& obj : cursorResponse.getValue().batch) { buffer.appendBuf((void*)obj.objdata(), obj.objsize()); ++numResults; } replyToQuery(0, request.p(), request.m(), buffer.buf(), buffer.len(), numResults, cursorResponse.getValue().numReturnedSoFar.value_or(0), cursorResponse.getValue().cursorId); return; } shared_ptr<DBConfig> config = statusGetDb.getValue(); ShardPtr primary; ChunkManagerPtr info; config->getChunkManagerOrPrimary(txn, ns, info, primary); // // TODO: Cleanup cursor cache, consolidate into single codepath // const string host = cursorCache.getRef(id); ShardedClientCursorPtr cursor = cursorCache.get(id); int cursorMaxTimeMS = cursorCache.getMaxTimeMS(id); // Cursor ids should not overlap between sharded and unsharded cursors massert(17012, str::stream() << "duplicate sharded and unsharded cursor id " << id << " detected for " << ns << ", duplicated on host " << host, NULL == cursorCache.get(id).get() || host.empty()); ClientBasic* client = ClientBasic::getCurrent(); NamespaceString nsString(ns); AuthorizationSession* authSession = AuthorizationSession::get(client); Status status = authSession->checkAuthForGetMore(nsString, id, false); audit::logGetMoreAuthzCheck(client, nsString, id, status.code()); uassertStatusOK(status); if (!host.empty()) { LOG(3) << "single getmore: " << ns; // we used ScopedDbConnection because we don't get about config versions // not deleting data is handled elsewhere // and we don't want to call setShardVersion ScopedDbConnection conn(host); Message response; bool ok = conn->callRead(request.m(), response); uassert(10204, "dbgrid: getmore: error calling db", ok); bool hasMore = (response.singleData().getCursor() != 0); if (!hasMore) { cursorCache.removeRef(id); } request.reply(response, "" /*conn->getServerAddress() */); conn.done(); return; } else if (cursor) { if (cursorMaxTimeMS == kMaxTimeCursorTimeLimitExpired) { cursorCache.remove(id); uasserted(ErrorCodes::ExceededTimeLimit, "operation exceeded time limit"); } // TODO: Try to match logic of mongod, where on subsequent getMore() we pull lots more data? BufBuilder buffer(ShardedClientCursor::INIT_REPLY_BUFFER_SIZE); int docCount = 0; const int startFrom = cursor->getTotalSent(); bool hasMore = cursor->sendNextBatch(ntoreturn, buffer, docCount); if (hasMore) { // still more data cursor->accessed(); if (cursorMaxTimeMS != kMaxTimeCursorNoTimeLimit) { // Update remaining amount of time in cursor cache. int cursorLeftoverMillis = cursorMaxTimeMS - getMoreTimer.millis(); if (cursorLeftoverMillis <= 0) { cursorLeftoverMillis = kMaxTimeCursorTimeLimitExpired; } cursorCache.updateMaxTimeMS(id, cursorLeftoverMillis); } } else { // we've exhausted the cursor cursorCache.remove(id); } replyToQuery(0, request.p(), request.m(), buffer.buf(), buffer.len(), docCount, startFrom, hasMore ? cursor->getId() : 0); return; } else { LOG(3) << "could not find cursor " << id << " in cache for " << ns; replyToQuery(ResultFlag_CursorNotFound, request.p(), request.m(), 0, 0, 0); return; } }
void _update( Request& r , DbMessage& d, ChunkManagerPtr manager ){ int flags = d.pullInt(); BSONObj query = d.nextJsObj(); uassert( 10201 , "invalid update" , d.moreJSObjs() ); BSONObj toupdate = d.nextJsObj(); BSONObj chunkFinder = query; bool upsert = flags & UpdateOption_Upsert; bool multi = flags & UpdateOption_Multi; uassert( 10202 , "can't mix multi and upsert and sharding" , ! ( upsert && multi ) ); if ( upsert && !(manager->hasShardKey(toupdate) || (toupdate.firstElement().fieldName()[0] == '$' && manager->hasShardKey(query)))) { throw UserException( 8012 , "can't upsert something without shard key" ); } bool save = false; if ( ! manager->hasShardKey( query ) ){ if ( multi ){ } else if ( strcmp( query.firstElement().fieldName() , "_id" ) || query.nFields() != 1 ){ throw UserException( 8013 , "can't do non-multi update with query that doesn't have the shard key" ); } else { save = true; chunkFinder = toupdate; } } if ( ! save ){ if ( toupdate.firstElement().fieldName()[0] == '$' ){ BSONObjIterator ops(toupdate); while(ops.more()){ BSONElement op(ops.next()); if (op.type() != Object) continue; BSONObjIterator fields(op.embeddedObject()); while(fields.more()){ const string field = fields.next().fieldName(); uassert(13123, "Can't modify shard key's value", ! manager->getShardKey().partOfShardKey(field)); } } } else if ( manager->hasShardKey( toupdate ) ){ uassert( 8014, "change would move shards!", manager->getShardKey().compare( query , toupdate ) == 0 ); } else { uasserted(12376, "shard key must be in update object"); } } if ( multi ){ set<Shard> shards; manager->getShardsForQuery( shards , chunkFinder ); int * x = (int*)(r.d().afterNS()); x[0] |= UpdateOption_Broadcast; for ( set<Shard>::iterator i=shards.begin(); i!=shards.end(); i++){ doWrite( dbUpdate , r , *i , false ); } } else { int left = 5; while ( true ){ try { ChunkPtr c = manager->findChunk( chunkFinder ); doWrite( dbUpdate , r , c->getShard() ); c->splitIfShould( d.msg().header()->dataLen() ); break; } catch ( StaleConfigException& e ){ if ( left <= 0 ) throw e; left--; log() << "update failed b/c of StaleConfigException, retrying " << " left:" << left << " ns: " << r.getns() << " query: " << query << endl; r.reset( false ); manager = r.getChunkManager(); } } } }
int TcpClient::requestData(const int nSeq, const int nMsgId, const string& arg, NetworkProxy *pData) { TopMessage msgrep; msgrep.set_protocol_version("1.0"); msgrep.set_msg_type(REQUEST); msgrep.set_sub_msg_type(POST); msgrep.set_session_id(G.m_strSessionID); msgrep.set_seq(nSeq); msgrep.set_host(m_strIP); msgrep.set_user_name(G.m_strUserName); msgrep.set_version((float)NT_VERSION); Request req; req.set_domid(G.m_nDomID); req.set_msgid(nMsgId); req.set_arg(arg); int datalen = req.ByteSize(); char *buf = new char[datalen]; autoptr_arr<char> arrguard1(buf); if (!req.SerializeToArray(buf, datalen)) { //closeAndReConn(); return 1; } msgrep.set_data(buf, datalen); datalen = msgrep.ByteSize(); int headlen = CodedOutputStream::VarintSize32(datalen); char *databuf = new char[datalen]; autoptr_arr<char> arrguard(databuf); if (!msgrep.SerializeToArray(databuf, datalen)) { //closeAndReConn(); return 1; } //char *tmpArr = new char[datalen+headlen]; //autoptr_arr<char> arrguard2(tmpArr); lock_guard<mutex> lg(m_writeMutex); if (m_writeData.expand(datalen+headlen)) { ZeroCopyOutputStream* raw_output = new ArrayOutputStream(m_writeData.getBuf() + m_writeData.getPos(), datalen+headlen); CodedOutputStream* coded_output = new CodedOutputStream(raw_output); coded_output->WriteVarint32(datalen); coded_output->WriteRaw(databuf, datalen); m_writeData.setPos(m_writeData.getPos() + (datalen+headlen)); ReserveData *pReserveData = new ReserveData; pReserveData->pNetworkProxy = pData; pReserveData->nReqID = nMsgId; G.m_mapReserveData.insert(map<int, ReserveData*>::value_type(nSeq, pReserveData)); G.m_setReqSource.insert(pData); m_writeCv.notify_one(); delete coded_output; delete raw_output; } return 0; }
void ZatData::loadChannels() { Json::Value favs = loadFavourites(); ostringstream urlStream; urlStream << "zattoo.com/zapi/v2/cached/channels/" << powerHash << "?details=False"; HTTPSocketRaw *socket = new HTTPSocketRaw(); Request request; request.url = urlStream.str(); request.AddHeader("Cookie", cookie); Response response; socket->Execute(request, response); cookie = response.cookie; std::string jsonString = response.body; Json::Value json; Json::Reader reader; if (!reader.parse(jsonString,json)){ // report to the user the failure and their locations in the document. std::cout << "Failed to parse configuration\n" << reader.getFormatedErrorMessages(); return; } channelNumber = 1; Json::Value groups = json["channel_groups"]; PVRZattooChannelGroup favGroup; favGroup.name = "Favoriten"; //Load the channel groups and channels for ( int index = 0; index < groups.size(); ++index ) { PVRZattooChannelGroup group; group.name = groups[index]["name"].asString(); Json::Value channels = groups[index]["channels"]; for(int i = 0; i < channels.size(); ++i) { Json::Value qualities = channels[i]["qualities"]; for(int q = 0; q < qualities.size(); ++q) { if(qualities[q]["availability"].asString() == "available") { ZatChannel channel; channel.name = qualities[q]["title"].asString(); channel.strStreamURL = ""; //cout << channel.name << endl; std::string cid = channels[i]["cid"].asString(); //returns std::size_t channel.iUniqueId = GetChannelId(cid.c_str()); channel.cid = cid; channel.iChannelNumber = ++channelNumber; channel.strLogoPath = "http://logos.zattic.com"; channel.strLogoPath.append(qualities[q]["logo_white_84"].asString()); group.channels.insert(group.channels.end(), channel); //Yeah thats bad performance for (int fav = 0; fav < favs.size(); fav++) { if (favs[fav].asString() == cid) { favGroup.channels.insert(favGroup.channels.end(), channel); } } break; } } } if (group.channels.size() > 0) channelGroups.insert(channelGroups.end(),group); } if (favGroup.channels.size() > 0) channelGroups.insert(channelGroups.end(),favGroup); }
void Dispatcher::handleRequestReceived(const JoynrMessage& message) { std::string senderId = message.getHeaderFrom(); std::string receiverId = message.getHeaderTo(); // json request // lookup necessary data std::string jsonRequest = message.getPayload(); std::shared_ptr<RequestCaller> caller = requestCallerDirectory.lookup(receiverId); if (caller == nullptr) { JOYNR_LOG_ERROR( logger, "caller not found in the RequestCallerDirectory for receiverId {}, ignoring", receiverId); return; } std::string interfaceName = caller->getInterfaceName(); // Get the request interpreter that has been registered with this interface name std::shared_ptr<IRequestInterpreter> requestInterpreter = InterfaceRegistrar::instance().getRequestInterpreter(interfaceName); // deserialize json try { Request request = JsonSerializer::deserialize<Request>(jsonRequest); std::string requestReplyId = request.getRequestReplyId(); JoynrTimePoint requestExpiryDate = message.getHeaderExpiryDate(); std::function<void(std::vector<Variant>)> onSuccess = [requestReplyId, requestExpiryDate, this, senderId, receiverId]( std::vector<Variant> returnValueVar) { Reply reply; reply.setRequestReplyId(requestReplyId); reply.setResponse(std::move(returnValueVar)); // send reply back to the original sender (ie. sender and receiver ids are reversed // on // purpose) JOYNR_LOG_DEBUG(logger, "Got reply from RequestInterpreter for requestReplyId {}", requestReplyId); JoynrTimePoint now = std::chrono::time_point_cast<std::chrono::milliseconds>( std::chrono::system_clock::now()); std::int64_t ttl = std::chrono::duration_cast<std::chrono::milliseconds>( requestExpiryDate - now).count(); messageSender->sendReply(receiverId, // receiver of the request is sender of reply senderId, // sender of request is receiver of reply MessagingQos(ttl), reply); }; std::function<void(const exceptions::JoynrException&)> onError = [requestReplyId, requestExpiryDate, this, senderId, receiverId]( const exceptions::JoynrException& exception) { Reply reply; reply.setRequestReplyId(requestReplyId); reply.setError(joynr::exceptions::JoynrExceptionUtil::createVariant(exception)); JOYNR_LOG_DEBUG(logger, "Got error reply from RequestInterpreter for requestReplyId {}", requestReplyId); JoynrTimePoint now = std::chrono::time_point_cast<std::chrono::milliseconds>( std::chrono::system_clock::now()); std::int64_t ttl = std::chrono::duration_cast<std::chrono::milliseconds>( requestExpiryDate - now).count(); messageSender->sendReply(receiverId, // receiver of the request is sender of reply senderId, // sender of request is receiver of reply MessagingQos(ttl), reply); }; // execute request requestInterpreter->execute(caller, request.getMethodName(), request.getParams(), request.getParamDatatypes(), onSuccess, onError); } catch (const std::invalid_argument& e) { JOYNR_LOG_ERROR(logger, "Unable to deserialize request object from: {} - error: {}", jsonRequest, e.what()); return; } }
static size_t GotHeaderStatic( void *ptr, size_t size, size_t nmemb, void *userdata) { Request *mem = (Request *)userdata; return mem->GotHeader((const char *)ptr,size*nmemb); }
onion_connection_status StaticHandler::operator()(Request &req, Response &res) { return onion_shortcut_response_file((path+req.path()).c_str(), req.c_handler(), res.c_handler()); }
void CIwHTTPQueue::Update() { if (m_Request.size()) { if (g_GotResult) { m_HTTP.Cancel(); g_GotResult = false; Request request = m_Request[0]; m_Request.erase(0); if (g_Result) { // Call the requests callback with the received data if (request.Callback) { request.Callback(request.pArgument, (const char*)g_szContentType, g_Result, g_ResultLen); } // Free result s3eFree(g_Result); g_szContentType[0] = 0; g_Result = 0; } else { if (request.CallbackError) { request.CallbackError(request.pArgument); } } delete[] (char*)request.pURL; // Begin fetching the next request if (m_Request.size()) { if (m_Request[0].Callback) { if (m_Request[0].usePost) { m_timeout = m_Request[0].timeout; m_requestStart = s3eTimerGetMs(); m_HTTP.Post(m_Request[0].pURL, m_Request[0].szBuffer, m_Request[0].bufferLen, GotHeaders, NULL); } else { m_timeout = m_Request[0].timeout; m_requestStart = s3eTimerGetMs(); m_HTTP.Get(m_Request[0].pURL, GotHeaders, NULL); } } else { g_GotResult = true; } } } else { uint64 now = s3eTimerGetMs(); if (m_Request[0].timeout != -1 && (now - m_requestStart) > m_Request[0].timeout) { m_Request[0].timeout = -1; g_GotResult = true; m_HTTP.Cancel(); s3eDeviceYield(0); } } } }
int PamBackend::converse(int n, const struct pam_message **msg, struct pam_response **resp) { qDebug() << "[PAM] Conversation with" << n << "messages"; bool newRequest = false; if (n <= 0 || n > PAM_MAX_NUM_MSG) return PAM_CONV_ERR; for (int i = 0; i < n; i++) { switch(msg[i]->msg_style) { case PAM_PROMPT_ECHO_OFF: case PAM_PROMPT_ECHO_ON: newRequest = m_data->insertPrompt(msg[i], n == 1); break; case PAM_ERROR_MSG: m_app->error(QString::fromLocal8Bit(msg[i]->msg), Auth::ERROR_AUTHENTICATION); break; case PAM_TEXT_INFO: // if there's only the info message, let's predict the prompts too m_app->info(QString::fromLocal8Bit(msg[i]->msg), m_data->handleInfo(msg[i], n == 1)); break; default: break; } } if (newRequest) { Request sent = m_data->getRequest(); Request received; if (sent.valid()) { received = m_app->request(sent); if (!received.valid()) return PAM_CONV_ERR; m_data->completeRequest(received); } } *resp = (struct pam_response *) calloc(n, sizeof(struct pam_response)); if (!*resp) { return PAM_BUF_ERR; } for (int i = 0; i < n; i++) { QByteArray response = m_data->getResponse(msg[i]); resp[i]->resp = (char *) malloc(response.length() + 1); // on error, get rid of everything if (!resp[i]->resp) { for (int j = 0; j < n; j++) { free(resp[i]->resp); resp[i]->resp = nullptr; } free(*resp); *resp = nullptr; return PAM_BUF_ERR; } memcpy(resp[i]->resp, response.constData(), response.length()); resp[i]->resp[response.length()] = '\0'; } return PAM_SUCCESS; }
bool HttpClient::init(HTTPRequest *ptHttpRequest,Request &request,ExecutionContent &executionContent) { bool rtn = false; ptHttpRequest->delegate = this; ptHttpRequest->timeOutSeconds = _clientConfiguration.connectionTimeout; ptHttpRequest->userAgent = _clientConfiguration.userAgent; if ( !_clientConfiguration.proxyHost.empty() && _clientConfiguration.proxyPort > 0) { ptHttpRequest->proxyHost = _clientConfiguration.proxyHost; ptHttpRequest->proxyPort = _clientConfiguration.proxyPort; ptHttpRequest->proxyUserName = _clientConfiguration.proxyUserName; ptHttpRequest->proxyPassword = _clientConfiguration.proxyPassword; ptHttpRequest->proxyDomain = _clientConfiguration.proxyWorkstation; } ptHttpRequest->requestMethod = request.method; switch (request.method) { case HttpMethod_GET: { } break; case HttpMethod_PUT: { ptHttpRequest->addPostData(request.getContent(),request.getContentLength()); } break; case HttpMethod_POST: { ptHttpRequest->addPostData(request.getContent(),request.getContentLength()); } break; case HttpMethod_HEAD: { } break; case HttpMethod_DELETE: { } break; default: break; } map<string,string> dictHeaders = request.getHeaders(); map < string, string >::iterator iter=dictHeaders.begin(); for (iter = dictHeaders.begin(); iter != dictHeaders.end(); iter++ ) { string key = iter->first; string value = iter->second; // std::transform(key.begin(), key.end(), key.begin(), ::tolower); if(key.compare("Content-Length")==0 ||key.compare("Host")==0) { continue; } ptHttpRequest->addRequestHeader(key,value); } iter= dictHeaders.find("Content-Type"); if(iter == dictHeaders.end()) { ptHttpRequest->addRequestHeader("Content-Type",""); } rtn = true; iter = request.userInfo.find("method"); if(iter != request.userInfo.end()) { if(iter->second.compare("FetchObject") == 0) { map < string, string >::iterator iter2 = request.userInfo.find("path"); if(iter2 != request.userInfo.end()) { rtn = ptHttpRequest->SetReciveFile(iter2->second); } } } return rtn ; }
virtual std::shared_ptr<Response> handle( const CrackedUri &/*uri*/, const Request &request) override { return make_shared<AsyncResponse>(request.server()); }
void Ndbfs::execFSAPPENDREQ(Signal * signal) { const FsAppendReq * const fsReq = (FsAppendReq *)&signal->theData[0]; const Uint16 filePointer = (Uint16)fsReq->filePointer; const UintR userPointer = fsReq->userPointer; const BlockReference userRef = fsReq->userReference; const BlockNumber blockNumber = refToBlock(userRef); FsRef::NdbfsErrorCodeType errorCode; AsyncFile* openFile = theOpenFiles.find(filePointer); const NewVARIABLE *myBaseAddrRef = &getBat(blockNumber)[fsReq->varIndex]; const Uint32* tWA = (const Uint32*)myBaseAddrRef->WA; const Uint32 tSz = myBaseAddrRef->nrr; const Uint32 offset = fsReq->offset; const Uint32 size = fsReq->size; const Uint32 synch_flag = fsReq->synch_flag; Request *request = theRequestPool->get(); if (openFile == NULL) { jam(); errorCode = FsRef::fsErrFileDoesNotExist; goto error; } if (myBaseAddrRef == NULL) { jam(); // Ensure that a valid variable is used errorCode = FsRef::fsErrInvalidParameters; goto error; } if (fsReq->varIndex >= getBatSize(blockNumber)) { jam();// Ensure that a valid variable is used errorCode = FsRef::fsErrInvalidParameters; goto error; } if(offset + size > tSz){ jam(); // Ensure that a valid variable is used errorCode = FsRef::fsErrInvalidParameters; goto error; } request->error = 0; request->set(userRef, userPointer, filePointer); request->file = openFile; request->theTrace = signal->getTrace(); request->par.append.buf = (const char *)(tWA + offset); request->par.append.size = size << 2; if (!synch_flag) request->action = Request::append; else request->action = Request::append_synch; ndbrequire(forward(openFile, request)); return; error: jam(); theRequestPool->put(request); FsRef * const fsRef = (FsRef *)&signal->theData[0]; fsRef->userPointer = userPointer; fsRef->setErrorCode(fsRef->errorCode, errorCode); fsRef->osErrorCode = ~0; // Indicate local error jam(); sendSignal(userRef, GSN_FSAPPENDREF, signal, 3, JBB); return; }
void Ndbfs::readWriteRequest(int action, Signal * signal) { const FsReadWriteReq * const fsRWReq = (FsReadWriteReq *)&signal->theData[0]; Uint16 filePointer = (Uint16)fsRWReq->filePointer; const UintR userPointer = fsRWReq->userPointer; const BlockReference userRef = fsRWReq->userReference; const BlockNumber blockNumber = refToBlock(userRef); AsyncFile* openFile = theOpenFiles.find(filePointer); const NewVARIABLE *myBaseAddrRef = &getBat(blockNumber)[fsRWReq->varIndex]; UintPtr tPageSize; UintPtr tClusterSize; UintPtr tNRR; UintPtr tPageOffset; char* tWA; FsRef::NdbfsErrorCodeType errorCode; Request *request = theRequestPool->get(); request->error = 0; request->set(userRef, userPointer, filePointer); request->file = openFile; request->action = (Request::Action) action; request->theTrace = signal->getTrace(); Uint32 format = fsRWReq->getFormatFlag(fsRWReq->operationFlag); if (fsRWReq->numberOfPages == 0) { //Zero pages not allowed jam(); errorCode = FsRef::fsErrInvalidParameters; goto error; } if(format != FsReadWriteReq::fsFormatGlobalPage && format != FsReadWriteReq::fsFormatSharedPage) { if (fsRWReq->varIndex >= getBatSize(blockNumber)) { jam();// Ensure that a valid variable is used errorCode = FsRef::fsErrInvalidParameters; goto error; } if (myBaseAddrRef == NULL) { jam(); // Ensure that a valid variable is used errorCode = FsRef::fsErrInvalidParameters; goto error; } if (openFile == NULL) { jam(); //file not open errorCode = FsRef::fsErrFileDoesNotExist; goto error; } tPageSize = pageSize(myBaseAddrRef); tClusterSize = myBaseAddrRef->ClusterSize; tNRR = myBaseAddrRef->nrr; tWA = (char*)myBaseAddrRef->WA; switch (format) { // List of memory and file pages pairs case FsReadWriteReq::fsFormatListOfPairs: { jam(); for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) { jam(); const UintPtr varIndex = fsRWReq->data.listOfPair[i].varIndex; const UintPtr fileOffset = fsRWReq->data.listOfPair[i].fileOffset; if (varIndex >= tNRR) { jam(); errorCode = FsRef::fsErrInvalidParameters; goto error; }//if request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize]; request->par.readWrite.pages[i].size = tPageSize; request->par.readWrite.pages[i].offset = fileOffset * tPageSize; }//for request->par.readWrite.numberOfPages = fsRWReq->numberOfPages; break; }//case // Range of memory page with one file page case FsReadWriteReq::fsFormatArrayOfPages: { if ((fsRWReq->numberOfPages + fsRWReq->data.arrayOfPages.varIndex) > tNRR) { jam(); errorCode = FsRef::fsErrInvalidParameters; goto error; }//if const UintPtr varIndex = fsRWReq->data.arrayOfPages.varIndex; const UintPtr fileOffset = fsRWReq->data.arrayOfPages.fileOffset; request->par.readWrite.pages[0].offset = fileOffset * tPageSize; request->par.readWrite.pages[0].size = tPageSize * fsRWReq->numberOfPages; request->par.readWrite.numberOfPages = 1; request->par.readWrite.pages[0].buf = &tWA[varIndex * tPageSize]; break; }//case // List of memory pages followed by one file page case FsReadWriteReq::fsFormatListOfMemPages: { tPageOffset = fsRWReq->data.listOfMemPages.varIndex[fsRWReq->numberOfPages]; tPageOffset *= tPageSize; for (unsigned int i = 0; i < fsRWReq->numberOfPages; i++) { jam(); UintPtr varIndex = fsRWReq->data.listOfMemPages.varIndex[i]; if (varIndex >= tNRR) { jam(); errorCode = FsRef::fsErrInvalidParameters; goto error; }//if request->par.readWrite.pages[i].buf = &tWA[varIndex * tClusterSize]; request->par.readWrite.pages[i].size = tPageSize; request->par.readWrite.pages[i].offset = tPageOffset + (i*tPageSize); }//for request->par.readWrite.numberOfPages = fsRWReq->numberOfPages; break; // make it a writev or readv }//case default: { jam(); errorCode = FsRef::fsErrInvalidParameters; goto error; }//default }//switch } else if (format == FsReadWriteReq::fsFormatGlobalPage) { Ptr<GlobalPage> ptr; m_global_page_pool.getPtr(ptr, fsRWReq->data.pageData[0]); request->par.readWrite.pages[0].buf = (char*)ptr.p; request->par.readWrite.pages[0].size = ((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->numberOfPages; request->par.readWrite.pages[0].offset= ((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->varIndex; request->par.readWrite.numberOfPages = 1; } else { ndbrequire(format == FsReadWriteReq::fsFormatSharedPage); Ptr<GlobalPage> ptr; m_shared_page_pool.getPtr(ptr, fsRWReq->data.pageData[0]); request->par.readWrite.pages[0].buf = (char*)ptr.p; request->par.readWrite.pages[0].size = ((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->numberOfPages; request->par.readWrite.pages[0].offset= ((UintPtr)GLOBAL_PAGE_SIZE)*fsRWReq->varIndex; request->par.readWrite.numberOfPages = 1; } ndbrequire(forward(openFile, request)); return; error: theRequestPool->put(request); FsRef * const fsRef = (FsRef *)&signal->theData[0]; fsRef->userPointer = userPointer; fsRef->setErrorCode(fsRef->errorCode, errorCode); fsRef->osErrorCode = ~0; // Indicate local error switch (action) { case Request:: write: case Request:: writeSync: { jam(); sendSignal(userRef, GSN_FSWRITEREF, signal, 3, JBB); break; }//case case Request:: readPartial: case Request:: read: { jam(); sendSignal(userRef, GSN_FSREADREF, signal, 3, JBB); }//case }//switch return; }
void Ndbfs::execFSOPENREQ(Signal* signal) { jamEntry(); const FsOpenReq * const fsOpenReq = (FsOpenReq *)&signal->theData[0]; const BlockReference userRef = fsOpenReq->userReference; AsyncFile* file = getIdleFile(); ndbrequire(file != NULL); Filename::NameSpec spec(theFileSystemPath, theBackupFilePath); Uint32 userPointer = fsOpenReq->userPointer; if(fsOpenReq->fileFlags & FsOpenReq::OM_INIT) { Ptr<GlobalPage> page_ptr; if(m_global_page_pool.seize(page_ptr) == false) { FsRef * const fsRef = (FsRef *)&signal->theData[0]; fsRef->userPointer = userPointer; fsRef->setErrorCode(fsRef->errorCode, FsRef::fsErrOutOfMemory); fsRef->osErrorCode = ~0; // Indicate local error sendSignal(userRef, GSN_FSOPENREF, signal, 3, JBB); return; } file->m_page_ptr = page_ptr; } else { ndbassert(file->m_page_ptr.isNull()); file->m_page_ptr.setNull(); } if(signal->getNoOfSections() == 0){ jam(); file->theFileName.set(spec, userRef, fsOpenReq->fileNumber); } else { jam(); SegmentedSectionPtr ptr; signal->getSection(ptr, FsOpenReq::FILENAME); file->theFileName.set(spec, ptr, g_sectionSegmentPool); releaseSections(signal); } file->reportTo(&theFromThreads); if (getenv("NDB_TRACE_OPEN")) ndbout_c("open(%s)", file->theFileName.c_str()); Request* request = theRequestPool->get(); request->action = Request::open; request->error = 0; request->set(userRef, userPointer, newId() ); request->file = file; request->theTrace = signal->getTrace(); request->par.open.flags = fsOpenReq->fileFlags; request->par.open.page_size = fsOpenReq->page_size; request->par.open.file_size = fsOpenReq->file_size_hi; request->par.open.file_size <<= 32; request->par.open.file_size |= fsOpenReq->file_size_lo; request->par.open.auto_sync_size = fsOpenReq->auto_sync_size; ndbrequire(forward(file, request)); }
static int GotProgressStatic(void *clientp,double dltotal,double dlnow,double ultotal,double ulnow) { Request *mem = (Request *)clientp; return mem->GotProgress(dltotal,dlnow,ultotal,ulnow); }
void set_connection_header(Request& req) const { req.header().set_field(header::Connection, (keep_alive_) ? std::string{"keep-alive"} : std::string{"close"}); }
static void GotResolveStatic(void *arg, int status, int timeouts, struct hostent *hostent) { Request *mem = (Request *)arg; mem->GotResolve(status,timeouts,hostent); }
void execute(const Request& request, Response& response) { log_debug(GET_LOGGER("agent"), "Getting memory chunk info."); response.set_chunk(ComputeComponents::get_instance()-> get_memory_chunk_manager().get_entry( request.get_chunk())); }
/** Executes the corresponding header for client's request. * * \param request Is the user's request. */ void WebServer::handleRequest(Request &request){ RequestHandler &hdlr = requestManager.getHanlder(request.getUri()); hdlr.run(request); }
int main(int argc, char **argv) { const char *jobid, *user, *title, *options, *ppdFile, *file; unsigned long copies; Request request; PPDFile ppd; // Check the given arguments if (argc != 6 && argc != 7) { fprintf(stderr, _("Usage: %s job-id user title copies options " "[file]\n"), argv[0]); return 1; } jobid = argv[1]; user = argv[2]; title = argv[3]; options = argv[5]; file = argc == 7 ? argv[6] : NULL; copies = strtol(argv[4], (char **)NULL, 10); ppdFile = getenv("PPD"); // Get more information on the SpliX environment (for debugging) DEBUGMSG(_("SpliX filter V. %s by Aurélien Croc (AP²C)"), VERSION); DEBUGMSG(_("More information at: http://splix.ap2c.org")); DEBUGMSG(_("Compiled with: Threads=%s (#=%u, Cache=%u), JBIG=%s, " "BlackOptim=%s"), opt_threads ? _("enabled") : _("disabled"), THREADS, CACHESIZE, opt_jbig ? _("enabled") : _("disabled"), opt_blackoptim ? _("enabled") : _("disabled")); // Open the given file if (file && !freopen(file, "r", stdin)) { ERRORMSG(_("Cannot open file %s"), file); return errno; } // Open the PPD file if (!ppd.open(ppdFile, PPDVERSION, options)) return 1; // Load the request if (!request.loadRequest(&ppd, jobid, user, title, copies)) return 2; #ifndef DISABLE_THREADS if (!initializeCache()) return 3; #endif /* DISABLE_THREADS */ // Render the request if (!render(request)) { uninitializeCache(); return 4; } #ifndef DISABLE_THREADS if (!uninitializeCache()) return 5; #endif /* DISABLE_THREADS */ return 0; }
bool BluetoothParent::RecvPBluetoothRequestConstructor( PBluetoothRequestParent* aActor, const Request& aRequest) { BluetoothRequestParent* actor = static_cast<BluetoothRequestParent*>(aActor); #ifdef DEBUG actor->mRequestType = aRequest.type(); #endif switch (aRequest.type()) { case Request::TGetAdaptersRequest: return actor->DoRequest(aRequest.get_GetAdaptersRequest()); case Request::TStartBluetoothRequest: return actor->DoRequest(aRequest.get_StartBluetoothRequest()); case Request::TStopBluetoothRequest: return actor->DoRequest(aRequest.get_StopBluetoothRequest()); case Request::TSetPropertyRequest: return actor->DoRequest(aRequest.get_SetPropertyRequest()); case Request::TStartDiscoveryRequest: return actor->DoRequest(aRequest.get_StartDiscoveryRequest()); case Request::TStopDiscoveryRequest: return actor->DoRequest(aRequest.get_StopDiscoveryRequest()); case Request::TStartLeScanRequest: return actor->DoRequest(aRequest.get_StartLeScanRequest()); case Request::TStopLeScanRequest: return actor->DoRequest(aRequest.get_StopLeScanRequest()); case Request::TPairRequest: return actor->DoRequest(aRequest.get_PairRequest()); case Request::TUnpairRequest: return actor->DoRequest(aRequest.get_UnpairRequest()); case Request::TPairedDevicePropertiesRequest: return actor->DoRequest(aRequest.get_PairedDevicePropertiesRequest()); case Request::TConnectedDevicePropertiesRequest: return actor->DoRequest(aRequest.get_ConnectedDevicePropertiesRequest()); case Request::TFetchUuidsRequest: return actor->DoRequest(aRequest.get_FetchUuidsRequest()); case Request::TPinReplyRequest: return actor->DoRequest(aRequest.get_PinReplyRequest()); case Request::TSspReplyRequest: return actor->DoRequest(aRequest.get_SspReplyRequest()); case Request::TSetPinCodeRequest: return actor->DoRequest(aRequest.get_SetPinCodeRequest()); case Request::TSetPasskeyRequest: return actor->DoRequest(aRequest.get_SetPasskeyRequest()); case Request::TConfirmPairingConfirmationRequest: return actor->DoRequest(aRequest.get_ConfirmPairingConfirmationRequest()); case Request::TDenyPairingConfirmationRequest: return actor->DoRequest(aRequest.get_DenyPairingConfirmationRequest()); case Request::TConnectRequest: return actor->DoRequest(aRequest.get_ConnectRequest()); case Request::TDisconnectRequest: return actor->DoRequest(aRequest.get_DisconnectRequest()); case Request::TSendFileRequest: return actor->DoRequest(aRequest.get_SendFileRequest()); case Request::TStopSendingFileRequest: return actor->DoRequest(aRequest.get_StopSendingFileRequest()); case Request::TConfirmReceivingFileRequest: return actor->DoRequest(aRequest.get_ConfirmReceivingFileRequest()); case Request::TDenyReceivingFileRequest: return actor->DoRequest(aRequest.get_DenyReceivingFileRequest()); case Request::TConnectScoRequest: return actor->DoRequest(aRequest.get_ConnectScoRequest()); case Request::TDisconnectScoRequest: return actor->DoRequest(aRequest.get_DisconnectScoRequest()); case Request::TIsScoConnectedRequest: return actor->DoRequest(aRequest.get_IsScoConnectedRequest()); case Request::TSetObexPasswordRequest: return actor->DoRequest(aRequest.get_SetObexPasswordRequest()); case Request::TRejectObexAuthRequest: return actor->DoRequest(aRequest.get_RejectObexAuthRequest()); case Request::TReplyTovCardPullingRequest: return actor->DoRequest(aRequest.get_ReplyTovCardPullingRequest()); case Request::TReplyToPhonebookPullingRequest: return actor->DoRequest(aRequest.get_ReplyToPhonebookPullingRequest()); case Request::TReplyTovCardListingRequest: return actor->DoRequest(aRequest.get_ReplyTovCardListingRequest()); case Request::TReplyToFolderListingRequest: return actor->DoRequest(aRequest.get_ReplyToFolderListingRequest()); case Request::TReplyToMessagesListingRequest: return actor->DoRequest(aRequest.get_ReplyToMessagesListingRequest()); case Request::TReplyToGetMessageRequest: return actor->DoRequest(aRequest.get_ReplyToGetMessageRequest()); case Request::TReplyToSetMessageStatusRequest: return actor->DoRequest(aRequest.get_ReplyToSetMessageStatusRequest()); case Request::TReplyToSendMessageRequest: return actor->DoRequest(aRequest.get_ReplyToSendMessageRequest()); case Request::TReplyToMessageUpdateRequest: return actor->DoRequest(aRequest.get_ReplyToMessageUpdateRequest()); #ifdef MOZ_B2G_RIL case Request::TAnswerWaitingCallRequest: return actor->DoRequest(aRequest.get_AnswerWaitingCallRequest()); case Request::TIgnoreWaitingCallRequest: return actor->DoRequest(aRequest.get_IgnoreWaitingCallRequest()); case Request::TToggleCallsRequest: return actor->DoRequest(aRequest.get_ToggleCallsRequest()); #endif case Request::TSendMetaDataRequest: return actor->DoRequest(aRequest.get_SendMetaDataRequest()); case Request::TSendPlayStatusRequest: return actor->DoRequest(aRequest.get_SendPlayStatusRequest()); case Request::TConnectGattClientRequest: return actor->DoRequest(aRequest.get_ConnectGattClientRequest()); case Request::TDisconnectGattClientRequest: return actor->DoRequest(aRequest.get_DisconnectGattClientRequest()); case Request::TDiscoverGattServicesRequest: return actor->DoRequest(aRequest.get_DiscoverGattServicesRequest()); case Request::TGattClientStartNotificationsRequest: return actor->DoRequest( aRequest.get_GattClientStartNotificationsRequest()); case Request::TGattClientStopNotificationsRequest: return actor->DoRequest( aRequest.get_GattClientStopNotificationsRequest()); case Request::TUnregisterGattClientRequest: return actor->DoRequest(aRequest.get_UnregisterGattClientRequest()); case Request::TGattClientReadRemoteRssiRequest: return actor->DoRequest(aRequest.get_GattClientReadRemoteRssiRequest()); case Request::TGattClientReadCharacteristicValueRequest: return actor->DoRequest( aRequest.get_GattClientReadCharacteristicValueRequest()); case Request::TGattClientWriteCharacteristicValueRequest: return actor->DoRequest( aRequest.get_GattClientWriteCharacteristicValueRequest()); case Request::TGattClientReadDescriptorValueRequest: return actor->DoRequest( aRequest.get_GattClientReadDescriptorValueRequest()); case Request::TGattClientWriteDescriptorValueRequest: return actor->DoRequest( aRequest.get_GattClientWriteDescriptorValueRequest()); case Request::TGattServerConnectPeripheralRequest: return actor->DoRequest( aRequest.get_GattServerConnectPeripheralRequest()); case Request::TGattServerDisconnectPeripheralRequest: return actor->DoRequest( aRequest.get_GattServerDisconnectPeripheralRequest()); case Request::TUnregisterGattServerRequest: return actor->DoRequest(aRequest.get_UnregisterGattServerRequest()); case Request::TGattServerAddServiceRequest: return actor->DoRequest(aRequest.get_GattServerAddServiceRequest()); case Request::TGattServerAddIncludedServiceRequest: return actor->DoRequest( aRequest.get_GattServerAddIncludedServiceRequest()); case Request::TGattServerAddCharacteristicRequest: return actor->DoRequest( aRequest.get_GattServerAddCharacteristicRequest()); case Request::TGattServerAddDescriptorRequest: return actor->DoRequest(aRequest.get_GattServerAddDescriptorRequest()); case Request::TGattServerRemoveServiceRequest: return actor->DoRequest(aRequest.get_GattServerRemoveServiceRequest()); case Request::TGattServerStartServiceRequest: return actor->DoRequest(aRequest.get_GattServerStartServiceRequest()); case Request::TGattServerStopServiceRequest: return actor->DoRequest(aRequest.get_GattServerStopServiceRequest()); case Request::TGattServerSendResponseRequest: return actor->DoRequest(aRequest.get_GattServerSendResponseRequest()); case Request::TGattServerSendIndicationRequest: return actor->DoRequest( aRequest.get_GattServerSendIndicationRequest()); default: MOZ_CRASH("Unknown type!"); } MOZ_CRASH("Should never get here!"); }
void PagerLoader::traverse(osg::NodeVisitor& nv) { // only called when _mergesPerFrame > 0 if ( nv.getVisitorType() == nv.UPDATE_VISITOR ) { if ( nv.getFrameStamp() ) { setFrameStamp(nv.getFrameStamp()); } int count; for(count=0; count < _mergesPerFrame && !_mergeQueue.empty(); ++count) { Request* req = _mergeQueue.begin()->get(); if ( req && req->_lastTick >= _checkpoint ) { OE_START_TIMER(req_apply); req->apply( getFrameStamp() ); double s = OE_STOP_TIMER(req_apply); req->setState(Request::FINISHED); } _mergeQueue.erase( _mergeQueue.begin() ); } // cull finished requests. { Threading::ScopedMutexLock lock( _requestsMutex ); unsigned fn = 0; if ( nv.getFrameStamp() ) fn = nv.getFrameStamp()->getFrameNumber(); // Purge expired requests. for(Requests::iterator i = _requests.begin(); i != _requests.end(); ) { Request* req = i->second.get(); if ( req->isFinished() ) { //OE_INFO << LC << req->getName() << "(" << i->second->getUID() << ") finished." << std::endl; req->setState( Request::IDLE ); if ( REPORT_ACTIVITY ) Registry::instance()->endActivity( req->getName() ); _requests.erase( i++ ); } else if ( !req->isMerging() && (fn - req->getLastFrameSubmitted() > 2) ) { //OE_INFO << LC << req->getName() << "(" << i->second->getUID() << ") died waiting after " << fn-req->getLastFrameSubmitted() << " frames" << std::endl; req->setState( Request::IDLE ); if ( REPORT_ACTIVITY ) Registry::instance()->endActivity( req->getName() ); _requests.erase( i++ ); } else // still valid. { ++i; } } //OE_NOTICE << LC << "PagerLoader: requests=" << _requests.size() << "; mergeQueue=" << _mergeQueue.size() << std::endl; } } LoaderGroup::traverse( nv ); }
bool ZatData::LoadEPG(time_t iStart, time_t iEnd) { // iStart -= (iStart % (3600/2)) - 86400; // Do s // iEnd = iStart + 3600*3; //Do some time magic that the start date is not to far in the past because zattoo doesnt like that time_t tempStart = iStart - (iStart % (3600/2)) - 86400; time_t tempEnd = tempStart + 3600*5; //Add 5 hours while(tempEnd < iEnd) { ostringstream urlStream; urlStream << "zattoo.com/zapi/v2/cached/program/power_guide/" << powerHash << "?end=" << tempEnd << "&start=" << tempStart << "&format=json"; HTTPSocket *socket = new HTTPSocketRaw(); Request request; request.url = urlStream.str(); request.AddHeader("Cookie", cookie); Response response; socket->Execute(request,response); cookie = response.cookie; std::string jsonString = response.body; Json::Value json; Json::Reader reader; bool parsingSuccessful = reader.parse(jsonString,json); //D(cout << json << endl); Json::Value channels = json["channels"]; //Load the channel groups and channels for ( int index = 0; index < channels.size(); ++index ) { string cid = channels[index]["cid"].asString(); for (int i = 0; i < channels[index]["programs"].size(); ++i) { Json::Value program = channels[index]["programs"][i]; int channelId = GetChannelId(cid.c_str()); ZatChannel *channel = FindChannel(channelId); if (!channel) { continue; } PVRIptvEpgEntry entry; entry.strTitle = program["t"].asString(); entry.startTime = program["s"].asInt(); entry.endTime = program["e"].asInt(); entry.iBroadcastId = program["id"].asInt(); entry.strIconPath = program["i_url"].asString(); entry.iChannelId = channel->iChannelNumber; entry.strPlot = program["et"].asString(); Json::Value genres = program["g"]; ostringstream generesStream; for (int genre = 0; genre < genres.size(); genre++) { generesStream << genres[genre].asString() << " "; } entry.strGenreString = generesStream.str(); if (channel) channel->epg.insert(channel->epg.end(), entry); } } tempStart = tempEnd; tempEnd = tempStart + 3600*5; //Add 5 hours } return true; }
void ReservationUserUpdateAction::run(Request& request) { stringstream s; DBLogModule::appendToLogIfChange(s, "Login", _user->getLogin(), _login); DBLogModule::appendToLogIfChange(s, "Adresse", _user->getAddress(), _address); DBLogModule::appendToLogIfChange(s, "E-mail", _user->getEMail(), _email); DBLogModule::appendToLogIfChange(s, "Code postal", _user->getPostCode(), _postalCode); DBLogModule::appendToLogIfChange(s, "Ville", _user->getCityText(), _city); DBLogModule::appendToLogIfChange(s, "Téléphone", _user->getPhone(), _phone); if(_authorizedLogin) { DBLogModule::appendToLogIfChange(s, "Autorisation de connexion", lexical_cast<string>(_user->getConnectionAllowed()), lexical_cast<string>(*_authorizedLogin)); } DBLogModule::appendToLogIfChange(s, "Nom", _user->getName(), _name); DBLogModule::appendToLogIfChange(s, "Prénom", _user->getSurname(), _surname); _user->setLogin(_login); _user->setAddress(_address); _user->setEMail(_email); _user->setPostCode(_postalCode); _user->setCityText(_city); _user->setPhone(_phone); if(_authorizedLogin) { _user->setConnectionAllowed(*_authorizedLogin); } _user->setName(_name); _user->setSurname(_surname); if(!s.str().empty()) { SecurityLog::addUserAdmin(request.getUser().get(), _user.get(), s.str()); ResaDBLog::AddUserAdminEntry(*request.getSession(), *_user, s.str()); } if( _autoResaActivated && ( _user->getProfile()->getKey() == ResaModule::GetBasicResaCustomerProfile()->getKey() || _user->getProfile()->getKey() == ResaModule::GetAutoResaResaCustomerProfile()->getKey() ) ){ stringstream s2; DBLogModule::appendToLogIfChange( s2, "Activation auto-réservation", _user->getProfile()->getKey() == ResaModule::GetAutoResaResaCustomerProfile()->getKey() ? "OUI" : "NON", *_autoResaActivated ? "OUI" : "NON" ); _user->setProfile( (*_autoResaActivated ? ResaModule::GetAutoResaResaCustomerProfile() : ResaModule::GetBasicResaCustomerProfile()).get() ); // Change detection if(!s2.str().empty()) { ResaDBLog::AddUserChangeAutoResaActivationEntry(*request.getSession(), *_user); // Send confirmation e-mail to the customer if(_autoResaActivated) { // Create a login if empty if(_user->getLogin().empty()) { string idealLogin(_user->getSurname().substr(0,1) + _user->getName()); algorithm::replace_all(idealLogin, " ", string()); algorithm::replace_all(idealLogin, "'", string()); algorithm::to_lower(idealLogin); UserTableSync::SearchResult logins(UserTableSync::Search(*_env, idealLogin)); if(logins.empty()) { _user->setLogin(idealLogin); } else { for(int i=0; i<999999; ++i) { UserTableSync::SearchResult logins(UserTableSync::Search(*_env, idealLogin + lexical_cast<string>(i))); if(logins.empty()) { _user->setLogin(idealLogin + lexical_cast<string>(i)); break; } } } } // Create random password if empty if(_user->getPassword().empty()) { _user->setRandomPassword(); } // Send confirmation email if(ResaModule::GetReservationContact()) { if(ResaModule::GetReservationContact()->sendCustomerEMail(*_user)) { ResaDBLog::AddEMailEntry(*request.getSession(), *_user, "Message d'activation de réservation en ligne"); } } } } } UserTableSync::Save(_user.get()); }
inline void notFoundHandler(const Request& request, Response* pResponse) { pResponse->setNotFoundError(request.uri()); }
int main( void ){ // Backup the stdio streambufs streambuf * cin_streambuf = cin.rdbuf(); streambuf * cout_streambuf = cout.rdbuf(); streambuf * cerr_streambuf = cerr.rdbuf(); FCGX_Request fastcgi_request; FCGX_Init(); FCGX_InitRequest(&fastcgi_request, 0, 0); Timer my_timer; int x = 0; Request *request = new Request( &fastcgi_request ); map<string,string>::iterator parameter_iterator; while( FCGX_Accept_r(&fastcgi_request) == 0 ){ x++; my_timer.start(); request->reload(); //cout << request->message_body << endl; print_as_hex( request->message_body, cout ); cout << endl; fcgi_streambuf cin_fcgi_streambuf( fastcgi_request.in ); fcgi_streambuf cout_fcgi_streambuf( fastcgi_request.out ); fcgi_streambuf cerr_fcgi_streambuf( fastcgi_request.err ); cin.rdbuf( &cin_fcgi_streambuf ); cout.rdbuf( &cout_fcgi_streambuf ); cerr.rdbuf( &cerr_fcgi_streambuf ); cout << "Content-type: text/html\r\n" << "\r\n" << "<html>\n" << " <head>\n" << " <title>Hello, World!</title>\n" << " </head>\n" << " <body>\n" << " <h1>Hello, World!</h1>\n" ; //usleep(10000000); //cin >> input; cout << sha256(request->message_body) << endl; //cout << request->message_body << endl; cout << endl; cout << sizeof( FCGX_Request ) << endl; cout << x << "<br/>" << endl; for( parameter_iterator = request->parameters.begin(); parameter_iterator != request->parameters.end(); parameter_iterator++ ){ cout << parameter_iterator->first << " => " << parameter_iterator->second << "<br/>" << endl; } cout << "</body></html>" << endl; my_timer.stop(); cout << my_timer.getComment() << endl; // Note: the fcgi_streambuf destructor will auto flush } // restore stdio streambufs cin.rdbuf( cin_streambuf ); cout.rdbuf( cout_streambuf ); cerr.rdbuf( cerr_streambuf ); delete request; return 0; }
virtual void queryOp( Request& r ){ QueryMessage q( r.d() ); log(3) << "shard query: " << q.ns << " " << q.query << endl; if ( q.ntoreturn == 1 && strstr(q.ns, ".$cmd") ) throw UserException( 8010 , "something is wrong, shouldn't see a command here" ); ChunkManagerPtr info = r.getChunkManager(); assert( info ); Query query( q.query ); set<Shard> shards; info->getShardsForQuery( shards , query.getFilter() ); set<ServerAndQuery> servers; for ( set<Shard>::iterator i = shards.begin(); i != shards.end(); i++ ){ servers.insert( ServerAndQuery( i->getConnString() , BSONObj() ) ); } if ( logLevel > 4 ){ StringBuilder ss; ss << " shard query servers: " << servers.size() << '\n'; for ( set<ServerAndQuery>::iterator i = servers.begin(); i!=servers.end(); i++ ){ const ServerAndQuery& s = *i; ss << " " << s.toString() << '\n'; } log() << ss.str(); } ClusteredCursor * cursor = 0; BSONObj sort = query.getSort(); if ( sort.isEmpty() ){ cursor = new SerialServerClusteredCursor( servers , q ); } else { cursor = new ParallelSortClusteredCursor( servers , q , sort ); } assert( cursor ); try { cursor->init(); log(5) << " cursor type: " << cursor->type() << endl; shardedCursorTypes.hit( cursor->type() ); if ( query.isExplain() ){ BSONObj explain = cursor->explain(); replyToQuery( 0 , r.p() , r.m() , explain ); delete( cursor ); return; } } catch(...) { delete cursor; throw; } ShardedClientCursorPtr cc (new ShardedClientCursor( q , cursor )); if ( ! cc->sendNextBatch( r ) ){ return; } log(6) << "storing cursor : " << cc->getId() << endl; cursorCache.store( cc ); }
static size_t GotData(void *ptr, size_t size, size_t nmemb, void *data) { size_t realsize = size * nmemb; Request *mem = (Request *)data; return mem->GotContent(ptr,realsize); }
virtual void queryOp( Request& r ){ QueryMessage q( r.d() ); log(3) << "shard query: " << q.ns << " " << q.query << endl; if ( q.ntoreturn == 1 && strstr(q.ns, ".$cmd") ) throw UserException( 8010 , "something is wrong, shouldn't see a command here" ); ChunkManager * info = r.getChunkManager(); assert( info ); Query query( q.query ); vector<Chunk*> shards; info->getChunksForQuery( shards , query.getFilter() ); set<ServerAndQuery> servers; map<string,int> serverCounts; for ( vector<Chunk*>::iterator i = shards.begin(); i != shards.end(); i++ ){ servers.insert( ServerAndQuery( (*i)->getShard() , (*i)->getFilter() ) ); int& num = serverCounts[(*i)->getShard()]; num++; } if ( logLevel > 4 ){ StringBuilder ss; ss << " shard query servers: " << servers.size() << "\n"; for ( set<ServerAndQuery>::iterator i = servers.begin(); i!=servers.end(); i++ ){ const ServerAndQuery& s = *i; ss << " " << s.toString() << "\n"; } log() << ss.str(); } ClusteredCursor * cursor = 0; BSONObj sort = query.getSort(); if ( sort.isEmpty() ){ // 1. no sort, can just hit them in serial cursor = new SerialServerClusteredCursor( servers , q ); } else { int shardKeyOrder = info->getShardKey().canOrder( sort ); if ( shardKeyOrder ){ // 2. sort on shard key, can do in serial intelligently set<ServerAndQuery> buckets; for ( vector<Chunk*>::iterator i = shards.begin(); i != shards.end(); i++ ){ Chunk * s = *i; buckets.insert( ServerAndQuery( s->getShard() , s->getFilter() , s->getMin() ) ); } cursor = new SerialServerClusteredCursor( buckets , q , shardKeyOrder ); } else { // 3. sort on non-sharded key, pull back a portion from each server and iterate slowly cursor = new ParallelSortClusteredCursor( servers , q , sort ); } } assert( cursor ); log(5) << " cursor type: " << cursor->type() << endl; ShardedClientCursor * cc = new ShardedClientCursor( q , cursor ); if ( ! cc->sendNextBatch( r ) ){ delete( cursor ); return; } log(6) << "storing cursor : " << cc->getId() << endl; cursorCache.store( cc ); }
void Strategy::clientCommandOp(OperationContext* txn, Request& request) { QueryMessage q(request.d()); LOG(3) << "command: " << q.ns << " " << q.query << " ntoreturn: " << q.ntoreturn << " options: " << q.queryOptions; if (q.queryOptions & QueryOption_Exhaust) { uasserted(18527, string("the 'exhaust' query option is invalid for mongos commands: ") + q.ns + " " + q.query.toString()); } NamespaceString nss(request.getns()); // Regular queries are handled in strategy_shard.cpp verify(nss.isCommand() || nss.isSpecialCommand()); if (handleSpecialNamespaces(txn, request, q)) return; int loops = 5; bool cmChangeAttempted = false; while (true) { BSONObjBuilder builder; try { BSONObj cmdObj = q.query; { BSONElement e = cmdObj.firstElement(); if (e.type() == Object && (e.fieldName()[0] == '$' ? str::equals("query", e.fieldName() + 1) : str::equals("query", e.fieldName()))) { // Extract the embedded query object. if (cmdObj.hasField(Query::ReadPrefField.name())) { // The command has a read preference setting. We don't want // to lose this information so we copy this to a new field // called $queryOptions.$readPreference BSONObjBuilder finalCmdObjBuilder; finalCmdObjBuilder.appendElements(e.embeddedObject()); BSONObjBuilder queryOptionsBuilder( finalCmdObjBuilder.subobjStart("$queryOptions")); queryOptionsBuilder.append(cmdObj[Query::ReadPrefField.name()]); queryOptionsBuilder.done(); cmdObj = finalCmdObjBuilder.obj(); } else { cmdObj = e.embeddedObject(); } } } Command::runAgainstRegistered(txn, q.ns, cmdObj, builder, q.queryOptions); BSONObj x = builder.done(); replyToQuery(0, request.p(), request.m(), x); return; } catch (const StaleConfigException& e) { if (loops <= 0) throw e; loops--; log() << "retrying command: " << q.query; // For legacy reasons, ns may not actually be set in the exception :-( string staleNS = e.getns(); if (staleNS.size() == 0) staleNS = q.ns; ShardConnection::checkMyConnectionVersions(txn, staleNS); if (loops < 4) versionManager.forceRemoteCheckShardVersionCB(txn, staleNS); } catch (const DBException& e) { if (e.getCode() == ErrorCodes::IncompatibleCatalogManager) { fassert(28791, !cmChangeAttempted); cmChangeAttempted = true; grid.forwardingCatalogManager()->waitForCatalogManagerChange(txn); } else { Command::appendCommandStatus(builder, e.toStatus()); BSONObj x = builder.done(); replyToQuery(0, request.p(), request.m(), x); return; } } } }