void InputServer::sendToClients(char* eventPacket, int priority)
{
std::map<char*,NetClient*>::iterator itr = netClients.begin();
while( itr != netClients.end() )
{
NetClient* client = itr->second;
if( client->isLegacy() )
{
//client->sendEvent(legacyPacket, 512);
}
else
{
if (priority == 0) // UDP
{
client->sendEvent(eventPacket, DEFAULT_BUFLEN);
}
else if (priority == 1) // TCP
{
client->sendMsg(eventPacket, DEFAULT_BUFLEN);
}
}
itr++;
}
}
bool ServerConnectMgr::ConnectToServer(int32 nServerID,int32 nServerType,const char arrHost[32],int32 nPort,NetMsgEnter fEnter,NetMsgOn fMsg,NetMsgExit fExit)
{
NetClientInfoVecterType::iterator it = m_vecNetClientInfo.begin();
NetClientInfoVecterType::iterator itEnd = m_vecNetClientInfo.end();
for (; it != itEnd;++it)
{
if((*it)->nServerID == nServerID)
return false;
}
NetClient* pNetClient = new NetClient();
pNetClient->SetAddress(arrHost, nPort);
pNetClient->SetHandler(fEnter,fMsg,fExit);
pNetClient->Start();
NetClientInfo* pConn = new NetClientInfo();
pConn->pNetClient = pNetClient;
pConn->nServerID = nServerID;
pConn->nServerType = nServerType;
m_vecNetClientInfo.push_back(pConn);
return true;
}
void sendMatrix(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
NetClient *nc = GetNetClient(nrhs, prhs);
if (nrhs != 2) mexErrMsgTxt("Two arguments required: handle, matrix.");
unsigned long datalen = mxGetN(prhs[1]) * mxGetM(prhs[1]);
switch(mxGetClassID(prhs[1])) {
case mxINT8_CLASS:
case mxUINT8_CLASS:
case mxCHAR_CLASS: datalen *= sizeof(char); break;
case mxINT16_CLASS:
case mxUINT16_CLASS: datalen *= sizeof(short); break;
case mxUINT32_CLASS:
case mxINT32_CLASS: datalen *= sizeof(int); break;
case mxDOUBLE_CLASS: datalen *= sizeof(double); break;
case mxSINGLE_CLASS: datalen *= sizeof(float); break;
default:
mexErrMsgTxt("Argument 2 must be a matrix of numeric type.");
}
void *theMatrix = mxGetPr(prhs[1]);
try {
nc->sendData(theMatrix, datalen);
} catch (const SocketException & e) {
const std::string why (e.why());
if (why.length()) mexWarnMsgTxt(why.c_str());
RETURN_NULL();
}
RETURN(1);
}
void ServerConnectMgr::Update(int32 nSrvTime)
{
// 检查要断开的NetClient
DisconnectServerIDVectorType::iterator itServerID = m_vecNetClient.begin();
DisconnectServerIDVectorType::iterator itEndServerID = m_vecNetClient.end();
for (;itServerID != itEndServerID;++itServerID)
{
uint32 nServerID = *itServerID;
for(NetClientInfoVecterType::iterator it = m_vecNetClientInfo.begin();it != m_vecNetClientInfo.end();)
{
if((*it)->nServerID == nServerID)
{
delete (*it)->pNetClient;
(*it)->pNetClient = NULL;
it = m_vecNetClientInfo.erase(it);
}else
{
++it;
}
}
}
m_vecNetClient.clear();
NetClientInfoVecterType::iterator it = m_vecNetClientInfo.begin();
NetClientInfoVecterType::iterator itEnd = m_vecNetClientInfo.end();
for(; it != itEnd; ++it)
{
NetClient* pNetClient = (*it)->pNetClient;
if(pNetClient)
{
pNetClient->Update(nSrvTime);//1
}
}
}
/*
* query the number instances of a series
*/
int query_series_instances(const std::string& studyinstanceuid, const std::string& seriesinstanceuid, const std::string& server, const std::string& local_aet) {
DcmDataset query;
DcmElement* e = NULL;
e = newDicomElement(DCM_QueryRetrieveLevel);
e->putString("IMAGE");
query.insert(e);
e = newDicomElement(DCM_StudyInstanceUID);
e->putString(studyinstanceuid.c_str());
query.insert(e);
e = newDicomElement(DCM_SeriesInstanceUID);
e->putString(seriesinstanceuid.c_str());
query.insert(e);
e = newDicomElement(DCM_SOPInstanceUID);
query.insert(e);
e = newDicomElement(DCM_InstanceNumber);
query.insert(e);
std::cout << "NEW QUERY:" << std::endl;
query.print(COUT);
NetClient<FindAssociation> a;
a.QueryServer(&query, server, local_aet, UID_FINDStudyRootQueryRetrieveInformationModel);
DcmStack* result = a.GetResultStack();
std::cout << "query_series_instances = " << result->card() << std::endl;
return result->card();
}
void OInputServer::sendToClients(char* event){
// Iterate through all clients
std::map<char*,NetClient*>::iterator itr = netClients.begin();
while( itr != netClients.end() ){
NetClient* client = itr->second;
client->sendEvent( event );
itr++;
}// while
delete[] event; // Clean up event after being set to all clients
}// createClient
int NetClient::syncSender (void* instance){ /** OPCIONAL **/
NetClient* pNetClient = (NetClient *) instance;
while (!pNetClient->m_stopClient){
SDL_Delay(NetControl::M_SYNC_SEND_PERIOD);
pNetClient->asyncSend();
}
pNetClient->m_syncSenderIsOn = false;
return 0;
}
void readString(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if(nlhs < 1) mexErrMsgTxt("One output argument required.");
NetClient *nc = GetNetClient(nrhs, prhs);
try {
std::string theString ( nc->receiveString() );
plhs[0] = mxCreateString(theString.c_str());
} catch (const SocketException & e) {
mexWarnMsgTxt(e.why().c_str());
RETURN_NULL(); // note empty return..
}
}
static void
doA()
{
cout << "[A] Initialized." << endl;
NetClient* net = new MPIClient(0);
mpz_t a;
mpz_init_set_si(a, rand() + 213);
cout << "[A] Send " << 1 << " mpz_t to A" << endl;
gmp_printf("[A] Should expect: %Zd\n", a);
net->sendZVector("Vec from A.", &a, 1);
string header;
header = net->waitForMessage();
int valid = net->getDataAsZVector(&a, 1);
cout << "[A] Recv " << valid << " mpz_t from B with the header: '" << header << "'" << endl;
gmp_printf("[A] We got: %Zd\n", a);
cout << "[A] Sending empty message." << endl;
net->sendEmpty("Empty message from A.");
header = "MSG 1";
cout << "[A] Sending message: '" << header << "'." << endl;
net->sendData(header, header.c_str(), header.length());
header = "MSG 2";
cout << "[A] Sending message: '" << header << "'." << endl;
net->sendData(header, header.c_str(), header.length());
cout << net->getGlobalStat() << endl;
delete net;
}
void SMWServer::onDisconnect(NetClient& client)
{
printf("Disconnect event [%lu].\n", client.getPlayerID());
uint64_t playerID = client.getPlayerID();
if (players.count(playerID)) {
playerLeavesRoom(playerID);
log("[info] %s@%s disconnected.",
players[playerID].name.c_str(),
players[playerID].network_client->addressAsString().c_str());
players.erase(playerID);
}
else
printf("No such player!\n");
}
void query_series_from_net(const std::string& studyinstanceuid, const std::string& server, const std::string& local_aet, const sigc::slot< void, const Glib::RefPtr< ImagePool::Series >& >& resultslot) {
DcmDataset query;
DcmElement* e = NULL;
e = newDicomElement(DCM_QueryRetrieveLevel);
e->putString("SERIES");
query.insert(e);
e = newDicomElement(DCM_SpecificCharacterSet);
query.insert(e);
e = newDicomElement(DCM_StudyInstanceUID);
e->putString(studyinstanceuid.c_str());
query.insert(e);
e = newDicomElement(DCM_SeriesInstanceUID);
query.insert(e);
e = newDicomElement(DCM_SeriesNumber);
query.insert(e);
e = newDicomElement(DCM_Modality);
query.insert(e);
e = newDicomElement(DCM_SeriesDescription);
query.insert(e);
e = newDicomElement(DCM_SeriesTime);
query.insert(e);
e = newDicomElement(DCM_StationName);
query.insert(e);
e = newDicomElement(DCM_NumberOfSeriesRelatedInstances);
query.insert(e);
std::cout << "NEW QUERY:" << std::endl;
query.print(COUT);
NetClient<FindAssociation> a;
a.QueryServer(&query, server, local_aet, UID_FINDStudyRootQueryRetrieveInformationModel);
DcmStack* result = a.GetResultStack();
for(unsigned int i=0; i<result->card(); i++) {
DcmDataset* dset = (DcmDataset*)result->elem(i);
dset->print(COUT);
resultslot(create_query_series(dset));
}
}
static void* st_WaitEeventThreadProc(void* lpParam)
{
NetClient* pClientThis = (NetClient*)lpParam;
int sockeId = pClientThis->GetSockId();
std::string recvStr;
while (!pClientThis->GetShutDown())
{
recvStr.clear();
fu_socket_recv(sockeId, recvStr);
if (!recvStr.empty())
{
pClientThis->NotifyRecvText(recvStr.c_str(), recvStr.length());
}
}
return 0;
}
void readLines(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if(nlhs < 1) mexErrMsgTxt("One output argument required.");
NetClient *nc = GetNetClient(nrhs, prhs);
try {
char **lines = nc->receiveLines();
int m;
for (m = 0; lines[m]; m++) {} // count number of lines
plhs[0] = mxCreateCharMatrixFromStrings(m, const_cast<const char **>(lines));
NetClient::deleteReceivedLines(lines);
} catch (const SocketException &e) {
mexWarnMsgTxt(e.why().c_str());
RETURN_NULL(); // empty return set
}
}
void createNewClient(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if (nlhs != 1) mexErrMsgTxt("Cannot create a client since no output (lhs) arguments were specified!");
if (nrhs != 2) mexErrMsgTxt("Need two input arguments: Host, port!");
const mxArray *host = prhs[0], *port = prhs[1];
if ( !mxIsChar(host) || mxGetM(host) != 1 ) mexErrMsgTxt("Hostname must be a string row vector!");
if ( !mxIsDouble(port) || mxGetM(port) != 1 || mxGetN(port) != 1) mexErrMsgTxt("Port must be a single numeric value.");
char *hostStr = mxArrayToString(host);
unsigned short portNum = static_cast<unsigned short>(*mxGetPr(port));
NetClient *nc = new NetClient(hostStr, portNum);
mxFree(hostStr);
nc->setSocketOption(Socket::TCPNoDelay, true);
int h = handleId++;
MapPut(h, nc);
RETURN(h);
}
/*
* query all seriesinstanceuid's and the number series of a study
*/
int query_study_series(const std::string& studyinstanceuid, const std::string& server, const std::string& local_aet, std::list<std::string>& seriesinstanceuids) {
DcmDataset query;
DcmElement* e = NULL;
e = newDicomElement(DCM_QueryRetrieveLevel);
e->putString("SERIES");
query.insert(e);
e = newDicomElement(DCM_StudyInstanceUID);
e->putString(studyinstanceuid.c_str());
query.insert(e);
e = newDicomElement(DCM_SeriesInstanceUID);
query.insert(e);
e = newDicomElement(DCM_SeriesNumber);
query.insert(e);
e = newDicomElement(DCM_Modality);
query.insert(e);
std::cout << "NEW QUERY:" << std::endl;
query.print(COUT);
NetClient<FindAssociation> a;
a.QueryServer(&query, server, local_aet, UID_FINDStudyRootQueryRetrieveInformationModel);
DcmStack* result = a.GetResultStack();
DcmDataset* dset;
OFString ofstr;
seriesinstanceuids.clear();
for(int i = 0; i < result->card(); i++) {
dset = (DcmDataset*)result->elem(i);
if(dset->findAndGetOFString(DCM_SeriesInstanceUID, ofstr).good()) {
seriesinstanceuids.push_back(ofstr.c_str());
}
}
std::cout << result->card() << " Responses" << std::endl;
int count = result->card();
return count;
}
void tryConnection(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
NetClient *nc = GetNetClient(nrhs, prhs);
//if(nlhs < 1) mexErrMsgTxt("One output argument required.");
bool ok = false;
try {
ok = nc->connect();
} catch (const SocketException & e) {
mexWarnMsgTxt(e.why().c_str());
RETURN_NULL();
}
if (!ok) {
mexWarnMsgTxt(nc->errorReason().c_str());
RETURN_NULL();
}
RETURN(1);
}
void sendMatrix(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
NetClient *nc = GetNetClient(nrhs, prhs);
if(nrhs != 2) mexErrMsgTxt("Two arguments required: handle, matrix.");
//if(nlhs < 1) mexErrMsgTxt("One output argument required.");
if(mxGetClassID(prhs[0]) != mxDOUBLE_CLASS)
mexErrMsgTxt("Argument 2 must be a matrix of doubles.");
double *theMatrix = mxGetPr(prhs[1]);
int msglen = mxGetN(prhs[1]) * mxGetM(prhs[1]) * sizeof(double);
try {
nc->sendData(theMatrix, msglen);
} catch (const SocketException & e) {
mexWarnMsgTxt(e.why().c_str());
RETURN_NULL();
}
RETURN(1);
}
void sendString(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
NetClient *nc = GetNetClient(nrhs, prhs);
if(nrhs != 2) mexErrMsgTxt("Two arguments required: handle, string.");
//if(nlhs < 1) mexErrMsgTxt("One output argument required.");
if(mxGetClassID(prhs[1]) != mxCHAR_CLASS)
mexErrMsgTxt("Argument 2 must be a string.");
char *tmp = mxArrayToString(prhs[1]);
std::string theString (tmp);
mxFree(tmp);
try {
nc->sendString(theString);
} catch (const SocketException & e) {
mexWarnMsgTxt(e.why().c_str());
RETURN_NULL();
}
RETURN(1);
}
void tryConnection(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
NetClient *nc = GetNetClient(nrhs, prhs);
//if(nlhs < 1) mexErrMsgTxt("One output argument required.");
bool ok = false;
try {
ok = nc->connect();
if (ok) nc->setSocketOption(Socket::TCPNoDelay, true);
} catch (const SocketException & e) {
const std::string why (e.why());
if (why.length()) mexWarnMsgTxt(why.c_str());
RETURN_NULL();
}
if (!ok) {
mexWarnMsgTxt(nc->errorReason().c_str());
RETURN_NULL();
}
RETURN(1);
}
int main()
{
signal(SIGFPE, signal_handler);
init_quote();
//connect socket server
NetClient* ClientHandler = new NetClient();
ClientHandler->initClient(server_ip, server_prot);
ClientHandler->netSocket();
ClientHandler->netConnect();
ClientHandler->verifyLogin();
//start save db pthread
//ClientHandler->start_save_thread();
//start revc data and send msg to topic
ClientHandler->startSendMsg();
//destory active mq
ActiveMqProducer::getInstance()->close();
activemq::library::ActiveMQCPP::shutdownLibrary();
//destory zlog
zlog_fini();
//delete
delete ClientHandler;
return 0;
}
void readMatrix(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
NetClient *nc = GetNetClient(nrhs, prhs);
int ndims, datalen;
if (!nlhs)
mexErrMsgTxt("output (lhs) parameter is required.");
if (nrhs < 3 || !mxIsChar(prhs[1]) || !mxIsDouble(prhs[2]) || (ndims=mxGetN(prhs[2])) < 2 || mxGetM(prhs[2]) != 1)
mexErrMsgTxt("'readMatrix' needs arguments:\n Argument 1 handle\n Argument 2, a string 'double' or 'single' or 'uint8'\n Argument 3, a 1x4, 1x3 or 1x2 vector of dimensions for m,n[,o,p]");
int buflen = (mxGetM(prhs[1]) * mxGetN(prhs[1]) * sizeof(mxChar)) + 1;
std::string stdstr(buflen, '0');
mxGetString(prhs[1], &stdstr[0], buflen);
const char *str = stdstr.c_str();
const double *dims_dbls = mxGetPr(prhs[2]);
if (ndims > 4) ndims = 4;
const int dims[] = { static_cast<int>(dims_dbls[0]),
static_cast<int>(dims_dbls[1]),
ndims >= 3 ? static_cast<int>(dims_dbls[2]) : 1,
ndims >= 4 ? static_cast<int>(dims_dbls[3]) : 1 };
datalen = dims[0]*dims[1]*dims[2]*dims[3];
mxClassID cls;
if (!strcmpi(str, "double")) cls = mxDOUBLE_CLASS, datalen *= sizeof(double);
else if (!strcmpi(str, "single")) cls = mxSINGLE_CLASS, datalen *= sizeof(float);
else if (!strcmpi(str, "int8")) cls = mxINT8_CLASS, datalen *= sizeof(char);
else if (!strcmpi(str, "uint8")) cls = mxUINT8_CLASS, datalen *= sizeof(char);
else if (!strcmpi(str, "int16")) cls = mxINT16_CLASS, datalen *= sizeof(short);
else if (!strcmpi(str, "uint16")) cls = mxUINT16_CLASS, datalen *= sizeof(short);
else if (!strcmpi(str, "int32")) cls = mxINT32_CLASS, datalen *= sizeof(int);
else if (!strcmpi(str, "uint32")) cls = mxUINT32_CLASS, datalen *= sizeof(int);
else mexErrMsgTxt("Output matrix type must be one of 'single', 'double', 'int8', 'uint8', 'int16', 'int16', 'int32', 'uint32'.");
plhs[0] = mxCreateNumericArray(ndims, dims, cls, mxREAL);
try {
nc->receiveData(mxGetData(plhs[0]), datalen, true);
} catch (const SocketException & e) {
const std::string why (e.why());
if (why.length()) mexWarnMsgTxt(why.c_str());
mxDestroyArray(plhs[0]);
plhs[0] = 0; // nullify (empty) return..
RETURN_NULL();
}
}
void ClientInit()
{
InitNetMsg();
for (int32 i = 0; i < MAX_CLIENT_COUNT; ++i)
{
NetClient* gNetClient = new NetClient();
gNetClient->SetAddress("127.0.0.1", 9900);
gNetClient->SetHandler(OnNetMsgEnter, OnNetMsg, OnNetMsgExit);
gNetClient->Start();
ClientPlayer* gPlayer = new ClientPlayer();
gPlayer->SetSocket(gNetClient->GetSocket());
ClientPlayerMgr::Instance()->AddSocket(gNetClient,gPlayer);
}
//命令调试
//gGameCommond.Init(gNetClient->GetSocket());
//GameCommand::CommandHelp();
}
void sendInt32Matrix(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
NetClient *nc = GetNetClient(nrhs, prhs);
if(nrhs != 2) mexErrMsgTxt("Two arguments required: handle, vector.");
if(mxGetClassID(prhs[0]) != mxDOUBLE_CLASS)
mexErrMsgTxt("Argument 2 must be a 1x1 scalar of doubles.");
if(mxGetClassID(prhs[1]) != mxINT32_CLASS)
mexErrMsgTxt("Argument 3 must be a matrix of int32s.");
int32 *theInts = reinterpret_cast<int32 *>(mxGetData(prhs[1]));
int msglen = mxGetN(prhs[1]) * mxGetM(prhs[1]) * sizeof(int32);
try {
nc->sendData(theInts, msglen);
} catch (const SocketException & e) {
mexWarnMsgTxt(e.why().c_str());
RETURN_NULL();
}
RETURN(1);
}
void readInt32Matrix(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
NetClient *nc = GetNetClient(nrhs, prhs);
if(nrhs != 3 || !mxIsDouble(prhs[1]) || !mxIsDouble(prhs[2]) ) mexErrMsgTxt("Output matrix size M, N as 2 real argument are required.");
//if(nlhs < 1) mexErrMsgTxt("One output argument required.");
const int m = static_cast<int>(*mxGetPr(prhs[1])),
n = static_cast<int>(*mxGetPr(prhs[2]));
const int dataLen = m*n*sizeof(int32);
const int dims[] = { m, n };
plhs[0] = mxCreateNumericArray(2, dims, mxINT32_CLASS, mxREAL);
try {
nc->receiveData(mxGetData(plhs[0]), dataLen, true);
} catch (const SocketException & e) {
mexWarnMsgTxt(e.why().c_str());
mxDestroyArray(plhs[0]);
plhs[0] = 0; // nullify (empty) return..
RETURN_NULL();
}
}
static void worker (Thread *thread)
{
NetClient *client = thread->argument;
NetClientEpollEvent event;
int count;
int i;
while (net_client_epoll_events_count (client->epoll, &count)) {
for (i = 0; i < count; i++) {
event = net_client_epoll_event (client->epoll, i);
if (event.stop) {
return;
}
else if (event.connect) {
worker_connect (client, event.pointer);
}
else {
worker_connect_error (client, event.pointer);
}
}
}
client->on_error (client);
return;
}
static void
doB()
{
cout << "[B] Initialized." << endl;
NetClient* net = new MPIClient(1);
mpz_t a;
mpz_init_set_ui(a, 0);
string header;
header = net->waitForMessage();
int valid = net->getDataAsZVector(&a, 1);
cout << "[B] Recv " << valid << " mpz_t from A with the header: '" << header << "'" << endl;
gmp_printf("[B] We got: %Zd\n", a);
mpz_set_si(a, rand() + 2342);
cout << "[B] Send " << 1 << " mpz_t to A." << endl;
gmp_printf("[B] Should expect: %Zd\n", a);
net->sendZVector("Vec from B.", &a, 1);
header = net->waitForMessage();
cout << "[B] Recv Empty from A." << endl;
cout << "[B] H: " << header << endl;
header = net->waitForMessage();
cout << "[B] Recv MSG treated as empty from A." << endl;
cout << "[B] H: " << header << endl;
char* buf;
header = net->waitForMessage();
size_t len = net->getData(&buf);
cout << "[B] Recv MSG from A." << endl;
cout << "[B] H: " << header << endl;
header.assign(buf, len);
cout << "[B] len: " << len << " D: " << header << endl;
cout << net->getGlobalStat() << endl;
delete net;
}
static size_t
getDataAsVector(NetClient& net, T* vec, size_t len)
{
FILE* f = tmpfile();
net.getDataAsFile(f);
rewind(f);
size_t nvalid;
for (nvalid = 0; nvalid < len; nvalid++)
{
if (!inRaw(vec[nvalid], f))
break;
}
fclose(f);
return nvalid;
}
void SMWServer::sendVisibleRoomEntries(NetClient& client)
{
if (!rooms.size()) {
sendCode(client, NET_RESPONSE_NO_ROOMS);
return;
}
printf("Sending %lu rooms:\n", rooms.size());
auto it = rooms.begin();
while (it != rooms.end()) {
Room* room = &it->second;
if (room->visible)
{
RoomInfoPackage roomInfo;
{
roomInfo.protocolMajorVersion = NET_PROTOCOL_VERSION_MAJOR;
roomInfo.protocolMinorVersion = NET_PROTOCOL_VERSION_MINOR;
roomInfo.packageType = NET_RESPONSE_ROOM_LIST_ENTRY;
roomInfo.roomID = room->roomID;
memcpy(roomInfo.name, room->name, NET_MAX_ROOM_NAME_LENGTH);
roomInfo.name[NET_MAX_ROOM_NAME_LENGTH - 1] = '\0';
roomInfo.passwordRequired = false;
if (room->password[0] != '\0')
roomInfo.passwordRequired = true;
roomInfo.currentPlayerCount = 0;
for (long unsigned p = 0; p < 4; p++)
if (room->players[p])
roomInfo.currentPlayerCount++;
roomInfo.gamemodeID = room->gamemodeID;
printf(" room %d: {%s; pass?: %d; players: %d}\n",
roomInfo.roomID, roomInfo.name, roomInfo.passwordRequired, roomInfo.currentPlayerCount);
}
client.sendData(&roomInfo, sizeof(RoomInfoPackage));
}
++it;
}
}
static void
sendVector(NetClient& net, const string& vecname, const T* vec, size_t len)
{
FILE* f = tmpfile();
size_t fsize = 0;
for (size_t i = 0; i < len; i++)
{
size_t outLen = 0;
if ((outLen = outRaw(f, vec[i])))
fsize += outLen;
else
cerr << "[NetClient] Failed writing a gmp element.";
}
rewind(f);
net.sendFile(vecname, f, fsize);
fclose(f);
}
int main()
{
int port = 10088;
int port2 = 5188;
std::string ip = "183.62.250.18";
NetClient* ClientHandler = new NetClient();
ClientHandler->initClient(ip, port);
ClientHandler->netSocket();
ClientHandler->netConnect();
//init mqtt client
mqtt::async_client client(ADDRESS, CLIENTID);
callback cb;
client.set_callback(cb);
mqtt::itoken_ptr conntok = client.connect();
try{
std::cout << "the mqtt waiting for the connection..." << std::flush;
conntok->wait_for_completion();
std::cout << "OK" << std::endl;
}catch (const mqtt::exception& exc) {
std::cerr << "Error: " << exc.what() << std::endl;
}
//test mqtt
std::string test_message = "this is a test meesage...";
mqtt::message_ptr pubmsg = std::make_shared<mqtt::message>(test_message);
pubmsg->set_qos(QOS);
client.publish(TOPIC, pubmsg)->wait_for_completion(TIMEOUT);
//init active mq
std::string brokerURI = "failover:(tcp://101.37.33.121:61616)";
bool useTopic = true;
bool clientAck = false;
std::string topic = "QUOTE.ORG";
activemq::library::ActiveMQCPP::initializeLibrary();
ActiveMqProducer::getInstance()->initProducer(brokerURI, useTopic, clientAck);
//init write file
std::string date = getDate();
std::string filename = date +".log";
std::ofstream out_file(filename, ios::app);
//start recv json data
bool log_flag = ClientHandler->verifyLogin();
std::string str="";
while( log_flag )
{
ClientHandler->recvData( str );
if(!str.empty())
{
std::string tmep_send = str.substr(0, str.length()-1);
ActiveMqProducer::getInstance()->sendMessage(topic, tmep_send);
//write the message to another file
out_file << getDateAndTime() << "[The received data:]" << tmep_send << std::endl << std::endl;
str="";
}
}
std::vector<mqtt::idelivery_token_ptr> toks = client.get_pending_delivery_tokens();
if (!toks.empty())
{
std::cout << "Error: There are pending delivery tokens!" << std::endl;
}
// mqtt disconnect
std::cout << "Disconnecting..." << std::flush;
conntok = client.disconnect();
conntok->wait_for_completion();
std::cout << "OK" << std::endl;
//destory active mq
ActiveMqProducer::getInstance()->close();
activemq::library::ActiveMQCPP::shutdownLibrary();
//delete
delete ClientHandler;
return 0;
}
