int main(int argc, char** argv) { std::string broker = argc > 1 ? argv[1] : "localhost:5672"; std::string address = argc > 2 ? argv[2] : "amq.topic"; Connection connection(broker); try { connection.open(); Session session = connection.createSession(); Receiver receiver = session.createReceiver(address); Sender sender = session.createSender(address); sender.send(Message("Hello world!")); Message message = receiver.fetch(Duration::SECOND * 1); std::cout << message.getContent() << std::endl; session.acknowledge(); connection.close(); return 0; } catch(const std::exception& error) { std::cerr << error.what() << std::endl; connection.close(); return 1; } }
static int qpidhello(char *br) { std::string broker = br ? br : "localhost:5672"; std::string address = "amq.topic"; std::string connectionOptions = ""; Connection connection(broker, connectionOptions); try { connection.open(); Session session = connection.createSession(); Receiver receiver = session.createReceiver(address); Sender sender = session.createSender(address); sender.send(Message("Hello world!")); Message message = receiver.fetch(Duration::SECOND * 1); std::cout << message.getContent() << std::endl; session.acknowledge(); connection.close(); return 0; } catch(const std::exception& error) { std::cerr << error.what() << std::endl; connection.close(); return 1; } }
int main() { title("Testing Sender package ", '='); try { Sender sender; Verbose v(true); SocketSystem ss; SocketConnecter si; Message msg; while (!si.connect("localhost", 9085)) { Verbose::show("client waiting to connect"); ::Sleep(100); } // TODO sent msg.commandType = UPLOAD; msg.senderPort = 9080; msg.destAdd = "localhost"; msg.destPort = 9085; msg.fileName = "demo.txt"; sender.sendFiledata(si, msg, true); Verbose::show("\n client calling send shutdown\n"); si.shutDownSend(); } catch (std::exception& ex) { Verbose::show(" Exception caught:", always); Verbose::show(std::string("\n ") + ex.what() + "\n\n"); } }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { if (parse_args (argc, argv) == -1) return -1; Sender sender; Receiver receiver; // If passive side if (host == 0) { if (receiver.open_addr (ACE_INET_Addr (port)) == -1) return -1; } // If active side else if (sender.open (host, port) == -1) return -1; for (int success = 1; success > 0 && !done; ) // Dispatch events via Proactor singleton. success = ACE_Proactor::instance ()->handle_events (); return 0; }
int Purger_Thread::svc (void) { for (; !this->reactor_.reactor_event_loop_done ();) { // Get a connection from the cache. Sender *sender = this->connection_cache_.acquire_connection (); // If no connection is available in the cache, sleep for a while. if (sender == 0) ACE_OS::sleep (ACE_Time_Value (0, 10 * 1000)); else { // The reference count on the sender was increased by the // cache before it was returned to us. ACE_Event_Handler_var safe_sender (sender); // Actively close the connection. ACE_DEBUG ((LM_DEBUG, "Purger thread calling Sender::close() for handle %d\n", sender->handle_)); sender->close (); } } return 0; }
// Function for retreving the content for downloading in client string Receiver::downloadMessage(string msg1,Message *msgobj,Socket &si) { string msgstr = ""; Sender sd; Message *m = new Message(); string filename = m->getmsgBody1(msg1), sendaddres = msgobj->getsendAddr(msg1), clientaddres = msgobj->getrecvAddr(msg1); string client_port, client_addrs, server_port, server_addrs, parsed, parsed1; stringstream input_stringstream1(sendaddres), input_stringstream(clientaddres); if (getline(input_stringstream1, parsed, ',')) client_addrs = parsed; if (getline(input_stringstream1, parsed, ' ')) client_port = parsed; if (getline(input_stringstream, parsed1, ',')) server_addrs = parsed1; if (getline(input_stringstream, parsed1, ' ')) server_port = parsed1; int clientport = atoi(client_port.c_str()); int serverport = atoi(server_port.c_str()); sd.sendTextFile(client_addrs, clientport, server_addrs, serverport, filename, si, "false"); Message ackmsg; ackmsg.setCommand("Acknowledgement"); ackmsg.setsendAddr(msgobj->getrecvAddr(msg1)); ackmsg.setrecAddr(msgobj->getsendAddr(msg1)); string s = "Message :" + msgobj->getmsgBody1(msg1) + "Received by client with address: " + msgobj->getrecvAddr(msg1); ackmsg.setmsgBody(s); msgstr = ackmsg.getMessage(); si.sendString(msgstr); return msgstr; }
///return 0: succeed -1: can't found 1: buffer_full int ClientConnFactoryInnerConnImp2::send_pack(uint64_t connect_id,Sender& s) { DAT* p_dat; if(m_connection_map.find_id(connect_id, p_dat)<0) { return -1; } try { uint64_t get_sz=s.headerSize() + s.bodySize(); p_dat->conn->send(s); p_dat->total_write_bytes+=get_sz; } catch(std::runtime_error& e) { return 1; } catch(std::exception& x) { log(Warn, "ClientConnFactoryInnerConnImp2::send_pack std::exception: %s", x.what()); disconnect(connect_id); return -1; } return 0; }
void ClientHandler::operator()(Socket& socket_) { Display *disp = new Display(); BlockingQueue<string> q_; while (true) { Receiver *rs = new Receiver(); std::string command = socket_.recvString(); q_.enQ(command); if (command.size() == 0) break; size_t size= q_.size(); string ackmsg; for (size_t i = 0; i < size; i++) { command = q_.deQ(); ackmsg = rs->start(command, socket_); } Sender *s = new Sender(); if (ackmsg != "") { s->sendAck(socket_, ackmsg); } } disp->show("ClientHandler socket connection closing"); socket_.shutDown(); socket_.close(); disp->show("ClientHandler thread terminating"); }
void Mac::SentFrame(bool aAcked) { Address destination; Neighbor *neighbor; Sender *sender; switch (mState) { case kStateActiveScan: mAckTimer.Start(mScanDuration); break; case kStateTransmitBeacon: ScheduleNextTransmission(); break; case kStateTransmitData: if (mSendFrame.GetAckRequest() && !aAcked) { otDumpDebgMac("NO ACK", mSendFrame.GetHeader(), 16); if (mTransmitAttempts < kMaxFrameAttempts) { mTransmitAttempts++; StartCsmaBackoff(); ExitNow(); } mSendFrame.GetDstAddr(destination); if ((neighbor = mMle.GetNeighbor(destination)) != NULL) { neighbor->mState = Neighbor::kStateInvalid; } } mTransmitAttempts = 0; sender = mSendHead; mSendHead = mSendHead->mNext; if (mSendHead == NULL) { mSendTail = NULL; } mDataSequence++; sender->HandleSentFrame(mSendFrame); ScheduleNextTransmission(); break; default: assert(false); break; } exit: {} }
//----< Test Stub to test the sender>-------------------------------- int main() { title("Message Passing Communication", '='); try { Sender s; Verbose v(true); SocketSystem ss; SocketConnecter si; while (!si.connect("localhost", 9080)) { Verbose::show("client waiting to connect"); ::Sleep(100); } title("Starting string test on client"); std::vector<std::string> messageDetails; messageDetails.push_back("upload"); messageDetails.push_back("localhost"); messageDetails.push_back("9080"); messageDetails.push_back("Delay.pdf"); messageDetails.push_back("localhost"); messageDetails.push_back("9081"); s.clientFileHandling(si, messageDetails, "input/"); si.shutDownSend(); } catch (std::exception& ex) { Verbose::show("Exception caught:", always); Verbose::show(std::string("\n ") + ex.what() + "\n\n"); } }
int main(int argc, char** argv) { const char* url = argc>1 ? argv[1] : "amqp:tcp:127.0.0.1:5672"; try { Connection connection = Connection::open(url); Session session = connection.newSession(); Receiver receiver = session.createReceiver("service_queue; {create: always}"); while (true) { Message request = receiver.fetch(); const Address& address = request.getReplyTo(); if (address) { Sender sender = session.createSender(address); std::string s = request.getContent(); std::transform(s.begin(), s.end(), s.begin(), toupper); Message response(s); sender.send(response); std::cout << "Processed request: " << request.getContent() << " -> " << response.getContent() << std::endl; session.acknowledge(); } else { std::cerr << "Error: no reply address specified for request: " << request.getContent() << std::endl; session.reject(request); } } connection.close(); return 0; } catch(const std::exception& error) { std::cout << error.what() << std::endl; } return 1; }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { if (parse_args (argc, argv) == -1) return -1; Sender sender; // Note: acceptor parameterized by the Receiver. ACE_Asynch_Acceptor<Receiver> acceptor; // If passive side if (host == 0) { if (acceptor.open (ACE_INET_Addr (port), initial_read_size, 1) == -1) return -1; } // If active side else if (sender.open (host, port) == -1) return -1; int success = 1; while (success > 0 && !done) // Dispatch events via Proactor singleton. success = ACE_Proactor::instance ()->handle_events (); return 0; }
int main() { UserCase* uc = new UserCase; UserCase_* uc_ = new UserCase_; { Sender se; se.si.connect(uc, &UserCase::func1); se.si.connect(uc, &UserCase::func2); se.si.connect(uc_, &UserCase_::func); se.si.connect(globalfunc1); se.si.connect(globalfunc2); se.si.disconnect(globalfunc1); delete uc_; Signal<float, float, double>::Rv_Vector_Set_Sp ret = se.si(50, 100); cout << endl; Signal<float, float, double>::Rv_Vector_Set_Sp::const_iterator it = ret.begin(); Signal<float, float, double>::Rv_Vector_Set_Sp::const_iterator itEnd = ret.end(); while (it != itEnd) { cout << "value = " << (*it)->value << endl; cout << "class_ = " << (*it)->class_ << endl; cout << "function_ = " << (*it)->function_ << endl; cout << endl; ++it; } } delete uc; return 0; }
int main(int argc, char *argv[]) { QApplication app(argc, argv); Sender sender; sender.show(); return app.exec(); }
int lansink_poll_revents(snd_pcm_ioplug_t *_pPlug, struct pollfd *_pFD, unsigned int _cFDs, unsigned short *_pREvents) { Sender *pPlug = (Sender *)_pPlug->private_data; try { static char buf[1]; assert(_pFD && _cFDs == 1 && _pREvents); *_pREvents = _pFD[0].revents & ~(POLLIN | POLLOUT); if (_pFD[0].revents & POLLIN) { read(_pFD[0].fd, buf, 1); *_pREvents |= POLLOUT; pPlug->log.debug("get_delay() = %ld, get_buffer_size() = %lu", pPlug->get_delay(), pPlug->get_buffer_size()); } pPlug->log.debug("%s() = %d, _pFD[0].revents = %d, *_pREvents = %d", __FUNCTION__, 0, _pFD[0].revents, *_pREvents); } catch (std::exception &e) { pPlug->log.error(e.what()); } return 0; }
int main(int argc, char *argv[]) { QApplication a(argc, argv); Sender w; w.show(); return a.exec(); }
int main() { Sender s; Receiver r(9060); Message m; m.constructMessage("file_upload", "../Peer/UploadDirectory/test.txt", "localhost", 9050, "localhost", 9060); s.postMessage(m); return 0; }
void IRCServer::handleBan(Sender sender, const QString &channel, int ban_type, bool apply) { QString nick = (ban_type & BAN_NICK) ? sender.GetNickName() : "*"; QString user = (ban_type & BAN_USER) ? sender.GetUser() : "*"; QString host = (ban_type & BAN_HOST) ? sender.GetHost() : "*"; QString full_ban = nick + IRC::UserPrefix + user + IRC::HostPrefix + host; QByteArray command = "MODE " + channel.toUtf8() + " "+ (apply ? "+" : "-") + "b " + full_ban.toUtf8(); sendCommandAsap(command); }
static void test_func(void) { test_caseStart("Testing functions"); { Sender<int> s; tuple<int> x(2); s.subscribe(func_recv(test_func0)); s.subscribe(bind1_func_recv(2,test_func1)); s.subscribe(bind1_func_recv(x,test_func2)); s.subscribe(bind1_func_recv(const_cast<const tuple<int>&>(x),test_func3)); s.send(1); for(size_t i = 0; i <= 3; ++i) test_assertSize(calls[i],1); } { Sender<int&> s; tuple<int> x(2); s.subscribe(func_recv(test_func4)); s.subscribe(bind1_func_recv(x,test_func5)); int y = 1; s.send(y); for(size_t i = 4; i <= 5; ++i) test_assertSize(calls[i],1); } test_caseSucceeded(); }
int main(int argc, char *argv[]) { QApplication app(argc, argv); Sender sender; #ifdef Q_OS_SYMBIAN sender.showMaximized(); #else sender.show(); #endif return app.exec(); }
int ACE_TMAIN (int argc, ACE_TCHAR *argv[]) { ACE_UNUSED_ARG (initial_read_size); if (parse_args (argc, argv) == -1) return -1; #if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE) ACE_WIN32_Proactor * pImpl = new ACE_WIN32_Proactor; #elif defined (ACE_HAS_AIO_CALLS) // ACE_POSIX_AIOCB_Proactor * pImpl = new ACE_POSIX_AIOCB_Proactor; ACE_POSIX_SIG_Proactor * pImpl = new ACE_POSIX_SIG_Proactor; #endif ACE_Proactor Proactor ( pImpl ,1 ); ACE_Proactor::instance( & Proactor ); MyTask Task1 ; if (Task1.activate (THR_NEW_LWP, nThreads ) == -1) { ACE_ERROR_RETURN ((LM_ERROR, "%p.\n", "main"), -1); } Sender sender; ACE_Asynch_Acceptor<Receiver> acceptor; int Rc = -1 ; if ( host == NULL ) // Acceptor { // Simplify , initial read with zero size Rc = acceptor.open (ACE_INET_Addr (port),0,1); } else { Rc = sender.open (host, port); } if ( Rc == 0 ) { char c ; cout << "Press any key to stop and exit=>\n" << flush ; cin.clear (); cin >> c ; }
int main(int argc, char** argv) { const char* url = argc>1 ? argv[1] : "amqp:tcp:127.0.0.1:5672"; std::string connectionOptions = argc > 2 ? argv[2] : ""; Connection connection(url, connectionOptions); try { connection.open(); Session session = connection.createSession(); Receiver receiver = session.createReceiver("service_queue; {create: always}"); while (true) { Message request = receiver.fetch(); const Address& address = request.getReplyTo(); if (address) { Sender sender = session.createSender(address); Message response; qpid::types::Variant requestObj = request.getContentObject(); if (requestObj.getType() == qpid::types::VAR_STRING) { // Received a string. // Server returns request string in upper case with same encoding. std::string s = requestObj; std::transform(s.begin(), s.end(), s.begin(), toupper); qpid::types::Variant responseObj(s); responseObj.setEncoding( requestObj.getEncoding() ); response.setContentObject( responseObj ); } else { // Received something other than a string. // Server echos received object as a utf8 string. qpid::types::Variant responseObj( requestObj.asString() ); responseObj.setEncoding( "utf8" ); response.setContentObject( requestObj ); } sender.send(response); std::cout << "Processed request: " << request.getContentObject() << " -> " << response.getContentObject() << std::endl; session.acknowledge(); sender.close(); } else { std::cerr << "Error: no reply address specified for request: " << request.getContent() << std::endl; session.reject(request); } } connection.close(); return 0; } catch(const std::exception& error) { std::cout << error.what() << std::endl; connection.close(); } return 1; }
int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); MyThread *souThread=new MyThread; souThread->start(); Sender w; w.setTimer(); return a.exec(); }
int lansink_delay(snd_pcm_ioplug_t *_pPlug, snd_pcm_sframes_t *_pnDelay) { Sender *pPlug = (Sender *)_pPlug->private_data; try { *_pnDelay = pPlug->get_delay(); pPlug->log.debug("%s() = %d; *_pnDelay = %ld", __FUNCTION__, 0, *_pnDelay); } catch (std::exception &e) { pPlug->log.error(e.what()); } return 0; }
int lansink_stop(snd_pcm_ioplug_t *_pPlug) { Sender *pPlug = (Sender *)_pPlug->private_data; try { pPlug->stop(); pPlug->log.debug("%s() = %d", __FUNCTION__, 0); } catch (std::exception &e) { pPlug->log.error(e.what()); } return 0; }
snd_pcm_sframes_t lansink_pointer(snd_pcm_ioplug_t *_pPlug) { Sender *pPlug = (Sender *)_pPlug->private_data; snd_pcm_sframes_t nResult = 0; try { nResult = pPlug->get_buffer_pointer(); pPlug->log.debug("%s() = %d", __FUNCTION__, nResult); } catch (std::exception &e) { pPlug->log.error(e.what()); } return nResult; }
void Connector::on_delete_sender (Sender & sndr) { ACE_Guard<ACE_Recursive_Thread_Mutex> locker (this->mutex_); this->sessions_--; this->total_snd_ += sndr.get_total_snd(); this->total_rcv_ += sndr.get_total_rcv(); this->total_w_ += sndr.get_total_w(); this->total_r_ += sndr.get_total_r(); if (sndr.index_ < MAX_SENDERS && this->list_senders_[sndr.index_] == &sndr) this->list_senders_[sndr.index_] = 0; ACE_TCHAR bufs [256]; ACE_TCHAR bufr [256]; ACE_OS::sprintf ( bufs , ACE_TEXT ("%ld(%ld)"), sndr.get_total_snd(), sndr.get_total_w() ); ACE_OS::sprintf ( bufr , ACE_TEXT ("%ld(%ld)"), sndr.get_total_rcv(), sndr.get_total_r() ); ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Sender::~DTOR index=%d snd=%s rcv=%s sessions_=%d\n"), sndr.index_, bufs, bufr, this->sessions_)); }
int main (int argc, char *argv []) { QCoreApplication app (argc, argv); Receiver r; Disconnector d; Sender s (&r, &d); r.s = &s; d.s = &s; ::Step = 0; s.fire (); return 0; }
ssize_t TransmissionManager::send( Sender& sender, bool start_and_end, useconds_t udelay) { ssize_t rc = 0; if (start_and_end && ! _started) { rc = this->start(sender); hlog_regression("send: rc=%zd start", rc); if (rc < 0) return -errno; if (udelay > 0) { usleep(udelay); } } const ITransmissionManager* src = this; while (src != NULL) { for (std::list<IObject*>::const_iterator it = _objects.begin(); it != _objects.end(); ++it) { IObject& o = **it; while (o.ready()) { if (o.length() < 0) { rc = sender.error(static_cast<int>(-o.length())); if (rc < 0) return -errno; return o.length(); } else { rc = sender.write(o.tag(), o.value(), o.length()); hlog_generic(HLOG_GENERIC_BOTH, debug, Report::HLOG_TLV_NOSEND, -1, o.length(), o.value(), "send: rc=%zd tag=%d len=%zu val:", rc, o.tag(), o.length()); if (rc < 0) return -errno; if (udelay > 0) { usleep(udelay); } } } } src = src->next(); } if (start_and_end && _started) { rc = sender.end(); hlog_regression("send: rc=%zd end", rc); if (rc < 0) return -errno; _started = false; if (udelay > 0) { usleep(udelay); } } return 0; }
SettingsMessage SettingsMessage::toMessage(const QVariant & message, const Sender & sender, const Reciever & reciever, const Recievers & recievers, const ReliableTime & reliableTime) { QVariantMap messageMap = message.toMap(); QVariantMap msHeader = messageMap["header"].toMap(); Recievers recieversList; for (const QVariant & reciever : msHeader["recievers"].toList()) { recieversList << reciever.value<Reciever>(); } Message::SettingsMessage ms( sender.isEmpty() ? msHeader["sender"].value<Message::Sender>() : sender, reciever.isEmpty() ? msHeader["reciever"].value<Message::Reciever>() : reciever, recievers.isEmpty() ? recieversList : recievers ); if (msHeader.contains("reliableTime")) { ms.setReliableTime(reliableTime == ReliableTime(-1) ? msHeader["reliableTime"].value<Message::ReliableTime>() : reliableTime); } ms.data = messageMap["data"].toMap(); return ms; }