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