qpid::types::Variant::Map agocontrol::AgoConnection::getInventory() {
Variant::Map content;
Variant::Map responseMap;
content["command"] = "inventory";
Message message;
encode(content, message);
Address responseQueue("#response-queue; {create:always, delete:always}");
Receiver responseReceiver = session.createReceiver(responseQueue);
message.setReplyTo(responseQueue);
sender.send(message);
try {
Message response = responseReceiver.fetch(Duration::SECOND * 3);
session.acknowledge();
if (response.getContentSize() > 3) {
decode(response,responseMap);
}
} catch (qpid::messaging::NoMessageAvailable) {
printf("WARNING, no reply message to fetch\n");
}
try {
responseReceiver.close();
} catch(const std::exception& error) {
std::cerr << error.what() << std::endl;
}
return responseMap;
}
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;
}
}
qpid::types::Variant::Map agocontrol::AgoConnection::sendMessageReply(const char *subject, qpid::types::Variant::Map content) {
Message message;
qpid::types::Variant::Map responseMap;
Receiver responseReceiver;
try {
encode(content, message);
message.setSubject(subject);
Address responseQueue("#response-queue; {create:always, delete:always}");
responseReceiver = session.createReceiver(responseQueue);
message.setReplyTo(responseQueue);
sender.send(message);
Message response = responseReceiver.fetch(Duration::SECOND * 3);
session.acknowledge();
if (response.getContentSize() > 3) {
decode(response,responseMap);
} else {
responseMap["response"] = response.getContent();
}
} catch (qpid::messaging::NoMessageAvailable) {
printf("WARNING, no reply message to fetch\n");
} catch(const std::exception& error) {
std::cerr << error.what() << std::endl;
}
try {
responseReceiver.close();
} catch(const std::exception& error) {
std::cerr << error.what() << std::endl;
}
return responseMap;
}
int main(int argc, char** argv)
{
Options options;
if (options.parse(argc, argv) && options.checkAddress()) {
Connection connection;
try {
connection = Connection(options.url, options.connectionOptions);
connection.open();
Session session = connection.createSession();
Receiver receiver = session.createReceiver(options.address);
Duration timeout = options.getTimeout();
int count = options.getCount();
Message message;
int i = 0;
while (receiver.fetch(message, timeout)) {
std::cout << message << std::endl;
session.acknowledge();
if (count && (++i == count))
break;
}
receiver.close();
session.close();
connection.close();
return 0;
} catch(const std::exception& error) {
std::cout << "Error: " << 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;
}
}
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;
}
void run()
{
try {
Message message;
while (receiver.fetch(message)) {
connection.setOption("reconnect-urls", message.getProperties()["amq.failover"]);
QPID_LOG(debug, "Set reconnect-urls to " << message.getProperties()["amq.failover"]);
session.acknowledge();
}
}
catch (const ClosedException&) {}
catch (const qpid::TransportFailure& e) {
QPID_LOG(warning, "Failover updates stopped on loss of connection. " << e.what());
}
catch (const std::exception& e) {
QPID_LOG(warning, "Failover updates stopped due to exception: " << e.what());
}
}
int main(int argc, char** argv)
{
Options options;
if (options.parse(argc, argv) && options.checkAddress()) {
Connection connection(options.url, options.connectionOptions);
try {
connection.open();
Session session = connection.createSession();
Receiver receiver = session.createReceiver(options.address);
Duration timeout = options.getTimeout();
int count = options.getCount();
Message message;
int i = 0;
while (receiver.fetch(message, timeout)) {
std::cout << "Message(properties=" << message.getProperties();
if (!message.getSubject().empty()) {
std::cout << ", subject='" << message.getSubject() << "'";
}
std::cout << ", content='";
if (message.getContentType() == "amqp/map") {
std::cout << message.getContentObject().asMap();
} else {
std::cout << message.getContentObject();
}
std::cout << "')" << std::endl;
session.acknowledge();
if (count && (++i == count))
break;
}
receiver.close();
session.close();
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;
}
}
int main(int argc, char ** argv)
{
Connection connection;
try {
Options opts;
if (opts.parse(argc, argv)) {
connection = Connection(opts.url, opts.connectionOptions);
connection.open();
std::auto_ptr<FailoverUpdates> updates(opts.failoverUpdates ? new FailoverUpdates(connection) : 0);
Session session = opts.tx ? connection.createTransactionalSession() : connection.createSession();
Receiver receiver = session.createReceiver(opts.address);
receiver.setCapacity(opts.capacity);
Message msg;
uint count = 0;
uint txCount = 0;
SequenceTracker sequenceTracker(opts);
Duration timeout = opts.getTimeout();
bool done = false;
Reporter<ThroughputAndLatency> reporter(std::cout, opts.reportEvery, opts.reportHeader);
if (!opts.readyAddress.empty()) {
session.createSender(opts.readyAddress).send(msg);
if (opts.tx)
session.commit();
}
// For receive rate calculation
qpid::sys::AbsTime start = qpid::sys::now();
int64_t interval = 0;
if (opts.receiveRate) interval = qpid::sys::TIME_SEC/opts.receiveRate;
std::map<std::string,Sender> replyTo;
while (!done && receiver.fetch(msg, timeout)) {
reporter.message(msg);
if (sequenceTracker.track(msg)) {
if (msg.getContent() == EOS) {
done = true;
} else {
++count;
if (opts.printHeaders) {
if (msg.getSubject().size()) std::cout << "Subject: " << msg.getSubject() << std::endl;
if (msg.getReplyTo()) std::cout << "ReplyTo: " << msg.getReplyTo() << std::endl;
if (msg.getMessageId().size()) std::cout << "MessageId: " << msg.getMessageId() << std::endl;
if (msg.getCorrelationId().size()) std::cout << "CorrelationId: " << msg.getCorrelationId() << std::endl;
if (msg.getUserId().size()) std::cout << "UserId: " << msg.getUserId() << std::endl;
if (msg.getTtl().getMilliseconds()) std::cout << "TTL: " << msg.getTtl().getMilliseconds() << std::endl;
if (msg.getPriority()) std::cout << "Priority: " << ((uint) msg.getPriority()) << std::endl;
if (msg.getDurable()) std::cout << "Durable: true" << std::endl;
if (msg.getRedelivered()) std::cout << "Redelivered: true" << std::endl;
std::cout << "Properties: " << msg.getProperties() << std::endl;
std::cout << std::endl;
}
if (opts.printContent) {
if (!msg.getContentObject().isVoid()) std::cout << msg.getContentObject() << std::endl;
else std::cout << msg.getContent() << std::endl;
}
if (opts.messages && count >= opts.messages) done = true;
}
}
if (opts.tx && (count % opts.tx == 0)) {
if (opts.rollbackFrequency && (++txCount % opts.rollbackFrequency == 0)) {
session.rollback();
} else {
session.commit();
}
} else if (opts.ackFrequency && (count % opts.ackFrequency == 0)) {
session.acknowledge();
}
if (msg.getReplyTo() && !opts.noReplies) { // Echo message back to reply-to address.
Sender& s = replyTo[msg.getReplyTo().str()];
if (s.isNull()) {
s = session.createSender(msg.getReplyTo());
s.setCapacity(opts.capacity);
replyTo[msg.getReplyTo().str()] = s;
}
msg.setReplyTo(Address(opts.replyto));
s.send(msg);
}
if (opts.receiveRate) {
qpid::sys::AbsTime waitTill(start, count*interval);
int64_t delay = qpid::sys::Duration(qpid::sys::now(), waitTill);
if (delay > 0) qpid::sys::usleep(delay/qpid::sys::TIME_USEC);
}
}
if (opts.reportTotal) reporter.report();
if (opts.tx) {
if (opts.rollbackFrequency && (++txCount % opts.rollbackFrequency == 0)) {
session.rollback();
} else {
session.commit();
}
} else if (opts.ackFrequency) {
session.acknowledge();
}
session.close();
connection.close();
return 0;
}
} catch(const std::exception& error) {
std::cerr << "qpid-receive: " << error.what() << std::endl;
connection.close();
return 1;
}
}
int
main(int argc, char *argv[])
{
string broker = "amqp:tcp:127.0.0.1:5672";
string address;
static struct option options[] = {
{"broker", 1, NULL, 'b'},
{"address", 1, NULL, 'a'},
{NULL, 0, NULL, 0}
};
int c;
while (1) {
c = getopt_long(argc, argv, ":b:a:", options, NULL);
if (-1 == c) break;
switch (c) {
case 'b':
broker = optarg;
break;
case 'a':
address = optarg;
break;
case ':':
cerr << argv[optind - 1] << " requires an argument" << endl;
usage(argv);
break;
case '?':
cerr << "unknown argument: " << argv[optind - 1] << endl;
usage(argv);
break;
default:
usage(argv);
break;
}
}
if (address.empty()) {
cerr << "--address required" << endl;
usage(argv);
}
cout << "config: address = " << address << "; broker = " << broker << endl;
Connection connection(broker);
connection.open();
Session session = connection.createSession();
Receiver receiver = session.createReceiver(address);
receiver.setCapacity(1024);
int count = 0;
while (1) {
Message message = receiver.fetch();
Variant::Map content;
decode(message, content);
string id = message.getSubject();
if ("DONE" == id) {
session.acknowledge();
break;
}
for (qpid::types::Variant::Map::const_iterator i = content.begin();
content.end() != i;
i++) {
cout << id << " " << (*i).first << " " << (*i).second << endl;
}
if (!(++count % 128)) session.acknowledge();
}
session.acknowledge();
receiver.close();
connection.close();
return 0;
}
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;
}
}
int main(int argc, char** argv)
{
/***
sample emp addresses
src_emp = "uprr.l.uprr.0000:tmc";
dst_emp = "bnsf.l.bnsf.0000:tmc";
wiu_emp = "uprr.w.003074:28.wiu";
***/
struct emp_header_light holder;
bool has_host = false;
bool has_port = false;
bool has_target = false;
std::string src_emp;
std::string dst_emp;
std::string wiu_emp;
std::string target;
unsigned short msg_id;
std::string host = "127.0.0.1";
std::string port = "10002";
int i;
if(!(argc % 2) || (argc < 3))
{
print_usage(argv[0]);
exit(-1);
}
for(i = 1; i < argc; ++i)
{
if('-' == argv[i][0])
{
if('q' == argv[i][1])
{
target = argv[++i];
has_target = true;
}
else if('h' == argv[i][1])
{
host = argv[++i];
has_host = true;
}
else if('p' == argv[i][1])
{
port = argv[++i];
has_port = true;
}
}
}
if(false == has_target)
{
print_usage(argv[0]);
exit(-1);
}
cout << "queue: " << target << endl;
cout << "host: " << host << endl;
cout << "port: " << port << endl;
std::string connection_url = "amqp://*****:*****@" + host + ":" + port;
cout << "connection url: " << connection_url << endl;
Connection connection(connection_url, "");
// Connection connection("amqp://*****:*****@127.0.0.1:10002", "");
try
{
int i = 0;
connection.open();
Session session = connection.createSession();
// Sender sender = session.createSender("uprr.b.wsrs.ToApplication");
Receiver receiver = session.createReceiver(target);
receiver.setCapacity(10);
Message message;
unsigned long long int received_msg = 1;
while(receiver.fetch(message, Duration::FOREVER))
{
// printf("Start\n");
string tmp2 = message.getContent();
printf("\n=========================== %u ==========================\n\n", received_msg++);
print_hex((char *)tmp2.c_str(), tmp2.length());
printf("%u\n",received_msg++);
redirect_full_emp(tmp2);
//recordreceivetime();
session.acknowledge();
}
receiver.close();
session.sync();
session.close();
connection.close();
} catch(const std::exception& error) {
std::cout << error.what() << std::endl;
connection.close();
exit(-1);
}
return 0;
}
