void fill_ctdb_event_request_run(TALLOC_CTX *mem_ctx,
struct ctdb_event_request_run *p)
{
p->event = rand_int(CTDB_EVENT_MAX);
p->timeout = rand();
fill_ctdb_string(mem_ctx, &p->arg_str);
}
static void fill_ctdb_reply_control(TALLOC_CTX *mem_ctx,
struct ctdb_reply_control *c,
uint32_t opcode)
{
c->status = -rand_int(2);
if (c->status == 0) {
c->errmsg = NULL;
fill_ctdb_reply_control_data(mem_ctx, &c->rdata, opcode);
} else {
fill_ctdb_string(mem_ctx, &c->errmsg);
}
}
static void fill_ctdb_req_control_data(TALLOC_CTX *mem_ctx,
struct ctdb_req_control_data *cd,
uint32_t opcode)
{
cd->opcode = opcode;
switch (opcode) {
case CTDB_CONTROL_PROCESS_EXISTS:
cd->data.pid = rand32();
break;
case CTDB_CONTROL_STATISTICS:
break;
case CTDB_CONTROL_PING:
break;
case CTDB_CONTROL_GETDBPATH:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_GETVNNMAP:
break;
case CTDB_CONTROL_SETVNNMAP:
cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
assert(cd->data.vnnmap != NULL);
fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap);
break;
case CTDB_CONTROL_GET_DEBUG:
break;
case CTDB_CONTROL_SET_DEBUG:
cd->data.loglevel = rand_int(5);
break;
case CTDB_CONTROL_GET_DBMAP:
break;
case CTDB_CONTROL_PULL_DB:
cd->data.pulldb = talloc(mem_ctx, struct ctdb_pulldb);
assert(cd->data.pulldb != NULL);
fill_ctdb_pulldb(mem_ctx, cd->data.pulldb);
break;
case CTDB_CONTROL_PUSH_DB:
cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
assert(cd->data.recbuf != NULL);
fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
break;
case CTDB_CONTROL_GET_RECMODE:
break;
case CTDB_CONTROL_SET_RECMODE:
cd->data.recmode = rand_int(2);
break;
case CTDB_CONTROL_STATISTICS_RESET:
break;
case CTDB_CONTROL_DB_ATTACH:
fill_ctdb_string(mem_ctx, &cd->data.db_name);
assert(cd->data.db_name != NULL);
break;
case CTDB_CONTROL_SET_CALL:
break;
case CTDB_CONTROL_TRAVERSE_START:
cd->data.traverse_start = talloc(mem_ctx, struct ctdb_traverse_start);
assert(cd->data.traverse_start != NULL);
fill_ctdb_traverse_start(mem_ctx, cd->data.traverse_start);
break;
case CTDB_CONTROL_TRAVERSE_ALL:
cd->data.traverse_all = talloc(mem_ctx, struct ctdb_traverse_all);
assert(cd->data.traverse_all != NULL);
fill_ctdb_traverse_all(mem_ctx, cd->data.traverse_all);
break;
case CTDB_CONTROL_TRAVERSE_DATA:
cd->data.rec_data = talloc(mem_ctx, struct ctdb_rec_data);
assert(cd->data.rec_data != NULL);
fill_ctdb_rec_data(mem_ctx, cd->data.rec_data);
break;
case CTDB_CONTROL_REGISTER_SRVID:
break;
case CTDB_CONTROL_DEREGISTER_SRVID:
break;
case CTDB_CONTROL_GET_DBNAME:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_ENABLE_SEQNUM:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_UPDATE_SEQNUM:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_DUMP_MEMORY:
break;
case CTDB_CONTROL_GET_PID:
break;
case CTDB_CONTROL_GET_RECMASTER:
break;
case CTDB_CONTROL_SET_RECMASTER:
cd->data.recmaster = rand_int(32);
break;
case CTDB_CONTROL_FREEZE:
break;
case CTDB_CONTROL_THAW:
break;
case CTDB_CONTROL_GET_PNN:
break;
case CTDB_CONTROL_SHUTDOWN:
break;
case CTDB_CONTROL_GET_MONMODE:
break;
case CTDB_CONTROL_TCP_CLIENT:
cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
assert(cd->data.conn != NULL);
fill_ctdb_connection(mem_ctx, cd->data.conn);
break;
case CTDB_CONTROL_TCP_ADD:
cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
assert(cd->data.conn != NULL);
fill_ctdb_connection(mem_ctx, cd->data.conn);
break;
case CTDB_CONTROL_TCP_REMOVE:
cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
assert(cd->data.conn != NULL);
fill_ctdb_connection(mem_ctx, cd->data.conn);
break;
case CTDB_CONTROL_STARTUP:
break;
case CTDB_CONTROL_SET_TUNABLE:
cd->data.tunable = talloc(mem_ctx, struct ctdb_tunable);
assert(cd->data.tunable != NULL);
fill_ctdb_tunable(mem_ctx, cd->data.tunable);
break;
case CTDB_CONTROL_GET_TUNABLE:
fill_ctdb_string(mem_ctx, &cd->data.tun_var);
assert(cd->data.tun_var != NULL);
break;
case CTDB_CONTROL_LIST_TUNABLES:
break;
case CTDB_CONTROL_MODIFY_FLAGS:
cd->data.flag_change = talloc(mem_ctx, struct ctdb_node_flag_change);
assert(cd->data.flag_change != NULL);
fill_ctdb_node_flag_change(mem_ctx, cd->data.flag_change);
break;
case CTDB_CONTROL_GET_ALL_TUNABLES:
break;
case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
assert(cd->data.addr != NULL);
fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
break;
case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
assert(cd->data.tickles != NULL);
fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
break;
case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
fill_ctdb_string(mem_ctx, &cd->data.db_name);
assert(cd->data.db_name != NULL);
break;
case CTDB_CONTROL_UPDATE_RECORD:
cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
assert(cd->data.recbuf != NULL);
fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
break;
case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
assert(cd->data.addr_info != NULL);
fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
break;
case CTDB_CONTROL_TRANSACTION_START:
cd->data.tid = rand32();
break;
case CTDB_CONTROL_TRANSACTION_COMMIT:
cd->data.tid = rand32();
break;
case CTDB_CONTROL_WIPE_DATABASE:
cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
assert(cd->data.transdb != NULL);
fill_ctdb_transdb(mem_ctx, cd->data.transdb);
break;
case CTDB_CONTROL_UPTIME:
break;
case CTDB_CONTROL_START_RECOVERY:
break;
case CTDB_CONTROL_END_RECOVERY:
break;
case CTDB_CONTROL_RELOAD_NODES_FILE:
break;
case CTDB_CONTROL_TRY_DELETE_RECORDS:
cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
assert(cd->data.recbuf != NULL);
fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
break;
case CTDB_CONTROL_ENABLE_MONITOR:
break;
case CTDB_CONTROL_DISABLE_MONITOR:
break;
case CTDB_CONTROL_ADD_PUBLIC_IP:
cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
assert(cd->data.addr_info != NULL);
fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
break;
case CTDB_CONTROL_DEL_PUBLIC_IP:
cd->data.addr_info = talloc(mem_ctx, struct ctdb_addr_info);
assert(cd->data.addr_info != NULL);
fill_ctdb_addr_info(mem_ctx, cd->data.addr_info);
break;
case CTDB_CONTROL_RUN_EVENTSCRIPTS:
fill_ctdb_string(mem_ctx, &cd->data.event_str);
assert(cd->data.event_str != NULL);
break;
case CTDB_CONTROL_GET_CAPABILITIES:
break;
case CTDB_CONTROL_START_PERSISTENT_UPDATE:
break;
case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
break;
case CTDB_CONTROL_RECD_PING:
break;
case CTDB_CONTROL_RELEASE_IP:
cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
assert(cd->data.pubip != NULL);
fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
break;
case CTDB_CONTROL_TAKEOVER_IP:
cd->data.pubip = talloc(mem_ctx, struct ctdb_public_ip);
assert(cd->data.pubip != NULL);
fill_ctdb_public_ip(mem_ctx, cd->data.pubip);
break;
case CTDB_CONTROL_GET_PUBLIC_IPS:
break;
case CTDB_CONTROL_GET_NODEMAP:
break;
case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
cd->data.event = rand_int(CTDB_EVENT_MAX);
break;
case CTDB_CONTROL_TRAVERSE_KILL:
cd->data.traverse_start = talloc(mem_ctx, struct ctdb_traverse_start);
assert(cd->data.traverse_start != NULL);
fill_ctdb_traverse_start(mem_ctx, cd->data.traverse_start);
break;
case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
cd->data.reclock_latency = rand_double();
break;
case CTDB_CONTROL_GET_RECLOCK_FILE:
break;
case CTDB_CONTROL_SET_RECLOCK_FILE:
fill_ctdb_string(mem_ctx, &cd->data.reclock_file);
assert(cd->data.reclock_file != NULL);
break;
case CTDB_CONTROL_STOP_NODE:
break;
case CTDB_CONTROL_CONTINUE_NODE:
break;
case CTDB_CONTROL_SET_LMASTERROLE:
cd->data.role = rand_int(2);
break;
case CTDB_CONTROL_SET_RECMASTERROLE:
cd->data.role = rand_int(2);
break;
case CTDB_CONTROL_ENABLE_SCRIPT:
fill_ctdb_string(mem_ctx, &cd->data.script);
assert(cd->data.script != NULL);
break;
case CTDB_CONTROL_DISABLE_SCRIPT:
fill_ctdb_string(mem_ctx, &cd->data.script);
assert(cd->data.script != NULL);
break;
case CTDB_CONTROL_SET_BAN_STATE:
cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
assert(cd->data.ban_state != NULL);
fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
break;
case CTDB_CONTROL_GET_BAN_STATE:
break;
case CTDB_CONTROL_SET_DB_PRIORITY:
cd->data.db_prio = talloc(mem_ctx, struct ctdb_db_priority);
assert(cd->data.db_prio != NULL);
fill_ctdb_db_priority(mem_ctx, cd->data.db_prio);
break;
case CTDB_CONTROL_GET_DB_PRIORITY:
cd->data.db_prio = talloc(mem_ctx, struct ctdb_db_priority);
assert(cd->data.db_prio != NULL);
fill_ctdb_db_priority(mem_ctx, cd->data.db_prio);
break;
case CTDB_CONTROL_TRANSACTION_CANCEL:
break;
case CTDB_CONTROL_REGISTER_NOTIFY:
cd->data.notify = talloc(mem_ctx, struct ctdb_notify_data);
assert(cd->data.notify != NULL);
fill_ctdb_notify_data(mem_ctx, cd->data.notify);
break;
case CTDB_CONTROL_DEREGISTER_NOTIFY:
cd->data.srvid = rand64();
break;
case CTDB_CONTROL_TRANS3_COMMIT:
cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
assert(cd->data.recbuf != NULL);
fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
break;
case CTDB_CONTROL_GET_DB_SEQNUM:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_DB_SET_HEALTHY:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_DB_GET_HEALTH:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
cd->data.addr = talloc(mem_ctx, ctdb_sock_addr);
assert(cd->data.addr != NULL);
fill_ctdb_sock_addr(mem_ctx, cd->data.addr);
break;
case CTDB_CONTROL_GET_IFACES:
break;
case CTDB_CONTROL_SET_IFACE_LINK_STATE:
cd->data.iface = talloc(mem_ctx, struct ctdb_iface);
assert(cd->data.iface != NULL);
fill_ctdb_iface(mem_ctx, cd->data.iface);
break;
case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
cd->data.conn = talloc(mem_ctx, struct ctdb_connection);
assert(cd->data.conn != NULL);
fill_ctdb_connection(mem_ctx, cd->data.conn);
break;
case CTDB_CONTROL_GET_STAT_HISTORY:
break;
case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
cd->data.key = talloc(mem_ctx, struct ctdb_key_data);
assert(cd->data.key != NULL);
fill_ctdb_key_data(mem_ctx, cd->data.key);
break;
case CTDB_CONTROL_SET_DB_READONLY:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_CHECK_SRVIDS:
cd->data.u64_array = talloc(mem_ctx, struct ctdb_uint64_array);
assert(cd->data.u64_array != NULL);
fill_ctdb_uint64_array(mem_ctx, cd->data.u64_array);
break;
case CTDB_CONTROL_TRAVERSE_START_EXT:
cd->data.traverse_start_ext = talloc(mem_ctx, struct ctdb_traverse_start_ext);
assert(cd->data.traverse_start_ext != NULL);
fill_ctdb_traverse_start_ext(mem_ctx, cd->data.traverse_start_ext);
break;
case CTDB_CONTROL_GET_DB_STATISTICS:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_SET_DB_STICKY:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
break;
case CTDB_CONTROL_TRAVERSE_ALL_EXT:
cd->data.traverse_all_ext = talloc(mem_ctx, struct ctdb_traverse_all_ext);
assert(cd->data.traverse_all_ext != NULL);
fill_ctdb_traverse_all_ext(mem_ctx, cd->data.traverse_all_ext);
break;
case CTDB_CONTROL_RECEIVE_RECORDS:
cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
assert(cd->data.recbuf != NULL);
fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
break;
case CTDB_CONTROL_IPREALLOCATED:
break;
case CTDB_CONTROL_GET_RUNSTATE:
break;
case CTDB_CONTROL_DB_DETACH:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_GET_NODES_FILE:
break;
case CTDB_CONTROL_DB_FREEZE:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_DB_THAW:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_DB_TRANSACTION_START:
cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
assert(cd->data.transdb != NULL);
fill_ctdb_transdb(mem_ctx, cd->data.transdb);
break;
case CTDB_CONTROL_DB_TRANSACTION_COMMIT:
cd->data.transdb = talloc(mem_ctx, struct ctdb_transdb);
assert(cd->data.transdb != NULL);
fill_ctdb_transdb(mem_ctx, cd->data.transdb);
break;
case CTDB_CONTROL_DB_TRANSACTION_CANCEL:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_DB_PULL:
cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
assert(cd->data.pulldb_ext != NULL);
fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
break;
case CTDB_CONTROL_DB_PUSH_START:
cd->data.pulldb_ext = talloc(mem_ctx, struct ctdb_pulldb_ext);
assert(cd->data.pulldb_ext != NULL);
fill_ctdb_pulldb_ext(mem_ctx, cd->data.pulldb_ext);
break;
case CTDB_CONTROL_DB_PUSH_CONFIRM:
cd->data.db_id = rand32();
break;
}
}
static void fill_ctdb_reply_control_data(TALLOC_CTX *mem_ctx,
struct ctdb_reply_control_data *cd,
uint32_t opcode)
{
cd->opcode = opcode;
switch (opcode) {
case CTDB_CONTROL_PROCESS_EXISTS:
break;
case CTDB_CONTROL_STATISTICS:
cd->data.stats = talloc(mem_ctx, struct ctdb_statistics);
assert(cd->data.stats != NULL);
fill_ctdb_statistics(mem_ctx, cd->data.stats);
break;
case CTDB_CONTROL_PING:
break;
case CTDB_CONTROL_GETDBPATH:
fill_ctdb_string(mem_ctx, &cd->data.db_path);
assert(cd->data.db_path != NULL);
break;
case CTDB_CONTROL_GETVNNMAP:
cd->data.vnnmap = talloc(mem_ctx, struct ctdb_vnn_map);
assert(cd->data.vnnmap != NULL);
fill_ctdb_vnn_map(mem_ctx, cd->data.vnnmap);
break;
case CTDB_CONTROL_SETVNNMAP:
break;
case CTDB_CONTROL_GET_DEBUG:
cd->data.loglevel = rand_int(5);
break;
case CTDB_CONTROL_SET_DEBUG:
break;
case CTDB_CONTROL_GET_DBMAP:
cd->data.dbmap = talloc(mem_ctx, struct ctdb_dbid_map);
assert(cd->data.dbmap != NULL);
fill_ctdb_dbid_map(mem_ctx, cd->data.dbmap);
break;
case CTDB_CONTROL_PULL_DB:
cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
assert(cd->data.recbuf != NULL);
fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
break;
case CTDB_CONTROL_PUSH_DB:
break;
case CTDB_CONTROL_GET_RECMODE:
break;
case CTDB_CONTROL_SET_RECMODE:
break;
case CTDB_CONTROL_STATISTICS_RESET:
break;
case CTDB_CONTROL_DB_ATTACH:
cd->data.db_id = rand32();
break;
case CTDB_CONTROL_SET_CALL:
break;
case CTDB_CONTROL_TRAVERSE_START:
break;
case CTDB_CONTROL_TRAVERSE_ALL:
break;
case CTDB_CONTROL_TRAVERSE_DATA:
break;
case CTDB_CONTROL_REGISTER_SRVID:
break;
case CTDB_CONTROL_DEREGISTER_SRVID:
break;
case CTDB_CONTROL_GET_DBNAME:
fill_ctdb_string(mem_ctx, &cd->data.db_name);
assert(cd->data.db_name);
break;
case CTDB_CONTROL_ENABLE_SEQNUM:
break;
case CTDB_CONTROL_UPDATE_SEQNUM:
break;
case CTDB_CONTROL_DUMP_MEMORY:
fill_ctdb_string(mem_ctx, &cd->data.mem_str);
assert(cd->data.mem_str);
break;
case CTDB_CONTROL_GET_PID:
break;
case CTDB_CONTROL_GET_RECMASTER:
break;
case CTDB_CONTROL_SET_RECMASTER:
break;
case CTDB_CONTROL_FREEZE:
break;
case CTDB_CONTROL_THAW:
break;
case CTDB_CONTROL_GET_PNN:
break;
case CTDB_CONTROL_SHUTDOWN:
break;
case CTDB_CONTROL_GET_MONMODE:
break;
case CTDB_CONTROL_TCP_CLIENT:
break;
case CTDB_CONTROL_TCP_ADD:
break;
case CTDB_CONTROL_TCP_REMOVE:
break;
case CTDB_CONTROL_STARTUP:
break;
case CTDB_CONTROL_SET_TUNABLE:
break;
case CTDB_CONTROL_GET_TUNABLE:
cd->data.tun_value = rand32();
break;
case CTDB_CONTROL_LIST_TUNABLES:
cd->data.tun_var_list = talloc(mem_ctx, struct ctdb_var_list);
assert(cd->data.tun_var_list != NULL);
fill_ctdb_var_list(mem_ctx, cd->data.tun_var_list);
break;
case CTDB_CONTROL_MODIFY_FLAGS:
break;
case CTDB_CONTROL_GET_ALL_TUNABLES:
cd->data.tun_list = talloc(mem_ctx, struct ctdb_tunable_list);
assert(cd->data.tun_list != NULL);
fill_ctdb_tunable_list(mem_ctx, cd->data.tun_list);
break;
case CTDB_CONTROL_GET_TCP_TICKLE_LIST:
cd->data.tickles = talloc(mem_ctx, struct ctdb_tickle_list);
assert(cd->data.tickles != NULL);
fill_ctdb_tickle_list(mem_ctx, cd->data.tickles);
break;
case CTDB_CONTROL_SET_TCP_TICKLE_LIST:
break;
case CTDB_CONTROL_DB_ATTACH_PERSISTENT:
break;
case CTDB_CONTROL_UPDATE_RECORD:
break;
case CTDB_CONTROL_SEND_GRATUITOUS_ARP:
break;
case CTDB_CONTROL_TRANSACTION_START:
break;
case CTDB_CONTROL_TRANSACTION_COMMIT:
break;
case CTDB_CONTROL_WIPE_DATABASE:
break;
case CTDB_CONTROL_UPTIME:
cd->data.uptime = talloc(mem_ctx, struct ctdb_uptime);
assert(cd->data.uptime != NULL);
fill_ctdb_uptime(mem_ctx, cd->data.uptime);
break;
case CTDB_CONTROL_START_RECOVERY:
break;
case CTDB_CONTROL_END_RECOVERY:
break;
case CTDB_CONTROL_RELOAD_NODES_FILE:
break;
case CTDB_CONTROL_TRY_DELETE_RECORDS:
cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
assert(cd->data.recbuf != NULL);
fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
break;
case CTDB_CONTROL_ENABLE_MONITOR:
break;
case CTDB_CONTROL_DISABLE_MONITOR:
break;
case CTDB_CONTROL_ADD_PUBLIC_IP:
break;
case CTDB_CONTROL_DEL_PUBLIC_IP:
break;
case CTDB_CONTROL_RUN_EVENTSCRIPTS:
break;
case CTDB_CONTROL_GET_CAPABILITIES:
cd->data.caps = rand32();
break;
case CTDB_CONTROL_START_PERSISTENT_UPDATE:
break;
case CTDB_CONTROL_CANCEL_PERSISTENT_UPDATE:
break;
case CTDB_CONTROL_RECD_PING:
break;
case CTDB_CONTROL_RELEASE_IP:
break;
case CTDB_CONTROL_TAKEOVER_IP:
break;
case CTDB_CONTROL_GET_PUBLIC_IPS:
cd->data.pubip_list = talloc(mem_ctx, struct ctdb_public_ip_list);
assert(cd->data.pubip_list != NULL);
fill_ctdb_public_ip_list(mem_ctx, cd->data.pubip_list);
break;
case CTDB_CONTROL_GET_NODEMAP:
cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
assert(cd->data.nodemap != NULL);
fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
break;
case CTDB_CONTROL_GET_EVENT_SCRIPT_STATUS:
cd->data.script_list = talloc(mem_ctx, struct ctdb_script_list);
assert(cd->data.script_list != NULL);
fill_ctdb_script_list(mem_ctx, cd->data.script_list);
break;
case CTDB_CONTROL_TRAVERSE_KILL:
break;
case CTDB_CONTROL_RECD_RECLOCK_LATENCY:
break;
case CTDB_CONTROL_GET_RECLOCK_FILE:
fill_ctdb_string(mem_ctx, &cd->data.reclock_file);
assert(cd->data.reclock_file != NULL);
break;
case CTDB_CONTROL_SET_RECLOCK_FILE:
break;
case CTDB_CONTROL_STOP_NODE:
break;
case CTDB_CONTROL_CONTINUE_NODE:
break;
case CTDB_CONTROL_SET_LMASTERROLE:
break;
case CTDB_CONTROL_SET_RECMASTERROLE:
break;
case CTDB_CONTROL_ENABLE_SCRIPT:
break;
case CTDB_CONTROL_DISABLE_SCRIPT:
break;
case CTDB_CONTROL_SET_BAN_STATE:
break;
case CTDB_CONTROL_GET_BAN_STATE:
cd->data.ban_state = talloc(mem_ctx, struct ctdb_ban_state);
assert(cd->data.ban_state != NULL);
fill_ctdb_ban_state(mem_ctx, cd->data.ban_state);
break;
case CTDB_CONTROL_SET_DB_PRIORITY:
break;
case CTDB_CONTROL_GET_DB_PRIORITY:
break;
case CTDB_CONTROL_TRANSACTION_CANCEL:
break;
case CTDB_CONTROL_REGISTER_NOTIFY:
break;
case CTDB_CONTROL_DEREGISTER_NOTIFY:
break;
case CTDB_CONTROL_TRANS3_COMMIT:
break;
case CTDB_CONTROL_GET_DB_SEQNUM:
cd->data.seqnum = rand64();
break;
case CTDB_CONTROL_DB_SET_HEALTHY:
break;
case CTDB_CONTROL_DB_GET_HEALTH:
fill_ctdb_string(mem_ctx, &cd->data.reason);
assert(cd->data.reason != NULL);
break;
case CTDB_CONTROL_GET_PUBLIC_IP_INFO:
cd->data.ipinfo = talloc(mem_ctx, struct ctdb_public_ip_info);
assert(cd->data.ipinfo != NULL);
fill_ctdb_public_ip_info(mem_ctx, cd->data.ipinfo);
break;
case CTDB_CONTROL_GET_IFACES:
cd->data.iface_list = talloc(mem_ctx, struct ctdb_iface_list);
assert(cd->data.iface_list != NULL);
fill_ctdb_iface_list(mem_ctx, cd->data.iface_list);
break;
case CTDB_CONTROL_SET_IFACE_LINK_STATE:
break;
case CTDB_CONTROL_TCP_ADD_DELAYED_UPDATE:
break;
case CTDB_CONTROL_GET_STAT_HISTORY:
cd->data.stats_list = talloc(mem_ctx, struct ctdb_statistics_list);
assert(cd->data.stats_list != NULL);
fill_ctdb_statistics_list(mem_ctx, cd->data.stats_list);
break;
case CTDB_CONTROL_SCHEDULE_FOR_DELETION:
break;
case CTDB_CONTROL_SET_DB_READONLY:
break;
case CTDB_CONTROL_CHECK_SRVIDS:
cd->data.u8_array = talloc(mem_ctx, struct ctdb_uint8_array);
assert(cd->data.u8_array != NULL);
fill_ctdb_uint8_array(mem_ctx, cd->data.u8_array);
break;
case CTDB_CONTROL_TRAVERSE_START_EXT:
break;
case CTDB_CONTROL_GET_DB_STATISTICS:
cd->data.dbstats = talloc(mem_ctx, struct ctdb_db_statistics);
assert(cd->data.dbstats != NULL);
fill_ctdb_db_statistics(mem_ctx, cd->data.dbstats);
break;
case CTDB_CONTROL_SET_DB_STICKY:
break;
case CTDB_CONTROL_RELOAD_PUBLIC_IPS:
break;
case CTDB_CONTROL_TRAVERSE_ALL_EXT:
break;
case CTDB_CONTROL_RECEIVE_RECORDS:
cd->data.recbuf = talloc(mem_ctx, struct ctdb_rec_buffer);
assert(cd->data.recbuf != NULL);
fill_ctdb_rec_buffer(mem_ctx, cd->data.recbuf);
break;
case CTDB_CONTROL_IPREALLOCATED:
break;
case CTDB_CONTROL_GET_RUNSTATE:
cd->data.runstate = rand32();
break;
case CTDB_CONTROL_DB_DETACH:
break;
case CTDB_CONTROL_GET_NODES_FILE:
cd->data.nodemap = talloc(mem_ctx, struct ctdb_node_map);
assert(cd->data.nodemap != NULL);
fill_ctdb_node_map(mem_ctx, cd->data.nodemap);
break;
case CTDB_CONTROL_DB_PULL:
cd->data.num_records = rand32();
break;
case CTDB_CONTROL_DB_PUSH_CONFIRM:
cd->data.num_records = rand32();
break;
}
}
void fill_ctdb_event_request_script_disable(TALLOC_CTX *mem_ctx,
struct ctdb_event_request_script_disable *p)
{
fill_ctdb_string(mem_ctx, &p->script_name);
}
