void get_map_1(vector<string> &mqueue, uint32_t num_nodes) { //map<uint32_t, NodeList> update_map; //uint32_t num_nodes = svrclient.memberList.size(); for(vector<string>::iterator it = mqueue.begin(); it != mqueue.end(); ++it) { Package package; package.ParseFromString(*it); //cout << "key = " << package.virtualpath() << endl; uint32_t serverid = myhash(package.virtualpath().c_str(), num_nodes); string str(*it); str.append("#"); if(update_map_zht.find(serverid) == update_map_zht.end()) { str.append("$"); NodeList new_list; new_list.push_back(str); update_map_zht.insert(make_pair(serverid, new_list)); } else { NodeList &exist_list = update_map_zht[serverid]; string last_str(exist_list.back()); if((last_str.size() + str.size()) > STRING_THRESHOLD) { str.append("$"); exist_list.push_back(str); } else { exist_list.pop_back(); str.append(last_str); exist_list.push_back(str); } } } //return update_map; }
int Worker::zht_insert(string str) { Package package; package.ParseFromString(str); package.set_operation(3); str = package.SerializeAsString(); int index; svrclient.str2Host(str, index); if (index != selfIndex) { //cout << "NOOOOO..index = " << index << endl; pthread_mutex_lock(&msg_lock); int ret = svrclient.insert(str); pthread_mutex_unlock(&msg_lock); return ret; } else { string key = package.virtualpath(); //cout << "key = " << key << endl; //pthread_mutex_lock(&zht_lock); int ret = pmap->put(key, str); //pthread_mutex_unlock(&zht_lock); if (ret != 0) { cerr << "insert error: key = " << key << " ret = " << ret << endl; return -3; } else return 0; } }
void* notQueue(void* args) { Worker *worker = (Worker*) args; string *st; Package package; while (ON) { while (notifyq.size() > 0) { pthread_mutex_lock(¬q_lock); if (notifyq.size() > 0) { try { st = notifyq.front(); notifyq.pop(); } catch (exception& e) { cout << "void* notifyq: " << e.what() << endl; exit(1); } } else { pthread_mutex_unlock(¬q_lock); continue; } pthread_mutex_unlock(¬q_lock); package.ParseFromString(*st); delete st; worker->update(package); } } }
int benchmarkInsert() { double start = 0; double end = 0; start = TimeUtil::getTime_msec(); int errCount = 0; int c = 0; vector<string>::iterator it; for (it = pkgList.begin(); it != pkgList.end(); it++) { c++; string pkg_str = *it; Package pkg; pkg.ParseFromString(pkg_str); int ret = zc.insert(pkg.virtualpath(), pkg_str); if (ret < 0) { errCount++; } } end = TimeUtil::getTime_msec(); char buf[200]; sprintf(buf, "Inserted packages, %d, %d, cost(ms), %f", numOfOps - errCount, numOfOps, end - start); cout << buf << endl; return 0; }
//transfer a key to a host index where it should go struct HostEntity ZHTClient::str2Host(string str) { Package pkg; pkg.ParseFromString(str); int index = myhash(pkg.virtualpath().c_str(), this->memberList.size()); struct HostEntity host = this->memberList.at(index); return host; }
int benchmarkAppend() { vector<string> pkgList_append; vector<string>::iterator it; for (it = pkgList.begin(); it != pkgList.end(); it++) { Package package; package.ParseFromString((*it)); package.add_listitem("item-----6-append"); pkgList_append.push_back(package.SerializeAsString()); } double start = 0; double end = 0; start = TimeUtil::getTime_msec(); int errCount = 0; int c = 0; for (it = pkgList_append.begin(); it != pkgList_append.end(); it++) { c++; string pkg_str = *it; Package pkg; pkg.ParseFromString(pkg_str); int ret = zc.append(pkg.virtualpath(), pkg_str); if (ret < 0) { errCount++; } } end = TimeUtil::getTime_msec(); char buf[200]; sprintf(buf, "Appended packages, %d, %d, cost(ms), %f", numOfOps - errCount, numOfOps, end - start); cout << buf << endl; return 0; }
struct HostEntity str2Host(string str, vector<struct HostEntity> memberList, int &index) { Package pkg; pkg.ParseFromString(str); int index_inner = myhash(pkg.virtualpath().c_str(), memberList.size()); struct HostEntity host = memberList.at(index_inner); index = index_inner; return host; }
void submittaskszht(ZHTClient &clientRet, string client_id) { int ret = 0; Package package; package.set_virtualpath(client_id); package.set_operation(21); cout << "Ok, what is the hell!\n" << endl; for (map<uint32_t, NodeList>::iterator map_it = update_map_zht.begin(); map_it != update_map_zht.end(); ++map_it) { uint32_t index = map_it->first; NodeList &update_list = map_it->second; while (!update_list.empty()) { int num_vector_count, per_vector_count; string alltasks; vector< vector<string> > tokenize_string = tokenize_1(update_list.front(), '$', '#', num_vector_count, per_vector_count); //cout << " num_vector_count = " << num_vector_count << " per_vector_count = " << per_vector_count << endl; for(int i = 0; i < per_vector_count; i++) { Package tmpPackage; tmpPackage.ParseFromString(tokenize_string.at(0).at(i)); string key = tmpPackage.virtualpath(); alltasks.append(key); alltasks.append("\'\""); } //cout << "Serve package.set_realfullpath(alltasks); string str = package.SerializeAsString(); ret += clientRet.svrtosvr(str, str.length(), index); update_list.pop_front(); } } // Package package; string alltasks; // package.set_virtualpath(client_id); // Here key is just the client ID // package.set_operation(21); // //package.set_operation(22); // num_packages++; // // int num_tasks_this_package = max_tasks_per_package; // int num_tasks_left = num_tasks - total_submitted1; // if (num_tasks_left < max_tasks_per_package) { // num_tasks_this_package = num_tasks_left; // } // for(int j = 0; j < num_tasks_this_package; j++) { // int task_id = it->first; ++it; // // stringstream task_id_ss; // task_id_ss << task_id << client_id; // Task ID + Client ID // alltasks.append(task_id_ss.str()); alltasks.append("\'\""); // Task ID // } // total_submitted1 = total_submitted1 + num_tasks_this_package; // package.set_realfullpath(alltasks); // string str = package.SerializeAsString(); // //cout << "String size = " << str.size() << " str length = " << strlen(str.c_str()); // int32_t ret = clientRet.svrtosvr(str, str.length(), toserver); }
int ZHTClient::remove(string str) { Package package; package.ParseFromString(str); char *c_str; int size = str.length(); c_str = (char*) malloc((size + 5 + 1) * sizeof(char)); if (c_str == NULL) { cout << "ZHTClient::svrtosvr: " << strerror(errno) << endl; exit(1); } int len = copystring(c_str, str); if (package.virtualpath().empty()) //empty key not allowed. return -1; /*if (package.realfullpath().empty()) //coup, to fix ridiculous bug of protobuf! package.set_realfullpath(" ");*/ package.set_operation(2); //1 for look up, 2 for remove, 3 for insert package.set_replicano(3); //5: original, 3 not original str = package.SerializeAsString(); int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; struct HostEntity dest = this->str2Host(str); sockaddr_in recvAddr; //pthread_mutex_lock(&msg_lock); int sentSize = generalSendTo(dest.host.data(), dest.port, sock, c_str, len, TCP); //pthread_mutex_unlock(&msg_lock); //int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), str.size(), TCP); // cout<<"remove sentSize "<< sentSize <<endl; int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret_buf, sizeof(int32_t), 0); //pthread_mutex_lock(&msg_lock); generalReceive(sock, (void*) ret_buf, sizeof(int32_t), recvAddr, 0, TCP); //pthread_mutex_unlock(&msg_lock); // generalSendTCP(sock, str.c_str()); // int32_t* ret = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret, sizeof(int32_t), 0); int ret_1 = *(int32_t*) ret_buf; // cout<<"remove got: "<< ret_1 <<endl; //cout <<"Returned status: "<< *(int32_t*) ret<<endl; // d3_closeConnection(sock); free(ret_buf); return ret_1; }
// general server to server send (for load information and task stealing) int32_t ZHTClient::svrtosvr(string str, int size, int index) { Package package; package.ParseFromString(str); if (package.virtualpath().empty()) //empty key not allowed. { return -1; } str = package.SerializeAsString(); char *c_str; c_str = (char*) malloc((size + 5 + 1) * sizeof(char)); if (c_str == NULL) { cout << "ZHTClient::svrtosvr: " << strerror(errno) << endl; exit(1); } int len = copystring(c_str, str); if (package.virtualpath().empty()) //empty key not allowed. { return -1; } //cout << "C++ string len = " << str.length() << endl; cout << "C++ string: \n" << str << endl; /*cout << "C string: " << endl; for(int i = 0; i < len; i++) cout << c_str[i]; cout << endl; return 1;*/ int sock = this->index2SockLRU(index, TCP); reuseSock(sock); struct HostEntity dest = this->index2Host(index); sockaddr_in recvAddr; //cout << "going to acquire lock" << endl; //pthread_mutex_lock(&msg_lock); //cout << "lock acquired" << endl; //int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), str.size(), TCP); //cout << "what is the f**k!" << dest.host.data() << endl; int sentSize = generalSendTo(dest.host.data(), dest.port, sock, c_str, len, TCP); //cout << "svrsvr sent" << endl; //pthread_mutex_unlock(&msg_lock); int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); //pthread_mutex_lock(&msg_lock); generalReceive(sock, (void*) ret_buf, sizeof(int32_t), recvAddr, 0, TCP); //cout << "svrsvr recv" << endl; //pthread_mutex_unlock(&msg_lock); //cout << "lock released" << endl; int32_t ret_1 = *(int32_t*) ret_buf; free(ret_buf); //if(package.operation() == 14) { // cout << "ZHTClient::svrtosvr num_task = " << ret_1 << endl; //} return ret_1; }
//send a plain string to destination, receive return state. int ZHTClient::insert(string str) { /* int sock = -1; struct HostEntity dest = this->str2Host(str); // cout<<"Client: will send to "<<dest.host<<endl; //int ret = simpleSend(str, dest, sock); sock = makeClientSocket(dest.host.c_str(), dest.port, 1); // cout<<"client sock = "<< sock<<endl; reuseSock(sock); generalSendTCP(sock, str.c_str()); */ Package package; package.ParseFromString(str); if (package.virtualpath().empty()) //empty key not allowed. return -1; if (package.realfullpath().empty()) //coup, to fix ridiculous bug of protobuf! package.set_realfullpath(" "); package.set_operation(3); //1 for look up, 2 for remove, 3 for insert package.set_replicano(5); //5: original, 3 not original str = package.SerializeAsString(); int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; // int sentSize = generalSendTCP(sock, str.c_str()); struct HostEntity dest = this->str2Host(str); sockaddr_in recvAddr; int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), TCP); // cout <<"Client inseret sent: "<<sentSize<<endl; int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret_buf, sizeof(int32_t), 0); generalReceive(sock, (void*) ret_buf, 4, recvAddr, 0, TCP); int ret = *(int32_t*) ret_buf; if (ret < 0) { // cerr << "zht_util.h: Failed to insert." << endl; } //cout <<"Returned status: "<< *(int32_t*) ret<<endl; // d3_closeConnection(sock); free(ret_buf); //return ret_1; // cout<<"insert got: "<< *ret <<endl; return ret; }
//DEPRECATED struct metadata* zht_unparse_meta(const char* text) { Package package; package.ParseFromString(text); struct metadata* meta = (struct metadata*)malloc(sizeof(struct metadata)); meta->loc = (struct comLocations *) malloc(sizeof(struct comLocations)); meta->key = package.virtualpath().c_str(); meta->k = package.k(); meta->m = package.m(); meta->bufsize = package.bufsize(); meta->fileSize = package.filesize(); meta->encodingLib = package.encodinglib(); return meta; }
int Worker::zht_ins_mul(Package &package) { int num_vector_count, per_vector_count; vector<vector<string> > tokenize_string = tokenize(package.realfullpath(), '$', '#', num_vector_count, per_vector_count); //cout << " num_vector_count = " << num_vector_count << " per_vector_count = " << per_vector_count << endl; for (int i = 0; i < per_vector_count; i++) { zht_insert(tokenize_string.at(0).at(i)); } //cout << "Server: " << selfIndex << " no. tasks inserted = " << per_vector_count << endl; TaskQueue_Item *qi; pthread_mutex_lock(&w_lock); for (int i = 0; i < per_vector_count; i++) { Package pkg; pkg.ParseFromString(tokenize_string.at(0).at(i)); qi = new TaskQueue_Item(); qi->task_id = pkg.virtualpath(); (&wqueue)->push_back(qi); } pthread_mutex_unlock(&w_lock); return per_vector_count; }
int32_t ZHTClient::send(string str, int size) { Package package; package.ParseFromString(str); char *c_str; c_str = (char*) malloc((size + 5 + 1) * sizeof(char)); if (c_str == NULL) { cout << "ZHTClient::send: " << strerror(errno) << endl; exit(1); } int len = copystring(c_str, str); if (package.virtualpath().empty()) //empty key not allowed. return -1; //cout << "C++ string len = " << str.length() << endl; cout << "C++ string: \n" << str << endl; /*cout << "C string: " << endl; for(int i = 0; i < len; i++) cout << c_str[i]; cout << endl; return 1;*/ int sock = this->str2SockLRU(str, TCP); reuseSock(sock); struct HostEntity dest = this->str2Host(str); sockaddr_in recvAddr; //pthread_mutex_lock(&msg_lock); //int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), str.size(), TCP); int sentSize = generalSendTo(dest.host.data(), dest.port, sock, c_str, len, TCP); //pthread_mutex_unlock(&msg_lock); //cout << " Sent size = " << sentSize << endl; int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); //pthread_mutex_lock(&msg_lock); generalReceive(sock, (void*) ret_buf, sizeof(int32_t), recvAddr, 0, TCP); //pthread_mutex_unlock(&msg_lock); int ret_1 = *(int32_t*) ret_buf; free(ret_buf); return ret_1; }
float benchmarkRemove(vector<string> strList, ZHTClient &client) { vector<string>::iterator it; for (it = strList.begin(); it != strList.end(); it++) { Package package; package.ParseFromString((*it)); package.set_operation(2); // 3 for insert, 1 for look up, 2 for remove package.set_replicano(5); //5: original, 3 not original strList.erase(it); string newStr = package.SerializeAsString(); strList.push_back(newStr); } double start = 0; double end = 0; start = getTime_msec(); int errCount = 0; int c=0; for (it = strList.begin(); it != strList.end(); it++) { string result; c++; //cout <<"Remove count "<< c << endl; //cout <<"Remove: "<< (*it).c_str() << endl; if (client.remove((*it)) < 0) { errCount++; } } end = getTime_msec(); cout << "Remove " << strList.size() - errCount << " packages out of " << strList.size() << ", cost " << end - start << " ms" << endl; return 0; return 0; }
int Worker::zht_append(string str) { Package package; package.ParseFromString(str); package.set_operation(4); str = package.SerializeAsString(); int index; svrclient.str2Host(str, index); if (index != selfIndex) { pthread_mutex_lock(&msg_lock); int ret = svrclient.append(str); pthread_mutex_unlock(&msg_lock); return ret; } else { string key = package.virtualpath(); int ret = pmap->append(key, str); if (ret != 0) { cerr << "Append error: ret = " << ret << endl; return -4; } else return 0; } }
float benchmarkLookup() { double start = 0; double end = 0; start = TimeUtil::getTime_msec(); int errCount = 0; int c = 0; vector<string>::iterator it; for (it = pkgList.begin(); it != pkgList.end(); it++) { string result; c++; string pkg_str = *it; Package pkg; pkg.ParseFromString(pkg_str); int ret = zc.lookup(pkg.virtualpath(), result); if (ret < 0) { errCount++; } else if (result.empty()) { //empty string errCount++; } } end = TimeUtil::getTime_msec(); char buf[200]; sprintf(buf, "Lookuped packages, %d, %d, cost(ms), %f", numOfOps - errCount, numOfOps, end - start); cout << buf << endl; return 0; }
// Insert tasks into queue without repeated fields //int32_t Worker::HB_insertQ_new(NoVoHT *map, Package &package) { void* HB_insertQ_new(void* args) { package_thread_args targs = *((package_thread_args*) args); queue<string*> *source = targs.source; TaskQueue *dest = targs.dest; pthread_mutex_t *slock = targs.slock; pthread_mutex_t *dlock = targs.dlock; Worker *worker = targs.worker; string *st; Package package; while (ON) { while (source->size() > 0) { pthread_mutex_lock(slock); if (source->size() > 0) { try { st = source->front(); source->pop(); //cout << "recd something" << endl; } catch (exception& e) { cout << "void* HB_insertQ_new: " << e.what() << endl; exit(1); } } else { pthread_mutex_unlock(slock); continue; } pthread_mutex_unlock(slock); package.ParseFromString(*st); delete st; TaskQueue_Item *qi; uint32_t task_recd_count = 0; string alltasks(package.realfullpath()); int num_vector_count, per_vector_count; vector<vector<string> > tokenize_string = tokenize(alltasks, '\"', '\'', num_vector_count, per_vector_count); //cout << "num_vector_count = " << num_vector_count << " per_vector_count = " << per_vector_count << endl; task_recd_count = num_vector_count; for (int i = 0; i < num_vector_count; i++) { qi = new TaskQueue_Item(); try { qi->task_id = tokenize_string.at(i).at(0); //cout << "insertq: qi->task_id = " << qi->task_id << endl; } catch (exception& e) { cout << "void* HB_insertQ_new: (tokenize_string.at(i).at(0)) " << " " << e.what() << endl; exit(1); } /*stringstream num_moves_ss; try { num_moves_ss << tokenize_string.at(i).at(1); } catch (exception& e) { cout << "void* HB_insertQ_new: (tokenize_string.at(i).at(0)) " << " " << e.what() << endl; exit(1); } num_moves_ss >> qi->num_moves;*/ if (LOGGING) { task_fp << " taskid = " << qi->task_id; //task_fp << " num moves = " << qi->num_moves; } pthread_mutex_lock(dlock); try { dest->push_back(qi); } catch (std::bad_alloc& exc) { cout << "HB_InsertQ_new: cannot allocate memory while adding element to ready queue" << endl; pthread_exit(NULL); } pthread_mutex_unlock(dlock); } if (LOGGING) { log_fp << "Num tasks received = " << task_recd_count << " Queue length = " << dest->size() << endl; } } } }
int ZHTClient::lookup(string str, string &returnStr) { Package package; package.ParseFromString(str); if (package.virtualpath().empty()) //empty key not allowed. return -1; if (package.realfullpath().empty()) //coup, to fix ridiculous bug of protobuf! package.set_realfullpath(" "); package.set_operation(1); // 1 for look up, 2 for remove, 3 for insert package.set_replicano(3); //5: original, 3 not original str = package.SerializeAsString(); struct HostEntity dest = this->str2Host(str); // cout << "client::lookup is called, now send request..." << endl; Package pack; pack.ParseFromString(str); // cout<<"ZHTClient::lookup: operation = "<<pack.operation()<<endl; // int ret = simpleSend(str, dest, sock); // sock = makeClientSocket(dest.host.c_str(), dest.port, 1); // cout<<"client sock = "<< sock<<endl; int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; sockaddr_in recvAddr; int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), TCP); // int ret = generalSendTCP(sock, str.c_str()); // cout << "ZHTClient::lookup: simpleSend return = " << ret << endl; char buff[MAX_MSG_SIZE]; //MAX_MSG_SIZE memset(buff, 0, sizeof(buff)); int rcv_size = -1; int status = -1; string sRecv; string sStatus; if (sentSize == str.length()) { //this only work for TCP. UDP need to make a new one so accept returns from server. // cout << "before protocol judge" << endl; rcv_size = generalReceive(sock, (void*) buff, sizeof(buff), recvAddr, 0, TCP); if (rcv_size < 0) { cout << "Lookup receive error." << endl; } else { sRecv.assign(buff); returnStr = sRecv.substr(3); //the left is real thing need to be deserilized. sStatus = sRecv.substr(0, 3); //the first three chars means status code, like -1, -2, 0, -98, -99 and so on. } // cout << "after protocol judge" << endl; } // d3_closeConnection(sock); if (!sStatus.empty()) status = atoi(sStatus.c_str()); return status; }
int ZHTClient::lookup(string path, string &returnStr) { Package package; package.set_operation(1); // 3 for insert, 1 for look up, 2 for remove package.set_replicano(3); //5: original, 3 not original package.set_virtualpath(path); string str = package.SerializeAsString(); struct HostEntity dest = this->str2Host(str); // cout << "client::lookup is called, now send request..." << endl; Package pack; pack.ParseFromString(str); // cout<<"ZHTClient::lookup: operation = "<<pack.operation()<<endl; // int ret = simpleSend(str, dest, sock); // sock = makeClientSocket(dest.host.c_str(), dest.port, 1); // cout<<"client sock = "<< sock<<endl; int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; sockaddr_in recvAddr; int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), TCP); // int ret = generalSendTCP(sock, str.c_str()); // cout << "ZHTClient::lookup: simpleSend return = " << ret << endl; char buff[MAX_MSG_SIZE]; //MAX_MSG_SIZE memset(buff, 0, sizeof(buff)); int rcv_size = -1; if (sentSize == str.length()) { //this only work for TCP. UDP need to make a new one so accept returns from server. // cout << "before protocol judge" << endl; rcv_size = generalReceive(sock, (void*)buff, sizeof(buff),recvAddr,0, TCP); /* if (TRANS_PROTOCOL == USE_TCP) { rcv_size = d3_recv_data(sock, buff, MAX_MSG_SIZE, 0); //MAX_MSG_SIZE } else if (TRANS_PROTOCOL == USE_UDP) { //int svrPort = dest.port;//surely wrong, it's just the 50000 port //int svrPort = 50001; srand(getpid() + clock()); // int z = rand() % 10000 + 10000; // cout<<"Client:lookup: random port: "<<z<<endl; // int server_sock = d3_svr_makeSocket(rand() % 10000 + 10000);// use random port to send, and receive lookup result from it too. // cout<<"Client:lookup: UDP socket: "<<server_sock<<endl; sockaddr_in tmp_sockaddr; memset(&tmp_sockaddr, 0, sizeof(sockaddr_in)); // cout << "lookup: before receive..." << endl; rcv_size = d3_svr_recv(sock, buff, MAX_MSG_SIZE, 0, &tmp_sockaddr); //receive lookup result //d3_closeConnection(server_sock); // cout << "lookup received " << rcv_size << " bytes." << endl; }*/ if (rcv_size < 0) { cout << "Lookup receive error." << endl; return rcv_size; } else { returnStr.assign(buff); } // cout << "after protocol judge" << endl; } // d3_closeConnection(sock); return rcv_size; }
struct metadata * zht_lookup_meta(ZHTClient_c zhtClient, const char * key){ //1. Lookup in ZHT ZHTClient * zhtcppClient = (ZHTClient *) zhtClient; string keyStr(key); string resSerializedPackage; Package keyPackage; keyPackage.set_virtualpath(keyStr); //as key keyPackage.set_isdir(false); keyPackage.set_replicano(1); keyPackage.set_operation(1); //1 for look up, 2 for remove, 3 for insert int res = zhtcppClient->lookup(keyPackage.SerializeAsString(),resSerializedPackage); dbgprintf("Package Length:%i\n",resSerializedPackage.size()); //2. Parse Package and fill meta Package package; package.ParseFromString(resSerializedPackage); struct metadata* meta = (struct metadata*)malloc(sizeof(struct metadata)); //2.1 General file infos meta->key = package.virtualpath().c_str(); meta->k = package.k(); meta->m = package.m(); meta->bufsize = package.bufsize(); meta->fileSize = package.filesize(); meta->encodingLib = package.encodinglib(); //2.2 Locations meta->loc = (struct comLocations *) malloc(sizeof(struct comLocations)); struct comTransfer * current; struct comTransfer * prev = NULL; for (int j = package.location_size() -1 ; j >= 0; j--) { current = (struct comTransfer *) malloc(sizeof(struct comTransfer)); const Package_Location& location = package.location(j); //const std::string host = location.hostname(); current->hostName = (char *) malloc((location.hostname()).size()+1); strcpy(current->hostName,location.hostname().c_str()); current->port = location.port(); current->distantChunkName = (char *) malloc((location.distantchunkname()).size()+1); strcpy(current->distantChunkName,location.distantchunkname().c_str()); dbgprintf("Host (%i):%s - port: %i - chunkname: %s\n",j,location.hostname().c_str(),location.port(), location.distantchunkname().c_str()); current->next = prev; prev = current; } meta->loc->transfers = current; return meta; }
int ZHTClient::lookup(string str, string &returnStr) { Package package; package.ParseFromString(str); if (package.virtualpath().empty()) //empty key not allowed. return -1; /*if (package.realfullpath().empty()) //coup, to fix ridiculous bug of protobuf! package.set_realfullpath(" ");*/ package.set_operation(1); // 1 for look up, 2 for remove, 3 for insert package.set_replicano(3); //5: original, 3 not original str = package.SerializeAsString(); struct HostEntity dest = this->str2Host(str); // cout << "client::lookup is called, now send request..." << endl; char *c_str; int size = str.length(); c_str = (char*) malloc((size + 5 + 1) * sizeof(char)); if (c_str == NULL) { cout << "ZHTClient::svrtosvr: " << strerror(errno) << endl; exit(1); } int len = copystring(c_str, str); Package pack; pack.ParseFromString(str); // cout<<"ZHTClient::lookup: operation = "<<pack.operation()<<endl; // int ret = simpleSend(str, dest, sock); // sock = makeClientSocket(dest.host.c_str(), dest.port, 1); // cout<<"client sock = "<< sock<<endl; int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; sockaddr_in recvAddr; //cout << "lookup str = " << str << endl; //pthread_mutex_lock(&msg_lock); int sentSize = generalSendTo(dest.host.data(), dest.port, sock, c_str, len, TCP); //pthread_mutex_unlock(&msg_lock); //int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), str.size(), TCP); // int ret = generalSendTCP(sock, str.c_str()); // cout << "ZHTClient::lookup: simpleSend return = " << ret << endl; char buff[Env::MAX_MSG_SIZE]; //Env::MAX_MSG_SIZE memset(buff, 0, sizeof(buff)); int rcv_size = -1; int status = -1; string sRecv; string sStatus; //if (sentSize == str.length()) { //this only work for TCP. UDP need to make a new one so accept returns from server. if (sentSize == len) { // cout << "before protocol judge" << endl; //pthread_mutex_lock(&msg_lock); rcv_size = generalReceive(sock, (void*) buff, sizeof(buff), recvAddr, 0, TCP); //pthread_mutex_unlock(&msg_lock); if (rcv_size < 0) { cout << "Lookup receive error." << endl; } else { //cout << "ZHTClient::lookup: buff = " << buff << " size = " << rcv_size << endl; sRecv.assign(buff); //cout << "ZHTClient::lookup: for key " << package.virtualpath() << " recd = " << sRecv << endl; try { returnStr = sRecv.substr(3); //the left is real thing need to be deserilized. } catch (exception& e) { cout << "ZHTClient::lookup: (substr(3)) " << " " << e.what() << endl; exit(1); } try { sStatus = sRecv.substr(0, 3); //the first three chars means status code, like 001, 002, -98, -99 and so on. } catch (exception& e) { cout << "ZHTClient::lookup: (substr(0, 3)) " << " " << e.what() << endl; exit(1); } } // cout << "after protocol judge" << endl; } // d3_closeConnection(sock); if (!sStatus.empty()) status = atoi(sStatus.c_str()); return status; }