const QByteArray* PbSession::createRequest(const QString& alias)
{
seqNum_++;
WorkGroupsListRequest* wglist = WorkGroupsListRequest().New();
wglist->set_session_id(alias.toStdString());
wglist->set_filter(ALL_ENTRIES);
Request sampleReq;
sampleReq.set_allocated_workgroups_list(wglist);
sampleReq.set_message_type(RPC_WORKGROUPS_LIST);
sampleReq.set_service_type(1);
sampleReq.set_is_debug(true);
std::string stdString;
sampleReq.SerializeToString(&stdString);
PbHeader hdr = {seqNum_++, sampleReq.ByteSize(), 0};
cache_.reset( new QByteArray((const char*)&hdr.seqNum, sizeof(hdr)) );
cache_->append(stdString.c_str());
// release and check the memory integrity
sampleReq.release_workgroups_list();
return cache_.data();
}
Response MarketSession::executeProtobuf(Request request)
{
QByteArray requestBytes(request.SerializeAsString().c_str(),request.ByteSize());
QByteArray responseBytes;
if(!context.issecure())
responseBytes = executeRawHttpQuery(requestBytes);
else
responseBytes = executeRawHttpsQuery(requestBytes);
Response r;
r.ParseFromArray(responseBytes.constData(),responseBytes.size());
return r;
}
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;
}
int request_handler ( struct mg_connection *conn, enum mg_event ev ) {
switch ( ev ) {
case MG_AUTH:
return MG_TRUE;
case MG_CLOSE:
if ( conn->connection_param ) {
const string& storeKey = *(reinterpret_cast<string*>(conn->connection_param));
if ( requests.find(storeKey) != requests.end() ) {
--requests[storeKey];
if ( requests[storeKey] == 0 ) {
requests.erase(storeKey); // clean up store.
cerr << "deleting storeKey because of MG_CLOSE: " << storeKey << endl;
}
}
if ( conn->connection_param ) {
delete reinterpret_cast<string*>(conn->connection_param);
conn->connection_param = NULL;
}
}
return MG_TRUE;
case MG_REQUEST:
{
if ( strcmp ( conn->request_method, "GET" ) == 0 ) { // GET method
if ( strcmp ( conn->uri, "/get" ) == 0 ) { // get uri
return handle_get(conn);
}
else if ( strcmp ( conn->uri, "/kmermatch" ) == 0 ) { // kmermatch uri
return handle_kmermatch(conn);
}
else if ( strcmp ( conn->uri, "/gt" ) == 0 ) { // gt uri
return handle_gt(conn);
}
else {
mg_send_status(conn, 400);
mg_printf_data(conn, "Bad Request: invalid uri.");
}
}
else {
mg_send_status(conn, 400);
mg_printf_data(conn, "Bad Request: only GET method is accepted.");
}
return MG_TRUE;
}
case MG_POLL:
if ( conn->connection_param ) {
const string& storeKey = *(reinterpret_cast<string*>(conn->connection_param));
if ( completed_requests.find(storeKey) != completed_requests.end() && completed_requests[storeKey]->isReady() ) { // results ready
const string prefix = Reply_RequestType_Name(Reply_RequestType_CountReads);
if ( storeKey.size() > prefix.size() && storeKey.substr(0, prefix.size()) == prefix ) { // Count reads request
if ( completed_requests[storeKey]->hasReply() ) { // contains error message
mg_send_status(conn, 400);
mg_printf_data(conn, "%s", completed_requests[storeKey]->getReply()->c_str());
}
else { // no error message (matched reads within limit)
// first remove the entry for count reads request
--requests[storeKey];
if ( requests[storeKey] == 0 ) {
requests.erase(storeKey);
}
delete reinterpret_cast<string*>(conn->connection_param);
conn->connection_param = NULL;
// second build new request (the orginal request)
string output("all");
const map<string, string>& query_params = parse_query_string(conn->query_string);
map<string, string>::const_iterator output_iter = query_params.find("output");
if ( output_iter != query_params.end() ) {
output = output_iter->second;
}
map<string, string>::const_iterator query_iter = query_params.find("query");
const string& query = query_iter->second;
const string& newStoreKey = getKey(query, Reply_RequestType_ExactMatch, msRplTypes[output]);
if ( requests.find(newStoreKey) == requests.end() ) {
requests[newStoreKey] = 1;
Request r;
r.set_t(Request_RequestType_ExactMatch);
r.set_rt(msRtnTypes[output]);
r.set_q(query);
zmq::message_t message(r.ByteSize());
r.SerializeToArray(message.data(), r.ByteSize());
sender.send(message);
}
else {
++requests[storeKey];
}
conn->connection_param = static_cast<void*>(new string(newStoreKey));
return MG_MORE;
}
}
else { // Normal request
mg_printf_data(conn, "%s", string("{"+serialise(parse_query_string(conn->query_string))).c_str());
mg_printf_data(conn, "%s", completed_requests[storeKey]->getReply()->c_str());
}
--requests[storeKey];
if ( requests[storeKey] == 0 ) {
requests.erase(storeKey);
// we ought to erase storeKey from completed_requests, but due to the fact the this could be removed when we
// fetch new set of completed results, we can leave this safely.
}
delete reinterpret_cast<string*>(conn->connection_param);
conn->connection_param = NULL;
return MG_TRUE;
}
}
return MG_FALSE;
default:
return MG_FALSE;
}
}
int handle_kmermatch ( struct mg_connection *conn ) {
const char* query_string = conn->query_string;
if ( query_string == NULL ) {
mg_send_status(conn, 400);
mg_printf_data(conn, "Bad Request: please provide query string.");
return MG_TRUE;
}
const map<string, string>& query_params = parse_query_string(conn->query_string);
map<string, string>::const_iterator query_iter = query_params.find("query");
if ( query_iter == query_params.end() ) {
mg_send_status(conn, 400);
mg_printf_data(conn, "Bad Request: query is not supplied.");
return MG_TRUE;
}
map<string, string>::const_iterator kmer_iter = query_params.find("kmer");
if ( kmer_iter == query_params.end() ) {
mg_send_status(conn, 400);
mg_printf_data(conn, "Bad Request: kmer is not supplied.");
return MG_TRUE;
}
map<string, string>::const_iterator skip_iter = query_params.find("skip");
if ( skip_iter == query_params.end() ) {
mg_send_status(conn, 400);
mg_printf_data(conn, "Bad Request: skip is not supplied.");
return MG_TRUE;
}
string output("all");
map<string, string>::const_iterator output_iter = query_params.find("output");
if ( output_iter != query_params.end() ) {
output = output_iter->second;
}
const string& query = query_iter->second;
const string& kmer = kmer_iter->second;
const string& skip = skip_iter->second;
const string& storeKey = getKey(query, Reply_RequestType_KmerMatch, msRplTypes[output]);
if ( requests.find(storeKey) == requests.end() ) {
requests[storeKey] = 1;
Request r;
r.set_t(Request_RequestType_KmerMatch);
r.set_rt(msRtnTypes[output]);
r.set_q(query);
r.set_k(stoi(kmer));
r.set_s(stoi(skip));
zmq::message_t message(r.ByteSize());
r.SerializeToArray(message.data(), r.ByteSize());
sender.send(message);
}
else {
++requests[storeKey];
}
conn->connection_param = static_cast<void*>(new string(storeKey));
return MG_MORE;
}
int handle_get ( struct mg_connection *conn ) {
const char* query_string = conn->query_string;
if ( query_string == NULL ) {
mg_send_status(conn, 400);
mg_printf_data(conn, "Bad Request: please provide query string.");
return MG_TRUE;
}
const map<string, string>& query_params = parse_query_string(conn->query_string);
map<string, string>::const_iterator query_iter = query_params.find("query");
if ( query_iter == query_params.end() ) {
mg_send_status(conn, 400);
mg_printf_data(conn, "Bad Request: please provide query string.");
return MG_TRUE;
}
const string& query = query_iter->second;
if ( query.size() > max_query_length ) {
mg_send_status(conn, 400);
mg_printf_data(conn, string("Bad Request: query string is too long (maximum: ").append(max_query_length + ").").c_str());
return MG_TRUE;
}
string output("all");
map<string, string>::const_iterator output_iter = query_params.find("output");
if ( output_iter != query_params.end() ) {
output = output_iter->second;
}
if ( msRplTypes.find(output) == msRplTypes.end() ) {
mg_send_status(conn, 400);
mg_printf_data(conn, "Bad Request: output is specified but not one of these: \"all\", \"count\", \"reads\", \"samples\".");
return MG_TRUE;
}
if ( output == "samples" ) {
if ( query.size() != MAX_READ_LENGTH && query.size() != MIN_READ_LENGTH ) {
mg_send_status(conn, 400);
mg_printf_data(conn, string("Bad Request: query is not of length " + MIN_READ_LENGTH).append(" or " + MAX_READ_LENGTH).append(".").c_str());
return MG_TRUE;
}
}
if ( query.size() < max_query_length_count_threshold && output != "count" && output != "samples" ) {
const string& storeKey = getKey(query, Reply_RequestType_CountReads, msRplTypes["count"]);
if ( requests.find(storeKey) == requests.end() ) {
requests[storeKey] = 1;
Request r;
r.set_t(Request_RequestType_CountReads);
r.set_rt(msRtnTypes["count"]);
r.set_q(query);
zmq::message_t message(r.ByteSize());
r.SerializeToArray(message.data(), r.ByteSize());
sender.send(message);
}
else {
++requests[storeKey];
}
conn->connection_param = static_cast<void*>(new string(storeKey));
}
else {
const string& storeKey = getKey(query, Reply_RequestType_ExactMatch, msRplTypes[output]);
if ( requests.find(storeKey) == requests.end() ) {
requests[storeKey] = 1;
Request r;
r.set_t(Request_RequestType_ExactMatch);
r.set_rt(msRtnTypes[output]);
r.set_q(query);
zmq::message_t message(r.ByteSize());
r.SerializeToArray(message.data(), r.ByteSize());
if ( output != "samples" ) {
sender.send(message);
}
else {
string msg(query.rbegin(), query.rbegin()+3);
msg.append(" ");
zmq::message_t newmsg(message.size() + msg.size());
memcpy(newmsg.data(), msg.c_str(), msg.size());
memcpy(reinterpret_cast<void*>(reinterpret_cast<char*>(newmsg.data())+msg.size()), message.data(), message.size());
if ( !(sender_samples.send(newmsg)) ) {
cerr << "failed to send message for " << query << endl;
}
}
}
else {
++requests[storeKey];
}
conn->connection_param = static_cast<void*>(new string(storeKey));
}
return MG_MORE;
}
