static int run_action_server_do(struct async *as, struct sdirs *sdirs,
const char *incexc, int srestore, int *timer_ret, struct conf **cconfs)
{
int ret;
int resume=0;
char msg[256]="";
struct iobuf *rbuf=as->asfd->rbuf;
// Make sure some directories exist.
if(mkpath(&sdirs->current, sdirs->dedup))
{
snprintf(msg, sizeof(msg),
"could not mkpath %s", sdirs->current);
log_and_send(as->asfd, msg);
return -1;
}
if(rbuf->cmd!=CMD_GEN) return unknown_command(as->asfd);
// List and diff should work even while backups are running.
if(!strncmp_w(rbuf->buf, "list ")
|| !strncmp_w(rbuf->buf, "listb "))
return run_list(as->asfd, sdirs, cconfs);
if(!strncmp_w(rbuf->buf, "diff "))
return run_diff(as->asfd, sdirs, cconfs);
switch((ret=get_lock_sdirs(as->asfd, sdirs)))
{
case 0: break; // OK.
case 1: return 1; // Locked out.
default: // Error.
maybe_do_notification(as->asfd, ret,
"", "error in get_lock_sdirs()",
"", buf_to_notify_str(rbuf), cconfs);
return -1;
}
switch((ret=check_for_rubble(as, sdirs, incexc, &resume, cconfs)))
{
case 0: break; // OK.
case 1: return 1; // Now finalising.
default: // Error.
maybe_do_notification(as->asfd, ret,
"", "error in check_for_rubble()",
"", buf_to_notify_str(rbuf), cconfs);
return -1;
}
if(!strncmp_w(rbuf->buf, "backup"))
{
ret=run_backup(as, sdirs, cconfs, incexc, timer_ret, resume);
if(*timer_ret<0)
maybe_do_notification(as->asfd, ret, "",
"error running timer script",
"", "backup", cconfs);
else if(!*timer_ret)
maybe_do_notification(as->asfd, ret, sdirs->client,
sdirs->current, "log", "backup", cconfs);
return ret;
}
if(!strncmp_w(rbuf->buf, "restore ")
|| !strncmp_w(rbuf->buf, "verify "))
return run_restore(as->asfd, sdirs, cconfs, srestore);
if(!strncmp_w(rbuf->buf, "Delete "))
return run_delete(as->asfd, sdirs, cconfs);
// Old clients will send 'delete', possibly accidentally due to the
// user trying to use the new diff/long diff options.
// Stop them from working, just to be safe.
if(!strncmp_w(rbuf->buf, "delete "))
{
logp("old style delete from %s denied\n",
get_string(cconfs[OPT_CNAME]));
as->asfd->write_str(as->asfd, CMD_ERROR,
"old style delete is not supported on this server");
return -1;
}
return unknown_command(as->asfd);
}
/* main - slurmctld main function, start various threads and process RPCs */
int main(int argc, char *argv[])
{
pthread_attr_t thread_attr;
char node_name[128];
void *db_conn = NULL;
assoc_init_args_t assoc_init_arg;
_init_config();
log_init(argv[0], log_opts, LOG_DAEMON, NULL);
if (read_slurmdbd_conf())
exit(1);
_parse_commandline(argc, argv);
_update_logging(true);
_update_nice();
if (slurm_auth_init(NULL) != SLURM_SUCCESS) {
fatal("Unable to initialize %s authentication plugin",
slurmdbd_conf->auth_type);
}
if (slurm_acct_storage_init(NULL) != SLURM_SUCCESS) {
fatal("Unable to initialize %s accounting storage plugin",
slurmdbd_conf->storage_type);
}
_kill_old_slurmdbd();
if (foreground == 0)
_daemonize();
/*
* Need to create pidfile here in case we setuid() below
* (init_pidfile() exits if it can't initialize pid file).
* On Linux we also need to make this setuid job explicitly
* able to write a core dump.
* This also has to happen after daemon(), which closes all fd's,
* so we keep the write lock of the pidfile.
*/
_init_pidfile();
_become_slurm_user();
if (foreground == 0)
_set_work_dir();
log_config();
#ifdef PR_SET_DUMPABLE
if (prctl(PR_SET_DUMPABLE, 1) < 0)
debug ("Unable to set dumpable to 1");
#endif /* PR_SET_DUMPABLE */
if (xsignal_block(dbd_sigarray) < 0)
error("Unable to block signals");
/* Create attached thread for signal handling */
slurm_attr_init(&thread_attr);
if (pthread_create(&signal_handler_thread, &thread_attr,
_signal_handler, NULL))
fatal("pthread_create %m");
slurm_attr_destroy(&thread_attr);
memset(&assoc_init_arg, 0, sizeof(assoc_init_args_t));
/* If we are tacking wckey we need to cache
wckeys, if we aren't only cache the users and qos */
assoc_init_arg.cache_level = ASSOC_MGR_CACHE_USER | ASSOC_MGR_CACHE_QOS;
if (slurmdbd_conf->track_wckey)
assoc_init_arg.cache_level |= ASSOC_MGR_CACHE_WCKEY;
db_conn = acct_storage_g_get_connection(NULL, 0, false, NULL);
if (assoc_mgr_init(db_conn, &assoc_init_arg, errno) == SLURM_ERROR) {
error("Problem getting cache of data");
acct_storage_g_close_connection(&db_conn);
goto end_it;
}
if (gethostname_short(node_name, sizeof(node_name)))
fatal("getnodename: %m");
while (1) {
if (slurmdbd_conf->dbd_backup &&
(!strcmp(node_name, slurmdbd_conf->dbd_backup) ||
!strcmp(slurmdbd_conf->dbd_backup, "localhost"))) {
info("slurmdbd running in background mode");
have_control = false;
backup = true;
run_backup();
if (!shutdown_time)
assoc_mgr_refresh_lists(db_conn, NULL);
} else if (slurmdbd_conf->dbd_host &&
(!strcmp(slurmdbd_conf->dbd_host, node_name) ||
!strcmp(slurmdbd_conf->dbd_host, "localhost"))) {
backup = false;
have_control = true;
} else {
fatal("This host not configured to run SlurmDBD "
"(%s != %s | (backup) %s)",
node_name, slurmdbd_conf->dbd_host,
slurmdbd_conf->dbd_backup);
}
if (!shutdown_time) {
/* Create attached thread to process incoming RPCs */
slurm_attr_init(&thread_attr);
if (pthread_create(&rpc_handler_thread, &thread_attr,
rpc_mgr, NULL))
fatal("pthread_create error %m");
slurm_attr_destroy(&thread_attr);
}
if (!shutdown_time) {
/* Create attached thread to do usage rollup */
slurm_attr_init(&thread_attr);
if (pthread_create(&rollup_handler_thread,
&thread_attr,
_rollup_handler, db_conn))
fatal("pthread_create error %m");
slurm_attr_destroy(&thread_attr);
}
/* Daemon is fully operational here */
if (!shutdown_time || primary_resumed) {
shutdown_time = 0;
info("slurmdbd version %s started",
SLURM_VERSION_STRING);
if (backup)
run_backup();
}
_request_registrations(db_conn);
/* this is only ran if not backup */
if (rollup_handler_thread)
pthread_join(rollup_handler_thread, NULL);
if (rpc_handler_thread)
pthread_join(rpc_handler_thread, NULL);
if (backup && primary_resumed) {
shutdown_time = 0;
info("Backup has given up control");
}
if (shutdown_time)
break;
}
/* Daemon termination handled here */
if (signal_handler_thread)
pthread_join(signal_handler_thread, NULL);
end_it:
acct_storage_g_close_connection(&db_conn);
if (slurmdbd_conf->pid_file &&
(unlink(slurmdbd_conf->pid_file) < 0)) {
verbose("Unable to remove pidfile '%s': %m",
slurmdbd_conf->pid_file);
}
assoc_mgr_fini(NULL);
slurm_acct_storage_fini();
slurm_auth_fini();
log_fini();
free_slurmdbd_conf();
exit(0);
}
