/*
{
"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);
}
/*
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);
}
rkv_error_t r_kv_avro_value_get_string(avro_value_t *avro_value,
const char *name,
const char **ret_value,
int *ret_size) {
avro_value_t field;
rkv_error_t ret = RKV_SUCCESS;
const char *value;
size_t size;
if (!avro_value || !name || !ret_value) {
return RKV_INVALID_ARGUEMENTS;
}
if (avro_value_get_by_name(avro_value, name, &field, NULL) != 0) {
return RKV_INVALID_ARGUEMENTS;
}
if (avro_value_get_string(&field, &value, &size) == EINVAL) {
ret = RKV_INVALID_AVRO_SET_OP;
}
*ret_value = value;
if (ret_size) {
*ret_size = size;
}
//avro_value_decref(&field);
return ret;
}
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);
}
rkv_error_t r_kv_avro_value_set_double(avro_value_t *avro_value,
const char *name,
double value) {
avro_value_t field;
rkv_error_t ret = RKV_SUCCESS;
if (!avro_value || !name) {
return RKV_INVALID_ARGUEMENTS;
}
if (avro_value_get_by_name(avro_value, name, &field, NULL) != 0) {
return RKV_INVALID_ARGUEMENTS;
}
if (avro_value_set_double(&field, value) == EINVAL) {
ret = RKV_INVALID_AVRO_SET_OP;
}
//avro_value_decref(&field);
return ret;
}
rkv_error_t r_kv_avro_value_get_long(avro_value_t *avro_value,
const char *name,
int64_t *ret_value) {
avro_value_t field;
rkv_error_t ret = RKV_SUCCESS;
int64_t value = 0;
if (!avro_value || !name || !ret_value) {
return RKV_INVALID_ARGUEMENTS;
}
if (avro_value_get_by_name(avro_value, name, &field, NULL) != 0) {
return RKV_INVALID_ARGUEMENTS;
}
if (avro_value_get_long(&field, &value) == EINVAL) {
ret = RKV_INVALID_AVRO_SET_OP;
}
*ret_value = value;
//avro_value_decref(&field);
return ret;
}
/* 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 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);
}
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
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);
}
int
avro_value_equal_fast(avro_value_t *val1, avro_value_t *val2)
{
avro_type_t type1 = avro_value_get_type(val1);
avro_type_t type2 = avro_value_get_type(val2);
if (type1 != type2) {
return 0;
}
switch (type1) {
case AVRO_BOOLEAN:
{
int v1;
int v2;
check_return(0, avro_value_get_boolean(val1, &v1));
check_return(0, avro_value_get_boolean(val2, &v2));
return (v1 == v2);
}
case AVRO_BYTES:
{
const void *buf1;
const void *buf2;
size_t size1;
size_t size2;
check_return(0, avro_value_get_bytes(val1, &buf1, &size1));
check_return(0, avro_value_get_bytes(val2, &buf2, &size2));
if (size1 != size2) {
return 0;
}
return (memcmp(buf1, buf2, size1) == 0);
}
case AVRO_DOUBLE:
{
double v1;
double v2;
check_return(0, avro_value_get_double(val1, &v1));
check_return(0, avro_value_get_double(val2, &v2));
return (v1 == v2);
}
case AVRO_FLOAT:
{
float v1;
float v2;
check_return(0, avro_value_get_float(val1, &v1));
check_return(0, avro_value_get_float(val2, &v2));
return (v1 == v2);
}
case AVRO_INT32:
{
int32_t v1;
int32_t v2;
check_return(0, avro_value_get_int(val1, &v1));
check_return(0, avro_value_get_int(val2, &v2));
return (v1 == v2);
}
case AVRO_INT64:
{
int64_t v1;
int64_t v2;
check_return(0, avro_value_get_long(val1, &v1));
check_return(0, avro_value_get_long(val2, &v2));
return (v1 == v2);
}
case AVRO_NULL:
{
check_return(0, avro_value_get_null(val1));
check_return(0, avro_value_get_null(val2));
return 1;
}
case AVRO_STRING:
{
const char *buf1;
const char *buf2;
size_t size1;
size_t size2;
check_return(0, avro_value_get_string(val1, &buf1, &size1));
check_return(0, avro_value_get_string(val2, &buf2, &size2));
if (size1 != size2) {
return 0;
}
return (memcmp(buf1, buf2, size1) == 0);
}
case AVRO_ARRAY:
{
size_t count1;
size_t count2;
check_return(0, avro_value_get_size(val1, &count1));
check_return(0, avro_value_get_size(val2, &count2));
if (count1 != count2) {
return 0;
}
size_t i;
for (i = 0; i < count1; i++) {
avro_value_t child1;
avro_value_t child2;
check_return(0, avro_value_get_by_index
(val1, i, &child1, NULL));
check_return(0, avro_value_get_by_index
(val2, i, &child2, NULL));
if (!avro_value_equal_fast(&child1, &child2)) {
return 0;
}
}
return 1;
}
case AVRO_ENUM:
{
int v1;
int v2;
check_return(0, avro_value_get_enum(val1, &v1));
check_return(0, avro_value_get_enum(val2, &v2));
return (v1 == v2);
}
case AVRO_FIXED:
{
const void *buf1;
const void *buf2;
size_t size1;
size_t size2;
check_return(0, avro_value_get_fixed(val1, &buf1, &size1));
check_return(0, avro_value_get_fixed(val2, &buf2, &size2));
if (size1 != size2) {
return 0;
}
return (memcmp(buf1, buf2, size1) == 0);
}
case AVRO_MAP:
{
size_t count1;
size_t count2;
check_return(0, avro_value_get_size(val1, &count1));
check_return(0, avro_value_get_size(val2, &count2));
if (count1 != count2) {
return 0;
}
size_t i;
for (i = 0; i < count1; i++) {
avro_value_t child1;
avro_value_t child2;
const char *key1;
check_return(0, avro_value_get_by_index
(val1, i, &child1, &key1));
check_return(0, avro_value_get_by_name
(val2, key1, &child2, NULL));
if (!avro_value_equal_fast(&child1, &child2)) {
return 0;
}
}
return 1;
}
case AVRO_RECORD:
{
size_t count1;
check_return(0, avro_value_get_size(val1, &count1));
size_t i;
for (i = 0; i < count1; i++) {
avro_value_t child1;
avro_value_t child2;
check_return(0, avro_value_get_by_index
(val1, i, &child1, NULL));
check_return(0, avro_value_get_by_index
(val2, i, &child2, NULL));
if (!avro_value_equal_fast(&child1, &child2)) {
return 0;
}
}
return 1;
}
case AVRO_UNION:
{
int disc1;
int disc2;
check_return(0, avro_value_get_discriminant(val1, &disc1));
check_return(0, avro_value_get_discriminant(val2, &disc2));
if (disc1 != disc2) {
return 0;
}
avro_value_t branch1;
avro_value_t branch2;
check_return(0, avro_value_get_current_branch(val1, &branch1));
check_return(0, avro_value_get_current_branch(val2, &branch2));
return avro_value_equal_fast(&branch1, &branch2);
}
default:
return 0;
}
}
