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(); }
static void test_memfunc(void) { test_caseStart("Testing member functions"); { Test test; const Test ctest; Sender<int> s; tuple<int> x(2); s.subscribe(mem_recv(&test,&Test::test_func6)); s.subscribe(bind1_mem_recv(2,&test,&Test::test_func7)); s.subscribe(bind1_mem_recv(x,&test,&Test::test_func8)); s.subscribe(bind1_mem_recv(const_cast<const tuple<int>&>(x),&test,&Test::test_func9)); s.subscribe(bind1_mem_recv(x,&ctest,&Test::test_func10)); s.subscribe(bind1_mem_recv(const_cast<const tuple<int>&>(x),&ctest,&Test::test_func11)); s.send(1); for(size_t i = 6; i <= 11; ++i) test_assertSize(calls[i],1); } { Test test; const Test ctest; Sender<int&> s; tuple<int> x(2); s.subscribe(mem_recv(&test,&Test::test_func12)); s.subscribe(bind1_mem_recv(x,&test,&Test::test_func13)); s.subscribe(bind1_mem_recv(x,&ctest,&Test::test_func14)); int y = 1; s.send(y); for(size_t i = 12; i <= 14; ++i) test_assertSize(calls[i],1); } test_caseSucceeded(); }
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; } }
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; }
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; } }
static void ExpectRegistered( std::string const & iTemporaryRobotId, std::string const & iExpectedRobotId, std::string const & iExpectedTeam, Sender & ioPusher, Receiver & ioSubscriber) { Register aRegisterMessage; aRegisterMessage.set_temporary_robot_id(iTemporaryRobotId); aRegisterMessage.set_video_url("http://localhost:80"); aRegisterMessage.set_image("this is a photo of the robot.jpg"); RawMessage aMessage( iTemporaryRobotId, "Register", aRegisterMessage.SerializeAsString()); ioPusher.send(aMessage); RawMessage aResponse; if (not Common::ExpectMessage("Registered", ioSubscriber, aResponse)) { ORWELL_LOG_ERROR("Expected Registered but received " << aResponse._type); g_status = -1; } else { Registered aRegistered; aRegistered.ParsePartialFromString(aResponse._payload); if (aRegistered.robot_id() != iExpectedRobotId) { ORWELL_LOG_ERROR("Expected robot ID '" << iExpectedRobotId << "' but received '" << aRegistered.robot_id() << "'"); g_status = -2; } if (iExpectedTeam.length() > 0) { if (aRegistered.has_team()) { ORWELL_LOG_INFO("The robot will be in team: " << aRegistered.team()); if (iExpectedTeam != aRegistered.team()) { ORWELL_LOG_ERROR("Expected team '" << iExpectedTeam << "' but received '" << aRegistered.team() << "'"); g_status = -4; } } else { ORWELL_LOG_ERROR("Expected a team but none found."); g_status = -3; } } } }
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) { 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(); Sender sender = session.createSender("service_queue"); //create temp queue & receiver... Receiver receiver = session.createReceiver("#"); Address responseQueue = receiver.getAddress(); // Now send some messages ... string s[] = { "Twas brillig, and the slithy toves", "Did gire and gymble in the wabe.", "All mimsy were the borogroves,", "And the mome raths outgrabe." }; Message request; request.setReplyTo(responseQueue); for (int i=0; i<4; i++) { request.setContent(s[i]); sender.send(request); Message response = receiver.fetch(); std::cout << request.getContent() << " -> " << response.getContent() << std::endl; } 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) { std::string broker = argc > 1 ? argv[1] : "localhost:5445"; std::string address = argc > 2 ? argv[2] : "jms.queue.exampleQueue"; // Connection options documented at http://qpid.apache.org/releases/qpid-0.30/programming/book/connections.html#connection-options std::string connectionOptions = argc > 3 ? argv[3] : "{protocol:amqp1.0}"; try { // Step 3. Create an amqp qpid 1.0 connection Connection connection(broker, connectionOptions); connection.open(); // Step 4. Create a session Session session = connection.createSession(); // Step 5. Create a sender Sender sender = session.createSender(address); // Step 6. send a simple message sender.send(Message("Hello world!")); // Step 7. create a receiver Receiver receiver = session.createReceiver(address); // Step 8. receive the simple message Message message = receiver.fetch(Duration::SECOND * 1); std::cout << "Received a message with this following content \"" << message.getContent() << "\"" << std::endl; // Step 9. acknowledge the message session.acknowledge(); // Step 10. close the connection connection.close(); return 0; } catch(const std::exception& error) { std::cerr << error.what() << std::endl; return 1; } }
void RequestResponse::run() { const char *options[] = {"", "--log-enable", "trace+", "--log-to-stdout", "on", "--log-time", "on", "--log-level", "on"}; Logger::configure(9, options); std::string url = "amqp:ssl:" + _options.getHost() + ":" + std::to_string(_options.getPort()); Connection connection(url, "{ protocol: amqp1.0 }"); connection.setOption("sasl_mechanisms", "EXTERNAL"); connection.setOption("heartbeat", "30"); Address reply(_replyAddress); Address request(_requestAddress); Address response(_responseAddress); Duration timeout = Duration::SECOND * _options.getTimeout(); try { connection.open(); Session session = connection.createSession(); std::cout << "-I- Connection opened, session created" << std::endl; Sender sender = session.createSender(request); sender.setCapacity(_capacity); std::cout << "-I- Sender created " << sender.getName() << std::endl; Receiver receiver = session.createReceiver(response); receiver.setCapacity(_capacity); std::cout << "-I- Receiver created " << receiver.getName() << std::endl; Message requestMsg("<FIXML>...</FIXML>"); requestMsg.setDurable(false); requestMsg.setReplyTo(reply); sender.send(requestMsg, true); std::cout << "-I- Request message sent" << std::endl; try { Message responseMsg = receiver.fetch(timeout); std::cout << "-I- Received message with content: " << responseMsg.getContent() << std::endl; session.acknowledge(true); _messageCounter++; } catch (NoMessageAvailable noMessage) { std::cout << "-I- No message received for " << timeout.getMilliseconds()/1000 << " seconds" << std::endl; } session.sync(true); sender.close(); receiver.close(); session.close(); connection.close(); } catch (const std::exception &error) { connection.close(); std::cerr << "-E- Caught exception: " << error.what() << std::endl; throw error; } }
void agocontrol::AgoConnection::run() { try { receiver = session.createReceiver("agocontrol; {create: always, node: {type: topic}}"); } catch(const std::exception& error) { std::cerr << error.what() << std::endl; printf("could not create receiver when connecting to broker\n"); _exit(1); } // reportDevices(); // this is obsolete as it is handled by addDevice while( true ) { try{ Variant::Map content; Message message = receiver.fetch(Duration::SECOND * 3); session.acknowledge(); // workaround for bug qpid-3445 if (message.getContent().size() < 4) { throw qpid::messaging::EncodingException("message too small"); } decode(message, content); // std::cout << content << std::endl; if (content["command"] == "discover") { reportDevices(); // make resolver happy and announce devices on discover request } else { if (message.getSubject().size() == 0) { // no subject, this is a command string internalid = uuidToInternalId(content["uuid"].asString()); // lets see if this is for one of our devices bool isOurDevice = (internalid.size() > 0) && (deviceMap.find(internalIdToUuid(internalid)) != deviceMap.end()); // only handle if a command handler is set. In addition it needs to be one of our device when the filter is enabled if ( ( isOurDevice || (!(filterCommands))) && commandHandler != NULL) { // printf("command for id %s found, calling handler\n", internalid.c_str()); if (internalid.size() > 0) content["internalid"] = internalid; qpid::types::Variant::Map responsemap = commandHandler(content); // found a match, reply to sender and pass the command to the assigned handler method const Address& replyaddress = message.getReplyTo(); // only send a reply if this was for one of our childs // or if it was the special command inventory when the filterCommands was false, that's used by the resolver // to reply to "anonymous" requests not destined to any specific uuid if ((replyaddress && isOurDevice) || (content["command"]=="inventory" && filterCommands==false)) { // std::cout << "sending reply" << std::endl; Session replysession = connection.createSession(); try { Sender replysender = replysession.createSender(replyaddress); Message response; encode(responsemap, response); response.setSubject(instance); replysender.send(response); replysession.close(); } catch(const std::exception& error) { printf("can't send reply\n"); replysession.close(); } } } } else if (eventHandler != NULL) { eventHandler(message.getSubject(), content); } } } catch(const NoMessageAvailable& error) { } catch(const std::exception& error) { std::cerr << error.what() << std::endl; if (session.hasError()) { clog << agocontrol::kLogCrit << "Session has error, recreating" << std::endl; session.close(); session = connection.createSession(); receiver = session.createReceiver("agocontrol; {create: always, node: {type: topic}}"); sender = session.createSender("agocontrol; {create: always, node: {type: topic}}"); } usleep(50); } } }
int main() { Sender sender; sender.send("a"); sender.send("b"); }