struct link * s3_send_message(struct s3_message *mesg, struct link *server, time_t stoptime) {
char *message_text;
char address[16];
int message_length, data_sent;
if(!server) {
if(!domain_name_cache_lookup(s3_endpoint, address))
return NULL;
server = link_connect(address, 80, stoptime);
}
if(!server)
return NULL;
message_length = s3_message_to_string(mesg, &message_text);
if(message_length <= 0) {
link_close(server);
return NULL;
}
data_sent = link_write(server, message_text, message_length, stoptime);
debug(D_TCP, "S3 Message Sent:\n%s\n", message_text);
free(message_text);
if(data_sent < message_length) {
link_close(server);
server = NULL;
}
return server;
}
struct chirp_client *chirp_client_connect(const char *hostport, int negotiate_auth, time_t stoptime)
{
struct chirp_client *c;
char addr[LINK_ADDRESS_MAX];
char host[DOMAIN_NAME_MAX];
int save_errno;
int port;
if(sscanf(hostport, "%[^:]:%d", host, &port) == 2) {
/* use the split host and port */
} else {
strcpy(host, hostport);
port = CHIRP_PORT;
}
if(!domain_name_cache_lookup(host, addr)) {
errno = ENOENT;
return 0;
}
c = malloc(sizeof(*c));
if(c) {
c->link = link_connect(addr, port, stoptime);
c->broken = 0;
c->serial = global_serial++;
strcpy(c->hostport, hostport);
if(c->link) {
link_tune(c->link, LINK_TUNE_INTERACTIVE);
if(negotiate_auth) {
char *type, *subject;
int result = auth_assert(c->link, &type, &subject, stoptime);
if(result) {
free(type);
free(subject);
return c;
} else {
chirp_client_disconnect(c);
c = 0;
if(time(0) >= stoptime) {
errno = ECONNRESET;
} else {
errno = EACCES;
}
}
} else {
return c;
}
}
save_errno = errno;
free(c);
errno = save_errno;
}
return 0;
}
static int catalog_update_tcp( const char *host, const char *address, int port, const char *text )
{
debug(D_DEBUG, "sending update via tcp to %s(%s):%d", host, address, port);
time_t stoptime = time(0) + 15;
struct link *l = link_connect(address,port,stoptime);
if(!l) {
debug(D_DEBUG, "failed to connect to %s(%s):%d: %s",host,address,port,strerror(errno));
return 0;
}
link_write(l,text,strlen(text),stoptime);
link_close(l);
return 1;
}
int do_direct_query( const char *master_host, int master_port, time_t stoptime )
{
static struct nvpair_header *query_headers[4] = { queue_headers, task_headers, worker_headers, master_resource_headers };
static const char * query_strings[4] = {"queue","task","worker", "master_resource"};
struct nvpair_header *query_header = query_headers[query_mode];
const char * query_string = query_strings[query_mode];
struct link *l;
struct nvpair *nv;
char master_addr[LINK_ADDRESS_MAX];
if(!domain_name_cache_lookup(master_host,master_addr)) {
fprintf(stderr,"couldn't find address of %s\n",master_host);
return 1;
}
l = link_connect(master_addr,master_port,stoptime);
if(!l) {
fprintf(stderr,"couldn't connect to %s port %d: %s\n",master_host,master_port,strerror(errno));
return 1;
}
link_putfstring(l,"%s_status\n",stoptime,query_string);
if(format_mode==FORMAT_TABLE) {
nvpair_print_table_header(stdout, query_header);
}
while((nv = link_nvpair_read(l,stoptime))) {
if(format_mode == FORMAT_TABLE) {
nvpair_print_table(nv, stdout, query_header);
} else {
nvpair_print_text(nv, stdout);
}
nvpair_delete(nv);
}
if(format_mode == FORMAT_TABLE) {
nvpair_print_table_footer(stdout, query_header);
}
return EXIT_SUCCESS;
}
struct list* do_direct_query( const char *master_host, int master_port )
{
const char * query_string = "queue";
struct link *l;
char master_addr[LINK_ADDRESS_MAX];
time_t stoptime = time(0) + work_queue_status_timeout;
if(!domain_name_cache_lookup(master_host,master_addr)) {
fprintf(stderr,"couldn't find address of %s\n",master_host);
return 0;
}
l = link_connect(master_addr,master_port,stoptime);
if(!l) {
fprintf(stderr,"couldn't connect to %s port %d: %s\n",master_host,master_port,strerror(errno));
return 0;
}
link_putfstring(l,"%s_status\n",stoptime,query_string);
struct jx *jarray = jx_parse_link(l,stoptime);
struct jx *j = jarray->u.items->value;
link_close(l);
if(!j) {
fprintf(stderr,"couldn't read from %s port %d: %s\n",master_host,master_port,strerror(errno));
return 0;
}
j->type = JX_OBJECT;
struct list* master_list = list_create();
list_push_head(master_list, j);
return master_list;
}
struct link *http_query_size_via_proxy(const char *proxy, const char *urlin, const char *action, INT64_T * size, time_t stoptime, int cache_reload)
{
char url[HTTP_LINE_MAX];
char newurl[HTTP_LINE_MAX];
char line[HTTP_LINE_MAX];
char addr[LINK_ADDRESS_MAX];
struct link *link;
int save_errno;
int response;
char actual_host[HTTP_LINE_MAX];
int actual_port;
*size = 0;
url_encode(urlin, url, sizeof(url));
if(proxy && !strcmp(proxy, "DIRECT"))
proxy = 0;
if(proxy) {
int fields = sscanf(proxy, "http://%[^:]:%d", actual_host, &actual_port);
if(fields == 2) {
/* host and port are good */
} else if(fields == 1) {
actual_port = HTTP_PORT;
} else {
debug(D_HTTP, "invalid proxy syntax: %s", proxy);
return 0;
}
} else {
int fields = sscanf(url, "http://%[^:]:%d", actual_host, &actual_port);
if(fields != 2) {
fields = sscanf(url, "http://%[^/]", actual_host);
if(fields == 1) {
actual_port = HTTP_PORT;
} else {
debug(D_HTTP, "malformed url: %s", url);
return 0;
}
}
}
debug(D_HTTP, "connect %s port %d", actual_host, actual_port);
if(!domain_name_lookup(actual_host, addr))
return 0;
link = link_connect(addr, actual_port, stoptime);
if(!link) {
errno = ECONNRESET;
return 0;
}
{
buffer_t B;
buffer_init(&B);
buffer_abortonfailure(&B, 1);
buffer_printf(&B, "%s %s HTTP/1.1\r\n", action, url);
if(cache_reload)
buffer_putliteral(&B, "Cache-Control: max-age=0\r\n");
buffer_putliteral(&B, "Connection: close\r\n");
buffer_printf(&B, "Host: %s\r\n", actual_host);
if(getenv("HTTP_USER_AGENT"))
buffer_printf(&B, "User-Agent: Mozilla/5.0 (compatible; CCTools %d.%d.%s Parrot; http://www.nd.edu/~ccl/ %s)\r\n", CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO, getenv("HTTP_USER_AGENT"));
else
buffer_printf(&B, "User-Agent: Mozilla/5.0 (compatible; CCTools %d.%d.%s Parrot; http://www.nd.edu/~ccl/)\r\n", CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO);
buffer_putliteral(&B, "\r\n"); /* header terminator */
debug(D_HTTP, "%s", buffer_tostring(&B, NULL));
link_putstring(link, buffer_tostring(&B, NULL), stoptime);
buffer_free(&B);
}
if(link_readline(link, line, HTTP_LINE_MAX, stoptime)) {
string_chomp(line);
debug(D_HTTP, "%s", line);
if(sscanf(line, "HTTP/%*d.%*d %d", &response) == 1) {
newurl[0] = 0;
while(link_readline(link, line, HTTP_LINE_MAX, stoptime)) {
string_chomp(line);
debug(D_HTTP, "%s", line);
sscanf(line, "Location: %s", newurl);
sscanf(line, "Content-Length: %" SCNd64, size);
if(strlen(line) <= 2) {
break;
}
}
switch (response) {
case 200:
return link;
break;
case 301:
case 302:
case 303:
case 307:
link_close(link);
if(newurl[0]) {
if(!strcmp(url, newurl)) {
debug(D_HTTP, "error: server gave %d redirect from %s back to the same url!", response, url);
errno = EIO;
return 0;
} else {
return http_query_size_via_proxy(proxy,newurl,action,size,stoptime,cache_reload);
}
} else {
errno = ENOENT;
return 0;
}
break;
default:
link_close(link);
errno = http_response_to_errno(response);
return 0;
break;
}
} else {
debug(D_HTTP, "malformed response");
save_errno = ECONNRESET;
}
} else {
debug(D_HTTP, "malformed response");
save_errno = ECONNRESET;
}
link_close(link);
errno = save_errno;
return 0;
}
struct link *http_query_size_via_proxy(const char *proxy, const char *urlin, const char *action, INT64_T * size, time_t stoptime, int cache_reload)
{
char url[HTTP_LINE_MAX];
char newurl[HTTP_LINE_MAX];
char line[HTTP_LINE_MAX];
char addr[LINK_ADDRESS_MAX];
struct link *link;
int save_errno;
int response;
char actual_host[HTTP_LINE_MAX];
int actual_port;
*size = 0;
url_encode(urlin, url, sizeof(url));
if(proxy && !strcmp(proxy, "DIRECT"))
proxy = 0;
if(proxy) {
int fields = sscanf(proxy, "http://%[^:]:%d", actual_host, &actual_port);
if(fields == 2) {
/* host and port are good */
} else if(fields == 1) {
actual_port = HTTP_PORT;
} else {
debug(D_HTTP, "invalid proxy syntax: %s", proxy);
return 0;
}
} else {
int fields = sscanf(url, "http://%[^:]:%d", actual_host, &actual_port);
if(fields != 2) {
fields = sscanf(url, "http://%[^/]", actual_host);
if(fields == 1) {
actual_port = HTTP_PORT;
} else {
debug(D_HTTP, "malformed url: %s", url);
return 0;
}
}
}
debug(D_HTTP, "connect %s port %d", actual_host, actual_port);
if(!domain_name_lookup(actual_host, addr))
return 0;
link = link_connect(addr, actual_port, stoptime);
if(!link) {
errno = ECONNRESET;
return 0;
}
if(cache_reload == 0) {
debug(D_HTTP, "%s %s HTTP/1.0\r\nHost: %s\r\nConnection: close\r\n\r\n", action, url, actual_host);
link_putfstring(link, "%s %s HTTP/1.0\r\nHost: %s\r\nConnection: close\r\n\r\n", stoptime, action, url, actual_host);
} else {
// force refresh of cache end-to-end (RFC 2616)
debug(D_HTTP, "%s %s HTTP/1.1\r\nHost: %s\r\nCache-Control: max-age=0\r\nConnection: close\r\n\r\n", action, url, actual_host);
link_putfstring(link, "%s %s HTTP/1.1\r\nHost: %s\r\nCache-Control: max-age=0\r\nConnection: close\r\n\r\n", stoptime, action, url, actual_host);
}
if(link_readline(link, line, HTTP_LINE_MAX, stoptime)) {
string_chomp(line);
debug(D_HTTP, "%s", line);
if(sscanf(line, "HTTP/%*d.%*d %d", &response) == 1) {
newurl[0] = 0;
while(link_readline(link, line, HTTP_LINE_MAX, stoptime)) {
string_chomp(line);
debug(D_HTTP, "%s", line);
sscanf(line, "Location: %s", newurl);
sscanf(line, "Content-Length: %lld", size);
if(strlen(line) <= 2) {
break;
}
}
switch (response) {
case 200:
return link;
break;
case 301:
case 302:
case 303:
case 307:
link_close(link);
if(newurl[0]) {
if(!strcmp(url, newurl)) {
debug(D_HTTP, "error: server gave %d redirect from %s back to the same url!", response, url);
errno = EIO;
return 0;
} else {
return http_query(newurl, action, stoptime);
}
} else {
errno = ENOENT;
return 0;
}
break;
default:
link_close(link);
errno = http_response_to_errno(response);
return 0;
break;
}
} else {
debug(D_HTTP, "malformed response");
save_errno = ECONNRESET;
}
} else {
debug(D_HTTP, "malformed response");
save_errno = ECONNRESET;
}
link_close(link);
errno = save_errno;
return 0;
}
int main(int argc, char **argv){
signal(SIGALRM, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGTERM, signal_handler);
struct itimerval tv;
tv.it_interval.tv_sec = 0;
tv.it_interval.tv_usec = PACKET_TIME * 1000;
tv.it_value.tv_sec = 0;
tv.it_value.tv_usec = 1;
setitimer(ITIMER_REAL, &tv, NULL); // not accurate
if(argc != 2){
printf("Usage: %s music_file\n", argv[0]);
exit(0);
}
std::string music_file = argv[1];
sf::SoundBuffer sound;
if(!sound.loadFromFile(music_file)){
log_error("invalid music file");
exit(0);
}
int chunk_size = FRAME_SIZE;
int count = sound.getSampleCount();
int rate = sound.getSampleRate();
log_debug("count=%d rate=%d chunk_size=%d %f", count, rate, chunk_size, (float)count/rate);
if(rate != SAMPLE_RATE){
log_error("invalid sample rate %d, it should be %d", rate, SAMPLE_RATE);
exit(0);
}
int sample_size;
if(count % chunk_size == 0){
sample_size = count;
}else{
sample_size = (count/chunk_size + 1) * chunk_size;
log_debug("resize samples to %d", sample_size);
}
sf::Int16 *samples = (sf::Int16 *)malloc(sizeof(sf::Int16) * sample_size);
memcpy(samples, (void *)sound.getSamples(), count * sizeof(sf::Int16));
const sf::Int16 *data = samples;
int seq = 65400;
UdpLink *link = link_connect("127.0.0.1", 10210);
if(!link){
log_error("connect error");
exit(0);
}
uint32_t last_timer_ticks = timer_ticks;
while(!quit){
usleep((PACKET_TIME-5) * 1000);
uint32_t curr_ticks = timer_ticks;
if(last_timer_ticks < curr_ticks){
uint32_t elapsed_ticks = (uint32_t)(curr_ticks - last_timer_ticks);
last_timer_ticks = curr_ticks;
if(elapsed_ticks > 5 * 1000/PACKET_TIME){ // 5 seconds
// something blocks too long
elapsed_ticks = 0;
}else{
for(int i=0; i<elapsed_ticks; i++){
if(data - samples >= count){
data = samples;
}
Packet req;
req.set_type(Packet::PUB);
req.set_seq(seq ++);
req.set_params(Bytes("0", 1), Bytes((char *)data, chunk_size * sizeof(sf::Int16)));
int ret = link->send(req);
log_debug("send %d", ret);
if(ret <= 0){
exit(0);
}
log_debug("offset: %d", data - samples);
data += chunk_size;
}
}
}
}
return 0;
}
int master_main(const char *host, int port, const char *addr) {
time_t idle_stoptime;
struct link *master = NULL;
int num_workers, i;
struct mpi_queue_job **workers;
struct itable *active_jobs = itable_create(0);
struct itable *waiting_jobs = itable_create(0);
struct list *complete_jobs = list_create();
MPI_Comm_size(MPI_COMM_WORLD, &num_workers);
workers = malloc(num_workers * sizeof(*workers));
memset(workers, 0, num_workers * sizeof(*workers));
idle_stoptime = time(0) + idle_timeout;
while(!abort_flag) {
char line[MPI_QUEUE_LINE_MAX];
if(time(0) > idle_stoptime) {
if(master) {
printf("mpi master: gave up after waiting %ds to receive a task.\n", idle_timeout);
} else {
printf("mpi master: gave up after waiting %ds to connect to %s port %d.\n", idle_timeout, host, port);
}
break;
}
if(!master) {
char working_dir[MPI_QUEUE_LINE_MAX];
master = link_connect(addr, port, idle_stoptime);
if(!master) {
sleep(5);
continue;
}
link_tune(master, LINK_TUNE_INTERACTIVE);
link_readline(master, line, sizeof(line), time(0) + active_timeout);
memset(working_dir, 0, MPI_QUEUE_LINE_MAX);
if(sscanf(line, "workdir %s", working_dir) == 1) {
MPI_Bcast(working_dir, MPI_QUEUE_LINE_MAX, MPI_CHAR, 0, MPI_COMM_WORLD);
} else {
link_close(master);
master = NULL;
continue;
}
}
if(link_readline(master, line, sizeof(line), time(0) + short_timeout)) {
struct mpi_queue_operation *op;
int jobid, mode;
INT64_T length;
char path[MPI_QUEUE_LINE_MAX];
op = NULL;
debug(D_MPI, "received: %s\n", line);
if(!strcmp(line, "get results")) {
struct mpi_queue_job *job;
debug(D_MPI, "results requested: %d available\n", list_size(complete_jobs));
link_putfstring(master, "num results %d\n", time(0) + active_timeout, list_size(complete_jobs));
while(list_size(complete_jobs)) {
job = list_pop_head(complete_jobs);
link_putfstring(master, "result %d %d %d %lld\n", time(0) + active_timeout, job->jobid, job->status, job->result, job->output_length);
if(job->output_length) {
link_write(master, job->output, job->output_length, time(0)+active_timeout);
}
mpi_queue_job_delete(job);
}
} else if(sscanf(line, "work %d %lld", &jobid, &length)) {
op = malloc(sizeof(*op));
memset(op, 0, sizeof(*op));
op->type = MPI_QUEUE_OP_WORK;
op->buffer_length = length+1;
op->buffer = malloc(length+1);
op->buffer[op->buffer_length] = 0;
link_read(master, op->buffer, length, time(0) + active_timeout);
op->result = -1;
} else if(sscanf(line, "stat %d %s", &jobid, path) == 2) {
op = malloc(sizeof(*op));
memset(op, 0, sizeof(*op));
op->type = MPI_QUEUE_OP_STAT;
sprintf(op->args, "%s", path);
op->result = -1;
} else if(sscanf(line, "unlink %d %s", &jobid, path) == 2) {
op = malloc(sizeof(*op));
memset(op, 0, sizeof(*op));
op->type = MPI_QUEUE_OP_UNLINK;
sprintf(op->args, "%s", path);
op->result = -1;
} else if(sscanf(line, "mkdir %d %s %o", &jobid, path, &mode) == 3) {
op = malloc(sizeof(*op));
memset(op, 0, sizeof(*op));
op->type = MPI_QUEUE_OP_MKDIR;
sprintf(op->args, "%s %o", path, mode);
op->result = -1;
} else if(sscanf(line, "close %d", &jobid) == 1) {
op = malloc(sizeof(*op));
memset(op, 0, sizeof(*op));
op->type = MPI_QUEUE_OP_CLOSE;
op->result = -1;
// } else if(sscanf(line, "symlink %d %s %s", &jobid, path, filename) == 3) {
// } else if(sscanf(line, "put %d %s %lld %o", &jobid, filename, &length, &mode) == 4) {
// } else if(sscanf(line, "rget %d %s", &jobid, filename) == 2) {
// } else if(sscanf(line, "get %d %s", &jobid, filename) == 2) {
// } else if(sscanf(line, "thirdget %d %d %s %[^\n]", &jobid, &mode, filename, path) == 4) {
// } else if(sscanf(line, "thirdput %d %d %s %[^\n]", &jobid, &mode, filename, path) == 4) {
} else if(!strcmp(line, "exit")) {
break;
} else {
abort_flag = 1;
continue;
}
if(op) {
struct mpi_queue_job *job;
job = itable_lookup(active_jobs, jobid);
if(!job) {
job = itable_lookup(waiting_jobs, jobid);
}
if(!job) {
job = malloc(sizeof(*job));
memset(job, 0, sizeof(*job));
job->jobid = jobid;
job->operations = list_create();
job->status = MPI_QUEUE_JOB_WAITING;
job->worker_rank = -1;
itable_insert(waiting_jobs, jobid, job);
}
list_push_tail(job->operations, op);
}
idle_stoptime = time(0) + idle_timeout;
} else {
link_close(master);
master = 0;
sleep(5);
}
int num_waiting_jobs = itable_size(waiting_jobs);
int num_unvisited_jobs = itable_size(active_jobs);
for(i = 1; i < num_workers && (num_unvisited_jobs > 0 || num_waiting_jobs > 0); i++) {
struct mpi_queue_job *job;
struct mpi_queue_operation *op;
int flag = 0;
UINT64_T jobid;
if(!workers[i]) {
if(num_waiting_jobs) {
itable_firstkey(waiting_jobs);
itable_nextkey(waiting_jobs, &jobid, (void **)&job);
itable_remove(waiting_jobs, jobid);
itable_insert(active_jobs, jobid, job);
workers[i] = job;
num_waiting_jobs--;
job->worker_rank = i;
job->status = MPI_QUEUE_JOB_READY;
} else {
continue;
}
} else {
num_unvisited_jobs--;
if(workers[i]->status == MPI_QUEUE_JOB_BUSY) {
MPI_Test(&workers[i]->request, &flag, &workers[i]->mpi_status);
if(flag) {
op = list_pop_head(workers[i]->operations);
if(op->output_length) {
op->output_buffer = malloc(op->output_length);
MPI_Recv(op->output_buffer, op->output_length, MPI_BYTE, workers[i]->worker_rank, 0, MPI_COMM_WORLD, &workers[i]->mpi_status);
}
workers[i]->status = MPI_QUEUE_JOB_READY;
if(op->type == MPI_QUEUE_OP_WORK || op->result < 0) {
if(workers[i]->output)
free(workers[i]->output);
workers[i]->output = op->output_buffer;
op->output_buffer = NULL;
workers[i]->output_length = op->output_length;
workers[i]->result = op->result;
if(op->result < 0) {
workers[i]->status = MPI_QUEUE_JOB_FAILED | op->type;
op->type = MPI_QUEUE_OP_CLOSE;
list_push_head(workers[i]->operations, op);
op = NULL;
}
}
if(op) {
if(op->buffer)
free(op->buffer);
if(op->output_buffer)
free(op->output_buffer);
free(op);
}
}
}
}
if( workers[i]->status != MPI_QUEUE_JOB_BUSY && list_size(workers[i]->operations)) {
op = list_peek_head(workers[i]->operations);
if(op->type == MPI_QUEUE_OP_CLOSE) {
itable_remove(active_jobs, workers[i]->jobid);
list_push_tail(complete_jobs, workers[i]);
if(!(workers[i]->status & MPI_QUEUE_JOB_FAILED))
workers[i]->status = MPI_QUEUE_JOB_COMPLETE;
workers[i] = NULL;
i--;
continue;
}
MPI_Send(op, sizeof(*op), MPI_BYTE, workers[i]->worker_rank, 0, MPI_COMM_WORLD);
if(op->buffer_length) {
MPI_Send(op->buffer, op->buffer_length, MPI_BYTE, workers[i]->worker_rank, 0, MPI_COMM_WORLD);
free(op->buffer);
op->buffer_length = 0;
op->buffer = NULL;
}
MPI_Irecv(op, sizeof(*op), MPI_BYTE, workers[i]->worker_rank, 0, MPI_COMM_WORLD, &workers[i]->request);
workers[i]->status = MPI_QUEUE_JOB_BUSY;
}
}
}
/** Clean up waiting & complete jobs, send Exit commands to each worker */
if(!master) {
// If the master link hasn't been set up yet
// the workers will be waiting for the working directory
char line[MPI_QUEUE_LINE_MAX];
memset(line, 0, MPI_QUEUE_LINE_MAX);
MPI_Bcast(line, MPI_QUEUE_LINE_MAX, MPI_CHAR, 0, MPI_COMM_WORLD);
} else {
link_close(master);
}
for(i = 1; i < num_workers; i++) {
struct mpi_queue_operation *op, close;
memset(&close, 0, sizeof(close));
close.type = MPI_QUEUE_OP_EXIT;
if(workers[i]) {
if(workers[i]->status == MPI_QUEUE_JOB_BUSY) {
MPI_Wait(&workers[i]->request, &workers[i]->mpi_status);
op = list_peek_head(workers[i]->operations);
if(op->output_length) {
op->output_buffer = malloc(op->output_length);
MPI_Recv(op->output_buffer, op->output_length, MPI_BYTE, workers[i]->worker_rank, 0, MPI_COMM_WORLD, &workers[i]->mpi_status);
}
}
itable_remove(active_jobs, workers[i]->jobid);
list_push_tail(complete_jobs, workers[i]);
}
MPI_Send(&close, sizeof(close), MPI_BYTE, i, 0, MPI_COMM_WORLD);
}
itable_firstkey(waiting_jobs);
while(itable_size(waiting_jobs)) {
struct mpi_queue_job *job;
UINT64_T jobid;
itable_nextkey(waiting_jobs, &jobid, (void **)&job);
itable_remove(waiting_jobs, jobid);
list_push_tail(complete_jobs, job);
}
while(list_size(complete_jobs)) {
mpi_queue_job_delete(list_pop_head(complete_jobs));
}
MPI_Finalize();
return abort_flag;
}
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;
}