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;
}
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)
{
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[])
{
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;
}
