static int l_schema_new_raw_value(lua_State *L) { LuaAvroSchema *l_schema = luaL_checkudata(L, 1, MT_AVRO_SCHEMA); if (l_schema->iface == NULL) { l_schema->iface = avro_generic_class_from_schema(l_schema->schema); if (l_schema->iface == NULL) { lua_pushstring(L, avro_strerror()); return lua_error(L); } } if (lua_gettop(L) >= 2) { LuaAvroValue *l_value = luaL_checkudata(L, 2, MT_AVRO_VALUE); if (l_value->should_decref && l_value->value.self != NULL) { avro_value_decref(&l_value->value); } check(avro_generic_value_new(l_schema->iface, &l_value->value)); l_value->should_decref = true; lua_pushvalue(L, 2); } else { avro_value_t value; check(avro_generic_value_new(l_schema->iface, &value)); lua_avro_push_value(L, &value, true); } return 1; }
int main(void) { int pass; for (pass = 0 ; json_schemas[pass] ; pass++) { int rval = 0; size_t len; static char buf[4096]; avro_writer_t writer; avro_file_writer_t file_writer; avro_file_reader_t file_reader; avro_schema_t schema = NULL; avro_schema_error_t error = NULL; char outpath[64]; const char *json_schema = json_schemas[pass]; printf("pass %d with schema %s\n", pass, json_schema); check(rval, avro_schema_from_json(json_schema, strlen(json_schema), &schema, &error)); avro_value_iface_t *iface = avro_generic_class_from_schema(schema); avro_value_t val; avro_generic_value_new(iface, &val); avro_value_t out; avro_generic_value_new(iface, &out); /* create the val */ avro_value_reset(&val); avro_value_set_string(&val, "test-1691"); /* Write value to file */ snprintf(outpath, sizeof(outpath), "test-1691-%d.avro", pass); /* create the writers */ writer = avro_writer_memory(buf, sizeof(buf)); check(rval, avro_file_writer_create(outpath, schema, &file_writer)); check(rval, avro_value_write(writer, &val)); len = avro_writer_tell(writer); check(rval, avro_file_writer_append_encoded(file_writer, buf, len)); check(rval, avro_file_writer_close(file_writer)); /* Read the value back */ check(rval, avro_file_reader(outpath, &file_reader)); check(rval, avro_file_reader_read_value(file_reader, &out)); if (!avro_value_equal(&val, &out)) { fprintf(stderr, "fail!\n"); exit(EXIT_FAILURE); } fprintf(stderr, "pass %d: ok: schema %s\n", pass, json_schema); check(rval, avro_file_reader_close(file_reader)); remove(outpath); } exit(EXIT_SUCCESS); }
/* { "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); }
static PyObject * AvroFileReader_iternext(AvroFileReader *self) { avro_value_t value; PyObject *result; avro_generic_value_new(self->iface, &value); int rval = avro_file_reader_read_value(self->reader, &value); if (rval) { avro_value_decref(&value); if (rval == EOF) { return NULL; } set_error_prefix("Error reading: "); return NULL; } result = avro_to_python(&self->info, &value); avro_value_decref(&value); return result; }
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; }
rkv_error_t r_kv_create_avro_value(kv_store_t *kvstore, const char *space, const char *schemaName, avro_value_t **ret_avro_value) { int ret; avro_schema_t schema = NULL; avro_value_iface_t *iface = NULL; avro_value_t *avro_value = NULL; if (!kvstore || !schemaName || !ret_avro_value) { return RKV_INVALID_ARGUEMENTS; } if ((schema = r_kv_get_schema(kvstore, space, schemaName)) == NULL) { return RKV_INVALID_SCHEMA; } ret = rkv_malloc(sizeof(avro_value_t), (void**)&avro_value); RETURN_IF_ERR(ret); iface = avro_generic_class_from_schema(schema); if (avro_generic_value_new(iface, avro_value) != 0) { return RKV_ERROR; } *ret_avro_value = avro_value; return RKV_SUCCESS; }
int process_frame_table_schema(avro_value_t *record_val, frame_reader_t reader, uint64_t wal_pos) { int err = 0, key_schema_present; avro_value_t relid_val, hash_val, key_schema_val, row_schema_val, branch_val; int64_t relid; const void *hash; const char *key_schema_json = NULL, *row_schema_json; size_t hash_len, key_schema_len = 1, row_schema_len; avro_schema_t key_schema = NULL, row_schema; check(err, avro_value_get_by_index(record_val, 0, &relid_val, NULL)); check(err, avro_value_get_by_index(record_val, 1, &hash_val, NULL)); check(err, avro_value_get_by_index(record_val, 2, &key_schema_val, NULL)); check(err, avro_value_get_by_index(record_val, 3, &row_schema_val, NULL)); check(err, avro_value_get_long(&relid_val, &relid)); check(err, avro_value_get_fixed(&hash_val, &hash, &hash_len)); check(err, avro_value_get_discriminant(&key_schema_val, &key_schema_present)); check(err, avro_value_get_string(&row_schema_val, &row_schema_json, &row_schema_len)); check(err, avro_schema_from_json_length(row_schema_json, row_schema_len - 1, &row_schema)); schema_list_entry *entry = schema_list_replace(reader, relid); entry->relid = relid; entry->hash = *((uint64_t *) hash); entry->row_schema = row_schema; entry->row_iface = avro_generic_class_from_schema(row_schema); avro_generic_value_new(entry->row_iface, &entry->row_value); avro_generic_value_new(entry->row_iface, &entry->old_value); entry->avro_reader = avro_reader_memory(NULL, 0); if (key_schema_present) { check(err, avro_value_get_current_branch(&key_schema_val, &branch_val)); check(err, avro_value_get_string(&branch_val, &key_schema_json, &key_schema_len)); check(err, avro_schema_from_json_length(key_schema_json, key_schema_len - 1, &key_schema)); entry->key_schema = key_schema; entry->key_iface = avro_generic_class_from_schema(key_schema); avro_generic_value_new(entry->key_iface, &entry->key_value); } else { entry->key_schema = NULL; } if (reader->on_table_schema) { check(err, reader->on_table_schema(reader->cb_context, wal_pos, relid, key_schema_json, key_schema_len - 1, key_schema, row_schema_json, row_schema_len - 1, row_schema)); } return err; }
/* typedef struct { int jobid; int vpid; } process_name_t; typedef struct { char *en_vars; char *args; char *host_name; process_name_t proc_name; } launch_context_t; typedef struct { bool is_successful; process_name_t proc_name; } launch_response_t; */ static void build_launch_response(launch_response_t *launch_response_array, int array_size, avro_slice_t **slice) { char filename[FILE_NAME_LEN]; char buf[BUFFER_SIZE]; long len = 0; avro_schema_t schema; avro_value_iface_t *iface; avro_value_t record; avro_value_t results_value, LaunchResult_value, is_successful_value, name_value, jobid_value, vpid_value; size_t index; int i; avro_writer_t writer; sprintf(filename, "%s/%s", SCHEMA_PATH, "LaunchResponseRecordAvro.avsc"); init_schema(filename, &schema); iface = avro_generic_class_from_schema(schema); avro_generic_value_new(iface, &record); avro_value_get_by_name(&record, "results", &results_value, &index); for (i = 0; i < array_size; i++) { avro_value_append(&results_value, &LaunchResult_value, &index); avro_value_get_by_name(&LaunchResult_value, "is_successful", &is_successful_value, &index); avro_value_set_boolean(&is_successful_value, launch_response_array[i].is_successful); avro_value_get_by_name(&LaunchResult_value, "name", &name_value, &index); avro_value_get_by_name(&name_value, "jobid", &jobid_value, &index); avro_value_set_int(&jobid_value, launch_response_array[i].proc_name.jobid); avro_value_get_by_name(&name_value, "vpid", &vpid_value, &index); avro_value_set_int(&vpid_value, launch_response_array[i].proc_name.vpid); } /* create a writer with memory buffer */ writer = avro_writer_memory(buf, sizeof(buf)); /* write record to writer (buffer) */ if (avro_value_write(writer, &record)) { fprintf(stderr, "Unable to write record to memory buffer\n"); fprintf(stderr, "Error: %s\n", avro_strerror()); exit(1); } avro_writer_flush(writer); len = avro_writer_tell(writer); //avro_generic_value_free(&record); avro_value_iface_decref(iface); avro_schema_decref(schema); *slice = xmalloc(sizeof(avro_slice_t)); (*slice)->buffer = xmalloc(len); (*slice)->len = len; memcpy((*slice)->buffer, buf, len); }
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; }
void process_file(FILE *input, avro_file_writer_t out, avro_schema_t schema, int verbose, int memstat, int errabort, int strjson, size_t max_str_sz) { json_error_t err; json_t *json; int n = 0; json = json_loadf(input, JSON_DISABLE_EOF_CHECK, &err); while (!feof(input)) { n++; if (verbose && !(n % 1000)) printf("Processing record %d\n", n); if (!json) { if (errabort) { fprintf(stderr, "JSON error on line %d, column %d, pos %d: %s, aborting.\n", n, err.column, err.position, err.text); return; } fprintf(stderr, "JSON error on line %d, column %d, pos %d: %s, skipping to EOL\n", n, err.column, err.position, err.text); while (getc(input) != '\n' && !feof(input)) {}; json = json_loadf(input, JSON_DISABLE_EOF_CHECK, &err); continue; } avro_value_t record; avro_value_iface_t *iface = avro_generic_class_from_schema(schema); avro_generic_value_new(iface, &record); if (!schema_traverse(schema, json, NULL, &record, 0, strjson, max_str_sz)) { if (avro_file_writer_append_value(out, &record)) { fprintf(stderr, "ERROR: avro_file_writer_append_value() FAILED: %s\n", avro_strerror()); exit(EXIT_FAILURE); } } else fprintf(stderr, "Error processing record %d, skipping...\n", n); avro_value_iface_decref(iface); avro_value_decref(&record); json_decref(json); if (memstat && !(n % 1000)) memory_status(); json = json_loadf(input, JSON_DISABLE_EOF_CHECK, &err); } if (memstat) memory_status(); avro_schema_decref(schema); }
static void process_file(const char *in_filename, const char *out_filename) { avro_file_reader_t reader; avro_file_writer_t writer; if (in_filename == NULL) { if (avro_file_reader_fp(stdin, "<stdin>", 0, &reader)) { fprintf(stderr, "Error opening <stdin>:\n %s\n", avro_strerror()); exit(1); } } else { if (avro_file_reader(in_filename, &reader)) { fprintf(stderr, "Error opening %s:\n %s\n", in_filename, avro_strerror()); exit(1); } } avro_schema_t wschema; avro_value_iface_t *iface; avro_value_t value; wschema = avro_file_reader_get_writer_schema(reader); iface = avro_generic_class_from_schema(wschema); avro_generic_value_new(iface, &value); if (avro_file_writer_create_with_codec (out_filename, wschema, &writer, codec, block_size)) { fprintf(stderr, "Error creating %s:\n %s\n", out_filename, avro_strerror()); exit(1); } while (avro_file_reader_read_value(reader, &value) == 0) { if (avro_file_writer_append_value(writer, &value)) { fprintf(stderr, "Error writing to %s:\n %s\n", out_filename, avro_strerror()); exit(1); } avro_value_reset(&value); } avro_file_reader_close(reader); avro_file_writer_close(writer); avro_value_decref(&value); avro_value_iface_decref(iface); avro_schema_decref(wschema); }
static void output_avro_startup(LogicalDecodingContext *ctx, OutputPluginOptions *opt, bool is_init) { plugin_state *state = palloc(sizeof(plugin_state)); ctx->output_plugin_private = state; opt->output_type = OUTPUT_PLUGIN_BINARY_OUTPUT; state->memctx = AllocSetContextCreate(ctx->context, "Avro decoder context", ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE); state->frame_schema = schema_for_frame(); state->frame_iface = avro_generic_class_from_schema(state->frame_schema); avro_generic_value_new(state->frame_iface, &state->frame_value); state->schema_cache = schema_cache_new(ctx->context); }
frame_reader_t frame_reader_new() { frame_reader_t reader = malloc(sizeof(frame_reader)); check_alloc(reader); memset(reader, 0, sizeof(frame_reader)); reader->num_schemas = 0; reader->capacity = 16; reader->schemas = malloc(reader->capacity * sizeof(void*)); check_alloc(reader->schemas); reader->frame_schema = schema_for_frame(); reader->frame_iface = avro_generic_class_from_schema(reader->frame_schema); avro_generic_value_new(reader->frame_iface, &reader->frame_value); reader->avro_reader = avro_reader_memory(NULL, 0); return reader; }
static int read_data() { int rval; int records_read = 0; avro_file_reader_t reader; avro_value_iface_t *iface; avro_value_t value; fprintf(stderr, "\nReading...\n"); rval = avro_file_reader(filename, &reader); if (rval) { fprintf(stderr, "Error: %s\n", avro_strerror()); return -1; } avro_schema_t schema = avro_file_reader_get_writer_schema(reader); iface = avro_generic_class_from_schema(schema); avro_generic_value_new(iface, &value); while ((rval = avro_file_reader_read_value(reader, &value)) == 0) { avro_value_t field; int32_t val; avro_value_get_by_index(&value, 0, &field, NULL); avro_value_get_int(&field, &val); fprintf(stderr, "value = %d\n", val); records_read++; avro_value_reset(&value); } avro_value_decref(&value); avro_value_iface_decref(iface); avro_schema_decref(schema); avro_file_reader_close(reader); fprintf(stderr, "read %d records.\n", records_read); if (rval != EOF) { fprintf(stderr, "Error: %s\n", avro_strerror()); return -1; } return records_read; }
static int write_data(int n_records) { int i; avro_schema_t schema; avro_schema_error_t error; avro_file_writer_t writer; avro_value_iface_t *iface; avro_value_t value; fprintf(stderr, "\nWriting...\n"); if (avro_schema_from_json(PERSON_SCHEMA, 0, &schema, &error)) { fprintf(stderr, "Unable to parse schema\n"); return -1; } if (avro_file_writer_create(filename, schema, &writer)) { fprintf(stderr, "There was an error creating file: %s\n", avro_strerror()); return -1; } iface = avro_generic_class_from_schema(schema); avro_generic_value_new(iface, &value); avro_value_t field; avro_value_get_by_index(&value, 0, &field, NULL); avro_value_set_int(&field, 123); for (i = 0; i < n_records; i++) { if (avro_file_writer_append_value(writer, &value)) { fprintf(stderr, "There was an error writing file: %s\n", avro_strerror()); return -1; } } if (avro_file_writer_close(writer)) { fprintf(stderr, "There was an error creating file: %s\n", avro_strerror()); return -1; } avro_value_decref(&value); avro_value_iface_decref(iface); avro_schema_decref(schema); return n_records; }
static void process_file(const char *filename) { avro_file_reader_t reader; if (filename == NULL) { if (avro_file_reader_fp(stdin, "<stdin>", 0, &reader)) { fprintf(stderr, "Error opening <stdin>:\n %s\n", avro_strerror()); exit(1); } } else { if (avro_file_reader(filename, &reader)) { fprintf(stderr, "Error opening %s:\n %s\n", filename, avro_strerror()); exit(1); } } avro_schema_t wschema; avro_value_iface_t *iface; avro_value_t value; wschema = avro_file_reader_get_writer_schema(reader); iface = avro_generic_class_from_schema(wschema); avro_generic_value_new(iface, &value); while (avro_file_reader_read_value(reader, &value) == 0) { char *json; if (avro_value_to_json(&value, 1, &json)) { fprintf(stderr, "Error converting value to JSON: %s\n", avro_strerror()); } else { printf("%s\n", json); free(json); } avro_value_reset(&value); } avro_file_reader_close(reader); avro_value_decref(&value); avro_value_iface_decref(iface); }
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; } }
static void read_using_writer_schema(const char *filename) { avro_file_reader_t file; avro_schema_t writer_schema; avro_value_iface_t *writer_iface; avro_value_t writer_value; // Open an Avro file and grab the writer schema that was used to create the // file. check_i(avro_file_reader(filename, &file)); writer_schema = avro_file_reader_get_writer_schema(file); // Then create a value that is an instance of the writer schema. As above, // we use the built-in "generic" value implementation for the value instance // that will actually store the data. check_p(writer_iface = avro_generic_class_from_schema(writer_schema)); check_i(avro_generic_value_new(writer_iface, &writer_value)); // Read values from the file until we run out, printing the contents of each // one. Here, we can read directly into `writer_value` since we know that // it's an instance of the schema that was used to create the file. while (avro_file_reader_read_value(file, &writer_value) == 0) { avro_value_t field; int32_t a; int32_t b; check_i(avro_value_get_by_name(&writer_value, "a", &field, NULL)); check_i(avro_value_get_int(&field, &a)); check_i(avro_value_get_by_name(&writer_value, "b", &field, NULL)); check_i(avro_value_get_int(&field, &b)); printf(" a: %" PRId32 ", b: %" PRId32 "\n", a, b); } // Close the file and clean up after ourselves. avro_file_reader_close(file); avro_value_decref(&writer_value); avro_value_iface_decref(writer_iface); avro_schema_decref(writer_schema); }
int main(void) { avro_schema_t schema = NULL; avro_schema_error_t error; avro_value_iface_t *simple_array_class; avro_value_t simple; /* Initialize the schema structure from JSON */ if (avro_schema_from_json(SIMPLE_ARRAY, sizeof(SIMPLE_ARRAY), &schema, &error)) { fprintf(stdout, "Unable to parse schema\n"); exit(EXIT_FAILURE); } // Create avro class and value simple_array_class = avro_generic_class_from_schema( schema ); if ( simple_array_class == NULL ) { fprintf(stdout, "Unable to create simple array class\n"); exit(EXIT_FAILURE); } if ( avro_generic_value_new( simple_array_class, &simple ) ) { fprintf(stdout, "Error creating instance of record\n" ); exit(EXIT_FAILURE); } // Release the avro class and value avro_value_decref( &simple ); avro_value_iface_decref( simple_array_class ); avro_schema_decref(schema); return 0; }
int process_file(const char *in_filename, const char *out_filename) { avro_file_reader_t reader; avro_file_writer_t writer; if (in_filename == NULL) { if (avro_file_reader_fp(stdin, "<stdin>", 0, &reader)) { fprintf(stderr, "Error opening <stdin>:\n %s\n", avro_strerror()); return 1; } } else { if (avro_file_reader(in_filename, &reader)) { fprintf(stderr, "Error opening %s:\n %s\n", in_filename, avro_strerror()); return 1; } } avro_schema_t wschema; wschema = avro_file_reader_get_writer_schema(reader); /* Check that the reader schema is the same as the writer schema */ { avro_schema_t oschema; avro_file_reader_t oreader; if (avro_file_reader(out_filename, &oreader)) { fprintf(stderr, "Error opening %s:\n %s\n", out_filename, avro_strerror()); avro_file_reader_close(reader); return 1; } oschema = avro_file_reader_get_writer_schema(oreader); if (avro_schema_equal(oschema, wschema) == 0) { fprintf(stderr, "Error: reader and writer schema are not equal.\n"); avro_file_reader_close(oreader); avro_file_reader_close(reader); return 1; } avro_file_reader_close(oreader); avro_schema_decref(oschema); } if (avro_file_writer_open(out_filename, &writer)) { fprintf(stderr, "Error opening %s:\n %s\n", out_filename, avro_strerror()); avro_file_reader_close(reader); return 1; } avro_value_iface_t *iface; avro_value_t value; iface = avro_generic_class_from_schema(wschema); avro_generic_value_new(iface, &value); while (avro_file_reader_read_value(reader, &value) == 0) { if (avro_file_writer_append_value(writer, &value)) { fprintf(stderr, "Error writing to %s:\n %s\n", out_filename, avro_strerror()); return 1; } avro_value_reset(&value); } avro_file_reader_close(reader); avro_file_writer_close(writer); avro_value_decref(&value); avro_value_iface_decref(iface); avro_schema_decref(wschema); return 0; }
/* function call from lmlite with parameters */ void network_devices_status_report(struct networkdevicestatusdata *head, BOOL extender, char* parent_mac) { int i = 0, k = 0; uint8_t* b64buffer = NULL; size_t decodesize = 0; int numElements = 0; struct networkdevicestatusdata* ptr = head; avro_writer_t writer; char * serviceName = "lmlite"; char * dest = "event:raw.kestrel.reports.NetworkDevicesStatus"; char * contentType = "avro/binary"; // contentType "application/json", "avro/binary" uuid_t transaction_id; char trans_id[37]; char CpeMacHoldingBuf[ 20 ] = {0}; unsigned char CpeMacid[ 7 ] = {0}; CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s : ENTER \n", __FUNCTION__ )); numElements = NumberofElementsinLinkedList(head); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, numElements = %d\n", numElements )); OneAvroSerializedSize = 0; /* goes thru total number of elements in link list */ writer = prepare_writer_status(); //Reset out writer avro_writer_reset(writer); //Network Device Report avro_value_t adr; avro_generic_value_new(iface, &adr); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, GatewayNetworkDeviceStatusReport\tType: %d\n", avro_value_get_type(&adr))); avro_value_t adrField = {0,0}; avro_value_t array = {0,0}; size_t new_index = 0; //Optional value for unions, mac address is an union avro_value_t optional = {0,0}; // timestamp - long avro_value_get_by_name(&adr, "header", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "timestamp", &adrField, NULL); avro_value_set_branch(&adrField, 1, &optional); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); struct timeval ts; gettimeofday(&ts, NULL); #ifndef UTC_ENABLE int64_t tstamp_av_main = ((int64_t) (ts.tv_sec - getTimeOffsetFromUtc()) * 1000000) + (int64_t) ts.tv_usec; #else int64_t tstamp_av_main = ((int64_t) (ts.tv_sec) * 1000000) + (int64_t) ts.tv_usec; #endif tstamp_av_main = tstamp_av_main/1000; avro_value_set_long(&optional, tstamp_av_main ); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, timestamp = ""%" PRId64 "\n", tstamp_av_main )); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, timestamp\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // uuid - fixed 16 bytes uuid_generate_random(transaction_id); uuid_unparse(transaction_id, trans_id); avro_value_get_by_name(&adr, "header", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "uuid", &adrField, NULL); avro_value_set_branch(&adrField, 1, &optional); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_fixed(&optional, transaction_id, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, uuid\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //source - string avro_value_get_by_name(&adr, "header", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "source", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_string(&optional, ReportSource); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, source\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); if ( extender == FALSE ) { //cpe_id block /* MAC - Get CPE mac address, do it only pointer is NULL */ memset(CpeMacHoldingBuf, 0, sizeof CpeMacHoldingBuf); memset(CpeMacid, 0, sizeof CpeMacid); if ( macStr == NULL ) { macStr = getDeviceMac(); strncpy( CpemacStr, macStr, sizeof(CpemacStr)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Received DeviceMac from Atom side: %s\n",macStr)); } for (k = 0; k < 6; k++ ) { /* copy 2 bytes */ CpeMacHoldingBuf[ k * 2 ] = CpemacStr[ k * 2 ]; CpeMacHoldingBuf[ k * 2 + 1 ] = CpemacStr[ k * 2 + 1 ]; CpeMacid[ k ] = (unsigned char)strtol(&CpeMacHoldingBuf[ k * 2 ], NULL, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Mac address = %0x\n", CpeMacid[ k ] )); } avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "mac_address", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_fixed(&optional, CpeMacid, 6); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, mac_address\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // cpe_type - string avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "cpe_type", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_string(&optional, CPE_TYPE_GATEWAY_STRING); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, cpe_type\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // cpe_parent - Recurrsive CPEIdentifier block avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "cpe_parent", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 0, &optional); avro_value_set_null(&optional); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, cpe_parent\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); } else { //cpe_id block avro_value_t parent_optional = {0,0}, parent_adrField = {0,0}; memset(CpeMacHoldingBuf, 0, sizeof CpeMacHoldingBuf); memset(CpeMacid, 0, sizeof CpeMacid); for (k = 0; k < 6; k++ ) { /* copy 2 bytes */ CpeMacHoldingBuf[ k * 2 ] = parent_mac[ k * 3 ]; CpeMacHoldingBuf[ k * 2 + 1 ] = parent_mac[ k * 3 + 1 ]; CpeMacid[ k ] = (unsigned char)strtol(&CpeMacHoldingBuf[ k * 2 ], NULL, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Extender Mac address = %0x\n", CpeMacid[ k ] )); } avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "mac_address", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_fixed(&optional, CpeMacid, 6); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, mac_address\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // cpe_type - string avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "cpe_type", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_string(&optional, CPE_TYPE_EXTENDER_STRING); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, cpe_type\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // cpe_parent - Recurrsive CPEIdentifier block avro_value_get_by_name(&adr, "cpe_id", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_get_by_name(&adrField, "cpe_parent", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); /* MAC - Get CPE mac address, do it only pointer is NULL */ if ( macStr == NULL ) { macStr = getDeviceMac(); strncpy( CpemacStr, macStr, sizeof(CpemacStr)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Received DeviceMac from Atom side: %s\n",macStr)); } memset(CpeMacHoldingBuf, 0, sizeof CpeMacHoldingBuf); memset(CpeMacid, 0, sizeof CpeMacid); for (k = 0; k < 6; k++ ) { /* copy 2 bytes */ CpeMacHoldingBuf[ k * 2 ] = CpemacStr[ k * 2 ]; CpeMacHoldingBuf[ k * 2 + 1 ] = CpemacStr[ k * 2 + 1 ]; CpeMacid[ k ] = (unsigned char)strtol(&CpeMacHoldingBuf[ k * 2 ], NULL, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG Parent Mac address = %0x\n", CpeMacid[ k ] )); } // assume 1 parent ONLY // Parent MAC avro_value_set_branch(&adrField, 1, &parent_optional); avro_value_get_by_name(&parent_optional, "mac_address", &parent_adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&parent_adrField, 1, &parent_optional); avro_value_set_fixed(&parent_optional, CpeMacid, 6); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, parent mac_address\tType: %d\n", avro_value_get_type(&parent_optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // Parent cpe_type avro_value_set_branch(&adrField, 1, &parent_optional); avro_value_get_by_name(&parent_optional, "cpe_type", &parent_adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&parent_adrField, 1, &parent_optional); avro_value_set_string(&parent_optional, CPE_TYPE_GATEWAY_STRING); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, parent cpe_type\tType: %d\n", avro_value_get_type(&parent_optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); // no more parent, set NULL avro_value_set_branch(&adrField, 1, &parent_optional); avro_value_get_by_name(&parent_optional, "cpe_parent", &parent_adrField, NULL); avro_value_set_branch(&parent_adrField, 0, &parent_optional); avro_value_set_null(&parent_optional); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, parent cpe_parent\tType: %d\n", avro_value_get_type(&parent_optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); } //host_table_version block avro_value_get_by_name(&adr, "host_table_version", &adrField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&adrField, 1, &optional); avro_value_set_long(&optional, lmHosts.lastActivity); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, host_table_version\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //Data Field block avro_value_get_by_name(&adr, "data", &adrField, NULL); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, NetworkDeviceStatusReports - data array\tType: %d\n", avro_value_get_type(&adrField))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //adrField now contains a reference to the AssociatedDeviceReportsArray //Device Report avro_value_t dr = {0,0}; //Current Device Report Field avro_value_t drField = {0,0}; while(ptr) { if( (!strcmp(ptr->parent, parent_mac) && (extender == TRUE)) || (extender == FALSE) ) { CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Current Link List Ptr = [0x%lx], numElements = %d\n", (ulong)ptr, numElements )); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tDevice entry #: %d\n", i + 1)); //Append a DeviceReport item to array avro_value_append(&adrField, &dr, NULL); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tDevice Status Report\tType: %d\n", avro_value_get_type(&dr))); //data array block memset(CpeMacHoldingBuf, 0, sizeof CpeMacHoldingBuf); memset(CpeMacid, 0, sizeof CpeMacid); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Mac address from node list = %s \n", ptr->device_mac )); for (k = 0; k < 6; k++ ) { /* copy 2 bytes */ CpeMacHoldingBuf[ k * 2 ] = ptr->device_mac[ k * 3 ]; CpeMacHoldingBuf[ k * 2 + 1 ] = ptr->device_mac[ k * 3 + 1 ]; CpeMacid[ k ] = (unsigned char)strtol(&CpeMacHoldingBuf[ k * 2 ], NULL, 16); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Mac address = %0x\n", CpeMacid[ k ] )); } //device_mac - fixed 6 bytes avro_value_get_by_name(&dr, "device_id", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, device_id\tType: %d\n", avro_value_get_type(&drField))); avro_value_get_by_name(&drField, "mac_address", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); avro_value_set_fixed(&optional, CpeMacid, 6); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tmac_address\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //device_type - string avro_value_get_by_name(&dr, "device_id", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, device_id\tType: %d\n", avro_value_get_type(&drField))); avro_value_get_by_name(&drField, "device_type", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); avro_value_set_string(&optional, ptr->device_type); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tdevice_type\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //timestamp - long avro_value_get_by_name(&dr, "timestamp", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); int64_t tstamp_av = (int64_t) ptr->timestamp.tv_sec * 1000000 + (int64_t) ptr->timestamp.tv_usec; tstamp_av = tstamp_av/1000; avro_value_set_long(&optional, tstamp_av); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, timestamp = ""%" PRId64 "\n", tstamp_av )); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \ttimestamp\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //interface_name - string avro_value_get_by_name(&dr, "interface_name", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); //avro_value_set_string(&optional, " aa "); avro_value_set_string(&optional, ptr->interface_name ); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tinterface_name\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //status - enum avro_value_get_by_name(&dr, "status", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, status\tType: %d\n", avro_value_get_type(&optional))); if ( ptr->is_active ) avro_value_set_enum(&optional, avro_schema_enum_get_by_name(avro_value_get_schema(&optional), "ONLINE")); else avro_value_set_enum(&optional, avro_schema_enum_get_by_name(avro_value_get_schema(&optional), "OFFLINE")); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //hostname - string avro_value_get_by_name(&dr, "hostname", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); avro_value_set_string(&optional, ptr->hostname); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \thostname\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); //ipaddress - array avro_value_get_by_name(&dr, "ip_addresses", &drField, NULL); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); avro_value_set_branch(&drField, 1, &optional); avro_value_append(&optional, &array, NULL); avro_value_set_string(&array, ptr->ipaddress); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, \tipaddress\tType: %d\n", avro_value_get_type(&optional))); if ( CHK_AVRO_ERR ) CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, %s\n", avro_strerror())); i++; } #if SIMULATION ptr = 0; #else ptr = ptr->next; // next link list #endif /* check for writer size, if buffer is almost full, skip trailing linklist */ avro_value_sizeof(&adr, &AvroSerializedSize); OneAvroSerializedSize = ( OneAvroSerializedSize == 0 ) ? AvroSerializedSize : OneAvroSerializedSize; if ( ( WRITER_BUF_SIZE - AvroSerializedSize ) < OneAvroSerializedSize ) { CcspLMLiteTrace(("RDK_LOG_ERROR, AVRO write buffer is almost full, size = %d func %s, exit!\n", (int)AvroSerializedSize, __FUNCTION__ )); break; } } //Thats the end of that avro_value_write(writer, &adr); avro_value_sizeof(&adr, &AvroSerializedSize); AvroSerializedSize += MAGIC_NUMBER_SIZE + SCHEMA_ID_LENGTH; CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Serialized writer size %d\n", (int)AvroSerializedSize)); //Free up memory avro_value_decref(&adr); avro_writer_free(writer); //free(buffer); /* if ( consoleDebugEnable ) { // b64 encoding decodesize = b64_get_encoded_buffer_size( AvroSerializedSize ); b64buffer = malloc(decodesize * sizeof(uint8_t)); b64_encode( (uint8_t*)AvroSerializedBuf, AvroSerializedSize, b64buffer); fprintf( stderr, "\nAVro serialized data\n"); for (k = 0; k < (int)AvroSerializedSize ; k++) { char buf[30]; if ( ( k % 32 ) == 0 ) fprintf( stderr, "\n"); sprintf(buf, "%02X", (unsigned char)AvroSerializedBuf[k]); fprintf( stderr, "%c%c", buf[0], buf[1] ); } fprintf( stderr, "\n\nB64 data\n"); for (k = 0; k < (int)decodesize; k++) { if ( ( k % 32 ) == 0 ) fprintf( stderr, "\n"); fprintf( stderr, "%c", b64buffer[k]); } fprintf( stderr, "\n\n"); free(b64buffer); }*/ CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, Before ND WebPA SEND message call\n")); #ifdef PARODUS_ENABLE CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, serviceName: %s\n", serviceName)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, dest: %s\n", dest)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, trans_id: %s\n", trans_id)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, contentType: %s\n", contentType)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, AvroSerializedBuf: %s\n", AvroSerializedBuf)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, AvroSerializedSize: %d\n", (int)AvroSerializedSize)); #endif // Send data from LMLite to webpa using CCSP bus interface sendWebpaMsg(serviceName, dest, trans_id, contentType, AvroSerializedBuf, AvroSerializedSize); CcspTraceWarning(("NetworkDevicesStatus report sent to Webpa, Destination=%s, Transaction-Id=%s \n",dest,trans_id)); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, After ND WebPA SEND message call\n")); CcspLMLiteConsoleTrace(("RDK_LOG_DEBUG, LMLite %s : EXIT \n", __FUNCTION__ )); #if SIMULATION exit(0); #endif }
static void process_file(const char *filename) { avro_file_reader_t reader; FILE *fp; int should_close; if (filename == NULL) { fp = stdin; filename = "<stdin>"; should_close = 0; } else { fp = fopen(filename, "rb"); should_close = 1; if (fp == NULL) { fprintf(stderr, "Error opening %s:\n %s\n", filename, strerror(errno)); exit(1); } } if (avro_file_reader_fp(fp, filename, 0, &reader)) { fprintf(stderr, "Error opening %s:\n %s\n", filename, avro_strerror()); if (should_close) { fclose(fp); } exit(1); } avro_schema_t wschema; avro_value_iface_t *iface; avro_value_t value; wschema = avro_file_reader_get_writer_schema(reader); iface = avro_generic_class_from_schema(wschema); avro_generic_value_new(iface, &value); int rval; while ((rval = avro_file_reader_read_value(reader, &value)) == 0) { char *json; if (avro_value_to_json(&value, 1, &json)) { fprintf(stderr, "Error converting value to JSON: %s\n", avro_strerror()); } else { printf("%s\n", json); free(json); } avro_value_reset(&value); } // If it was not an EOF that caused it to fail, // print the error. if (rval != EOF) { fprintf(stderr, "Error: %s\n", avro_strerror()); } avro_file_reader_close(reader); avro_value_decref(&value); avro_value_iface_decref(iface); avro_schema_decref(wschema); if (should_close) { fclose(fp); } }
static void read_with_schema_resolution(const char *filename, const char *reader_schema_json, const char *field_name) { avro_file_reader_t file; avro_schema_error_t error; avro_schema_t reader_schema; avro_schema_t writer_schema; avro_value_iface_t *writer_iface; avro_value_iface_t *reader_iface; avro_value_t writer_value; avro_value_t reader_value; // Open an Avro file and grab the writer schema that was used to create the // file. check_i(avro_file_reader(filename, &file)); writer_schema = avro_file_reader_get_writer_schema(file); // Create a value instance that we want to read the data into. Note that // this is *not* the writer schema! check_i(avro_schema_from_json (reader_schema_json, 0, &reader_schema, &error)); check_p(reader_iface = avro_generic_class_from_schema(reader_schema)); check_i(avro_generic_value_new(reader_iface, &reader_value)); // Create a resolved writer that will perform the schema resolution for us. // If the two schemas aren't compatible, this function will return an error, // and the error text should describe which parts of the schemas are // incompatible. check_p(writer_iface = avro_resolved_writer_new(writer_schema, reader_schema)); // Create an instance of the resolved writer, and tell it to wrap our reader // value instance. check_i(avro_resolved_writer_new_value(writer_iface, &writer_value)); avro_resolved_writer_set_dest(&writer_value, &reader_value); // Now we've got the same basic loop as above. But we've got two value // instances floating around! Which do we use? We have the file reader // fill in `writer_value`, since that's the value that is an instance of the // file's writer schema. Since it's an instance of a resolved writer, // though, it doesn't actually store any data itself. Instead, it will // perform schema resolution on the data read from the file, and fill in its // wrapped value (which in our case is `reader_value`). That means that // once the data has been read, we can get its (schema-resolved) contents // via `reader_value`. while (avro_file_reader_read_value(file, &writer_value) == 0) { avro_value_t field; int32_t value; check_i(avro_value_get_by_name(&reader_value, field_name, &field, NULL)); check_i(avro_value_get_int(&field, &value)); printf(" %s: %" PRId32 "\n", field_name, value); } // Close the file and clean up after ourselves. avro_file_reader_close(file); avro_value_decref(&writer_value); avro_value_iface_decref(writer_iface); avro_schema_decref(writer_schema); avro_value_decref(&reader_value); avro_value_iface_decref(reader_iface); avro_schema_decref(reader_schema); }
static void write_data(const char *filename) { avro_file_writer_t file; avro_schema_t writer_schema; avro_schema_error_t error; avro_value_iface_t *writer_iface; avro_value_t writer_value; avro_value_t field; // First parse the JSON schema into the C API's internal schema // representation. check_i(avro_schema_from_json(WRITER_SCHEMA, 0, &writer_schema, &error)); // Then create a value that is an instance of that schema. We use the // built-in "generic" value implementation, which is what you'll usually use // to create value instances that can actually store data. We only need to // create one instance, since we can re-use it for all of the values that // we're going to write into the file. check_p(writer_iface = avro_generic_class_from_schema(writer_schema)); check_i(avro_generic_value_new(writer_iface, &writer_value)); // Open a new data file for writing, and then write a slew of records into // it. check_i(avro_file_writer_create(filename, writer_schema, &file)); /* record 1 */ check_i(avro_value_get_by_name(&writer_value, "a", &field, NULL)); check_i(avro_value_set_int(&field, 10)); check_i(avro_value_get_by_name(&writer_value, "b", &field, NULL)); check_i(avro_value_set_int(&field, 11)); check_i(avro_file_writer_append_value(file, &writer_value)); /* record 2 */ check_i(avro_value_get_by_name(&writer_value, "a", &field, NULL)); check_i(avro_value_set_int(&field, 20)); check_i(avro_value_get_by_name(&writer_value, "b", &field, NULL)); check_i(avro_value_set_int(&field, 21)); check_i(avro_file_writer_append_value(file, &writer_value)); /* record 3 */ check_i(avro_value_get_by_name(&writer_value, "a", &field, NULL)); check_i(avro_value_set_int(&field, 30)); check_i(avro_value_get_by_name(&writer_value, "b", &field, NULL)); check_i(avro_value_set_int(&field, 31)); check_i(avro_file_writer_append_value(file, &writer_value)); /* record 4 */ check_i(avro_value_get_by_name(&writer_value, "a", &field, NULL)); check_i(avro_value_set_int(&field, 40)); check_i(avro_value_get_by_name(&writer_value, "b", &field, NULL)); check_i(avro_value_set_int(&field, 41)); check_i(avro_file_writer_append_value(file, &writer_value)); /* record 5 */ check_i(avro_value_get_by_name(&writer_value, "a", &field, NULL)); check_i(avro_value_set_int(&field, 50)); check_i(avro_value_get_by_name(&writer_value, "b", &field, NULL)); check_i(avro_value_set_int(&field, 51)); check_i(avro_file_writer_append_value(file, &writer_value)); // Close the file and clean up after ourselves. avro_file_writer_close(file); avro_value_decref(&writer_value); avro_value_iface_decref(writer_iface); avro_schema_decref(writer_schema); }
static void build_heartbeat_response(completed_proc_t *completed_proc_array, int array_size, avro_slice_t **slice) { char filename[FILE_NAME_LEN]; char buf[BUFFER_SIZE]; long len = 0; avro_schema_t schema; avro_value_iface_t *iface; avro_value_t record; avro_value_t completed_processes_value, ProcessStatus_value; avro_value_t name_value, ProcessName_value, jobid_value, vpid_value; avro_value_t state_value; avro_value_t exit_value_value; size_t index; int i; avro_writer_t writer; sprintf(filename, "%s/%s", SCHEMA_PATH, "HeartBeatResponseRecordAvro.avsc"); init_schema(filename, &schema); iface = avro_generic_class_from_schema(schema); avro_generic_value_new(iface, &record); avro_value_get_by_name(&record, "completed_processes", &completed_processes_value, &index); for (i = 0; i < array_size; i++) { avro_value_append(&completed_processes_value, &ProcessStatus_value, &index); avro_value_get_by_name(&ProcessStatus_value, "name", &name_value, &index); avro_value_get_by_name(&name_value, "jobid", &jobid_value, &index); avro_value_set_int(&jobid_value, completed_proc_array[i].proc_name.jobid); avro_value_get_by_name(&name_value, "vpid", &vpid_value, &index); avro_value_set_int(&vpid_value, completed_proc_array[i].proc_name.vpid); avro_value_get_by_name(&ProcessStatus_value, "state", &state_value, &index); avro_value_set_enum(&state_value, completed_proc_array[i].proc_state); avro_value_get_by_name(&ProcessStatus_value, "exit_value", &exit_value_value, &index); avro_value_set_int(&exit_value_value, completed_proc_array[i].exit_value); } /* create a writer with memory buffer */ writer = avro_writer_memory(buf, sizeof(buf)); /* write record to writer (buffer) */ if (avro_value_write(writer, &record)) { fprintf(stderr, "Unable to write record to memory buffer\n"); fprintf(stderr, "Error: %s\n", avro_strerror()); exit(1); } avro_writer_flush(writer); len = avro_writer_tell(writer); //avro_generic_value_free(&record); avro_value_iface_decref(iface); avro_schema_decref(schema); *slice = xmalloc(sizeof(avro_slice_t)); (*slice)->buffer = xmalloc(len); (*slice)->len = len; memcpy((*slice)->buffer, buf, len); }