static PyObject *
AvroDeserializer_deserialize(AvroDeserializer *self, PyObject *args)
{
int rval;
avro_value_t value;
char *buffer = NULL;
size_t buffer_size;
PyObject *result;
if (!PyArg_ParseTuple(args, "s#", &buffer, &buffer_size)) {
return NULL;
}
avro_reader_memory_set_source(self->datum_reader, buffer, buffer_size);
avro_generic_value_new(self->iface, &value);
rval = avro_value_read(self->datum_reader, &value);
if (rval) {
avro_value_decref(&value);
set_error_prefix("Read error: ");
return NULL;
}
result = avro_to_python(&self->info, &value);
avro_value_decref(&value);
return result;
}
/*
{
"type": "record",
"name": "FinishRequest",
"fields": [
{"name": "succeed", "type": "boolean"},
{"name": "diagnostics", "type": "string"}
]
}
*/
static void parse_finish_request(avro_slice_t *slice, bool *succeed, char **diag)
{
char filename[FILE_NAME_LEN];
avro_schema_t schema;
avro_value_iface_t *iface;
avro_value_t record, succeed_value, diag_value;
size_t index;
avro_reader_t reader;
size_t size;
sprintf(filename, "%s/%s", SCHEMA_PATH, "FinishRequestRecordAvro.avsc");
init_schema(filename, &schema);
iface = avro_generic_class_from_schema(schema);
avro_generic_value_new(iface, &record);
reader = avro_reader_memory(slice->buffer, slice->len);
if (avro_value_read(reader, &record)) {
fprintf(stderr, "Unable to read record from memory buffer\n");
fprintf(stderr, "Error: %s\n", avro_strerror());
exit(1);
}
avro_value_get_by_name(&record, "succeed", &succeed_value, &index);
avro_value_get_boolean(&succeed_value, succeed);
avro_value_get_by_name(&record, "diagnostics", &diag_value, &index);
avro_value_get_string(&diag_value, diag, &size);
//avro_generic_value_free(&record);
avro_value_iface_decref(iface);
avro_schema_decref(schema);
}
int avro_bin_to_json(avro_schema_t schema,
const void *val_bin, size_t val_len,
char **val_out, size_t *val_len_out) {
if (!val_bin) {
*val_out = NULL;
return 0;
} else if (!schema) {
log_error("json: got a value where we didn't expect one, and no schema to decode it");
*val_out = NULL;
return EINVAL;
}
avro_reader_t reader = avro_reader_memory(val_bin, val_len);
avro_value_iface_t *iface = avro_generic_class_from_schema(schema);
if (!iface) {
log_error("json: error in avro_generic_class_from_schema: %s", avro_strerror());
avro_reader_free(reader);
return EINVAL;
}
int err;
avro_value_t value;
err = avro_generic_value_new(iface, &value);
if (err) {
log_error("json: error in avro_generic_value_new: %s", avro_strerror());
avro_value_iface_decref(iface);
avro_reader_free(reader);
return err;
}
err = avro_value_read(reader, &value);
if (err) {
log_error("json: error decoding Avro value: %s", avro_strerror());
avro_value_decref(&value);
avro_value_iface_decref(iface);
avro_reader_free(reader);
return err;
}
err = avro_value_to_json(&value, 1, val_out);
if (err) {
log_error("json: error converting Avro value to JSON: %s", avro_strerror());
avro_value_decref(&value);
avro_value_iface_decref(iface);
avro_reader_free(reader);
return err;
}
*val_len_out = strlen(*val_out); // not including null terminator - to librdkafka it's just bytes
avro_value_decref(&value);
avro_value_iface_decref(iface);
avro_reader_free(reader);
return 0;
}
/* Parses the contents of a binary-encoded Avro buffer into an Avro value, ensuring
* that the entire buffer is read. */
int read_entirely(avro_value_t *value, avro_reader_t reader, const void *buf, size_t len) {
int err = 0;
avro_reader_memory_set_source(reader, buf, len);
check(err, avro_value_read(reader, value));
// Expect the reading of the Avro value from the buffer to entirely consume the
// buffer contents. If there's anything left at the end, something must be wrong.
// Avro doesn't seem to provide a way of checking how many bytes remain, so we
// test indirectly by trying to seek forward (expecting to see an error).
if (avro_skip(reader, 1) != ENOSPC) {
avro_set_error("Unexpected trailing bytes at the end of buffer");
return EINVAL;
}
return err;
}
extern int parse_heartbeat_request(avro_slice_t *slice)
{
char filename[FILE_NAME_LEN];
avro_schema_t schema;
avro_value_iface_t *iface;
avro_value_t record;
size_t index;
avro_reader_t reader;
size_t size = 0;
sprintf(filename, "%s/%s", SCHEMA_PATH, "HeartBeatRequestRecordAvro.avsc");
init_schema(filename, &schema);
iface = avro_generic_class_from_schema(schema);
avro_generic_value_new(iface, &record);
reader = avro_reader_memory(slice->buffer, slice->len);
if (avro_value_read(reader, &record)) {
fprintf(stderr, "Unable to read record from memory buffer\n");
fprintf(stderr, "Error: %s\n", avro_strerror());
exit(1);
}
avro_value_get_size(&record, &size);
avro_value_iface_decref(iface);
avro_schema_decref(schema);
// printf("slice->len = %d\n", slice->len);
// printf("size = %ld\n", size);
//
// if (size > 0) {
// return 0;
// } else {
// return -1;
// }
if (size == 0) {
return 0;
} else {
return -1;
}
}
