/* create a single kb */ static void handle_cmd_create_kb(int client_fd, uint16_t datasize) { int rv, err; unsigned char *msg = NULL; int exit_val; /* exit value from 4s-backend-setup */ /* unpack client data into buffer */ unsigned char *buf = (unsigned char *)malloc(datasize); rv = recv_from_client(client_fd, buf, datasize); if (rv <= 0) { /* errors already logged/handled */ free(buf); return; } /* parse buffer into kb setup args struct */ fsa_kb_setup_args *ksargs = fsap_decode_cmd_create_kb(buf); fsa_error(LOG_DEBUG, "ksargs->name: %s", ksargs->name); fsa_error(LOG_DEBUG, "ksargs->node_id: %d", ksargs->node_id); fsa_error(LOG_DEBUG, "ksargs->cluster_size: %d", ksargs->cluster_size); fsa_error(LOG_DEBUG, "ksargs->num_segments: %d", ksargs->num_segments); fsa_error(LOG_DEBUG, "ksargs->mirror_segments: %d",ksargs->mirror_segments); fsa_error(LOG_DEBUG, "ksargs->model_files: %d", ksargs->model_files); fsa_error(LOG_DEBUG, "ksargs->delete_existing: %d",ksargs->delete_existing); /* should already have been checked by client */ if (!fsa_is_valid_kb_name((const char *)ksargs->name)) { fsa_error(LOG_CRIT, "Invalid store name received from client"); send_error_message(client_fd, "store name invalid"); fsa_kb_setup_args_free(ksargs); } rv = fsab_create_local_kb(ksargs, &exit_val, &msg, &err); /* encode message for client */ int len; unsigned char *response = fsap_encode_rsp_create_kb(err, ksargs->name, msg, &len); fsa_error(LOG_DEBUG, "sending err: %d, kb_name: %s, msg: %s", err, ksargs->name, msg); fsa_kb_setup_args_free(ksargs); free(msg); fsa_error(LOG_DEBUG, "response size is %d bytes", len); /* send entire response back to client */ rv = fsa_sendall(client_fd, response, &len); free(response); if (rv == -1) { fsa_error(LOG_ERR, "failed to send response to client: %s", strerror(errno)); return; } fsa_error(LOG_DEBUG, "%d bytes sent to client", len); }
/* get all information about a specific kb on this host, send to client */ static void handle_cmd_get_kb_info(int client_fd, uint16_t datasize) { int rv, len, err; fsa_kb_info *ki; unsigned char *response; unsigned char *kb_name; kb_name = get_string_from_client(client_fd, datasize); if (kb_name == NULL) { /* errors already logged/handled */ return; } /* should already have been checked by client */ if (!fsa_is_valid_kb_name((const char *)kb_name)) { fsa_error(LOG_CRIT, "Invalid kb name received from client"); send_error_message(client_fd, "kb name invalid"); free(kb_name); return; } ki = fsab_get_local_kb_info(kb_name, &err); free(kb_name); /* done with kb_name */ if (ki == NULL || err == ADM_ERR_KB_NOT_EXISTS) { send_error_message(client_fd, "failed to get local kb info"); return; } /* encode message for client */ response = fsap_encode_rsp_get_kb_info(ki, &len); fsa_kb_info_free(ki); if (response == NULL) { send_error_message(client_fd, "failed to encode kb info"); return; } fsa_error(LOG_DEBUG, "response size is %d bytes", len); /* send entire response back to client */ rv = fsa_sendall(client_fd, response, &len); free(response); /* done with response buffer */ if (rv == -1) { fsa_error(LOG_ERR, "failed to send response to client: %s", strerror(errno)); return; } fsa_error(LOG_DEBUG, "%d bytes sent to client", len); }
/* delete a single kb */ static void handle_cmd_delete_kb(int client_fd, uint16_t datasize) { int rv, err; unsigned char *msg = NULL; int exit_val; /* exit value from 4s-backend-delete */ /* datasize = num chars in kb name */ unsigned char *kb_name = get_string_from_client(client_fd, datasize); if (kb_name == NULL) { /* errors already logged/handled */ return; } /* should already have been checked by client */ if (!fsa_is_valid_kb_name((const char *)kb_name)) { fsa_error(LOG_CRIT, "Invalid kb name received from client"); send_error_message(client_fd, "kb name invalid"); free(kb_name); return; } rv = fsab_delete_local_kb(kb_name, &exit_val, &msg, &err); /* encode message for client */ int len; unsigned char *response = fsap_encode_rsp_delete_kb(err, kb_name, msg, &len); fsa_error(LOG_DEBUG, "sending err: %d, kb_name: %s, msg: %s", err, kb_name, msg); free(msg); free(kb_name); fsa_error(LOG_DEBUG, "response size is %d bytes", len); /* send entire response back to client */ rv = fsa_sendall(client_fd, response, &len); free(response); /* done with response buffer */ if (rv == -1) { fsa_error(LOG_ERR, "failed to send response to client: %s", strerror(errno)); return; } fsa_error(LOG_DEBUG, "%d bytes sent to client", len); }
static int cmd_delete_stores(void) { if (args_index < 0) { /* no argument given, display help text */ fsa_error( LOG_ERR, "No store name(s) given. Use `%s help %s' for details", program_invocation_short_name, argv[cmd_index] ); return 1; } /* check for invalid store names */ int store_name_len = 11; for (int i = args_index; i < argc; i++) { if (!fsa_is_valid_kb_name(argv[i])) { fsa_error(LOG_ERR, "'%s' is not a valid store name", argv[i]); return 1; } int len = strlen(argv[i]); if (len > store_name_len) { store_name_len = len; } } /* get list of all storage nodes */ fsa_node_addr *node; fsa_node_addr *nodes = get_storage_nodes(); int n_nodes = 0; int node_name_len = 9; for (node = nodes; node != NULL; node = node->next) { int len = strlen(node->host); if (len > node_name_len) { node_name_len = len; } n_nodes += 1; } /* connections to each node */ int *sock_fds = init_sock_fds(n_nodes); /* Setup hints information */ struct addrinfo hints; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; char ipaddr[INET6_ADDRSTRLEN]; int cur_node = 0; int print_node_header = 1; int node_status; printf("Checking cluster status:\n"); for (fsa_node_addr *n = nodes; n != NULL; n = n->next) { sock_fds[cur_node] = fsaf_connect_to_admind(n->host, n->port, &hints, ipaddr); if (sock_fds[cur_node] == -1) { node_status = -1; } else { node_status = 0; } print_node_status_line(cur_node, n->host, node_status, node_name_len, print_node_header); print_node_header = 0; cur_node += 1; } /* check that we've got a connection to all nodes */ for (int i = 0; i < n_nodes; i++) { if (sock_fds[i] == -1) { cleanup_sock_fds(sock_fds, n_nodes); printf("Failed to connect to all nodes, aborting.\n"); return 1; } } printf("\n"); int response, bufsize, err, len; int n_errors = 0; int n_deleted; unsigned char *cmd; unsigned char *buf; int print_store_header = 1; /* delete one kb at a time across all nodes */ for (int i = args_index; i < argc; i++) { cur_node = 0; n_deleted = 0; cmd = fsap_encode_cmd_delete_kb((unsigned char *)argv[i], &len); if (cmd == NULL) { fsa_error(LOG_CRIT, "failed to encode %s command", argv[cmd_index]); n_errors += 1; break; } for (node = nodes; node != NULL; node = node->next) { fsa_error(LOG_DEBUG, "sending %s '%s' command to %s:%d", argv[cmd_index], argv[i], node->host, node->port); buf = fsaf_send_recv_cmd(node, sock_fds[cur_node], cmd, len, &response, &bufsize, &err); /* usually a network error */ if (buf == NULL) { /* error already handled */ n_errors += 1; break; } if (response == ADM_RSP_DELETE_KB) { fsa_kb_response *kbr = fsap_decode_rsp_delete_kb(buf); switch (kbr->return_val) { case ADM_ERR_OK: fsa_error( LOG_DEBUG, "kb '%s' deleted on node %s", kbr->kb_name, node->host ); n_deleted += 1; break; case ADM_ERR_KB_STATUS_UNKNOWN: /* kb deleted, but runtime status not confirmed */ fsa_error( LOG_DEBUG, "kb '%s' deleted on node %s, but runtime status " "not confirmed", kbr->kb_name, node->host ); n_deleted += 1; break; case ADM_ERR_KB_NOT_EXISTS: fsa_error( LOG_DEBUG, "kb '%s' does not exist on node %s", kbr->kb_name, node->host ); break; case ADM_ERR_KB_GET_INFO: fsa_error( LOG_ERR, "failed to get info for kb '%s' on node %s", kbr->kb_name, node->host ); n_errors += 1; break; case ADM_ERR_POPEN: case ADM_ERR_GENERIC: default: fsa_error( LOG_ERR, "failed to delete kb '%s' on node %s", kbr->kb_name, node->host ); n_errors += 1; break; } fsa_kb_response_free(kbr); } else if (response == ADM_RSP_ERROR) { unsigned char *errmsg = fsap_decode_rsp_error(buf, bufsize); fsa_error(LOG_ERR, "server error: %s", errmsg); free(errmsg); free(buf); n_errors += 1; break; } else { fsa_error(LOG_CRIT, "unknown response from server"); free(buf); n_errors += 1; break; } free(buf); if (n_errors > 0) { break; } cur_node += 1; } free(cmd); if (n_errors > 0) { break; } if (print_store_header) { if (colour_flag) { printf(ANSI_COLOUR_BLUE); } printf("%-*s store_status\n", store_name_len, "store_name"); if (colour_flag) { printf(ANSI_COLOUR_RESET); } print_store_header = 0; } printf("%-*s ", store_name_len, argv[i]); /* else kb deleted on all nodes */ if (n_deleted == 0) { print_colour("store_not_found\n", ANSI_COLOUR_YELLOW); } else { print_colour("deleted\n", ANSI_COLOUR_GREEN); } } /* cleanup */ cleanup_sock_fds(sock_fds, n_nodes); if (n_errors > 0) { printf( "An error occurred while deleting stores, check status manually\n" ); return 1; } return 0; }
/* Used to handle store starting/stopping, interface is mostly identical */ static int start_or_stop_stores(int action) { int all = 0; /* if -a flag, then start/stop all, instead of kb name */ int kb_name_len = 11; if (args_index < 0) { /* no argument given, display help text */ fsa_error( LOG_ERR, "No store name(s) given. Use `%s help %s' for details", program_invocation_short_name, argv[cmd_index] ); return 1; } if (strcmp("-a", argv[args_index]) == 0 || strcmp("--all", argv[args_index]) == 0) { all = 1; /* all stores */ } else { /* check for invalid store names */ for (int i = args_index; i < argc; i++) { if (!fsa_is_valid_kb_name(argv[i])) { fsa_error(LOG_ERR, "'%s' is not a valid store name", argv[i]); return 1; } int len = strlen(argv[i]); if (len > kb_name_len) { kb_name_len = len; } } } /* get list of all storage nodes */ fsa_node_addr *nodes = get_storage_nodes(); /* Setup hints information */ struct addrinfo hints; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; int sock_fd, len; char ipaddr[INET6_ADDRSTRLEN]; unsigned char *buf; int node_num = 0; unsigned char *cmd = NULL; int n_errors = 0; /* to be set by fsa_send_recv_cmd */ int response, bufsize, err; int print_node_header = 1; int print_store_header = 1; for (fsa_node_addr *n = nodes; n != NULL; n = n->next) { sock_fd = fsaf_connect_to_admind(n->host, n->port, &hints, ipaddr); print_node_line(node_num, n->host, print_node_header); print_node_header = 0; node_num += 1; if (sock_fd == -1) { print_colour("unreachable\n", ANSI_COLOUR_RED); continue; } if (all) { /* start/stop all kbs */ if (action == STOP_STORE) { cmd = fsap_encode_cmd_stop_kb_all(&len); } else if (action == START_STORE) { cmd = fsap_encode_cmd_start_kb_all(&len); } if (cmd == NULL) { fsa_error(LOG_CRIT, "failed to encode %s command", argv[cmd_index]); n_errors += 1; break; } fsa_error(LOG_DEBUG, "sending '%s' command to %s:%d", argv[cmd_index], n->host, n->port); /* send command and get reply */ buf = fsaf_send_recv_cmd(n, sock_fd, cmd, len, &response, &bufsize, &err); /* usually a network error */ if (buf == NULL) { /* error already handled */ n_errors += 1; break; } /* should get this if all went well */ if (response == ADM_RSP_EXPECT_N_KB) { int rv; uint8_t rspval; uint16_t datasize; unsigned char header_buf[ADM_HEADER_LEN]; fsa_kb_response *kbr = NULL; int max_kb_len; int expected_responses = fsap_decode_rsp_expect_n_kb(buf, &max_kb_len); free(buf); fsa_error(LOG_DEBUG, "expecting %d responses from server", expected_responses); /* print header */ if (print_store_header) { if (colour_flag) { printf(ANSI_COLOUR_BLUE); } printf(" %-*s status\n", max_kb_len, "store_name"); if (colour_flag) { printf(ANSI_COLOUR_RESET); } } /* get packet from server for each kb started/stopped */ for (int i = 0; i < expected_responses; i++) { rv = fsa_fetch_header(sock_fd, header_buf); if (rv == -1) { fsa_error(LOG_ERR, "failed to get response from %s:%d", n->host, n->port); break; } fsa_error(LOG_DEBUG, "got header %d/%d", i+1, expected_responses); rv = fsap_decode_header(header_buf, &rspval, &datasize); if (rv == -1) { fsa_error(LOG_CRIT, "unable to decode header from %s:%d", n->host, n->port); break; } if (rspval == ADM_RSP_ABORT_EXPECT) { fsa_error(LOG_ERR, "operation aborted by server"); break; } buf = (unsigned char *)malloc(datasize); rv = fsaf_recv_from_admind(sock_fd, buf, datasize); if (rv < 0) { /* error already handled/logged */ free(buf); break; } if (rspval == ADM_RSP_STOP_KB) { kbr = fsap_decode_rsp_stop_kb(buf); printf(" %-*s ", max_kb_len, kbr->kb_name); switch (kbr->return_val) { case ADM_ERR_OK: case ADM_ERR_KB_STATUS_STOPPED: print_colour("stopped", ANSI_COLOUR_GREEN); break; case ADM_ERR_KB_STATUS_UNKNOWN: print_colour("unknown", ANSI_COLOUR_RED); break; default: fsa_error( LOG_CRIT, "Unknown server response: %d", kbr->return_val ); print_colour("unknown", ANSI_COLOUR_RED); break; } } else if (rspval == ADM_RSP_START_KB) { kbr = fsap_decode_rsp_start_kb(buf); printf(" %-*s ", max_kb_len, kbr->kb_name); switch (kbr->return_val) { case ADM_ERR_OK: case ADM_ERR_KB_STATUS_RUNNING: print_colour("running", ANSI_COLOUR_GREEN); break; case ADM_ERR_KB_STATUS_STOPPED: print_colour("stopped", ANSI_COLOUR_YELLOW); break; case ADM_ERR_KB_STATUS_UNKNOWN: print_colour("unknown", ANSI_COLOUR_RED); break; default: fsa_error( LOG_CRIT, "Unknown server response: %d", kbr->return_val ); print_colour("unknown", ANSI_COLOUR_RED); break; } } printf("\n"); free(buf); buf = NULL; fsa_kb_response_free(kbr); kbr = NULL; } } else if (response == ADM_RSP_ERROR) { unsigned char *errmsg = fsap_decode_rsp_error(buf, bufsize); fsa_error(LOG_ERR, "server error: %s", errmsg); free(errmsg); free(buf); } else { fsa_error(LOG_ERR, "unexpected response from server: %d", response); free(buf); } } else { /* print header */ if (print_store_header) { if (colour_flag) { printf(ANSI_COLOUR_BLUE); } printf(" %-*s status\n", kb_name_len, "store_name"); if (colour_flag) { printf(ANSI_COLOUR_RESET); } print_store_header = 0; } /* stop kbs given on command line */ for (int i = args_index; i < argc; i++) { /* send start/stop command for each kb */ if (action == STOP_STORE) { cmd = fsap_encode_cmd_stop_kb((unsigned char *)argv[i], &len); } else if (action == START_STORE) { cmd = fsap_encode_cmd_start_kb((unsigned char *)argv[i], &len); } if (cmd == NULL) { fsa_error(LOG_CRIT, "failed to encode %s command", argv[cmd_index]); n_errors += 1; break; } fsa_error(LOG_DEBUG, "sending %s '%s' command to %s:%d", argv[cmd_index], argv[i], n->host, n->port); buf = fsaf_send_recv_cmd(n, sock_fd, cmd, len, &response, &bufsize, &err); free(cmd); cmd = NULL; /* usually a network error */ if (buf == NULL) { /* error already handled */ n_errors += 1; break; } printf(" %-*s ", kb_name_len, argv[i]); fsa_kb_response *kbr = NULL; if (response == ADM_RSP_STOP_KB) { kbr = fsap_decode_rsp_stop_kb(buf); switch (kbr->return_val) { case ADM_ERR_OK: case ADM_ERR_KB_STATUS_STOPPED: print_colour("stopped", ANSI_COLOUR_GREEN); break; case ADM_ERR_KB_NOT_EXISTS: print_colour("store_not_found", ANSI_COLOUR_RED); break; default: print_colour("unknown", ANSI_COLOUR_RED); break; } printf("\n"); fsa_kb_response_free(kbr); } else if (response == ADM_RSP_START_KB) { kbr = fsap_decode_rsp_start_kb(buf); switch (kbr->return_val) { case ADM_ERR_OK: case ADM_ERR_KB_STATUS_RUNNING: print_colour("running", ANSI_COLOUR_GREEN); break; case ADM_ERR_KB_STATUS_STOPPED: print_colour("stopped", ANSI_COLOUR_YELLOW); break; case ADM_ERR_KB_NOT_EXISTS: print_colour("store_not_found", ANSI_COLOUR_RED); break; default: print_colour("unknown", ANSI_COLOUR_RED); break; } printf("\n"); fsa_kb_response_free(kbr); } else if (response == ADM_RSP_ERROR) { unsigned char *msg = fsap_decode_rsp_error(buf, bufsize); printf("unknown: %s\n", msg); free(msg); n_errors += 1; } else { fsa_error(LOG_CRIT, "unknown response from server"); n_errors += 1; } free(buf); } } /* done with current server */ close(sock_fd); } if (n_errors > 0) { return 1; } return 0; }