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;
}
