static void parse_success(const char *url,
const char *user,
const char *password,
const char *host,
int port,
const char *vhost)
{
char *s = strdup(url);
struct amqp_connection_info ci;
int res;
amqp_default_connection_info(&ci);
res = amqp_parse_url(s, &ci);
if (res) {
fprintf(stderr,
"Expected to successfully parse URL, but didn't: %s (%s)\n",
url, amqp_error_string(-res));
abort();
}
match_string("user", user, ci.user);
match_string("password", password, ci.password);
match_string("host", host, ci.host);
match_int("port", port, ci.port);
match_string("vhost", vhost, ci.vhost);
free(s);
}
void die_on_error(int x, char const *context) {
if (x < 0) {
char *errstr = amqp_error_string(-x);
fprintf(stderr, "%s: %s\n", context, errstr);
free(errstr);
exit(1);
}
}
void ChannelImpl::CheckForError(int ret)
{
if (ret < 0)
{
char* errstr = amqp_error_string(-ret);
std::runtime_error error(errstr);
free(errstr);
throw error;
}
}
static gboolean
afamqp_dd_connect(AMQPDestDriver *self, gboolean reconnect)
{
int sockfd;
amqp_rpc_reply_t ret;
if (reconnect && self->conn)
{
ret = amqp_get_rpc_reply(self->conn);
if (ret.reply_type == AMQP_RESPONSE_NORMAL)
return TRUE;
}
self->conn = amqp_new_connection();
sockfd = amqp_open_socket(self->host, self->port);
if (sockfd < 0)
{
gchar *errstr = amqp_error_string(-sockfd);
msg_error("Error connecting to AMQP server",
evt_tag_str("driver", self->super.super.super.id),
evt_tag_str("error", errstr),
evt_tag_int("time_reopen", self->super.time_reopen),
NULL);
g_free(errstr);
return FALSE;
}
amqp_set_sockfd(self->conn, sockfd);
ret = amqp_login(self->conn, self->vhost, 0, 131072, 0,
AMQP_SASL_METHOD_PLAIN, self->user, self->password);
if (!afamqp_is_ok(self, "Error during AMQP login", ret))
return FALSE;
amqp_channel_open(self->conn, 1);
ret = amqp_get_rpc_reply(self->conn);
if (!afamqp_is_ok(self, "Error during AMQP channel open", ret))
return FALSE;
if (self->declare)
{
amqp_exchange_declare(self->conn, 1, amqp_cstring_bytes(self->exchange),
amqp_cstring_bytes(self->exchange_type), 0, 0,
amqp_empty_table);
ret = amqp_get_rpc_reply(self->conn);
if (!afamqp_is_ok(self, "Error during AMQP exchange declaration", ret))
return FALSE;
}
msg_debug ("Connecting to AMQP succeeded",
evt_tag_str("driver", self->super.super.super.id),
NULL);
return TRUE;
}
AmqpResponseLibraryException AmqpResponseLibraryException::CreateException(const amqp_rpc_reply_t_& reply, const std::string& context)
{
char* error_string = amqp_error_string(reply.library_error);
std::string message(context);
message.append(": ");
message.append(error_string);
free(error_string);
return AmqpResponseLibraryException(message);
}
/*
* Report general error
*/
static int
die_on_error(int x, char const *context)
{
int retVal = 0; // false
if (x < 0) {
char *errstr = amqp_error_string(-x);
errmsg.LogError(0, RS_RET_ERR, "omrabbitmq: %s: %s", context, errstr);
free(errstr);
retVal = 1; // true
}
return retVal;
}
void die_amqp_error(int err, const char *fmt, ...)
{
va_list ap;
char *errstr;
if (err >= 0) {
return;
}
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fprintf(stderr, ": %s\n", errstr = amqp_error_string(-err));
free(errstr);
exit(1);
}
/*
* Report AMQP specific error
*/
static int
die_on_amqp_error(amqp_rpc_reply_t x, char const *context)
{
int retVal = 1; // true
switch (x.reply_type) {
case AMQP_RESPONSE_NORMAL:
retVal = 0; // false
break;
case AMQP_RESPONSE_NONE:
errmsg.LogError(0, RS_RET_ERR, "omrabbitmq: %s: missing RPC reply type!", context);
break;
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
errmsg.LogError(0, RS_RET_ERR, "omrabbitmq: %s: %s", context, amqp_error_string(x.library_error));
break;
case AMQP_RESPONSE_SERVER_EXCEPTION:
switch (x.reply.id) {
case AMQP_CONNECTION_CLOSE_METHOD: {
amqp_connection_close_t *m = (amqp_connection_close_t *) x.reply.decoded;
errmsg.LogError(0, RS_RET_ERR, "omrabbitmq: %s: server connection error %d, message: %.*s",
context,
m->reply_code,
(int) m->reply_text.len, (char *) m->reply_text.bytes);
break;
}
case AMQP_CHANNEL_CLOSE_METHOD: {
amqp_channel_close_t *m = (amqp_channel_close_t *) x.reply.decoded;
errmsg.LogError(0, RS_RET_ERR, "omrabbitmq: %s: server channel error %d, message: %.*s",
context,
m->reply_code,
(int) m->reply_text.len, (char *) m->reply_text.bytes);
break;
}
default:
errmsg.LogError(0, RS_RET_ERR, "omrabbitmq: %s: unknown server error, method id 0x%08X\n", context, x.reply.id);
break;
}
break;
}
return retVal;
}
Exception::Exception(const string& message, amqp_rpc_reply_t& response, const string& file, int line) :
message_(message),
file_(file),
line_(line)
{
message_.append(" ");
switch (response.reply_type) {
case AMQP_RESPONSE_NORMAL:
return;
case AMQP_RESPONSE_NONE:
message_.append("Missing RPC reply type!");
break;
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
message_.append(amqp_error_string(response.library_error));
break;
case AMQP_RESPONSE_SERVER_EXCEPTION:
switch (response.reply.id) {
case AMQP_CONNECTION_CLOSE_METHOD: {
amqp_connection_close_t *m = (amqp_connection_close_t *) response.reply.decoded;
stringstream ss;
ss << "Server connection error(" << (int)m->reply_code << "): ";
message_.append(ss.str().append((char*)m->reply_text.bytes, (int)m->reply_text.len));
break;
}
case AMQP_CHANNEL_CLOSE_METHOD: {
amqp_channel_close_t *m = (amqp_channel_close_t *) response.reply.decoded;
stringstream ss;
ss << "Server channel error(" << (int)m->reply_code << "): ";
message_.append(ss.str().append((char*)m->reply_text.bytes, (int)m->reply_text.len));
break;
}
default:
stringstream ss;
ss << "Unknown server error, method id 0x" << (uint32_t)response.reply.id;
message_.append(ss.str());
break;
}
break;
}
}
void check(const char* context, int rc, bool nothrow)
{
if (rc < 0)
{
char* errstr = amqp_error_string(-rc);
BOOST_SCOPE_EXIT(&errstr) {
free(errstr);
} BOOST_SCOPE_EXIT_END
std::ostringstream stream;
std::ostream& error_stream = nothrow ? stream : std::cerr;
error_stream << context << ": " << errstr;
if(nothrow)
error_stream << std::endl;
else
throw std::runtime_error(stream.str());
}
char *amqp_rpc_reply_string(amqp_rpc_reply_t r)
{
switch (r.reply_type) {
case AMQP_RESPONSE_NORMAL:
return strdup("normal response");
case AMQP_RESPONSE_NONE:
return strdup("missing RPC reply type");
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
return amqp_error_string(r.library_error);
case AMQP_RESPONSE_SERVER_EXCEPTION:
return amqp_server_exception_string(r);
default:
abort();
}
}
void amqp_error(amqp_rpc_reply_t x, char ** pstr)
{
switch (x.reply_type) {
case AMQP_RESPONSE_NORMAL:
return;
case AMQP_RESPONSE_NONE:
spprintf(pstr, 0, "Missing RPC reply type.");
break;
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
spprintf(pstr, 0, "Library error: %s\n", amqp_error_string(x.library_error));
break;
case AMQP_RESPONSE_SERVER_EXCEPTION:
switch (x.reply.id) {
case AMQP_CONNECTION_CLOSE_METHOD: {
amqp_connection_close_t *m = (amqp_connection_close_t *)x.reply.decoded;
spprintf(pstr, 0, "Server connection error: %d, message: %.*s",
m->reply_code,
(int) m->reply_text.len,
(char *)m->reply_text.bytes);
/* No more error handling necessary, returning. */
return;
}
case AMQP_CHANNEL_CLOSE_METHOD: {
amqp_channel_close_t *m = (amqp_channel_close_t *) x.reply.decoded;
spprintf(pstr, 0, "Server channel error: %d, message: %.*s",
m->reply_code,
(int)m->reply_text.len,
(char *)m->reply_text.bytes);
/* No more error handling necessary, returning. */
return;
}
}
/* Default for the above switch should be handled by the below default. */
default:
spprintf(pstr, 0, "Unknown server error, method id 0x%08X", x.reply.id);
break;
}
}
void die_on_amqp_error(amqp_rpc_reply_t x, char const *context)
{
switch (x.reply_type) {
case AMQP_RESPONSE_NORMAL:
return;
case AMQP_RESPONSE_NONE:
fprintf(stderr, "%s: missing RPC reply type!\n", context);
break;
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
fprintf(stderr, "%s: %s\n", context, amqp_error_string(x.library_error));
break;
case AMQP_RESPONSE_SERVER_EXCEPTION:
switch (x.reply.id) {
case AMQP_CONNECTION_CLOSE_METHOD: {
amqp_connection_close_t *m = (amqp_connection_close_t *) x.reply.decoded;
fprintf(stderr, "%s: server connection error %d, message: %.*s\n",
context,
m->reply_code,
(int) m->reply_text.len, (char *) m->reply_text.bytes);
break;
}
case AMQP_CHANNEL_CLOSE_METHOD: {
amqp_channel_close_t *m = (amqp_channel_close_t *) x.reply.decoded;
fprintf(stderr, "%s: server channel error %d, message: %.*s\n",
context,
m->reply_code,
(int) m->reply_text.len, (char *) m->reply_text.bytes);
break;
}
default:
fprintf(stderr, "%s: unknown server error, method id 0x%08X\n", context, x.reply.id);
break;
}
break;
}
exit(1);
}
static gboolean
afamqp_is_ok(AMQPDestDriver *self, gchar *context, amqp_rpc_reply_t ret)
{
switch (ret.reply_type)
{
case AMQP_RESPONSE_NORMAL:
break;
case AMQP_RESPONSE_NONE:
msg_error(context,
evt_tag_str("driver", self->super.super.super.id),
evt_tag_str("error", "missing RPC reply type"),
evt_tag_int("time_reopen", self->super.time_reopen),
NULL);
log_threaded_dest_driver_suspend(&self->super);
return FALSE;
case AMQP_RESPONSE_LIBRARY_EXCEPTION:
{
gchar *errstr = amqp_error_string(ret.library_error);
msg_error(context,
evt_tag_str("driver", self->super.super.super.id),
evt_tag_str("error", errstr),
evt_tag_int("time_reopen", self->super.time_reopen),
NULL);
g_free (errstr);
log_threaded_dest_driver_suspend(&self->super);
return FALSE;
}
case AMQP_RESPONSE_SERVER_EXCEPTION:
switch (ret.reply.id)
{
case AMQP_CONNECTION_CLOSE_METHOD:
{
amqp_connection_close_t *m =
(amqp_connection_close_t *) ret.reply.decoded;
msg_error(context,
evt_tag_str("driver", self->super.super.super.id),
evt_tag_str("error", "server connection error"),
evt_tag_int("code", m->reply_code),
evt_tag_str("text", m->reply_text.bytes),
evt_tag_int("time_reopen", self->super.time_reopen),
NULL);
log_threaded_dest_driver_suspend(&self->super);
return FALSE;
}
case AMQP_CHANNEL_CLOSE_METHOD:
{
amqp_channel_close_t *m =
(amqp_channel_close_t *) ret.reply.decoded;
msg_error(context,
evt_tag_str("driver", self->super.super.super.id),
evt_tag_str("error", "server channel error"),
evt_tag_int("code", m->reply_code),
evt_tag_str("text", m->reply_text.bytes),
evt_tag_int("time_reopen", self->super.time_reopen),
NULL);
log_threaded_dest_driver_suspend(&self->super);
return FALSE;
}
default:
msg_error(context,
evt_tag_str("driver", self->super.super.super.id),
evt_tag_str("error", "unknown server error"),
evt_tag_printf("method id", "0x%08X", ret.reply.id),
evt_tag_int("time_reopen", self->super.time_reopen),
NULL);
log_threaded_dest_driver_suspend(&self->super);
return FALSE;
}
return FALSE;
}
return TRUE;
}
static void test_table_codec(FILE *out)
{
amqp_pool_t pool;
int result;
amqp_table_entry_t inner_entries[2];
amqp_table_t inner_table;
amqp_field_value_t inner_values[2];
amqp_array_t inner_array;
amqp_table_entry_t entries[14];
amqp_table_t table;
inner_entries[0].key = amqp_cstring_bytes("one");
inner_entries[0].value.kind = AMQP_FIELD_KIND_I32;
inner_entries[0].value.value.i32 = 54321;
inner_entries[1].key = amqp_cstring_bytes("two");
inner_entries[1].value.kind = AMQP_FIELD_KIND_UTF8;
inner_entries[1].value.value.bytes = amqp_cstring_bytes("A long string");
inner_table.num_entries = 2;
inner_table.entries = inner_entries;
inner_values[0].kind = AMQP_FIELD_KIND_I32;
inner_values[0].value.i32 = 54321;
inner_values[1].kind = AMQP_FIELD_KIND_UTF8;
inner_values[1].value.bytes = amqp_cstring_bytes("A long string");
inner_array.num_entries = 2;
inner_array.entries = inner_values;
entries[0].key = amqp_cstring_bytes("longstr");
entries[0].value.kind = AMQP_FIELD_KIND_UTF8;
entries[0].value.value.bytes = amqp_cstring_bytes("Here is a long string");
entries[1].key = amqp_cstring_bytes("signedint");
entries[1].value.kind = AMQP_FIELD_KIND_I32;
entries[1].value.value.i32 = 12345;
entries[2].key = amqp_cstring_bytes("decimal");
entries[2].value.kind = AMQP_FIELD_KIND_DECIMAL;
entries[2].value.value.decimal.decimals = 3;
entries[2].value.value.decimal.value = 123456;
entries[3].key = amqp_cstring_bytes("timestamp");
entries[3].value.kind = AMQP_FIELD_KIND_TIMESTAMP;
entries[3].value.value.u64 = 109876543209876;
entries[4].key = amqp_cstring_bytes("table");
entries[4].value.kind = AMQP_FIELD_KIND_TABLE;
entries[4].value.value.table = inner_table;
entries[5].key = amqp_cstring_bytes("byte");
entries[5].value.kind = AMQP_FIELD_KIND_I8;
entries[5].value.value.i8 = (int8_t)255;
entries[6].key = amqp_cstring_bytes("long");
entries[6].value.kind = AMQP_FIELD_KIND_I64;
entries[6].value.value.i64 = 1234567890;
entries[7].key = amqp_cstring_bytes("short");
entries[7].value.kind = AMQP_FIELD_KIND_I16;
entries[7].value.value.i16 = 655;
entries[8].key = amqp_cstring_bytes("bool");
entries[8].value.kind = AMQP_FIELD_KIND_BOOLEAN;
entries[8].value.value.boolean = 1;
entries[9].key = amqp_cstring_bytes("binary");
entries[9].value.kind = AMQP_FIELD_KIND_BYTES;
entries[9].value.value.bytes = amqp_cstring_bytes("a binary string");
entries[10].key = amqp_cstring_bytes("void");
entries[10].value.kind = AMQP_FIELD_KIND_VOID;
entries[11].key = amqp_cstring_bytes("array");
entries[11].value.kind = AMQP_FIELD_KIND_ARRAY;
entries[11].value.value.array = inner_array;
entries[12].key = amqp_cstring_bytes("float");
entries[12].value.kind = AMQP_FIELD_KIND_F32;
entries[12].value.value.f32 = M_PI;
entries[13].key = amqp_cstring_bytes("double");
entries[13].value.kind = AMQP_FIELD_KIND_F64;
entries[13].value.value.f64 = M_PI;
table.num_entries = 14;
table.entries = entries;
fprintf(out, "AAAAAAAAAA\n");
{
amqp_field_value_t val;
val.kind = AMQP_FIELD_KIND_TABLE;
val.value.table = table;
dump_value(0, val, out);
}
init_amqp_pool(&pool, 4096);
{
amqp_table_t decoded;
size_t decoding_offset = 0;
amqp_bytes_t decoding_bytes;
decoding_bytes.len = sizeof(pre_encoded_table);
decoding_bytes.bytes = pre_encoded_table;
result = amqp_decode_table(decoding_bytes, &pool, &decoded,
&decoding_offset);
if (result < 0)
die("Table decoding failed: %s", amqp_error_string(-result));
fprintf(out, "BBBBBBBBBB\n");
{
amqp_field_value_t val;
val.kind = AMQP_FIELD_KIND_TABLE;
val.value.table = decoded;
dump_value(0, val, out);
}
}
{
uint8_t encoding_buffer[4096];
amqp_bytes_t encoding_result;
size_t offset = 0;
memset(&encoding_buffer[0], 0, sizeof(encoding_buffer));
encoding_result.len = sizeof(encoding_buffer);
encoding_result.bytes = &encoding_buffer[0];
result = amqp_encode_table(encoding_result, &table, &offset);
if (result < 0)
die("Table encoding failed: %s", amqp_error_string(-result));
if (offset != sizeof(pre_encoded_table))
die("Offset should be %ld, was %ld", (long)sizeof(pre_encoded_table),
(long)offset);
result = memcmp(pre_encoded_table, encoding_buffer, offset);
if (result != 0)
die("Table encoding differed", result);
}
empty_amqp_pool(&pool);
}
