json_t *get_json_listener(listener_dest_info_t *header)
{
json_t *result = NULL;
json_t *jitem = NULL;
json_t *evt_type_item = NULL;
int32 i = 0;
int8 evt_type[128];
listener_dest_info_t *tmp;
result = json_array();
if (result == NULL) {
HTTPD_ERR("result json object request fail\n");
return NULL;
}
while (header) {
jitem = json_object();
json_object_add(jitem, RMM_JSON_RF_LINKS, json_string(header->dest));
evt_type_item = json_array();
for (i = 0; i < header->evt_index; i++) {
memset(evt_type, 0, 128);
get_event_type_by_nodeid(header->event_types[i], evt_type, sizeof(evt_type));
json_array_add(evt_type_item, json_string(evt_type));
}
json_object_add(jitem, RMM_JSON_RF_EVT_TYPES, evt_type_item);
json_array_add(result, jitem);
tmp = header->pnext;
free(header);
header = tmp;
}
return result;
}
void pack_rf_evt_links(json_t *result, rf_link_t *link)
{
int32 i = 0;
json_t *array = NULL;
json_t *listener = NULL;
array = json_array();
if (array == NULL) {
HTTPD_ERR("json array request fail\n");
return;
}
for (i = 0; i < RF_EVENT_MAX_LISTENER_NUM; i++) {
listener = NULL;
listener = json_object();
if (listener != NULL) {
if (strlen(link->subscription[i]) != 0) {
add_json_string(listener, RMM_JSON_RF_LISTENER, (uint8 *)(link->subscription[i]));
json_array_add(array, listener);
}
}
}
json_object_add(result, RMM_JSON_RF_SUBSCRIPTION, array);
add_json_string(result, RMM_JSON_RF_SELF, (uint8 *)link->self);
}
static json_t *tzone_coll_get(struct rest_uri_param *param)
{
collections_t *tzone_collections = NULL;
uint32 tzone_num = 0;
result_t rs = RESULT_OK;
json_t *result = NULL;
json_t *tzone = NULL;
json_t *array = NULL;
int32 i;
int32 zone_num = 0;
zone_num = libwrap_get_asset_num(MC_TYPE_TZONE);
if (zone_num == 0) {
HTTPD_ERR("get thermal zone num fail\n");
return NULL;
}
tzone_collections = (collections_t *)malloc(zone_num * sizeof(collections_t));
if (tzone_collections == NULL)
return NULL;
memset(tzone_collections, 0, zone_num * sizeof(collections_t));
rs = libwrap_get_tzone_coll(tzone_collections, &tzone_num);
if (rs != RESULT_OK) {
HTTPD_ERR("get cooling zone collection fail, result is %d\n", rs);
return NULL;
}
result = json_object();
if (result == NULL) {
HTTPD_ERR("result json object request error\n");
return NULL;
}
array = json_array();
if (array == NULL) {
HTTPD_ERR("json array request error\n");
return NULL;
}
for (i = 0; i < tzone_num; i++) {
tzone = NULL;
tzone = json_object();
if (tzone != NULL) {
add_json_integer(tzone, RMM_JSON_ID, tzone_collections[i].id);
add_json_string(tzone, RMM_JSON_UUID, tzone_collections[i].uuid);
add_json_string(tzone, RMM_JSON_NAME, tzone_collections[i].name);
update_href_host(tzone_collections[i].href, HREF_URL_LEN, param->host);
add_json_string(tzone, RMM_JSON_HREF, tzone_collections[i].href);
json_array_add(array, tzone);
}
}
json_object_add(result, RMM_JSON_THERMAL_ZONES, array);
if (tzone_collections)
free(tzone_collections);
return result;
}
int32 evt_listeners_pack_json(json_t *result, evt_listeners_t *listeners)
{
json_t *listener_array = NULL;
json_t * listener = NULL;
int32 i = 0;
json_object_add(result, RMM_JSON_ODATA_CONTEXT, json_string(listeners->odata_context));
json_object_add(result, RMM_JSON_ODATA_TYPE, json_string(listeners->odata_type));
json_object_add(result, RMM_JSON_NAME, json_string(listeners->name));
json_object_add(result, RMM_JSON_MEMBERS_ODATA_COUNT, json_integer(listeners->num));
listener_array = json_array();
if (listener_array == NULL) {
HTTPD_ERR("json array request fail\n");
return -1;
}
for (i = 0; i < listeners->num; i++) {
listener = json_object();
if (listener == NULL) {
HTTPD_ERR("json object request fail\n");
return -1;
}
json_object_add(listener, RMM_JSON_ODATA_ID, json_string(listeners->url[i]));
json_array_add(listener_array, listener);
}
json_object_add(result, RMM_JSON_MEMBERS, listener_array);
return 0;
}
static void
table_print_json__(const struct table *table, const struct table_style *style)
{
struct json *json, *headings, *data;
size_t x, y;
char *s;
json = json_object_create();
if (table->caption) {
json_object_put_string(json, "caption", table->caption);
}
if (table->timestamp) {
char *s = table_format_timestamp__();
json_object_put_string(json, "time", s);
free(s);
}
headings = json_array_create_empty();
for (x = 0; x < table->n_columns; x++) {
const struct column *column = &table->columns[x];
json_array_add(headings, json_string_create(column->heading));
}
json_object_put(json, "headings", headings);
data = json_array_create_empty();
for (y = 0; y < table->n_rows; y++) {
struct json *row = json_array_create_empty();
for (x = 0; x < table->n_columns; x++) {
const struct cell *cell = table_cell__(table, y, x);
if (cell->text) {
json_array_add(row, json_string_create(cell->text));
} else if (cell->json) {
json_array_add(row, json_clone(cell->json));
} else {
json_array_add(row, json_null_create());
}
}
json_array_add(data, row);
}
json_object_put(json, "data", data);
s = json_to_string(json, style->json_flags);
json_destroy(json);
puts(s);
free(s);
}
static int32 fan_add_property(json_t *threshold, json_t *property, int32 value, const int8 *name)
{
property = NULL;
property = json_object();
if (property != NULL) {
add_json_integer(property, name, value);
json_array_add(threshold, property);
}
return 0;
}
int32 rf_evt_pack_json(json_t *result, const int32 *evt_types, rf_evt_svc_t *service)
{
int32 i = 0;
json_t *types_array = NULL;
json_t *listener = NULL;
json_t *status = NULL;
json_object_add(result, RMM_JSON_ODATA_CONTEXT, json_string(service->links.odata_context));
json_object_add(result, RMM_JSON_ODATA_ID, json_string(service->links.odata_id));
add_json_string(result, RMM_JSON_ODATA_TYPE, service->fixed.odata_type);
add_json_string(result, RMM_JSON_RF_ID, service->fixed.id);
add_json_string(result, RMM_JSON_RF_NAME, service->fixed.name);
status = json_object();
if (status != NULL) {
add_json_string(status, RMM_JSON_RF_STATUS_STATE, service->fixed.status.state);
add_json_string(status, RMM_JSON_RF_STATUS_HEALTH, service->fixed.status.health);
}
json_object_add(result, RMM_JSON_RF_STATUS, status);
if (service->fixed.service_enabled)
json_object_add(result, RMM_JSON_RF_SERVICE_ENABLED, json_true());
else
json_object_add(result, RMM_JSON_RF_SERVICE_ENABLED, json_false());
add_json_integer(result, RMM_JSON_RF_DELIVERY_RETRY, service->fixed.retry);
add_json_integer(result, RMM_JSON_RF_DELIVERY_RETRY_INTERVAL, service->fixed.retry_interval);
types_array = json_array();
if (types_array == NULL)
return -1;
for (i = 0; i < MAX_EVT_ACTION_NUM; i++) {
if (evt_types[i] == 0)
continue;
json_array_add(types_array, json_string((int8 *)rf_evt_msg[i].type_name));
}
json_object_add(result, RMM_JSON_RF_SUPPORTED_EVT_TYPES, types_array);
listener = json_object();
if (listener == NULL)
return -1;
add_json_string(listener, RMM_JSON_ODATA_ID, service->links.subscriptions);
json_object_add(result, RMM_JSON_RF_SUBSCRIPTION, listener);
return 0;
}
int32 evt_listener_pack_json(json_t *result, evt_listener_t *listener)
{
int8 evt_type[128] = {};
int32 i = 0;
json_t *evt_type_item = NULL;
if (strnlen_s(listener->url, sizeof(listener->url)-1) == 0) {
HTTPD_ERR("invalid subscribe destination\n");
return -1;
}
json_object_add(result, RMM_JSON_ODATA_CONTEXT, json_string(listener->odata_context));
json_object_add(result, RMM_JSON_ODATA_ID, json_string(listener->odata_id));
json_object_add(result, RMM_JSON_ODATA_TYPE, json_string(listener->odata_type));
json_object_add(result, RMM_JSON_RF_ID, json_string(listener->id));
json_object_add(result, RMM_JSON_RF_NAME, json_string(listener->name));
json_object_add(result, RMM_JSON_RF_DESC, json_string(listener->description));
json_object_add(result, RMM_JSON_RF_DEST_URL, json_string(listener->url));
evt_type_item = json_array();
if (evt_type_item == NULL) {
HTTPD_ERR("json array request fail\n");
return -1;
}
for (i = 0; i < listener->evt_index; i++) {
memset(evt_type, 0, sizeof(evt_type));
get_event_type_by_node_type(listener->event_types[i], evt_type, sizeof(evt_type));
if (strnlen_s(evt_type, sizeof(evt_type)-1) != 0)
json_array_add(evt_type_item, json_string(evt_type));
}
json_object_add(result, RMM_JSON_RF_EVT_TYPES, evt_type_item);
json_object_add(result, RMM_JSON_RF_CONTEXT, json_string(listener->context));
json_object_add(result, RMM_JSON_RF_PROTOCOL, json_string(listener->protocol));
return 0;
}
struct json *
ovsdb_execute(struct ovsdb *db, const struct ovsdb_session *session,
const struct json *params,
long long int elapsed_msec, long long int *timeout_msec)
{
struct ovsdb_execution x;
struct ovsdb_error *error;
struct json *results;
size_t n_operations;
size_t i;
if (params->type != JSON_ARRAY
|| !params->u.array.n
|| params->u.array.elems[0]->type != JSON_STRING
|| strcmp(params->u.array.elems[0]->u.string, db->schema->name)) {
if (params->type != JSON_ARRAY) {
error = ovsdb_syntax_error(params, NULL, "array expected");
} else {
error = ovsdb_syntax_error(params, NULL, "database name expected "
"as first parameter");
}
results = ovsdb_error_to_json(error);
ovsdb_error_destroy(error);
return results;
}
x.db = db;
x.session = session;
x.txn = ovsdb_txn_create(db);
x.symtab = ovsdb_symbol_table_create();
x.durable = false;
x.elapsed_msec = elapsed_msec;
x.timeout_msec = LLONG_MAX;
results = NULL;
results = json_array_create_empty();
n_operations = params->u.array.n - 1;
error = NULL;
for (i = 1; i <= n_operations; i++) {
struct json *operation = params->u.array.elems[i];
struct ovsdb_error *parse_error;
struct ovsdb_parser parser;
struct json *result;
const struct json *op;
/* Parse and execute operation. */
ovsdb_parser_init(&parser, operation,
"ovsdb operation %"PRIuSIZE" of %"PRIuSIZE, i, n_operations);
op = ovsdb_parser_member(&parser, "op", OP_ID);
result = json_object_create();
if (op) {
const char *op_name = json_string(op);
ovsdb_operation_executor *executor = lookup_executor(op_name);
if (executor) {
error = executor(&x, &parser, result);
} else {
ovsdb_parser_raise_error(&parser, "No operation \"%s\"",
op_name);
}
} else {
ovs_assert(ovsdb_parser_has_error(&parser));
}
/* A parse error overrides any other error.
* An error overrides any other result. */
parse_error = ovsdb_parser_finish(&parser);
if (parse_error) {
ovsdb_error_destroy(error);
error = parse_error;
}
if (error) {
json_destroy(result);
result = ovsdb_error_to_json(error);
}
if (error && !strcmp(ovsdb_error_get_tag(error), "not supported")
&& timeout_msec) {
ovsdb_txn_abort(x.txn);
*timeout_msec = x.timeout_msec;
json_destroy(result);
json_destroy(results);
results = NULL;
goto exit;
}
/* Add result to array. */
json_array_add(results, result);
if (error) {
break;
}
}
if (!error) {
error = ovsdb_txn_commit(x.txn, x.durable);
if (error) {
json_array_add(results, ovsdb_error_to_json(error));
}
} else {
ovsdb_txn_abort(x.txn);
}
while (json_array(results)->n < n_operations) {
json_array_add(results, json_null_create());
}
exit:
ovsdb_error_destroy(error);
ovsdb_symbol_table_destroy(x.symtab);
return results;
}
static json_t *mbp_get(struct rest_uri_param *param)
{
int32 idx = 0;
result_t rs = RESULT_OK;
json_t *result = NULL;
json_t *fru = NULL;
json_t *av_action = NULL;
json_t *rs_json = NULL;
json_t *cap = NULL;
mbp_member_t mbp_member = { {0} };
json_t *loc = NULL;
idx = get_asset_idx(param, "mbp_id", MC_TYPE_CM);
if (idx == -1) {
HTTPD_ERR("get mbp index fail\n");
return NULL;
}
rs = libwrap_get_mbp_by_idx(idx, &mbp_member);
if (rs != RESULT_OK) {
HTTPD_ERR("get mbp info fail, result is %d\n", rs);
return NULL;
}
result = json_object();
if (result == NULL) {
HTTPD_ERR("result json object request fail\n");
return NULL;
}
pack_mbp_basic_info(&mbp_member, result);
loc = json_object();
if (loc == NULL) {
HTTPD_ERR("loc json object request fail\n");
return NULL;
}
add_loc_info(loc, (int32)mbp_member.loc.units, RMM_JSON_RACK_UNITS);
add_loc_info(loc, mbp_member.loc.u_location, RMM_JSON_ULOC);
add_loc_info(loc, mbp_member.loc.u_height, RMM_JSON_UHEIGHT);
add_loc_info(loc, mbp_member.loc.x_location, RMM_JSON_XLOC);
json_object_add(result, RMM_JSON_RACK_LOC, loc);
add_json_string(result, RMM_JSON_ASSET_TAG, mbp_member.asset.asset_tag);
fru = json_object();
if (fru != NULL) {
pack_fru_info(&(mbp_member.asset.fru), fru);
json_object_add(result, RMM_JSON_FRU_INFO, fru);
}
av_action = json_array();
if (av_action == NULL) {
HTTPD_ERR("available action array request fail\n");
return NULL;
}
/* action reset */
json_t *action = NULL;
action = json_object();
if (0 != prepare_get_action(mbp_member.av_action, action, 0)) {
HTTPD_ERR("action prepare fail\n");
return NULL;
}
cap = json_array();
if (cap != NULL) {
json_t *property = NULL;
json_t *allow_values = NULL;
allow_values = json_array();
/* soft reset */
property = json_object();
if ((property != NULL) && (allow_values != NULL)) {
if (0 != strcmp((int8 *)(mbp_member.av_action[0].cap[0].property), "")) {
json_object_add(property, RMM_JSON_PROPERTY_NAME, json_string((int8 *)(mbp_member.av_action[0].cap[0].property)));
json_array_add(allow_values, json_string((int8 *)(mbp_member.av_action[0].cap[0].av)));
}
json_object_add(property, RMM_JSON_ALLOWABLE_VALUES, allow_values);
json_array_add(cap, property);
}
json_object_add(action, RMM_JSON_CAPABILITIES, cap);
}
json_array_add(av_action, action);
/* action SetUartTarget */
action = NULL;
action = json_object();
if (0 != prepare_get_action(mbp_member.av_action, action, 1)) {
HTTPD_ERR("action prepare fail\n");
return NULL;
}
cap = NULL;
cap = json_array();
if (cap != NULL) {
json_t *property = NULL;
/* targetIndex */
property = json_object();
if (property != NULL) {
if (0 != strcmp((int8 *)(mbp_member.av_action[1].cap[0].property), ""))
json_object_add(property, RMM_JSON_PROPERTY_NAME, json_string((int8 *)(mbp_member.av_action[1].cap[0].property)));
json_array_add(cap, property);
}
json_object_add(action, RMM_JSON_CAPABILITIES, cap);
}
json_array_add(av_action, action);
/* action Update */
action = NULL;
action = json_object();
if (prepare_get_action(mbp_member.av_action, action, 2)) {
HTTPD_ERR("action prepare fail\n");
return NULL;
}
cap = NULL;
cap = json_array();
if (cap != NULL) {
json_t *property = NULL;
property = json_object();
if (property != NULL) {
if (0 != strcmp((int8 *)(mbp_member.av_action[2].cap[0].property), ""))
json_object_add(property, RMM_JSON_PROPERTY_NAME, json_string((int8 *)(mbp_member.av_action[2].cap[0].property)));
json_array_add(cap, property);
}
json_object_add(action, RMM_JSON_CAPABILITIES, cap);
}
json_array_add(av_action, action);
json_object_add(result, RMM_JSON_AVALIBLE_ACTIONS, av_action);
return result;
}
static json_t *mbp_coll_get(struct rest_uri_param *param)
{
collections_t *mbp_collections = NULL;
uint32 mbp_num = 0;
int32 i;
int32 cm_num = 0;
result_t rs = RESULT_OK;
json_t *result = NULL;
json_t *array = NULL;
json_t *sub_mbp = NULL;
cm_num = libwrap_get_asset_num(MC_TYPE_CM);
if (cm_num == 0) {
HTTPD_ERR("get mbp num fail\n");
return NULL;
}
mbp_collections = (collections_t *)malloc(cm_num * sizeof(collections_t));
if (mbp_collections == NULL)
return NULL;
memset(mbp_collections, 0, cm_num * sizeof(collections_t));
rs = libwrap_get_mbp_coll(mbp_collections, &mbp_num);
if (rs != RESULT_OK) {
HTTPD_ERR("get mbp coll info fail, result is %d\n", rs);
return NULL;
}
result = json_object();
if (result == NULL) {
HTTPD_ERR("result json object request fail\n");
return NULL;
}
array = json_array();
if (array == NULL) {
HTTPD_ERR("json array request fail\n");
return NULL;
}
for (i = 0; i < mbp_num; i++) {
sub_mbp = NULL;
sub_mbp = json_object();
if (sub_mbp == NULL) {
HTTPD_ERR("sub mbp json object request fail\n");
return NULL;
}
add_json_integer(sub_mbp, RMM_JSON_ID, mbp_collections[i].id);
add_json_string(sub_mbp, RMM_JSON_UUID, mbp_collections[i].uuid);
add_json_string(sub_mbp, RMM_JSON_NAME, mbp_collections[i].name);
update_href_host(mbp_collections[i].href, HREF_URL_LEN, param->host);
add_json_string(sub_mbp, RMM_JSON_HREF, mbp_collections[i].href);
json_array_add(array, sub_mbp);
}
json_object_add(result, RMM_JSON_MBPS, array);
if (mbp_collections)
free(mbp_collections);
return result;
}
int gami_register_req(gami_reg_t *reg_info)
{
jrpc_req_pkg_t req_pkg = {};
json_t *cap_array = NULL;
json_t *cap = NULL;
int i = 0;
int rc;
int64 ip = reg_info->ip_addr;
int64 port = reg_info->port;
printf("gami_register, name %s, ip %d, port %d.\n", reg_info->name, reg_info->ip_addr, reg_info->port);
fill_param(&req_pkg, JRPC_GAMI_REG_NAME, reg_info->name, JSON_STRING);
fill_param(&req_pkg, JRPC_GAMI_REG_IP, &ip, JSON_INTEGER);
fill_param(&req_pkg, JRPC_GAMI_REG_PORT, &port, JSON_INTEGER);
/*mbp*/
cap_array = json_array();
if (cap_array == NULL) {
return -1;
}
for (i = 0; i < GAMI_MAX_CAP_NUM; i++) {
if (strlen((char *)reg_info->capability.cap_mbp[i]) != 0) {
cap = NULL;
cap = json_object();
if (cap == NULL) {
return -1;
}
add_json_string(cap, JRPC_GAMI_CAP_NAME, (unsigned char *)reg_info->capability.cap_mbp[i]);
json_array_add(cap_array, cap);
}
}
fill_param(&req_pkg, JRPC_GAMI_REG_CAP_MBP, cap_array, JSON_ARRAY);
/*psu*/
cap_array = json_array();
if (cap_array == NULL) {
return -1;
}
for (i = 0; i < GAMI_MAX_CAP_NUM; i++) {
if (strlen((char *)reg_info->capability.cap_psu[i]) != 0) {
cap = NULL;
cap = json_object();
if (cap == NULL) {
return -1;
}
add_json_string(cap, JRPC_GAMI_CAP_NAME, (unsigned char *)reg_info->capability.cap_psu[i]);
json_array_add(cap_array, cap);
}
}
fill_param(&req_pkg, JRPC_GAMI_REG_CAP_PSU, cap_array, JSON_ARRAY);
/*fan*/
cap_array = json_array();
if (cap_array == NULL) {
return -1;
}
for (i = 0; i < GAMI_MAX_CAP_NUM; i++) {
if (strlen((char *)reg_info->capability.cap_fan[i]) != 0) {
cap = NULL;
cap = json_object();
if (cap == NULL) {
return -1;
}
add_json_string(cap, JRPC_GAMI_CAP_NAME, (unsigned char *)reg_info->capability.cap_fan[i]);
json_array_add(cap_array, cap);
}
}
fill_param(&req_pkg, JRPC_GAMI_REG_CAP_FAN, cap_array, JSON_ARRAY);
/*drawer*/
cap_array = json_array();
if (cap_array == NULL) {
return -1;
}
for (i = 0; i < GAMI_MAX_CAP_NUM; i++) {
if (strlen((char *)reg_info->capability.cap_drawer[i]) != 0) {
cap = NULL;
cap = json_object();
if (cap == NULL) {
return -1;
}
add_json_string(cap, JRPC_GAMI_CAP_NAME, (unsigned char *)reg_info->capability.cap_drawer[i]);
json_array_add(cap_array, cap);
}
}
fill_param(&req_pkg, JRPC_GAMI_REG_CAP_DRAWER, cap_array, JSON_ARRAY);
rc = send_msg_to_registerd(&req_pkg, REG_APP);
return rc;
}
static json_t *fan_get(struct rest_uri_param *param)
{
fan_member_t fan_member = { {0} };
result_t rs = RESULT_OK;
json_t *result = NULL;
json_t *threshold = NULL;
json_t *av_action = NULL;
json_t *fru = NULL;
json_t *property = NULL;
json_t *action = NULL;
json_t *cap = NULL;
int32 tzone_idx = 0, fan_idx = 0;
json_t *loc = NULL;
tzone_idx = get_asset_idx(param, "zone_id", MC_TYPE_TZONE);
if (tzone_idx == -1) {
HTTPD_ERR("get cooling zone index fail\n");
return NULL;
}
fan_idx = get_asset_idx(param, "fan_id", MC_TYPE_FAN);
if (fan_idx == -1) {
HTTPD_ERR("get fan index fail\n");
return NULL;
}
rs = libwrap_get_tzone_fan_by_idx(tzone_idx, fan_idx, &fan_member);
if (rs != RESULT_OK) {
HTTPD_ERR("get fan fail, result is %d\n", rs);
return NULL;
}
result = json_object();
if (result == NULL) {
HTTPD_ERR("result json object request fail\n");
return NULL;
}
pack_fan_basic_info(&fan_member, result);
loc = json_object();
if (loc != NULL) {
add_loc_info(loc, (int32)fan_member.fan_loc.units, RMM_JSON_RACK_UNITS);
add_loc_info(loc, fan_member.fan_loc.u_location, RMM_JSON_ULOC);
add_loc_info(loc, fan_member.fan_loc.u_height, RMM_JSON_UHEIGHT);
add_loc_info(loc, fan_member.fan_loc.x_location, RMM_JSON_XLOC);
}
json_object_add(result, RMM_JSON_RACK_LOC, loc);
threshold = NULL;
threshold = json_array();
if (threshold == NULL) {
HTTPD_ERR("threshold array request error\n");
return NULL;
}
fan_add_property(threshold, property, fan_member.tachometer.threshold.lower_non_critical, RMM_JSON_LOWER_NON_CRITICAL);
fan_add_property(threshold, property, fan_member.tachometer.threshold.upper_non_critical, RMM_JSON_UPPER_NON_CRITICAL);
fan_add_property(threshold, property, fan_member.tachometer.threshold.lower_critical, RMM_JSON_LOWER_CRITICAL);
fan_add_property(threshold, property, fan_member.tachometer.threshold.upper_critical, RMM_JSON_UPPER_CRITICAL);
json_object_add(result, RMM_JSON_THRESHOLD, threshold);
add_json_string(result, RMM_JSON_PRESENCE, fan_member.presence);
add_json_string(result, RMM_JSON_ASSET_TAG, fan_member.asset.asset_tag);
add_json_integer(result, RMM_JSON_SPEED_UNIT, fan_member.speed_unit);// 0--PWM, 1---RPM
fru = json_object();
if (fru != NULL) {
pack_fru_info(&(fan_member.asset.fru), fru);
json_object_add(result, RMM_JSON_FRU_INFO, fru);
}
av_action = json_array();
if (av_action == NULL) {
HTTPD_ERR("available action array request fail\n");
return NULL;
}
/* requestStateChange */
action = json_object();
if (0 != prepare_get_action(fan_member.av_action, action, 0)) {
HTTPD_ERR("action prepare fail\n");
return NULL;
}
cap = json_array();
if (cap != NULL) {
json_t *property = NULL;
json_t *allow_values = NULL;
allow_values = json_array();
property = json_object();
if ((property != NULL) && (allow_values != NULL)) {
if (0 != strcmp((int8 *)(fan_member.av_action[0].cap[0].property), "")) {
json_object_add(property, RMM_JSON_PROPERTY_NAME, json_string((int8 *)(fan_member.av_action[0].cap[0].property)));
json_array_add(allow_values, json_integer(str2int((int8 *)fan_member.av_action[0].cap[0].av)));
}
}
property = NULL;
property = json_object();
if ((property != NULL) && (allow_values != NULL)) {
if (0 != strcmp((int8 *)(fan_member.av_action[0].cap[1].property), "")) {
json_object_add(property, RMM_JSON_PROPERTY_NAME, json_string((int8 *)(fan_member.av_action[0].cap[1].property)));
json_array_add(allow_values, json_integer(str2int((int8 *)fan_member.av_action[0].cap[1].av)));
}
}
json_object_add(property, RMM_JSON_ALLOWABLE_VALUES, allow_values);
json_array_add(cap, property);
json_object_add(action, RMM_JSON_CAPABILITIES, cap);
}
json_array_add(av_action, action);
/* SetDesiredSpeed */
action = NULL;
action = json_object();
if (0 != prepare_get_action(fan_member.av_action, action, 1)) {
HTTPD_ERR("action prepare fail\n");
return NULL;
}
cap = NULL;
cap = json_array();
if (cap != NULL) {
json_t *property = NULL;
json_t *allow_values = NULL;
allow_values = json_array();
property = json_object();
if ((property != NULL) && (allow_values != NULL)) {
if (0 != strcmp((int8 *)(fan_member.av_action[1].cap[0].property), "")) {
json_object_add(property, RMM_JSON_PROPERTY_NAME, json_string((int8 *)(fan_member.av_action[1].cap[0].property)));
json_array_add(allow_values, json_string((int8 *)(fan_member.av_action[1].cap[0].av)));
}
if (0 != strcmp((int8 *)(fan_member.av_action[1].cap[1].property), "")) {
json_object_add(property, RMM_JSON_PROPERTY_NAME, json_string((int8 *)(fan_member.av_action[1].cap[1].property)));
json_array_add(allow_values, json_string((int8 *)(fan_member.av_action[1].cap[1].av)));
}
json_object_add(property, RMM_JSON_ALLOWABLE_VALUES, allow_values);
json_array_add(cap, property);
}
property = NULL;
property = json_object();
if (property != NULL) {
if (0 != strcmp((int8 *)(fan_member.av_action[1].cap[2].property), "")) {
json_object_add(property, RMM_JSON_PROPERTY_NAME, json_string((int8 *)(fan_member.av_action[1].cap[2].property)));
json_array_add(cap, property);
}
}
json_object_add(action, RMM_JSON_CAPABILITIES, cap);
}
json_array_add(av_action, action);
json_object_add(result, RMM_JSON_AVALIBLE_ACTIONS, av_action);
return result;
}
static json_t *fan_coll_get(struct rest_uri_param *param)
{
collections_t *tzone_fan_coll = NULL;
uint32 fan_num = 0;
int8 *p_tzone_id = NULL;
result_t rs = RESULT_OK;
json_t *result = NULL;
json_t *fan = NULL;
json_t *array = NULL;
int32 tzone_idx = 0;
int32 i;
tzone_fan_coll = (collections_t *)malloc(MAX_PWM_NUM * sizeof(collections_t));
if (tzone_fan_coll == NULL)
return NULL;
memset(tzone_fan_coll, 0, MAX_PWM_NUM * sizeof(collections_t));
tzone_idx = get_asset_idx(param, "zone_id", MC_TYPE_TZONE);
if (tzone_idx == -1) {
HTTPD_ERR("get cooling zone index fail\n");
return NULL;
}
rs = libwrap_get_tzone_fan_coll(tzone_idx, tzone_fan_coll, &fan_num);
if (rs != RESULT_OK) {
HTTPD_ERR("get fan collection fail, result is %d\n", rs);
return NULL;
}
result = json_object();
if (result == NULL) {
HTTPD_ERR("result json object request fail\n");
return NULL;
}
array = json_array();
if (array == NULL) {
HTTPD_ERR("json array request fail\n");
return NULL;
}
for (i = 0; i < fan_num; i++) {
fan = NULL;
fan = json_object();
if (NULL != fan) {
add_json_integer(fan, RMM_JSON_ID, tzone_fan_coll[i].id);
add_json_string(fan, RMM_JSON_UUID, tzone_fan_coll[i].uuid);
add_json_string(fan, RMM_JSON_NAME, tzone_fan_coll[i].name);
update_href_host(tzone_fan_coll[i].href, HREF_URL_LEN, param->host);
add_json_string(fan, RMM_JSON_HREF, tzone_fan_coll[i].href);
json_array_add(array, fan);
}
}
json_object_add(result, RMM_JSON_FANS, array);
if (tzone_fan_coll)
free(tzone_fan_coll);
return result;
}
