WatchdogNode* get_watchdog_node_from_json(char* json_data, int data_len, char** authkey)
{
json_value *root = NULL;
char* ptr;
WatchdogNode* wdNode = palloc0(sizeof(WatchdogNode));
root = json_parse(json_data,data_len);
/* The root node must be object */
if (root == NULL || root->type != json_object)
goto ERROR_EXIT;
if (json_get_long_value_for_key(root, "StartupTimeSecs", &wdNode->startup_time.tv_sec))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "State", (int*)&wdNode->state))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "WdPort", &wdNode->wd_port))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "PgpoolPort", &wdNode->pgpool_port))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "WdPriority", &wdNode->wd_priority))
goto ERROR_EXIT;
ptr = json_get_string_value_for_key(root, "NodeName");
if (ptr == NULL)
goto ERROR_EXIT;
strncpy(wdNode->nodeName, ptr, sizeof(wdNode->nodeName) -1);
ptr = json_get_string_value_for_key(root, "HostName");
if (ptr == NULL)
goto ERROR_EXIT;
strncpy(wdNode->hostname, ptr, sizeof(wdNode->hostname) -1);
ptr = json_get_string_value_for_key(root, "VIP");
if (ptr == NULL)
goto ERROR_EXIT;
strncpy(wdNode->delegate_ip, ptr, sizeof(wdNode->delegate_ip) -1);
if (authkey)
{
ptr = json_get_string_value_for_key(root, "authkey");
if (ptr != NULL)
*authkey = pstrdup(ptr);
else
*authkey = NULL;
}
return wdNode;
ERROR_EXIT:
if (root)
json_value_free(root);
pfree(wdNode);
return NULL;
}
bool parse_node_status_json(char* json_data, int data_len, int* nodeID, int* nodeStatus, char** message)
{
json_value* root;
char* ptr = NULL;
root = json_parse(json_data,data_len);
/* The root node must be object */
if (root == NULL || root->type != json_object)
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "NodeID", nodeID))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "NodeStatus", nodeStatus))
goto ERROR_EXIT;
ptr = json_get_string_value_for_key(root, "Message");
if (ptr != NULL)
*message = pstrdup(ptr);
json_value_free(root);
return true;
ERROR_EXIT:
if (root)
json_value_free(root);
return false;
}
static void
process_watchdog_info_response(PCPConnInfo* pcpConn, char* buf, int len)
{
char *json_data = NULL;
PCPWDClusterInfo* wd_cluster_info = NULL;
int clusterDataSize = 0;
if (strcmp(buf, "CommandComplete") == 0)
{
int tempVal;
char* ptr;
json_data = (char *) memchr(buf, '\0', len);
if(json_data == NULL)
goto INVALID_RESPONSE;
json_data +=1;
json_value* root;
json_value* value;
int i,nodeCount;
root = json_parse(json_data,len);
/* The root node must be object */
if (root == NULL || root->type != json_object)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
if (json_get_int_value_for_key(root, "NodeCount", &nodeCount))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
/* find the WatchdogNodes array */
value = json_get_value_for_key(root,"WatchdogNodes");
if (value == NULL)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
if (value->type != json_array)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
if (nodeCount != value->u.array.length)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
/* create the cluster object */
clusterDataSize = sizeof(PCPWDClusterInfo) + (sizeof(PCPWDNodeInfo) * nodeCount);
wd_cluster_info = malloc(clusterDataSize);
wd_cluster_info->nodeCount = nodeCount;
if (json_get_int_value_for_key(root, "RemoteNodeCount", &wd_cluster_info->remoteNodeCount))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
if (json_get_int_value_for_key(root, "QuorumStatus", &wd_cluster_info->quorumStatus))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
if (json_get_int_value_for_key(root, "AliveNodeCount", &wd_cluster_info->aliveNodeCount))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
if (json_get_int_value_for_key(root, "Escalated", &tempVal))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
wd_cluster_info->escalated = tempVal==0?false:true;
ptr = json_get_string_value_for_key(root, "MasterNodeName");
if (ptr == NULL)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
strncpy(wd_cluster_info->masterNodeName, ptr, sizeof(wd_cluster_info->masterNodeName) -1);
ptr = json_get_string_value_for_key(root, "MasterHostName");
if (ptr == NULL)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
strncpy(wd_cluster_info->masterHostName, ptr, sizeof(wd_cluster_info->masterHostName) -1);
/* Get watchdog nodes data */
for (i = 0; i < nodeCount; i++)
{
char* ptr;
json_value* nodeInfoValue = value->u.array.values[i];
PCPWDNodeInfo* wdNodeInfo = &wd_cluster_info->nodeList[i];
if (nodeInfoValue->type != json_object)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
if (json_get_int_value_for_key(nodeInfoValue, "ID", &wdNodeInfo->id))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
ptr = json_get_string_value_for_key(nodeInfoValue, "NodeName");
if (ptr == NULL)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
strncpy(wdNodeInfo->nodeName, ptr, sizeof(wdNodeInfo->nodeName) -1);
ptr = json_get_string_value_for_key(nodeInfoValue, "HostName");
if (ptr == NULL)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
strncpy(wdNodeInfo->hostName, ptr, sizeof(wdNodeInfo->hostName) -1);
ptr = json_get_string_value_for_key(nodeInfoValue, "DelegateIP");
if (ptr == NULL)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
strncpy(wdNodeInfo->delegate_ip, ptr, sizeof(wdNodeInfo->delegate_ip) -1);
if (json_get_int_value_for_key(nodeInfoValue, "WdPort", &wdNodeInfo->wd_port))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
if (json_get_int_value_for_key(nodeInfoValue, "PgpoolPort", &wdNodeInfo->pgpool_port))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
if (json_get_int_value_for_key(nodeInfoValue, "State", &wdNodeInfo->state))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
ptr = json_get_string_value_for_key(nodeInfoValue, "StateName");
if (ptr == NULL)
{
json_value_free(root);
goto INVALID_RESPONSE;
}
strncpy(wdNodeInfo->stateName, ptr, sizeof(wdNodeInfo->stateName) -1);
if (json_get_int_value_for_key(nodeInfoValue, "Priority", &wdNodeInfo->wd_priority))
{
json_value_free(root);
goto INVALID_RESPONSE;
}
}
json_value_free(root);
if (setNextResultBinaryData(pcpConn->pcpResInfo, (void *)wd_cluster_info,clusterDataSize , NULL) < 0)
goto INVALID_RESPONSE;
setCommandSuccessful(pcpConn);
}
else
{
pcp_internal_error(pcpConn,
"command failed with reason: \"%s\"\n",buf);
setResultStatus(pcpConn, PCP_RES_BAD_RESPONSE);
}
return;
INVALID_RESPONSE:
if(wd_cluster_info)
pfree(wd_cluster_info);
pcp_internal_error(pcpConn,
"command failed. invalid response\n");
setResultStatus(pcpConn, PCP_RES_BAD_RESPONSE);
}
bool parse_wd_node_function_json(char* json_data, int data_len, char** func_name, int **node_id_set, int *count)
{
json_value *root, *value;
char* ptr;
int node_count = 0;
int i;
*node_id_set = NULL;
*func_name = NULL;
*count = 0;
root = json_parse(json_data,data_len);
/* The root node must be object */
if (root == NULL || root->type != json_object)
{
json_value_free(root);
ereport(LOG,
(errmsg("watchdog is unable to parse node function json"),
errdetail("invalid json data \"%s\"",json_data)));
return false;
}
ptr = json_get_string_value_for_key(root, "Function");
if (ptr == NULL)
{
json_value_free(root);
ereport(LOG,
(errmsg("watchdog is unable to parse node function json"),
errdetail("function node not found in json data \"%s\"",json_data)));
return false;
}
*func_name = pstrdup(ptr);
/* If it is a node function ?*/
if (json_get_int_value_for_key(root, "NodeCount", &node_count))
{
/*node count not found, But we don't care much about this*/
json_value_free(root);
return true;
}
if (node_count <= 0)
{
json_value_free(root);
return true;
}
*count = node_count;
value = json_get_value_for_key(root,"NodeIdList");
if (value == NULL)
{
json_value_free(root);
ereport(LOG,
(errmsg("invalid json data"),
errdetail("unable to find NodeIdList node from data")));
return false;
}
if (value->type != json_array)
{
json_value_free(root);
ereport(WARNING,
(errmsg("invalid json data"),
errdetail("NodeIdList node does not contains Array")));
return false;
}
if (node_count != value->u.array.length)
{
json_value_free(root);
ereport(WARNING,
(errmsg("invalid json data"),
errdetail("NodeIdList array contains %d nodes while expecting %d",value->u.array.length, node_count)));
return false;
}
*node_id_set = palloc(sizeof(int) * node_count);
for (i = 0; i < node_count; i++)
{
*node_id_set[i] = value->u.array.values[i]->u.integer;
}
json_value_free(root);
return true;
}
WDNodeInfo* get_WDNodeInfo_from_wd_node_json(json_value* source)
{
char* ptr;
WDNodeInfo* wdNodeInfo = palloc0(sizeof(WDNodeInfo));
if (source->type != json_object)
ereport(ERROR,
(errmsg("invalid json data"),
errdetail("node is not of object type")));
if (json_get_int_value_for_key(source, "ID", &wdNodeInfo->id))
{
ereport(ERROR,
(errmsg("invalid json data"),
errdetail("unable to find Watchdog Node ID")));
}
ptr = json_get_string_value_for_key(source, "NodeName");
if (ptr == NULL)
{
ereport(ERROR,
(errmsg("invalid json data"),
errdetail("unable to find Watchdog Node Name")));
}
strncpy(wdNodeInfo->nodeName, ptr, sizeof(wdNodeInfo->nodeName) -1);
ptr = json_get_string_value_for_key(source, "HostName");
if (ptr == NULL)
{
ereport(ERROR,
(errmsg("invalid json data"),
errdetail("unable to find Watchdog Host Name")));
}
strncpy(wdNodeInfo->hostName, ptr, sizeof(wdNodeInfo->hostName) -1);
ptr = json_get_string_value_for_key(source, "DelegateIP");
if (ptr == NULL)
{
ereport(ERROR,
(errmsg("invalid json data"),
errdetail("unable to find Watchdog delegate IP")));
}
strncpy(wdNodeInfo->delegate_ip, ptr, sizeof(wdNodeInfo->delegate_ip) -1);
if (json_get_int_value_for_key(source, "PgpoolPort", &wdNodeInfo->wd_port))
{
ereport(ERROR,
(errmsg("invalid json data"),
errdetail("unable to find WdPort")));
}
if (json_get_int_value_for_key(source, "PgpoolPort", &wdNodeInfo->pgpool_port))
{
ereport(ERROR,
(errmsg("invalid json data"),
errdetail("unable to find PgpoolPort")));
}
if (json_get_int_value_for_key(source, "State", &wdNodeInfo->state))
{
ereport(ERROR,
(errmsg("invalid json data"),
errdetail("unable to find state")));
}
return wdNodeInfo;
}
POOL_CONFIG* get_pool_config_from_json(char* json_data, int data_len)
{
int i;
json_value *root = NULL;
json_value *value = NULL;
POOL_CONFIG *config = palloc0(sizeof(POOL_CONFIG));
config->backend_desc = palloc0(sizeof(BackendDesc));
root = json_parse(json_data,data_len);
/* The root node must be object */
if (root == NULL || root->type != json_object)
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "num_init_children", &config->num_init_children))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "listen_backlog_multiplier", &config->listen_backlog_multiplier))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "child_life_time", &config->child_life_time))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "connection_life_time", &config->connection_life_time))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "child_max_connections", &config->child_max_connections))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "client_idle_limit", &config->client_idle_limit))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "max_pool", &config->max_pool))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "replication_mode", &config->replication_mode))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "enable_pool_hba", &config->enable_pool_hba))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "load_balance_mode", &config->load_balance_mode))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "replication_stop_on_mismatch", &config->replication_stop_on_mismatch))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "failover_if_affected_tuples_mismatch", &config->failover_if_affected_tuples_mismatch))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "replicate_select", &config->replicate_select))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "master_slave_mode", &config->master_slave_mode))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "connection_cache", &config->connection_cache))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "health_check_timeout", &config->health_check_timeout))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "health_check_period", &config->health_check_period))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "health_check_max_retries", &config->health_check_max_retries))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "health_check_retry_delay", &config->health_check_retry_delay))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "fail_over_on_backend_error", &config->fail_over_on_backend_error))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "recovery_timeout", &config->recovery_timeout))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "search_primary_node_timeout", &config->search_primary_node_timeout))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "client_idle_limit_in_recovery", &config->client_idle_limit_in_recovery))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "insert_lock", &config->insert_lock))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "memory_cache_enabled", &config->memory_cache_enabled))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "use_watchdog", &config->use_watchdog))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "clear_memqcache_on_escalation", &config->clear_memqcache_on_escalation))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "wd_port", &config->wd_port))
goto ERROR_EXIT;
if (json_get_int_value_for_key(root, "wd_priority", &config->wd_priority))
goto ERROR_EXIT;
config->master_slave_sub_mode = json_get_string_value_for_key(root, "master_slave_sub_mode");
if (config->master_slave_sub_mode == NULL)
goto ERROR_EXIT;
config->master_slave_sub_mode = pstrdup(config->master_slave_sub_mode);
/* backend_desc array */
value = json_get_value_for_key(root,"backend_desc");
if (value == NULL || value->type != json_array)
goto ERROR_EXIT;
config->backend_desc->num_backends = value->u.array.length;
for (i = 0; i < config->backend_desc->num_backends; i++)
{
json_value *arr_value = value->u.array.values[i];
char *ptr;
if (json_get_int_value_for_key(arr_value, "backend_port", &config->backend_desc->backend_info[i].backend_port))
goto ERROR_EXIT;
ptr = json_get_string_value_for_key(arr_value, "backend_hostname");
if (ptr == NULL)
goto ERROR_EXIT;
strncpy(config->backend_desc->backend_info[i].backend_hostname, ptr,sizeof(config->backend_desc->backend_info[i].backend_hostname) -1);
}
/* wd_remote_nodes array */
value = json_get_value_for_key(root,"wd_remote_nodes");
if (value == NULL || value->type != json_array)
goto ERROR_EXIT;
config->wd_remote_nodes.num_wd = value->u.array.length;
for (i = 0; i < config->wd_remote_nodes.num_wd; i++)
{
json_value *arr_value = value->u.array.values[i];
char *ptr;
if (json_get_int_value_for_key(arr_value, "wd_port", &config->wd_remote_nodes.wd_remote_node_info[i].wd_port))
goto ERROR_EXIT;
if (json_get_int_value_for_key(arr_value, "pgpool_port", &config->wd_remote_nodes.wd_remote_node_info[i].pgpool_port))
goto ERROR_EXIT;
ptr = json_get_string_value_for_key(arr_value, "hostname");
if (ptr == NULL)
goto ERROR_EXIT;
strncpy(config->wd_remote_nodes.wd_remote_node_info[i].hostname, ptr,sizeof(config->wd_remote_nodes.wd_remote_node_info[i].hostname) -1);
}
json_value_free(root);
return config;
ERROR_EXIT:
if (root)
json_value_free(root);
if (config->backend_desc)
pfree(config->backend_desc);
if (config->master_slave_sub_mode)
pfree(config->master_slave_sub_mode);
pfree(config);
return NULL;
}
