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