int main(int argc, char *argv[]) {
char *func = argv[1];
char *loc = argv[2];
int result;
if(strstr(func, "create") != NULL) {
int64_t size = (string_metric_parse(argv[3]) / 1024);
result = disk_alloc_create(loc, size);
if(result != 0) {
printf("Could not create allocation.\n");
return -1;
}
printf("Allocation complete.\n");
return 0;
}
else if(strstr(func, "delete") != NULL) {
result = disk_alloc_delete(loc);
if(result != 0) {
printf("Could not delete allocation.\n");
return -1;
}
printf("Deallocation complete.\n");
return 0;
}
else {
printf("Invalid parameters defined.\n");
return -1;
}
}
int main( int argc, char *argv[] )
{
INT64_T size;
if(argc!=3) {
printf("use: parrot_mkalloc <path> <size>\n");
return 0;
}
size = string_metric_parse(argv[2]);
if(parrot_mkalloc(argv[1],size,0777)==0) {
return 0;
} else {
if(errno==ENOSYS || errno==EINVAL) {
fprintf(stderr,"parrot_mkalloc: This filesystem does not support allocations.\n");
} else {
fprintf(stderr,"parrot_mkalloc: %s\n",strerror(errno));
}
return 1;
}
}
int main(int argc, char *argv[])
{
batch_queue_type_t batch_queue_type = BATCH_QUEUE_TYPE_UNKNOWN;
catalog_host = CATALOG_HOST;
catalog_port = CATALOG_PORT;
batch_submit_options = getenv("BATCH_OPTIONS");
debug_config(argv[0]);
resources = rmsummary_create(-1);
int c;
while((c = getopt_long(argc, argv, "B:C:F:N:M:T:t:w:W:E:P:S:cd:o:O:vh", long_options, NULL)) > -1) {
switch (c) {
case 'B':
batch_submit_options = xxstrdup(optarg);
break;
case 'C':
config_file = xxstrdup(optarg);
break;
case 'F':
foremen_regex = xxstrdup(optarg);
break;
case 'N':
case 'M':
project_regex = xxstrdup(optarg);
break;
case 'T':
batch_queue_type = batch_queue_type_from_string(optarg);
if(batch_queue_type == BATCH_QUEUE_TYPE_UNKNOWN) {
fprintf(stderr, "unknown batch queue type: %s\n", optarg);
return EXIT_FAILURE;
}
break;
case 't':
worker_timeout = atoi(optarg);
break;
case 'w':
workers_min = atoi(optarg);
break;
case 'W':
workers_max = atoi(optarg);
break;
case LONG_OPT_WORKERS_PER_CYCLE:
workers_per_cycle = atoi(optarg);
break;
case LONG_OPT_TASKS_PER_WORKER:
tasks_per_worker = atof(optarg);
break;
case 'E':
extra_worker_args = xxstrdup(optarg);
break;
case LONG_OPT_CORES:
resources->cores = atoi(optarg);
break;
case LONG_OPT_AMAZON_CREDENTIALS:
amazon_credentials = xxstrdup(optarg);
break;
case LONG_OPT_AMAZON_AMI:
amazon_ami = xxstrdup(optarg);
break;
case LONG_OPT_MEMORY:
resources->memory = atoi(optarg);
break;
case LONG_OPT_DISK:
resources->disk = atoi(optarg);
break;
case LONG_OPT_GPUS:
resources->gpus = atoi(optarg);
break;
case LONG_OPT_AUTOSIZE:
autosize = 1;
break;
case LONG_OPT_FACTORY_TIMEOUT:
factory_timeout = MAX(0, atoi(optarg));
break;
case LONG_OPT_CONDOR_REQUIREMENTS:
if(condor_requirements) {
char *tmp = condor_requirements;
condor_requirements = string_format("(%s && (%s))", tmp, optarg);
free(tmp);
} else {
condor_requirements = string_format("(%s)", optarg);
}
break;
case LONG_OPT_WRAPPER:
wrapper_command = optarg;
break;
case LONG_OPT_WRAPPER_INPUT:
if(!wrapper_input) {
wrapper_input = strdup(optarg);
} else {
wrapper_input = string_format("%s,%s",wrapper_input,optarg);
}
break;
case 'P':
password_file = optarg;
break;
case 'S':
scratch_dir = optarg;
break;
case 'c':
consider_capacity = 1;
break;
case 'd':
debug_flags_set(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'O':
debug_config_file_size(string_metric_parse(optarg));
break;
case 'v':
cctools_version_print(stdout, argv[0]);
exit(EXIT_SUCCESS);
case 'h':
show_help(argv[0]);
exit(EXIT_SUCCESS);
default:
show_help(argv[0]);
return EXIT_FAILURE;
}
}
if(project_regex) {
using_catalog = 1;
}
else if((argc - optind) == 2) {
master_host = argv[optind];
master_port = atoi(argv[optind+1]);
}
else {
fprintf(stderr,"work_queue_factory: You must either give a project name with the -M option or master-name option with a configuration file, or give the master's host and port.\n");
show_help(argv[0]);
exit(1);
}
cctools_version_debug(D_DEBUG, argv[0]);
if(batch_queue_type == BATCH_QUEUE_TYPE_UNKNOWN) {
fprintf(stderr,"work_queue_factory: You must specify a batch type with the -T option.\n");
fprintf(stderr, "valid options:\n");
fprintf(stderr, "%s\n", batch_queue_type_string());
return 1;
}
if(config_file) {
char abs_path_name[PATH_MAX];
if(!realpath(config_file, abs_path_name)) {
fprintf(stderr, "work_queue_factory: could not resolve configuration file path: '%s'.\n", config_file);
exit(EXIT_FAILURE);
}
free(config_file);
/* From now on, read config_file from absolute path */
config_file = xxstrdup(abs_path_name);
if(!read_config_file(config_file)) {
fprintf(stderr,"work_queue_factory: There were errors in the configuration file: %s\n", config_file);
return 1;
}
}
if(workers_min>workers_max) {
fprintf(stderr,"work_queue_factory: min workers (%d) is greater than max workers (%d)\n",workers_min, workers_max);
return 1;
}
/*
Careful here: most of the supported batch systems expect
that jobs are submitting from a single shared filesystem.
Changing to /tmp only works in the case of Condor.
*/
if(!scratch_dir) {
if(batch_queue_type==BATCH_QUEUE_TYPE_CONDOR) {
scratch_dir = string_format("/tmp/wq-pool-%d",getuid());
} else {
scratch_dir = string_format("wq-pool-%d",getuid());
}
}
if(!create_dir(scratch_dir,0777)) {
fprintf(stderr,"work_queue_factory: couldn't create %s: %s",scratch_dir,strerror(errno));
return 1;
}
char cmd[1024];
sprintf(cmd,"cp \"$(which work_queue_worker)\" '%s'",scratch_dir);
if (system(cmd)) {
fprintf(stderr, "work_queue_factory: please add work_queue_worker to your PATH.\n");
exit(EXIT_FAILURE);
}
if(password_file) {
sprintf(cmd,"cp %s %s/pwfile",password_file,scratch_dir);
system(cmd);
}
if(chdir(scratch_dir)!=0) {
fprintf(stderr,"work_queue_factory: couldn't chdir to %s: %s",scratch_dir,strerror(errno));
return 1;
}
signal(SIGINT, handle_abort);
signal(SIGQUIT, handle_abort);
signal(SIGTERM, handle_abort);
signal(SIGHUP, ignore_signal);
queue = batch_queue_create(batch_queue_type);
if(!queue) {
fprintf(stderr,"work_queue_factory: couldn't establish queue type %s",batch_queue_type_to_string(batch_queue_type));
return 1;
}
batch_queue_set_option(queue, "batch-options", batch_submit_options);
batch_queue_set_option(queue, "autosize", autosize ? "yes" : NULL);
set_worker_resources_options( queue );
if (amazon_credentials != NULL) {
batch_queue_set_option(queue, "amazon-credentials", amazon_credentials);
}
if (amazon_ami != NULL) {
batch_queue_set_option(queue, "amazon-ami", amazon_ami);
}
if(condor_requirements != NULL && batch_queue_type != BATCH_QUEUE_TYPE_CONDOR) {
debug(D_NOTICE, "condor_requirements will be ignored as workers will not be running in condor.");
} else {
batch_queue_set_option(queue, "condor-requirements", condor_requirements);
}
mainloop( queue );
batch_queue_delete(queue);
return 0;
}
int main(int argc, char *argv[])
{
batch_queue_type_t batch_queue_type = BATCH_QUEUE_TYPE_UNKNOWN;
catalog_host = CATALOG_HOST;
catalog_port = CATALOG_PORT;
debug_config(argv[0]);
int c;
while((c = getopt_long(argc, argv, "F:N:M:T:t:w:W:E:P:S:cd:o:O:vh", long_options, NULL)) > -1) {
switch (c) {
case 'F':
foremen_regex = optarg;
break;
case 'N':
case 'M':
project_regex = optarg;
break;
case 'T':
batch_queue_type = batch_queue_type_from_string(optarg);
if(batch_queue_type == BATCH_QUEUE_TYPE_UNKNOWN) {
fprintf(stderr, "unknown batch queue type: %s\n", optarg);
return EXIT_FAILURE;
}
break;
case 't':
worker_timeout = atoi(optarg);
break;
case 'w':
workers_min = atoi(optarg);
break;
case 'W':
workers_max = atoi(optarg);
break;
case LONG_OPT_TASKS_PER_WORKER:
tasks_per_worker = atof(optarg);
break;
case 'E':
extra_worker_args = optarg;
break;
case LONG_OPT_CORES:
num_cores_option = xxstrdup(optarg);
break;
case LONG_OPT_MEMORY:
num_memory_option = xxstrdup(optarg);
break;
case LONG_OPT_DISK:
num_disk_option = xxstrdup(optarg);
break;
case LONG_OPT_GPUS:
num_gpus_option = xxstrdup(optarg);
break;
case 'P':
password_file = optarg;
break;
case 'S':
scratch_dir = optarg;
break;
case 'c':
consider_capacity = 1;
break;
case 'd':
debug_flags_set(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'O':
debug_config_file_size(string_metric_parse(optarg));
break;
case 'v':
cctools_version_print(stdout, argv[0]);
exit(EXIT_SUCCESS);
case 'h':
show_help(argv[0]);
exit(EXIT_SUCCESS);
default:
show_help(argv[0]);
return EXIT_FAILURE;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if(batch_queue_type == BATCH_QUEUE_TYPE_UNKNOWN) {
fprintf(stderr,"work_queue_pool: You must specify a batch type with the -T option.\n");
fprintf(stderr, "valid options:\n");
fprintf(stderr, "%s\n", batch_queue_type_string());
return 1;
}
if(!project_regex) {
fprintf(stderr,"work_queue_pool: You must give a project name with the -M option.\n");
return 1;
}
if(workers_min>workers_max) {
fprintf(stderr,"work_queue_pool: --min-workers (%d) is greater than --max-workers (%d)\n",workers_min,workers_max);
return 1;
}
if(tasks_per_worker < 1)
{
tasks_per_worker = num_cores_option ? atof(num_cores_option) : 1;
}
if(!scratch_dir) {
scratch_dir = string_format("/tmp/wq-pool-%d",getuid());
}
if(!create_dir(scratch_dir,0777)) {
fprintf(stderr,"work_queue_pool: couldn't create %s: %s",scratch_dir,strerror(errno));
return 1;
}
char cmd[1024];
sprintf(cmd,"cp \"$(which work_queue_worker)\" '%s'",scratch_dir);
if (system(cmd)) {
fprintf(stderr, "work_queue_pool: please add work_queue_worker to your PATH.\n");
exit(EXIT_FAILURE);
}
if(password_file) {
sprintf(cmd,"cp %s %s/pwfile",password_file,scratch_dir);
system(cmd);
}
if(chdir(scratch_dir)!=0) {
fprintf(stderr,"work_queue_pool: couldn't chdir to %s: %s",scratch_dir,strerror(errno));
return 1;
}
signal(SIGINT, handle_abort);
signal(SIGQUIT, handle_abort);
signal(SIGTERM, handle_abort);
signal(SIGHUP, ignore_signal);
struct batch_queue * queue = batch_queue_create(batch_queue_type);
if(!queue) {
fprintf(stderr,"work_queue_pool: couldn't establish queue type %s",batch_queue_type_to_string(batch_queue_type));
return 1;
}
set_worker_resources( queue );
mainloop( queue, project_regex, foremen_regex );
batch_queue_delete(queue);
return 0;
}
int main(int argc, char *argv[])
{
struct catalog_query *q;
struct nvpair *n;
time_t timeout = 60, stoptime;
const char *catalog_host = 0;
signed char c;
int i;
int count = 0;
int mode = MODE_TABLE;
INT64_T total = 0, avail = 0;
const char *filter_name = 0;
const char *filter_value = 0;
debug_config(argv[0]);
static struct option long_options[] = {
{"catalog", required_argument, 0, 'c'},
{"debug", required_argument, 0, 'd'},
{"debug-file", required_argument, 0, 'o'},
{"debug-rotate-max", required_argument, 0, 'O'},
{"server-space", required_argument, 0, 'A'},
{"all", no_argument, 0, 'a'},
{"timeout", required_argument, 0, 't'},
{"brief", no_argument, 0, 's'},
{"verbose", no_argument, 0, 'l'},
{"totals", no_argument, 0, 'T'},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
while((c = getopt_long(argc, argv, "aA:c:d:t:o:O:sTlvh", long_options, NULL)) > -1) {
switch (c) {
case 'a':
show_all_types = 1;
break;
case 'c':
catalog_host = optarg;
break;
case 'd':
debug_flags_set(optarg);
break;
case 't':
timeout = string_time_parse(optarg);
break;
case 'A':
minavail = string_metric_parse(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'O':
debug_config_file_size(string_metric_parse(optarg));
break;
case 'v':
cctools_version_print(stdout, argv[0]);
return 1;
case 's':
mode = MODE_SHORT;
break;
case 'l':
mode = MODE_LONG;
break;
case 'T':
mode = MODE_TOTAL;
break;
case 'h':
default:
show_help(argv[0]);
return 1;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if(argc - optind == 0) {
// fine, keep going
} else if((argc - optind) == 1) {
filter_name = "name";
filter_value = argv[optind];
} else if((argc - optind) == 2) {
filter_name = argv[optind];
filter_value = argv[optind + 1];
} else {
show_help(argv[0]);
return 1;
}
stoptime = time(0) + timeout;
q = catalog_query_create(catalog_host, 0, stoptime);
if(!q) {
fprintf(stderr, "couldn't query catalog: %s\n", strerror(errno));
return 1;
}
if(mode == MODE_TABLE) {
nvpair_print_table_header(stdout, headers);
}
while((n = catalog_query_read(q, stoptime))) {
table[count++] = n;
}
qsort(table, count, sizeof(*table), (int (*)(const void *, const void *)) compare_entries);
for(i = 0; i < count; i++) {
const char *etype = nvpair_lookup_string(table[i], "type");
if(!show_all_types) {
if(etype) {
if(!strcmp(etype, "chirp") || !strcmp(etype, "catalog")) {
/* ok, keep going */
} else {
continue;
}
} else {
continue;
}
}
if(minavail != 0) {
if(minavail > nvpair_lookup_integer(table[i], "avail")) {
continue;
}
}
if(filter_name) {
const char *v = nvpair_lookup_string(table[i], filter_name);
if(!v || strcmp(filter_value, v))
continue;
}
if(mode == MODE_SHORT) {
const char *t = nvpair_lookup_string(table[i], "type");
if(t && !strcmp(t, "chirp")) {
printf("%s:%d\n", nvpair_lookup_string(table[i], "name"), (int) nvpair_lookup_integer(table[i], "port"));
}
} else if(mode == MODE_LONG) {
nvpair_print_text(table[i], stdout);
} else if(mode == MODE_TABLE) {
nvpair_print_table(table[i], stdout, headers);
} else if(mode == MODE_TOTAL) {
avail += nvpair_lookup_integer(table[i], "avail");
total += nvpair_lookup_integer(table[i], "total");
}
}
if(mode == MODE_TOTAL) {
printf("NODES: %4d\n", count);
printf("TOTAL: %6sB\n", string_metric(total, -1, 0));
printf("AVAIL: %6sB\n", string_metric(avail, -1, 0));
printf("INUSE: %6sB\n", string_metric(total - avail, -1, 0));
}
if(mode == MODE_TABLE) {
nvpair_print_table_footer(stdout, headers);
}
return 0;
}
int main(int argc, char *argv[])
{
struct link *link, *list_port = 0;
char ch;
time_t current;
int is_daemon = 0;
char *pidfile = NULL;
outgoing_host_list = list_create();
debug_config(argv[0]);
while((ch = getopt(argc, argv, "bB:d:hH:l:L:m:M:n:o:O:p:ST:u:U:v")) != (char) -1) {
switch (ch) {
case 'b':
is_daemon = 1;
break;
case 'B':
free(pidfile);
pidfile = strdup(optarg);
break;
case 'd':
debug_flags_set(optarg);
break;
case 'h':
default:
show_help(argv[0]);
return 1;
case 'l':
lifetime = string_time_parse(optarg);
break;
case 'L':
logfilename = strdup(optarg);
break;
case 'H':
history_dir = strdup(optarg);
break;
case 'm':
child_procs_max = atoi(optarg);
break;
case 'M':
max_server_size = string_metric_parse(optarg);
break;
case 'n':
preferred_hostname = optarg;
break;
case 'o':
free(debug_filename);
debug_filename = strdup(optarg);
break;
case 'O':
debug_config_file_size(string_metric_parse(optarg));
break;
case 'p':
port = atoi(optarg);
break;
case 'S':
fork_mode = 0;
break;
case 'T':
child_procs_timeout = string_time_parse(optarg);
break;
case 'u':
list_push_head(outgoing_host_list, xxstrdup(optarg));
break;
case 'U':
outgoing_timeout = string_time_parse(optarg);
break;
case 'v':
cctools_version_print(stdout, argv[0]);
return 0;
}
}
if (is_daemon) daemonize(0, pidfile);
debug_config_file(debug_filename);
cctools_version_debug(D_DEBUG, argv[0]);
if(logfilename) {
logfile = fopen(logfilename,"a");
if(!logfile) fatal("couldn't open %s: %s\n",optarg,strerror(errno));
}
current = time(0);
debug(D_ALL, "*** %s starting at %s", argv[0], ctime(¤t));
if(!list_size(outgoing_host_list)) {
list_push_head(outgoing_host_list, CATALOG_HOST_DEFAULT);
}
install_handler(SIGPIPE, ignore_signal);
install_handler(SIGHUP, ignore_signal);
install_handler(SIGCHLD, ignore_signal);
install_handler(SIGINT, shutdown_clean);
install_handler(SIGTERM, shutdown_clean);
install_handler(SIGQUIT, shutdown_clean);
install_handler(SIGALRM, shutdown_clean);
if(!preferred_hostname) {
domain_name_cache_guess(hostname);
preferred_hostname = hostname;
}
username_get(owner);
starttime = time(0);
table = nvpair_database_create(history_dir);
if(!table)
fatal("couldn't create directory %s: %s\n",history_dir,strerror(errno));
update_dgram = datagram_create(port);
if(!update_dgram)
fatal("couldn't listen on udp port %d", port);
outgoing_dgram = datagram_create(0);
if(!outgoing_dgram)
fatal("couldn't create outgoing udp port");
list_port = link_serve(port);
if(!list_port)
fatal("couldn't listen on tcp port %d", port);
while(1) {
fd_set rfds;
int ufd = datagram_fd(update_dgram);
int lfd = link_fd(list_port);
int result, maxfd;
struct timeval timeout;
remove_expired_records();
if(time(0) > outgoing_alarm) {
update_all_catalogs(outgoing_dgram);
outgoing_alarm = time(0) + outgoing_timeout;
}
while(1) {
int status;
pid_t pid = waitpid(-1, &status, WNOHANG);
if(pid>0) {
child_procs_count--;
continue;
} else {
break;
}
}
FD_ZERO(&rfds);
FD_SET(ufd, &rfds);
if(child_procs_count < child_procs_max) {
FD_SET(lfd, &rfds);
}
maxfd = MAX(ufd, lfd) + 1;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
result = select(maxfd, &rfds, 0, 0, &timeout);
if(result <= 0)
continue;
if(FD_ISSET(ufd, &rfds)) {
handle_updates(update_dgram);
}
if(FD_ISSET(lfd, &rfds)) {
link = link_accept(list_port, time(0) + 5);
if(link) {
if(fork_mode) {
pid_t pid = fork();
if(pid == 0) {
alarm(child_procs_timeout);
handle_query(link);
_exit(0);
} else if (pid>0) {
child_procs_count++;
}
} else {
handle_query(link);
}
link_close(link);
}
}
}
return 1;
}
static void work_queue_status_parse_command_line_arguments(int argc, char *argv[])
{
signed int c;
static struct option long_options[] = {
{"statistics", no_argument, 0, 'Q'},
{"workers", no_argument, 0, 'W'},
{"tasks", no_argument, 0, 'T'},
{"verbose", no_argument, 0, 'l'},
{"resources", no_argument, 0, 'R'},
{"catalog", required_argument, 0, 'C'},
{"debug", required_argument, 0, 'd'},
{"timeout", required_argument, 0, 't'},
{"help", no_argument, 0, 'h'},
{0,0,0,0}};
while((c = getopt_long(argc, argv, "QTWC:d:lo:O:Rt:vh", long_options, NULL)) > -1) {
switch (c) {
case 'C':
if(!parse_catalog_server_description(optarg, &catalog_host, &catalog_port)) {
fprintf(stderr, "Cannot parse catalog description: %s. \n", optarg);
exit(EXIT_FAILURE);
}
break;
case 'd':
debug_flags_set(optarg);
break;
case 'Q':
query_mode = QUERY_QUEUE;
break;
case 'T':
query_mode = QUERY_TASKS;
break;
case 'W':
query_mode = QUERY_WORKERS;
break;
case 'l':
format_mode = FORMAT_LONG;
break;
case 'o':
debug_config_file(optarg);
break;
case 'O':
debug_config_file_size(string_metric_parse(optarg));
break;
case 't':
work_queue_status_timeout = strtol(optarg, NULL, 10);
break;
case 'h':
show_help(argv[0]);
exit(EXIT_SUCCESS);
break;
case 'R':
query_mode = QUERY_MASTER_RESOURCES;
resource_mode = 1;
break;
case 'v':
cctools_version_print(stdout, argv[0]);
exit(EXIT_SUCCESS);
default:
show_help(argv[0]);
exit(EXIT_FAILURE);
break;
}
}
}
int main(int argc, char *argv[])
{
enum {
LONGOPT_SERVER_LASTHEARDFROM = INT_MAX-0,
LONGOPT_SERVER_PROJECT = INT_MAX-1,
LONGOPT_WHERE = INT_MAX-2,
};
static const struct option long_options[] = {
{"all", no_argument, 0, 'a'},
{"brief", no_argument, 0, 's'},
{"catalog", required_argument, 0, 'c'},
{"debug", required_argument, 0, 'd'},
{"debug-file", required_argument, 0, 'o'},
{"debug-rotate-max", required_argument, 0, 'O'},
{"help", no_argument, 0, 'h'},
{"server-lastheardfrom", required_argument, 0, LONGOPT_SERVER_LASTHEARDFROM},
{"server-project", required_argument, 0, LONGOPT_SERVER_PROJECT},
{"server-space", required_argument, 0, 'A'},
{"timeout", required_argument, 0, 't'},
{"totals", no_argument, 0, 'T'},
{"verbose", no_argument, 0, 'l'},
{"version", no_argument, 0, 'v'},
{"where", required_argument, 0, LONGOPT_WHERE },
{0, 0, 0, 0}
};
struct catalog_query *q;
struct jx *j;
time_t timeout = 60, stoptime;
const char *catalog_host = 0;
int i;
int c;
int count = 0;
int mode = MODE_TABLE;
INT64_T sum_total = 0, sum_avail = 0;
const char *filter_name = 0;
const char *filter_value = 0;
const char *where_expr = "true";
int show_all_types = 0;
const char *server_project = NULL;
time_t server_lastheardfrom = 0;
uint64_t server_avail = 0;
debug_config(argv[0]);
while((c = getopt_long(argc, argv, "aA:c:d:t:o:O:sTlvh", long_options, NULL)) > -1) {
switch (c) {
case 'a':
show_all_types = 1;
break;
case 'c':
catalog_host = optarg;
break;
case 'd':
debug_flags_set(optarg);
break;
case 't':
timeout = string_time_parse(optarg);
break;
case 'A':
server_avail = string_metric_parse(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'O':
debug_config_file_size(string_metric_parse(optarg));
break;
case 'v':
cctools_version_print(stdout, argv[0]);
return 1;
case 's':
mode = MODE_SHORT;
break;
case 'l':
mode = MODE_LONG;
break;
case 'T':
mode = MODE_TOTAL;
break;
case LONGOPT_SERVER_LASTHEARDFROM:
server_lastheardfrom = time(0)-string_time_parse(optarg);
break;
case LONGOPT_SERVER_PROJECT:
server_project = xxstrdup(optarg);
break;
case LONGOPT_WHERE:
where_expr = optarg;
break;
case 'h':
default:
show_help(argv[0]);
return 1;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if(argc - optind == 0) {
// fine, keep going
} else if((argc - optind) == 1) {
filter_name = "name";
filter_value = argv[optind];
} else if((argc - optind) == 2) {
filter_name = argv[optind];
filter_value = argv[optind + 1];
} else {
show_help(argv[0]);
return 1;
}
stoptime = time(0) + timeout;
const char *query_expr;
if(show_all_types) {
query_expr = where_expr;
} else {
query_expr = string_format("%s && (type==\"chirp\" || type==\"catalog\")",where_expr);
}
struct jx *jexpr = jx_parse_string(query_expr);
if(!jexpr) {
fprintf(stderr,"invalid expression: %s\n",query_expr);
return 1;
}
q = catalog_query_create(catalog_host, 0, jexpr, stoptime);
if(!q) {
fprintf(stderr, "couldn't query catalog: %s\n", strerror(errno));
return 1;
}
if(mode == MODE_TABLE) {
jx_table_print_header(headers,stdout);
} else if(mode==MODE_LONG) {
printf("[\n");
}
while((j = catalog_query_read(q, stoptime))) {
table[count++] = j;
}
catalog_query_delete(q);
qsort(table, count, sizeof(*table), (int (*)(const void *, const void *)) compare_entries);
for(i = 0; i < count; i++) {
const char *lastheardfrom = jx_lookup_string(table[i], "lastheardfrom");
if (lastheardfrom && (time_t)strtoul(lastheardfrom, NULL, 10) < server_lastheardfrom)
continue;
const char *avail = jx_lookup_string(table[i], "avail");
if (avail && strtoul(avail, NULL, 10) < server_avail)
continue;
const char *project = jx_lookup_string(table[i], "project");
if (server_project && (project == NULL || !(strcmp(project, server_project) == 0)))
continue;
if(filter_name) {
const char *v = jx_lookup_string(table[i], filter_name);
if(!v || strcmp(filter_value, v))
continue;
}
if(mode == MODE_SHORT) {
const char *t = jx_lookup_string(table[i], "type");
if(t && !strcmp(t, "chirp")) {
printf("%s:%d\n", jx_lookup_string(table[i], "name"), (int) jx_lookup_integer(table[i], "port"));
}
} else if(mode == MODE_LONG) {
if(i!=0) printf(",\n");
jx_print_stream(table[i],stdout);
} else if(mode == MODE_TABLE) {
jx_table_print(headers, table[i], stdout);
} else if(mode == MODE_TOTAL) {
sum_avail += jx_lookup_integer(table[i], "avail");
sum_total += jx_lookup_integer(table[i], "total");
}
}
for(i=0;i<count;i++) {
jx_delete(table[i]);
}
if(mode == MODE_TOTAL) {
printf("NODES: %4d\n", count);
printf("TOTAL: %6sB\n", string_metric(sum_total, -1, 0));
printf("AVAIL: %6sB\n", string_metric(sum_avail, -1, 0));
printf("INUSE: %6sB\n", string_metric(sum_total - sum_avail, -1, 0));
} else if(mode == MODE_TABLE) {
jx_table_print_footer(headers,stdout);
} else if(mode==MODE_LONG) {
printf("\n]\n");
}
return 0;
}
int main(int argc, char *argv[])
{
struct link *link, *list_port = 0;
signed char ch;
time_t current;
int is_daemon = 0;
char *pidfile = NULL;
char *interface = NULL;
outgoing_host_list = list_create();
debug_config(argv[0]);
static const struct option long_options[] = {
{"background", no_argument, 0, 'b'},
{"pid-file", required_argument, 0, 'B'},
{"debug", required_argument, 0, 'd'},
{"help", no_argument, 0, 'h'},
{"history", required_argument, 0, 'H'},
{"lifetime", required_argument, 0, 'l'},
{"update-log", required_argument, 0, 'L'},
{"max-jobs", required_argument, 0, 'm'},
{"server-size", required_argument, 0, 'M'},
{"name", required_argument, 0, 'n'},
{"interface", required_argument, 0, 'I'},
{"debug-file", required_argument, 0, 'o'},
{"debug-rotate-max", required_argument, 0, 'O'},
{"port", required_argument, 0, 'p'},
{"single", no_argument, 0, 'S'},
{"timeout", required_argument, 0, 'T'},
{"update-host", required_argument, 0, 'u'},
{"update-interval", required_argument, 0, 'U'},
{"version", no_argument, 0, 'v'},
{"port-file", required_argument, 0, 'Z'},
{0,0,0,0}};
while((ch = getopt_long(argc, argv, "bB:d:hH:I:l:L:m:M:n:o:O:p:ST:u:U:vZ:", long_options, NULL)) > -1) {
switch (ch) {
case 'b':
is_daemon = 1;
break;
case 'B':
free(pidfile);
pidfile = strdup(optarg);
break;
case 'd':
debug_flags_set(optarg);
break;
case 'h':
default:
show_help(argv[0]);
return 1;
case 'l':
lifetime = string_time_parse(optarg);
break;
case 'L':
logfilename = strdup(optarg);
break;
case 'H':
history_dir = strdup(optarg);
break;
case 'I':
free(interface);
interface = strdup(optarg);
break;
case 'm':
child_procs_max = atoi(optarg);
break;
case 'M':
max_server_size = string_metric_parse(optarg);
break;
case 'n':
preferred_hostname = optarg;
break;
case 'o':
debug_config_file(optarg);
break;
case 'O':
debug_config_file_size(string_metric_parse(optarg));
break;
case 'p':
port = atoi(optarg);
break;
case 'S':
fork_mode = 0;
break;
case 'T':
child_procs_timeout = string_time_parse(optarg);
break;
case 'u':
list_push_head(outgoing_host_list, xxstrdup(optarg));
break;
case 'U':
outgoing_timeout = string_time_parse(optarg);
break;
case 'v':
cctools_version_print(stdout, argv[0]);
return 0;
case 'Z':
port_file = optarg;
port = 0;
break;
}
}
if (is_daemon) daemonize(0, pidfile);
cctools_version_debug(D_DEBUG, argv[0]);
if(logfilename) {
logfile = fopen(logfilename,"a");
if(!logfile) fatal("couldn't open %s: %s\n",optarg,strerror(errno));
}
current = time(0);
debug(D_NOTICE, "*** %s starting at %s", argv[0], ctime(¤t));
if(!list_size(outgoing_host_list)) {
list_push_head(outgoing_host_list, CATALOG_HOST_DEFAULT);
}
install_handler(SIGPIPE, ignore_signal);
install_handler(SIGHUP, ignore_signal);
install_handler(SIGCHLD, ignore_signal);
install_handler(SIGINT, shutdown_clean);
install_handler(SIGTERM, shutdown_clean);
install_handler(SIGQUIT, shutdown_clean);
install_handler(SIGALRM, shutdown_clean);
if(!preferred_hostname) {
domain_name_cache_guess(hostname);
preferred_hostname = hostname;
}
username_get(owner);
starttime = time(0);
table = nvpair_database_create(history_dir);
if(!table)
fatal("couldn't create directory %s: %s\n",history_dir,strerror(errno));
list_port = link_serve_address(interface, port);
if(list_port) {
/*
If a port was chosen automatically, read it back
so that the same one can be used for the update port.
There is the possibility that the UDP listen will
fail because that port is in use.
*/
if(port==0) {
char addr[LINK_ADDRESS_MAX];
link_address_local(list_port,addr,&port);
}
} else {
if(interface)
fatal("couldn't listen on TCP address %s port %d", interface, port);
else
fatal("couldn't listen on TCP port %d", port);
}
outgoing_dgram = datagram_create(0);
if(!outgoing_dgram)
fatal("couldn't create outgoing udp port");
update_dgram = datagram_create_address(interface, port);
if(!update_dgram) {
if(interface)
fatal("couldn't listen on UDP address %s port %d", interface, port);
else
fatal("couldn't listen on UDP port %d", port);
}
opts_write_port_file(port_file,port);
while(1) {
fd_set rfds;
int ufd = datagram_fd(update_dgram);
int lfd = link_fd(list_port);
int result, maxfd;
struct timeval timeout;
remove_expired_records();
if(time(0) > outgoing_alarm) {
update_all_catalogs(outgoing_dgram);
outgoing_alarm = time(0) + outgoing_timeout;
}
while(1) {
int status;
pid_t pid = waitpid(-1, &status, WNOHANG);
if(pid>0) {
child_procs_count--;
continue;
} else {
break;
}
}
FD_ZERO(&rfds);
FD_SET(ufd, &rfds);
if(child_procs_count < child_procs_max) {
FD_SET(lfd, &rfds);
}
maxfd = MAX(ufd, lfd) + 1;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
result = select(maxfd, &rfds, 0, 0, &timeout);
if(result <= 0)
continue;
if(FD_ISSET(ufd, &rfds)) {
handle_updates(update_dgram);
}
if(FD_ISSET(lfd, &rfds)) {
link = link_accept(list_port, time(0) + 5);
if(link) {
if(fork_mode) {
pid_t pid = fork();
if(pid == 0) {
alarm(child_procs_timeout);
handle_query(link);
_exit(0);
} else if (pid>0) {
child_procs_count++;
}
} else {
handle_query(link);
}
link_close(link);
}
}
}
return 1;
}
static INT64_T do_mkalloc(int argc, char **argv)
{
char full_path[CHIRP_PATH_MAX];
complete_remote_path(argv[1], full_path);
return chirp_reli_mkalloc(current_host, full_path, string_metric_parse(argv[2]), 0700, stoptime);
}
int main(int argc, char *argv[])
{
const char *host = NULL;
int port = MPI_QUEUE_DEFAULT_PORT;
char addr[LINK_ADDRESS_MAX];
char c;
int w, rank;
signal(SIGTERM, handle_abort);
signal(SIGQUIT, handle_abort);
signal(SIGINT, handle_abort);
MPI_Init(&argc, &argv);
debug_config(argv[0]);
while((c = getopt(argc, argv, "d:ho:t:w:v")) != (char) -1) {
switch (c) {
case 'd':
debug_flags_set(optarg);
break;
case 't':
idle_timeout = string_time_parse(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'v':
show_version(argv[0]);
return 0;
case 'w':
w = string_metric_parse(optarg);
link_window_set(w, w);
break;
case 'h':
default:
show_help(argv[0]);
return 1;
}
}
if ((argc - optind) != 2) {
show_help(argv[0]);
return 1;
}
host = argv[optind];
port = atoi(argv[optind + 1]);
if(!domain_name_cache_lookup(host, addr)) {
fprintf(stderr, "couldn't lookup address of host %s\n", host);
exit(1);
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
if(rank) {
return worker_main();
} else {
return master_main(host, port, addr);
}
}
int main(int argc, char *argv[])
{
signed char c;
random_init();
install_handler(SIGINT, handle_signal);
install_handler(SIGTERM, handle_signal);
install_handler(SIGQUIT, handle_signal);
install_handler(SIGCHLD, handle_signal);
install_handler(SIGHUP, handle_signal);
debug_config(argv[0]);
while(((c = getopt(argc, argv, "+d:o:O:m:M:s:S:vh")) > -1)) {
switch (c) {
case 'c':
check_interval = string_time_parse(optarg);
break;
case 'd':
debug_flags_set(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'O':
debug_config_file_size(string_metric_parse(optarg));
break;
case 'm':
min_wait_time = string_time_parse(optarg);
break;
case 'M':
max_wait_time = string_time_parse(optarg);
break;
case 's':
start_interval = string_time_parse(optarg);
break;
case 'S':
stop_interval = string_time_parse(optarg);
break;
case 'v':
cctools_version_print(stdout, argv[0]);
exit(0);
break;
case 'h':
default:
show_help(argv[0]);
break;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if(optind >= argc) {
show_help(argv[0]);
return 1;
}
program_argv = &argv[optind];
state_start = time(0);
state = STATE_READY;
if(program_argv[0][0] != '/') {
fprintf(stderr, "watchdog: please give me the full path to %s\n", program_argv[0]);
return 1;
}
while(1) {
time_t time_in_state = time(0) - state_start;
switch (state) {
case STATE_READY:
if(start_program()) {
change_state(STATE_STARTED);
} else {
change_state(STATE_STOPPED);
start_failures++;
}
break;
case STATE_STARTED:
if(program_exited()) {
change_state(STATE_STOPPED);
start_failures++;
} else if(time_in_state > start_interval) {
change_state(STATE_RUNNING);
} else if(want_to_exit) {
change_state(STATE_STOP_WAIT);
}
break;
case STATE_RUNNING:
start_failures = 0;
if(program_exited()) {
change_state(STATE_STOPPED);
} else if(program_changed()) {
change_state(STATE_STOP_WAIT);
} else if(want_to_exit) {
change_state(STATE_STOP_WAIT);
}
break;
case STATE_STOP_WAIT:
send_stop_signal();
if(program_exited()) {
change_state(STATE_STOPPED);
} else if(time_in_state > stop_interval) {
change_state(STATE_KILL_WAIT);
}
break;
case STATE_KILL_WAIT:
send_kill_signal();
if(program_exited()) {
change_state(STATE_STOPPED);
}
break;
case STATE_STOPPED:
if(want_to_exit) {
debug(D_DEBUG, "all done");
exit(0);
} else {
unsigned int wait_time;
int i;
wait_time = min_wait_time;
for(i = 0; i < start_failures; i++) {
wait_time *= 2;
}
if(wait_time > max_wait_time || wait_time < min_wait_time) {
wait_time = max_wait_time;
}
if(time_in_state >= (int) wait_time) {
change_state(STATE_READY);
}
}
break;
default:
fatal("invalid state %d!\n", state);
break;
}
if(state_changes == 0) {
sleep(5);
} else {
state_changes = 0;
}
}
return 1;
}
int main(int argc, char *argv[])
{
struct link *link, *master;
char *subject = 0, *type = 0;
time_t stoptime;
char line[1024];
signed char c;
int portnum = 30000;
char *hostname = 0;
int timeout = 30;
debug_config(argv[0]);
static struct option long_options[] = {
{"auth", required_argument, 0, 'a'},
{"port", required_argument, 0, 'p'},
{"host", required_argument, 0, 'r'},
{"help", required_argument, 0, 'h'},
{"debug-file", required_argument, 0, 'o'},
{"debug-rotate-max", required_argument, 0, 'O'},
{"debug", required_argument, 0, 'd'},
{0,0,0,0}
};
while((c = getopt_long(argc, argv, "a:p:r:d:o:O:", long_options, NULL)) > -1) {
switch (c) {
case 'p':
portnum = atoi(optarg);
break;
case 'h':
show_help(argv[0]);
exit(0);
break;
case 'r':
hostname = optarg;
break;
case 'd':
debug_flags_set(optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'O':
debug_config_file_size(string_metric_parse(optarg));
break;
case 'a':
if(!auth_register_byname(optarg))
fatal("couldn't register %s authentication", optarg);
break;
default:
show_use(argv[0]);
exit(1);
break;
}
}
if(hostname) {
char addr[LINK_ADDRESS_MAX];
stoptime = time(0) + timeout;
if(!domain_name_cache_lookup(hostname, addr))
fatal("unknown host name: %s", hostname);
link = link_connect(addr, portnum, stoptime);
if(!link)
fatal("couldn't connect to %s:%d: %s", hostname, portnum, strerror(errno));
if(auth_assert(link, &type, &subject, stoptime)) {
printf("server thinks I am %s %s\n", type, subject);
if(link_readline(link, line, sizeof(line), stoptime)) {
printf("got message: %s\n", line);
} else {
printf("lost connection!\n");
}
} else {
printf("unable to authenticate.\n");
}
link_close(link);
} else {
stoptime = time(0) + timeout;
master = link_serve(portnum);
if(!master)
fatal("couldn't serve port %d: %s\n", portnum, strerror(errno));
while(time(0) < stoptime) {
link = link_accept(master, stoptime);
if(!link)
continue;
if(auth_accept(link, &type, &subject, stoptime)) {
time_t t = time(0);
link_putfstring(link, "Hello %s:%s, it is now %s", stoptime, type, subject, ctime(&t)); /* ctime ends with newline */
} else {
printf("couldn't auth accept\n");
}
link_close(link);
}
}
return 0;
}