int main(int argc, char *argv[])
{
int did_explicit_auth = 0;
int follow_mode = 0;
int whole_file_mode = 1;
const char *hostname, *source_file, *target_file;
time_t stoptime;
FILE *file;
int c;
char *tickets = NULL;
debug_config(argv[0]);
static struct option long_options[] = {
{"auth", required_argument, 0, 'a'},
{"block-size", required_argument, 0, 'b'},
{"debug", required_argument, 0, 'd'},
{"follow", no_argument, 0, 'f'},
{"tickets", required_argument, 0, 'i'},
{"timeout", required_argument, 0, 't'},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
while((c = getopt_long(argc, argv, "a:b:d:fi:t:vh", long_options, NULL)) > -1) {
switch (c) {
case 'a':
auth_register_byname(optarg);
did_explicit_auth = 1;
break;
case 'b':
buffer_size = (size_t)strtoul(optarg, NULL, 0);
break;
case 'd':
debug_flags_set(optarg);
break;
case 'f':
follow_mode = 1;
break;
case 'i':
tickets = strdup(optarg);
break;
case 't':
timeout = string_time_parse(optarg);
break;
case 'v':
cctools_version_print(stdout, argv[0]);
exit(0);
break;
case 'h':
show_help(argv[0]);
exit(0);
break;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if(!did_explicit_auth)
auth_register_all();
if(tickets) {
auth_ticket_load(tickets);
free(tickets);
} else if(getenv(CHIRP_CLIENT_TICKETS)) {
auth_ticket_load(getenv(CHIRP_CLIENT_TICKETS));
} else {
auth_ticket_load(NULL);
}
if((argc - optind) < 3) {
show_help(argv[0]);
exit(0);
}
source_file = argv[optind];
hostname = argv[optind + 1];
target_file = argv[optind + 2];
stoptime = time(0) + timeout;
if(!strcmp(source_file, "-")) {
file = stdin;
source_file = "/dev/stdin";
} else {
file = fopen(source_file, "r");
if(!file) {
fprintf(stderr, "chirp_put: couldn't open %s: %s\n", source_file, strerror(errno));
return 1;
}
}
if(follow_mode)
whole_file_mode = 0;
if(whole_file_mode) {
INT64_T result = chirp_recursive_put(hostname, source_file, target_file, stoptime);
if(result < 0) {
fprintf(stderr, "chirp_put: couldn't put %s to host %s: %s\n", source_file, hostname, strerror(errno));
return 1;
} else {
return 0;
}
} else {
struct chirp_stream *stream;
char *buffer = xxmalloc(buffer_size);
INT64_T ractual, wactual;
stream = chirp_stream_open(hostname, target_file, CHIRP_STREAM_WRITE, stoptime);
if(!stream) {
fprintf(stderr, "chirp_put: couldn't open %s for writing: %s\n", target_file, strerror(errno));
return 1;
}
while(1) {
ractual = full_fread(file, buffer, buffer_size);
if(ractual == 0) {
if(follow_mode) {
debug(D_DEBUG, "waiting for more data...");
sleep(1);
continue;
} else {
break;
}
}
wactual = chirp_stream_write(stream, buffer, (int)ractual, stoptime);
if(wactual != ractual) {
fprintf(stderr, "chirp_put: couldn't write to %s: %s\n", target_file, strerror(errno));
return 1;
}
}
chirp_stream_close(stream, stoptime);
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[])
{
char c;
int did_explicit_auth = 0;
char *tickets = NULL;
struct fuse_args fa;
fa.argc = 0;
fa.argv = string_array_new();
fa.allocated = 1;
debug_config(argv[0]);
while((c = getopt(argc, argv, "a:b:d:Dfhi:m:o:t:v")) != -1) {
switch (c) {
case 'd':
debug_flags_set(optarg);
break;
case 'D':
enable_small_file_optimizations = 0;
break;
case 'b':
chirp_reli_blocksize_set(atoi(optarg));
break;
case 'i':
tickets = xxstrdup(optarg);
break;
case 'm':
fa.argc += 1;
fa.argv = string_array_append(fa.argv, optarg);
break;
case 'o':
debug_config_file(optarg);
break;
case 'a':
auth_register_byname(optarg);
did_explicit_auth = 1;
break;
case 't':
chirp_fuse_timeout = string_time_parse(optarg);
break;
case 'f':
run_in_foreground = 1;
break;
case 'v':
cctools_version_print(stdout, argv[0]);
return 0;
break;
case 'h':
default:
show_help(argv[0]);
return 1;
break;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if((argc - optind) != 1) {
show_help(argv[0]);
return 1;
}
fuse_mountpoint = argv[optind];
if(!did_explicit_auth)
auth_register_all();
if(tickets) {
auth_ticket_load(tickets);
free(tickets);
} else if(getenv(CHIRP_CLIENT_TICKETS)) {
auth_ticket_load(getenv(CHIRP_CLIENT_TICKETS));
} else {
auth_ticket_load(NULL);
}
file_table = itable_create(0);
signal(SIGHUP, exit_handler);
signal(SIGINT, exit_handler);
signal(SIGTERM, exit_handler);
fuse_chan = fuse_mount(fuse_mountpoint, &fa);
if(!fuse_chan) {
fprintf(stderr, "chirp_fuse: couldn't access %s\n", fuse_mountpoint);
return 1;
}
fuse_instance = fuse_new(fuse_chan, &fa, &chirp_fuse_operations, sizeof(chirp_fuse_operations), 0);
if(!fuse_instance) {
fuse_unmount(fuse_mountpoint, fuse_chan);
fprintf(stderr, "chirp_fuse: couldn't access %s\n", fuse_mountpoint);
return 1;
}
printf("chirp_fuse: mounted chirp on %s\n", fuse_mountpoint);
#ifdef CCTOOLS_OPSYS_DARWIN
printf("chirp_fuse: to unmount: umount %s\n", fuse_mountpoint);
#else
printf("chirp_fuse: to unmount: fusermount -u %s\n", fuse_mountpoint);
#endif
fflush(0);
if(!run_in_foreground)
daemon(0, 0);
fuse_loop(fuse_instance);
fuse_unmount(fuse_mountpoint, fuse_chan);
fuse_destroy(fuse_instance);
free(fa.argv);
return 0;
}
int main(int argc, char *argv[])
{
int did_explicit_auth = 0;
time_t stoptime;
char c;
int i, srcindex, nstreams;
FILE *localfile;
struct chirp_stream *stream[argc - 2];
const char *localmode;
int remotemode;
debug_config(argv[0]);
while((c = getopt(argc, argv, "a:b:d:t:vh")) != (char) -1) {
switch (c) {
case 'a':
auth_register_byname(optarg);
did_explicit_auth = 1;
break;
case 'b':
buffer_size = atoi(optarg);
break;
case 'd':
debug_flags_set(optarg);
break;
case 't':
timeout = string_time_parse(optarg);
break;
case 'v':
show_version(argv[0]);
exit(0);
break;
case 'h':
show_help(argv[0]);
exit(0);
break;
}
}
if(!did_explicit_auth)
auth_register_all();
if((argc - optind) < 4) {
show_help(argv[0]);
return 1;
}
if(!strcmp(argv[optind], "split")) {
stream_mode = MODE_SPLIT;
localmode = "r";
remotemode = CHIRP_STREAM_WRITE;
} else if(!strcmp(argv[optind], "copy")) {
stream_mode = MODE_COPY;
localmode = "r";
remotemode = CHIRP_STREAM_WRITE;
} else if(!strcmp(argv[optind], "join")) {
stream_mode = MODE_JOIN;
localmode = "w";
remotemode = CHIRP_STREAM_READ;
} else {
fprintf(stderr, "unknown operation: %s\n", argv[0]);
show_help(argv[0]);
return 1;
}
char *buffer = malloc(buffer_size);
srcindex = optind + 1;
nstreams = (argc - optind - 2) / 2;
stoptime = time(0) + timeout;
localfile = fopen(argv[srcindex], localmode);
if(!localfile) {
fprintf(stderr, "couldn't open %s: %s\n", argv[srcindex], strerror(errno));
return 1;
}
char **hostname = malloc(sizeof(*hostname) * nstreams);
char **filename = malloc(sizeof(*filename) * nstreams);
for(i = 0; i < nstreams; i++) {
hostname[i] = argv[srcindex + (2 * i) + 1];
filename[i] = argv[srcindex + (2 * i) + 2];
stream[i] = chirp_stream_open(hostname[i], filename[i], remotemode, stoptime);
if(!stream[i]) {
fprintf(stderr, "couldn't open %s:%s: %s\n", hostname[i], filename[i], strerror(errno));
return 1;
}
}
if(stream_mode == MODE_SPLIT) {
i = 0;
while(fgets(buffer, buffer_size, localfile)) {
int length = strlen(buffer);
int actual = chirp_stream_write(stream[i], buffer, length, stoptime);
if(actual != length) {
fprintf(stderr, "couldn't write to %s:%s: %s\n", hostname[i], filename[i], strerror(errno));
return 1;
}
i = (i + 1) % nstreams;
}
} else if(stream_mode == MODE_COPY) {
while(fgets(buffer, buffer_size, localfile)) {
int length = strlen(buffer);
for(i = 0; i < nstreams; i++) {
int actual = chirp_stream_write(stream[i], buffer, length, stoptime);
if(actual != length) {
fprintf(stderr, "couldn't write to %s:%s: %s\n", hostname[i], filename[i], strerror(errno));
return 1;
}
}
}
} else {
int streams_left = nstreams;
while(streams_left > 0) {
for(i = 0; i < nstreams; i++) {
if(!stream[i])
continue;
int length = chirp_stream_readline(stream[i], buffer, buffer_size, stoptime);
if(length > 0) {
length = strlen(buffer);
fprintf(localfile, "%s\n", buffer);
} else {
streams_left--;
}
}
}
}
for(i = 0; i < nstreams; i++) {
chirp_stream_flush(stream[i], stoptime);
chirp_stream_close(stream[i], stoptime);
}
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;
}
int main(int argc, char *argv[])
{
int did_explicit_auth = 0;
int follow_mode = 0;
time_t stoptime;
signed char c;
int setAindex, setBindex; // funcindex;
FILE *setA = NULL;
FILE *setB = NULL;
char setApath[CHIRP_PATH_MAX];
char setBpath[CHIRP_PATH_MAX];
char *LIST_FILE_NAME = "set.list";
char setAfilename[CHIRP_PATH_MAX];
char setBfilename[CHIRP_PATH_MAX];
int len = CHIRP_PATH_MAX;
struct chirp_matrix *mat = NULL;
int mathost, matpath;
double *resbuff = NULL;
int numels;
int cntr;
// Variables defined by Li
int i; // for multiprocess calculation
int numOfMovingElements, numOfStableElements;
//int setACount, setBCount;
int setAPos, setBPos;
long setAStartPos;
//long setBStartPos;
int x1, y1, x2, y2, topLeftX, topLeftY; // [x1,y1]-start position, [x2,y2]-end position, the sub matrix we compute in a round
int x_rel, y_rel;
double threshold;
double threshold_min = 0;
double threshold_max = 1;
double threshold_interval = 0.2;
int count_thresholds;
int count_genuine = 0;
int count_impostar = 0;
//int count_fa = 0;
//int count_fr = 0;
double (*roc_data)[3];
int subject_equal;
// ~Variables defined by Li
int w, h, e, n;
w = 10;
h = 10;
e = 8;
n = 1;
x1 = y1 = x2 = y2 = -1;
topLeftX = topLeftY = 0;
debug_config(argv[0]);
while((c = getopt(argc, argv, "a:b:d:ft:vhw:i:e:n:x:y:p:q:r:s:X:Y:c:")) > -1) {
switch (c) {
case 'a':
auth_register_byname(optarg);
did_explicit_auth = 1;
break;
case 'b':
buffer_size = atoi(optarg);
break;
case 'd':
debug_flags_set(optarg);
break;
case 'f':
follow_mode = 1;
break;
case 't':
timeout = string_time_parse(optarg);
break;
case 'w':
w = atoi(optarg);
break;
case 'i':
h = atoi(optarg);
break;
case 'e':
e = atoi(optarg);
break;
case 'n':
n = atoi(optarg);
break;
case 'v':
cctools_version_print(stdout, argv[0]);
exit(0);
break;
case 'h':
show_help(argv[0]);
exit(0);
break;
case 'x':
numOfStableElements = atoi(optarg);
break;
case 'y':
numOfMovingElements = atoi(optarg);
break;
case 'p':
x1 = atoi(optarg);
break;
case 'q':
y1 = atoi(optarg);
break;
case 'r':
x2 = atoi(optarg);
break;
case 's':
y2 = atoi(optarg);
break;
case 'X':
topLeftX = atoi(optarg);
break;
case 'Y':
topLeftY = atoi(optarg);
break;
case 'c':
//numOfCores = atoi(optarg);
break;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if(!did_explicit_auth)
auth_register_all();
if((argc - optind) < 4) {
fprintf(stderr, "after all options, you must have: setA setB function mathost matpath\n");
exit(0);
}
stoptime = time(0) + timeout;
setAindex = optind;
setBindex = optind + 1;
mathost = optind + 2;
matpath = optind + 3;
// Set threshhold min, max and interval
threshold_min = 0;
threshold_max = 1;
threshold_interval = 0.01;
// Initialize result array - roc_data
count_thresholds = (threshold_max - threshold_min) / threshold_interval + 1;
roc_data = malloc(count_thresholds * 3 * sizeof(double));
if(!roc_data) {
fprintf(stderr, "Cannot initialize result buffer!\n");
exit(1);
}
for(i = 0, threshold = threshold_min; i < count_thresholds; i++, threshold += threshold_interval) {
roc_data[i][0] = threshold;
}
// Load matrix to be verified
printf("X1,X2,Y1,Y2: %i,%i,%i,%i\n", x1, x2, y1, y2);
mat = chirp_matrix_open(argv[mathost], argv[matpath], stoptime);
if(mat == NULL) {
fprintf(stderr, "No such matrix. Fail.\n");
exit(1);
}
printf("Start loading matrix ... \n");
printf("Width, height: %d, %d\n\n", chirp_matrix_width(mat), chirp_matrix_height(mat));
numels = (x2 - x1 + 1) * (y2 - y1 + 1);
resbuff = (double *) malloc(numels * sizeof(double));
double *pilot_resbuff;
pilot_resbuff = resbuff;
// TODO get_range function can get at most 10*10 matrix a time (actually it can get more)
/**
for(j=0; j<y2-y1+1; j++) {
for(i=0; i<x2-x1+1; i++) {
int matrtn = chirp_matrix_get_range( mat, x1+i, y1+j, 1, 1, pilot_resbuff, stoptime); //(x2-x1+1), (y2-y1+1), resbuff, stoptime );
printf("%.2f\t", (*pilot_resbuff));
if(matrtn == -1) printf("return mat error @ [%d, %d]!!\n", x1+i, y1+j);
pilot_resbuff++;
}
printf("\n");
}*/
int matrtn = chirp_matrix_get_range(mat, x1, y1, x2 - x1 + 1, y2 - y1 + 1, resbuff, stoptime); //(x2-x1+1), (y2-y1+1), resbuff, stoptime );
if(matrtn == -1) {
fprintf(stderr, "return mat error @ [%d, %d], width: %d; height: %d!\n", x1, y1, x2 - x1 + 1, y2 - y1 + 1);
exit(1);
}
printf("*******end of loading matrix********\n\n");
// Get local path for data sets directories
if(get_local_path(setApath, argv[setAindex], stoptime) != 0 || get_local_path(setBpath, argv[setBindex], stoptime) != 0) {
fprintf(stderr, "Paths to data sets are invalid!\n");
exit(1);
}
// setA and setB each contains a list of file names that points to the data files
char setAlistfile[CHIRP_PATH_MAX];
char setBlistfile[CHIRP_PATH_MAX];
strcpy(setAlistfile, setApath);
strcat(setAlistfile, LIST_FILE_NAME);
if((setA = fopen(setAlistfile, "r")) == NULL) {
fprintf(stderr, "Cannot open data set A list file - %s!\n", setAlistfile);
exit(1);
}
strcpy(setBlistfile, setBpath);
strcat(setBlistfile, LIST_FILE_NAME);
if((setB = fopen(setBlistfile, "r")) == NULL) {
fprintf(stderr, "Cannot open data set B list file - %s!\n", setBlistfile);
exit(1);
}
// Initialize position parameters and allocate memory for storing results of a block (sub matrix)
x_rel = y_rel = 0; // relative to the sub-matrix we are actually working on
// Go forward until line x1 in Set A list file
for(i = 0; i < x1 && !feof(setA); i++) {
fgets(setAfilename, len, setA);
}
if(i < x1) {
fprintf(stderr, "Set A has less then x1 elements!\n");
exit(1);
}
setAStartPos = ftell(setA);
// Go forward until line y1 in Set B list file
for(i = 0; i < y1 && !feof(setB); i++) {
fgets(setBfilename, len, setB);
}
if(i < y1) {
fprintf(stderr, "Set B has less then x1 elements!\n");
exit(1);
}
//setBStartPos = ftell(setB);
debug(D_CHIRP, "Matrix data:\n");
// start loop
fgets(setBfilename, len, setB);
if(setBfilename != NULL) {
size_t last = strlen(setBfilename) - 1;
if(setBfilename[last] == '\n')
setBfilename[last] = '\0';
}
for(setBPos = y1; !feof(setB) && setBPos <= y2; setBPos++) { // Set B - column of matrix
// Go directly to line y1 in Set B list file
fseek(setA, setAStartPos, SEEK_SET);
fgets(setAfilename, len, setA);
if(setAfilename != NULL) {
size_t last = strlen(setAfilename) - 1;
if(setAfilename[last] == '\n')
setAfilename[last] = '\0';
}
setAPos = x1;
for(setAPos = x1; !feof(setA) && setAPos <= x2; setAPos++) { // Set A- row of matrix
// Threshhold comparison
cntr = ((setBPos - y1) * (x2 - x1 + 1)) + (setAPos - x1);
subject_equal = isSubjectIdEqual(setAfilename, setBfilename);
if(subject_equal == 1) { // A genuine match
for(threshold = threshold_max, i = count_thresholds - 1; 1 - resbuff[cntr] < threshold; threshold -= threshold_interval, i--) {
// False reject
roc_data[i][1] += 1;
}
count_genuine++;
} else if(subject_equal == 0) { // A impostar match
for(threshold = threshold_min, i = 0; 1 - resbuff[cntr] >= threshold; threshold += threshold_interval, i++) {
// False accept
roc_data[i][2] += 1;
}
count_impostar++;
} else {
fprintf(stderr, "Cannot resolve filename in either %s or %s!\n", setAfilename, setBfilename);
exit(1);
}
debug(D_CHIRP, "%.2f\t", resbuff[cntr]);
fgets(setAfilename, len, setA);
if(setAfilename != NULL) {
size_t last = strlen(setAfilename) - 1;
if(setAfilename[last] == '\n')
setAfilename[last] = '\0';
}
}
debug(D_CHIRP, "\n");
fgets(setBfilename, len, setB);
if(setBfilename != NULL) {
size_t last = strlen(setBfilename) - 1;
if(setBfilename[last] == '\n')
setBfilename[last] = '\0';
}
}
printf("\n**********************************************************************\n");
// Printf roc_data
debug(D_CHIRP, "ROC raw data format: Threshold | False reject count | False accept count\n");
for(i = 0; i < count_thresholds; i++) {
debug(D_CHIRP, "%.2f\t%.2f\t%.2f;\t", roc_data[i][0], roc_data[i][1], roc_data[i][2]);
}
debug(D_CHIRP, "\n");
// Transform roc_data to ROC curve data
for(i = 0; i < count_thresholds; i++) {
roc_data[i][1] = 1 - (roc_data[i][1] / count_genuine); // 1 - FRR
roc_data[i][2] = roc_data[i][2] / count_impostar; // FAR
}
// Printf roc_data
debug(D_CHIRP, "ROC curve data format: Threshold | 1 - False reject rate | False accept rate\n");
for(i = 0; i < count_thresholds; i++) {
debug(D_CHIRP, "%.2f\t%.2f\t%.2f;\t", roc_data[i][0], roc_data[i][1], roc_data[i][2]);
}
debug(D_CHIRP, "\n");
// Write to dat file for gnuplot's use
FILE *roc_data_fp;
//char roc_line[20];
roc_data_fp = fopen("roc.dat", "w");
for(i = 0; i < count_thresholds; i++) {
fprintf(roc_data_fp, "%.2f\t%.2f\n", roc_data[i][1], roc_data[i][2]); // 1 - FRR, FAR
}
fclose(roc_data_fp);
free(resbuff);
debug(D_CHIRP, "%d comparisons in the matrix are tested! Genuine matches: %d\t Impostar matches: %d\n\n", cntr + 1, count_genuine, count_impostar);
printf("\nROC curve data generation completed successfully!\n%d comparisons in the matrix are tested!\n", cntr + 1);
return 0;
}
int main( int argc, char *argv[] )
{
const char *dbdir=0;
const char *dbfile=0;
struct jx *where_expr = 0;
struct jx *filter_expr = 0;
struct list *output_exprs = list_create();
struct list *reduce_exprs = list_create();
time_t start_time = 0;
time_t stop_time = 0;
int display_every = 0;
int epoch_mode = 0;
char reduce_name[1024];
char reduce_attr[1024];
time_t current = time(0);
int c;
while((c=getopt_long(argc,argv,"D:L:o:w:f:F:T:e:tvh",long_options,0))!=-1) {
switch(c) {
case 'D':
dbdir = optarg;
break;
case 'L':
dbfile = optarg;
break;
case 'o':
if(2==sscanf(optarg,"%[^(](%[^)])",reduce_name,reduce_attr)) {
struct jx *reduce_expr = jx_parse_string(reduce_attr);
if(!reduce_expr) {
fprintf(stderr,"deltadb_query: invalid expression: %s\n",reduce_attr);
return 1;
}
struct deltadb_reduction *r = deltadb_reduction_create(reduce_name,reduce_expr);
if(!r) {
fprintf(stderr,"deltadb_query: invalid reduction: %s\n",reduce_name);
return 1;
}
list_push_tail(reduce_exprs,r);
} else {
struct jx *j = jx_parse_string(optarg);
if(!j) {
fprintf(stderr,"invalid expression: %s\n",optarg);
return 1;
}
list_push_tail(output_exprs,j);
}
break;
case 'w':
if(where_expr) {
fprintf(stderr,"Only one --where expression is allowed. Try joining the expressions with the && (and) operator.");
return 1;
}
where_expr = jx_parse_string(optarg);
if(!where_expr) {
fprintf(stderr,"invalid expression: %s\n",optarg);
return 1;
}
break;
case 'f':
if(filter_expr) {
fprintf(stderr,"Only one --filter expression is allowed. Try joining the expressions with the && (and) operator.");
return 1;
}
filter_expr = jx_parse_string(optarg);
if(!filter_expr) {
fprintf(stderr,"invalid expression: %s\n",optarg);
return 1;
}
break;
case 'F':
start_time = parse_time(optarg,current);
break;
case 'T':
stop_time = parse_time(optarg,current);
break;
case 'e':
display_every = string_time_parse(optarg);
break;
case 't':
epoch_mode = 1;
break;
case 'v':
cctools_version_print(stdout,"deltadb_query");
break;
case 'h':
show_help();
break;
}
}
if(!dbdir && !dbfile) {
fprintf(stderr,"deltadb_query: either --db or --file argument is required\n");
return 1;
}
if(start_time==0) {
fprintf(stderr,"deltadb_query: invalid --from time (must be \"YY-MM-DD\" or \"YY-MM-DD HH:MM:SS\")\n");
return 1;
}
if(stop_time==0) {
stop_time = time(0);
}
struct deltadb *db = deltadb_create(dbdir);
db->where_expr = where_expr;
db->filter_expr = filter_expr;
db->epoch_mode = epoch_mode;
db->output_exprs = output_exprs;
db->reduce_exprs = reduce_exprs;
db->display_every = display_every;
if(list_size(db->reduce_exprs) && list_size(db->output_exprs) ) {
struct deltadb_reduction *r = db->reduce_exprs->head->data;
const char *name = jx_print_string(db->output_exprs->head->data);
fprintf(stderr,"deltadb_query: cannot mix reductions like 'MAX(%s)' with plain outputs like '%s'\n",jx_print_string(r->expr),name);
return 1;
}
if(list_size(db->reduce_exprs)) {
display_mode = MODE_REDUCE;
} else if(list_size(db->output_exprs)) {
display_mode = MODE_OBJECT;
} else {
display_mode = MODE_STREAM;
}
if(dbfile) {
FILE *file = fopen(dbfile,"r");
if(!file) {
fprintf(stderr,"deltadb_query: couldn't open %s: %s\n",dbfile,strerror(errno));
return 1;
}
deltadb_process_stream(db,file,start_time,stop_time);
fclose(file);
} else {
log_play_time(db,start_time,stop_time);
}
return 0;
}
int main(int argc, char *argv[])
{
int did_explicit_auth = 0;
int stdout_mode = 0;
const char *hostname, *source_file, *target_file;
time_t stoptime;
FILE *file;
INT64_T result;
char c;
char *tickets = NULL;
debug_config(argv[0]);
while((c = getopt(argc, argv, "a:d:i:t:vh")) != (char) -1) {
switch (c) {
case 'a':
auth_register_byname(optarg);
did_explicit_auth = 1;
break;
case 'd':
debug_flags_set(optarg);
break;
case 'i':
tickets = strdup(optarg);
break;
case 't':
timeout = string_time_parse(optarg);
break;
case 'v':
show_version(argv[0]);
exit(0);
break;
case 'h':
show_help(argv[0]);
exit(0);
break;
}
}
if(!did_explicit_auth)
auth_register_all();
if(tickets) {
auth_ticket_load(tickets);
free(tickets);
} else if(getenv(CHIRP_CLIENT_TICKETS)) {
auth_ticket_load(getenv(CHIRP_CLIENT_TICKETS));
} else {
auth_ticket_load(NULL);
}
if((argc - optind) < 3) {
show_help(argv[0]);
exit(0);
}
hostname = argv[optind];
source_file = argv[optind + 1];
target_file = argv[optind + 2];
stoptime = time(0) + timeout;
if(!strcmp(target_file, "-")) {
stdout_mode = 1;
file = stdout;
}
if(stdout_mode) {
result = chirp_reli_getfile(hostname, source_file, file, stoptime);
} else {
result = chirp_recursive_get(hostname, source_file, target_file, stoptime);
}
if(result < 0) {
fprintf(stderr, "couldn't get %s:%s: %s\n", hostname, source_file, strerror(errno));
return 1;
} else {
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;
}
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;
}
/*
* Obtains information from the Catalog, format it, and make return it to user.
*/
int main(int argc, char** argv) {
static const struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"project", required_argument, 0, 'N'},
{"server", required_argument, 0, 's'},
{"timeout", required_argument, 0, 't'},
{"username", required_argument, 0, 'u'},
{0, 0, 0, 0}
};
struct catalog_query *q;
struct jx *j;
int c;
unsigned int i;
time_t timeout = 60;
char* catalog_host = NULL;
char* username = NULL;
char* project = NULL;
char* server = NULL;
while ((c = getopt_long(argc, argv, "N:t:u:w:s:h", long_options, NULL)) > -1) {
switch (c) {
case 'N':
project = xxstrdup(optarg);
break;
case 't':
timeout = string_time_parse(optarg);
break;
case 'u':
username = xxstrdup(optarg);
break;
case 's':
server = xxstrdup(optarg);
break;
case 'h':
default:
show_help(argv[0]);
return 1;
}
}
//setup address
if(server==NULL){
catalog_host = CATALOG_HOST;
}
//make query
struct jx *jexpr = jx_operator(
JX_OP_EQ,
jx_symbol("type"),
jx_string("makeflow")
);
if (project) {
jexpr = jx_operator(
JX_OP_AND,
jexpr,
jx_operator(
JX_OP_EQ,
jx_symbol("project"),
jx_string(project)
)
);
}
if (username) {
jexpr = jx_operator(
JX_OP_AND,
jexpr,
jx_operator(
JX_OP_EQ,
jx_symbol("username"),
jx_string(username)
)
);
}
time_t stoptime = time(0) + timeout;
unsigned int count = 0;
//create catalog_query from jx
q = catalog_query_create(catalog_host, jexpr, stoptime);
if (!q) {
fprintf(stderr, "couldn't query catalog: %s\n", strerror(errno));
return 1;
}
while ((j = catalog_query_read(q, stoptime))) {
table[count++] = j;
}
catalog_query_delete(q);//all done with connection
//sort
qsort(table, count, sizeof(*table), (int (*)(const void *, const void *)) compare_entries);
//print them out
printf("%-10s %-18s %6s %6s %6s %6s %6s %6s %6s\n",
"OWNER", "PROJECT", "JOBS", "WAIT", "RUN", "COMP", "ABRT", "FAIL", "TYPE");
for(i=0; i<count; i++){
printf("%-10s %-18s %6" PRId64 " %6" PRId64 " %6" PRId64 " %6" PRId64 " %6" PRId64 " %6" PRId64 " %6s\n",
jx_lookup_string(table[i], "owner"),
jx_lookup_string(table[i], "project"),
jx_lookup_integer(table[i], "total"),
jx_lookup_integer(table[i], "waiting"),
jx_lookup_integer(table[i], "running"),
jx_lookup_integer(table[i], "completed"),
jx_lookup_integer(table[i], "aborted"),
jx_lookup_integer(table[i], "failed"),
jx_lookup_string(table[i], "batch_type")
);
}
printf("\n");//be polite
//cleanup
for(i=0;i<count;i++) {
jx_delete(table[i]);
}
//done
return (EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
char *temp;
int did_explicit_auth = 0;
char *tickets = NULL;
char prompt[CHIRP_LINE_MAX];
char line[CHIRP_LINE_MAX];
char **user_argv = 0;
int user_argc;
signed char c;
int result = 0;
debug_config(argv[0]);
static struct option long_options[] = {
{"auth", required_argument, 0, 'a'},
{"debug", required_argument, 0, 'd'},
{"tickets", required_argument, 0, 'i'},
{"verbose", no_argument, 0, 'l'},
{"timeout", required_argument, 0, 't'},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
while((c = getopt_long(argc, argv, "+a:d:hi:lt:v", long_options, NULL)) > -1) {
switch (c) {
case 'a':
auth_register_byname(optarg);
did_explicit_auth = 1;
break;
case 'd':
debug_flags_set(optarg);
break;
case 'h':
show_help(argv[0]);
exit(0);
break;
case 'i':
tickets = strdup(optarg);
break;
case 'l':
long_information = 1;
break;
case 't':
timeout = string_time_parse(optarg);
break;
case 'v':
cctools_version_print(stdout, argv[0]);
exit(0);
break;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if(!did_explicit_auth)
auth_register_all();
if(tickets) {
auth_ticket_load(tickets);
free(tickets);
} else if(getenv(CHIRP_CLIENT_TICKETS)) {
auth_ticket_load(getenv(CHIRP_CLIENT_TICKETS));
} else {
auth_ticket_load(NULL);
}
getcwd(current_local_dir, CHIRP_PATH_MAX);
/* interactive mode if input is a TTY but we are not simply executing a
* command from argv */
interactive_mode = isatty(0) && !((argc - optind) > 1);
if(optind < argc) {
stoptime = time(0) + timeout;
if(do_open(1, &argv[optind - 1])) {
fprintf(stderr, "couldn't open %s: %s\n", argv[optind], strerror(errno));
return 1;
}
}
if((argc - optind) > 1) {
return !process_command(argc - optind - 1, &argv[optind + 1]);
}
while(1) {
if(interactive_mode) {
sprintf(prompt, " chirp:%s:%s> ", current_host, current_remote_dir);
} else {
prompt[0] = 0;
}
#ifdef HAS_LIBREADLINE
temp = readline(prompt);
if(!temp)
break;
strcpy(line, temp);
free(temp);
#else
printf("%s", prompt);
fflush(stdout);
if(!fgets(line, CHIRP_LINE_MAX, stdin))
break;
#endif
if(!line[0])
continue;
if(!interactive_mode && (temp = strchr(line, '#'))) { /* comment? */
for(temp--; temp > line && isspace((int) *temp); temp--); /* preceding space? */
if(temp <= line)
continue; /* else not comment */
}
#ifdef HAS_LIBREADLINE
add_history(line);
#endif
{
char *start = line, *last = strlen(line) + line;
while(*start != '\0') { /* process compound commands */
char *end = strchr(start, ';');
while(end != NULL && end != start && *(end - 1) == '\\')
end = strchr(end + 1, ';');
if(end == NULL)
end = start + strlen(start);
*end = '\0';
if(user_argv)
free(user_argv);
string_split(start, &user_argc, &user_argv);
if(user_argc == 0) {
start++;
continue;
}
result = process_command(user_argc, user_argv);
start = end == last ? last : end + 1;
}
}
if(!interactive_mode && !result)
break;
}
if(result) {
return 0;
} else {
return 1;
}
}
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[])
{
int did_explicit_auth = 0;
time_t stoptime;
signed char c;
int i, srcindex, nstreams;
FILE *localfile;
struct chirp_stream *stream[argc - 2];
const char *localmode;
int remotemode;
char *tickets = NULL;
debug_config(argv[0]);
static struct option long_options[] = {
{"auth", required_argument, 0, 'a'},
{"block-size", required_argument, 0, 'b'},
{"debug", required_argument, 0, 'd'},
{"tickets", required_argument, 0, 'i'},
{"timeout", required_argument, 0, 't'},
{"version", no_argument, 0, 'v'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0}
};
while((c = getopt_long(argc, argv, "a:b:d:i:t:vh", long_options, NULL)) > -1) {
switch (c) {
case 'a':
auth_register_byname(optarg);
did_explicit_auth = 1;
break;
case 'b':
buffer_size = atoi(optarg);
break;
case 'd':
debug_flags_set(optarg);
break;
case 'i':
tickets = strdup(optarg);
break;
case 't':
timeout = string_time_parse(optarg);
break;
case 'v':
cctools_version_print(stdout, argv[0]);
exit(0);
break;
case 'h':
show_help(argv[0]);
exit(0);
break;
}
}
cctools_version_debug(D_DEBUG, argv[0]);
if(!did_explicit_auth)
auth_register_all();
if(tickets) {
auth_ticket_load(tickets);
free(tickets);
} else if(getenv(CHIRP_CLIENT_TICKETS)) {
auth_ticket_load(getenv(CHIRP_CLIENT_TICKETS));
} else {
auth_ticket_load(NULL);
}
if((argc - optind) < 4) {
show_help(argv[0]);
return 1;
}
if(!strcmp(argv[optind], "split")) {
stream_mode = MODE_SPLIT;
localmode = "r";
remotemode = CHIRP_STREAM_WRITE;
} else if(!strcmp(argv[optind], "copy")) {
stream_mode = MODE_COPY;
localmode = "r";
remotemode = CHIRP_STREAM_WRITE;
} else if(!strcmp(argv[optind], "join")) {
stream_mode = MODE_JOIN;
localmode = "w";
remotemode = CHIRP_STREAM_READ;
} else {
fprintf(stderr, "unknown operation: %s\n", argv[0]);
show_help(argv[0]);
return 1;
}
char *buffer = malloc(buffer_size);
srcindex = optind + 1;
nstreams = (argc - optind - 2) / 2;
stoptime = time(0) + timeout;
localfile = fopen(argv[srcindex], localmode);
if(!localfile) {
fprintf(stderr, "couldn't open %s: %s\n", argv[srcindex], strerror(errno));
return 1;
}
char **hostname = malloc(sizeof(*hostname) * nstreams);
char **filename = malloc(sizeof(*filename) * nstreams);
for(i = 0; i < nstreams; i++) {
hostname[i] = argv[srcindex + (2 * i) + 1];
filename[i] = argv[srcindex + (2 * i) + 2];
stream[i] = chirp_stream_open(hostname[i], filename[i], remotemode, stoptime);
if(!stream[i]) {
fprintf(stderr, "couldn't open %s:%s: %s\n", hostname[i], filename[i], strerror(errno));
return 1;
}
}
if(stream_mode == MODE_SPLIT) {
i = 0;
while(fgets(buffer, buffer_size, localfile)) {
int length = strlen(buffer);
int actual = chirp_stream_write(stream[i], buffer, length, stoptime);
if(actual != length) {
fprintf(stderr, "couldn't write to %s:%s: %s\n", hostname[i], filename[i], strerror(errno));
return 1;
}
i = (i + 1) % nstreams;
}
} else if(stream_mode == MODE_COPY) {
while(fgets(buffer, buffer_size, localfile)) {
int length = strlen(buffer);
for(i = 0; i < nstreams; i++) {
int actual = chirp_stream_write(stream[i], buffer, length, stoptime);
if(actual != length) {
fprintf(stderr, "couldn't write to %s:%s: %s\n", hostname[i], filename[i], strerror(errno));
return 1;
}
}
}
} else {
int streams_left = nstreams;
while(streams_left > 0) {
for(i = 0; i < nstreams; i++) {
if(!stream[i])
continue;
int length = chirp_stream_readline(stream[i], buffer, buffer_size, stoptime);
if(length > 0) {
length = strlen(buffer);
fprintf(localfile, "%s\n", buffer);
} else {
streams_left--;
}
}
}
}
for(i = 0; i < nstreams; i++) {
chirp_stream_flush(stream[i], stoptime);
chirp_stream_close(stream[i], stoptime);
}
return 0;
}
