static int update_one_catalog(void *outgoing_host, const void *text)
{
char addr[DATAGRAM_ADDRESS_MAX];
if(domain_name_cache_lookup(outgoing_host, addr)) {
debug(D_DEBUG, "sending update to %s:%d", outgoing_host, CATALOG_PORT);
datagram_send(outgoing_dgram, text, strlen(text), addr, CATALOG_PORT);
}
return 1;
}
static void catalog_update_udp( const char *host, const char *address, int port, const char *text )
{
debug(D_DEBUG, "sending update via udp to %s(%s):%d", host, address, port);
struct datagram *d = datagram_create(DATAGRAM_PORT_ANY);
if(!d) return;
datagram_send(d, text, strlen(text), address, port);
datagram_delete(d);
}
int advertise_master_to_catalog(const char *catalog_host, int catalog_port, const char *project_name, const char *master_address, struct work_queue_stats *s, struct work_queue_resources *r, const char *workers_by_pool ) {
char address[DATAGRAM_ADDRESS_MAX];
char owner[USERNAME_MAX];
buffer_t *buffer = NULL;
const char *text;
size_t text_size;
if(!outgoing_datagram) {
outgoing_datagram = datagram_create(0);
if(!outgoing_datagram) {
fprintf(stderr, "Failed to advertise master to catalog server: couldn't create outgoing udp datagram!\n");
return 0;
}
}
if(!username_get(owner)) {
strcpy(owner,"unknown");
}
buffer = buffer_create();
int total_workers_working = s->workers_busy + s->workers_full;
int total_workers = total_workers_working + s->workers_ready;
debug(D_WQ,"%s advertising resources to the Catalog -- cores:%d memory:%d disk:%d\n",project_name,r->cores.total,r->memory.total,r->disk.total); //debug to see if information is being passed
buffer_printf(buffer,
"type wq_master\n"
"project %s\nstarttime %llu\npriority %d\n"
"port %d\nlifetime %d\n"
"tasks_waiting %d\ntasks_complete %d\ntasks_running %d\ntotal_tasks_dispatched %d\n"
"workers_init %d\nworkers_ready %d\nworkers_busy %d\nworkers %d\nworkers_by_pool %s\n"
"cores_total %d\nmemory_total %d\ndisk_total %d\n"
"capacity %d\n"
"my_master %s\n"
"version %d.%d.%s\nowner %s",
project_name, (s->start_time)/1000000, s->priority,
s->port, WORK_QUEUE_CATALOG_MASTER_AD_LIFETIME,
s->tasks_waiting, s->total_tasks_complete, s->tasks_running, s->total_tasks_dispatched,
s->workers_init, s->workers_ready, total_workers_working, total_workers, workers_by_pool,
r->cores.total, r->memory.total, r->disk.total,
s->capacity,
master_address,
CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO, owner);
text = buffer_tostring(buffer, &text_size);
if(domain_name_cache_lookup(catalog_host, address)) {
debug(D_WQ, "Advertising master status to the catalog server at %s:%d ...", catalog_host, catalog_port);
datagram_send(outgoing_datagram, text, strlen(text), address, catalog_port);
}
buffer_delete(buffer);
return 1;
}
int advertise_pool_decision_to_catalog(const char *catalog_host, int catalog_port, const char *pool_name, pid_t pid, time_t start_time, const char *decision, int workers_requested)
{
char address[DATAGRAM_ADDRESS_MAX];
char owner[USERNAME_MAX];
buffer_t B;
const char *text;
size_t text_size;
static time_t last_update_time = 0;
if(time(0) - last_update_time < WORK_QUEUE_CATALOG_POOL_UPDATE_INTERVAL) return 1;
if(!outgoing_datagram) {
outgoing_datagram = datagram_create(0);
if(!outgoing_datagram) {
fprintf(stderr, "Couldn't create outgoing udp port, thus work queue master info won't be sent to the catalog server!\n");
return 0;
}
}
if(!username_get(owner)) {
strcpy(owner,"unknown");
}
// port = MAX_TCP_PORT + process id, this is for the catalog server to
// distinguish the worker pools from the same host. See make_hash_key()
// function in catalog_server.c
INT64_T port = 65535 + pid;
buffer_init(&B);
buffer_abortonfailure(&B, 1);
buffer_printf(&B, "type wq_pool\npool_name %s\nport %" PRId64 "\nstarttime %llu\ndecision %s\nworkers_requested %d\nowner %s\nlifetime %d", pool_name, port, (unsigned long long) start_time, decision, workers_requested, owner, WORK_QUEUE_CATALOG_POOL_AD_LIFETIME);
text = buffer_tostring(&B, &text_size);
debug(D_WQ, "Pool AD: \n%s\n", text);
if(domain_name_cache_lookup(catalog_host, address)) {
debug(D_WQ, "Sending the pool decision to the catalog server at %s:%d ...", catalog_host, catalog_port);
datagram_send(outgoing_datagram, text, text_size, address, catalog_port);
}
buffer_free(&B);
last_update_time = time(0);
return 1;
}
int advertise_master_to_catalog(const char *catalog_host, int catalog_port, const char *project_name, struct work_queue_stats *s, const char *workers_by_pool, int now) {
char address[DATAGRAM_ADDRESS_MAX];
char owner[USERNAME_MAX];
buffer_t *buffer = NULL;
const char *text;
size_t text_size;
static time_t last_update_time = 0;
if(!now) {
if(time(0) - last_update_time < WORK_QUEUE_CATALOG_UPDATE_INTERVAL) return 1;
}
if(!outgoing_datagram) {
outgoing_datagram = datagram_create(0);
if(!outgoing_datagram) {
fprintf(stderr, "Failed to advertise master to catalog server: couldn't create outgoing udp datagram!\n");
return 0;
}
}
if(!username_get(owner)) {
strcpy(owner,"unknown");
}
buffer = buffer_create();
buffer_printf(buffer, "type wq_master\nproject %s\nstart_time %llu\npriority %d\nport %d\nlifetime %d\ntasks_waiting %d\ntasks_complete %d\ntask_running %d\ntotal_tasks_dispatched %d\nworkers_init %d\nworkers_ready %d\nworkers_busy %d\nworkers %d\nworkers_by_pool %s\ncapacity %d\nversion %d.%d.%d\nowner %s", project_name, s->start_time, s->priority, s->port, WORK_QUEUE_CATALOG_LIFETIME, s->tasks_waiting, s->total_tasks_complete, s->workers_busy, s->total_tasks_dispatched, s->workers_init, s->workers_ready, s->workers_busy, s->workers_ready + s->workers_busy, workers_by_pool, s->capacity, CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO, owner);
text = buffer_tostring(buffer, &text_size);
if(domain_name_cache_lookup(catalog_host, address)) {
debug(D_WQ, "Advertising master status to the catalog server at %s:%d ...", catalog_host, catalog_port);
datagram_send(outgoing_datagram, text, strlen(text), address, catalog_port);
}
buffer_delete(buffer);
last_update_time = time(0);
return 1;
}
int advertise_pool_decision_to_catalog(const char *catalog_host, int catalog_port, const char *pool_name, const char *decision)
{
char address[DATAGRAM_ADDRESS_MAX];
char owner[USERNAME_MAX];
buffer_t *buffer = NULL;
const char *text;
size_t text_size;
static time_t last_update_time = 0;
if(time(0) - last_update_time < WORK_QUEUE_CATALOG_UPDATE_INTERVAL) return 1;
if(!outgoing_datagram) {
outgoing_datagram = datagram_create(0);
if(!outgoing_datagram) {
fprintf(stderr, "Couldn't create outgoing udp port, thus work queue master info won't be sent to the catalog server!\n");
return 0;
}
}
if(!username_get(owner)) {
strcpy(owner,"unknown");
}
buffer = buffer_create();
buffer_printf(buffer, "type wq_pool\npool_name %s\ndecision %s\nowner %s", pool_name, decision, owner);
text = buffer_tostring(buffer, &text_size);
debug(D_WQ, "Pool AD: \n%s\n", text);
if(domain_name_cache_lookup(catalog_host, address)) {
debug(D_WQ, "Sending the pool decision to the catalog server at %s:%d ...", catalog_host, catalog_port);
datagram_send(outgoing_datagram, text, text_size, address, catalog_port);
}
buffer_delete(buffer);
last_update_time = time(0);
return 1;
}
static int luasocket_datagram_send(lua_State *L){
luasocket_t luasock = lua_touserdata(L,1);
int type = luasock->type;
if(type != _DATAGRAM){
lua_pushstring(L,"invaild socket");
return 1;
}
lua_packet_t pk = lua_getluapacket(L,2);
if(pk->_packet->type == RPACKET){
lua_pushstring(L,"invaild data");
return 1;
}
int ret = -1;
kn_sockaddr to;
if(0 == lua_getaddr(L,3,&to)){
ret = datagram_send(luasock->datagram,(packet_t)pk->_packet,&to);
}
if(ret >= 0)
lua_pushnil(L);
else
lua_pushstring(L,"send error");
pk->_packet = NULL;
return 1;
}
int main(int argc, char *argv[]) {
char *host = CATALOG_HOST;
int port = CATALOG_PORT;
static const struct option long_options[] = {
{"catalog", required_argument, 0, 'c'},
{0,0,0,0}
};
signed int c;
while ((c = getopt_long(argc, argv, "c:", long_options, NULL)) > -1) {
switch (c) {
case 'c':
host = optarg;
break;
default:
show_help(argv[0]);
return EXIT_FAILURE;
}
}
struct datagram *d;
d = datagram_create(DATAGRAM_PORT_ANY);
if (!d) {
fatal("could not create datagram port!");
}
struct utsname name;
int cpus;
int uptime;
double load[3];
UINT64_T memory_total, memory_avail;
char owner[USERNAME_MAX];
uname(&name);
string_tolower(name.sysname);
string_tolower(name.machine);
string_tolower(name.release);
load_average_get(load);
cpus = load_average_get_cpus();
host_memory_info_get(&memory_avail, &memory_total);
uptime = uptime_get();
username_get(owner);
struct jx *j = jx_object(0);
jx_insert_string(j,"type","node");
jx_insert(j,jx_string("version"),jx_format("%d.%d.%d",CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO));
jx_insert_string(j,"cpu",name.machine);
jx_insert_string(j,"opsys",name.sysname);
jx_insert_string(j,"opsysversion",name.release);
jx_insert_double(j,"load1",load[0]);
jx_insert_double(j,"load5",load[1]);
jx_insert_double(j,"load15",load[2]);
jx_insert_integer(j,"memory_total",memory_total);
jx_insert_integer(j,"memory_avail",memory_avail);
jx_insert_integer(j,"cpus",cpus);
jx_insert_integer(j,"uptime,",uptime);
jx_insert_string(j,"owner",owner);
int i;
for (i = optind; i < argc; i++) {
char *name;
char *value;
name = argv[i];
value = strchr(name, '=');
if (!value) {
fatal("invalid name/value pair = %s", name);
} else {
*value++ = 0;
}
jx_insert_string(j,name,value);
}
char *text = jx_print_string(j);
char address[DATAGRAM_ADDRESS_MAX];
if (domain_name_cache_lookup(host, address)) {
datagram_send(d, text, strlen(text), address, port);
} else {
fatal("unable to lookup address of host: %s", host);
}
jx_delete(j);
datagram_delete(d);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
char *host = CATALOG_HOST;
int port = CATALOG_PORT;
static struct option long_options[] = {{"catalog", required_argument, 0, 'c'},
{0,0,0,0}};
signed int c;
while ((c = getopt_long(argc, argv, "c:", long_options, NULL)) > -1) {
switch (c) {
case 'c':
host = optarg;
break;
default:
show_help(argv[0]);
return EXIT_FAILURE;
}
}
struct datagram *d;
d = datagram_create(DATAGRAM_PORT_ANY);
if (!d) {
fatal("could not create datagram port!");
}
buffer_t B;
const char *text;
size_t text_size;
buffer_init(&B);
buffer_abortonfailure(&B, 1);
struct utsname name;
int cpus;
int uptime;
double load[3];
UINT64_T memory_total, memory_avail;
char owner[USERNAME_MAX];
uname(&name);
string_tolower(name.sysname);
string_tolower(name.machine);
string_tolower(name.release);
load_average_get(load);
cpus = load_average_get_cpus();
memory_info_get(&memory_avail, &memory_total);
uptime = uptime_get();
username_get(owner);
buffer_printf(&B, "type %s\nversion %d.%d.%s\ncpu %s\nopsys %s\nopsysversion %s\nload1 %0.02lf\nload5 %0.02lf\nload15 %0.02lf\nmemory_total %llu\nmemory_avail %llu\ncpus %d\nuptime %d\nowner %s\n",
DEFAULT_TYPE,
CCTOOLS_VERSION_MAJOR, CCTOOLS_VERSION_MINOR, CCTOOLS_VERSION_MICRO,
name.machine,
name.sysname,
name.release,
load[0],
load[1],
load[2],
(unsigned long long) memory_total,
(unsigned long long) memory_avail,
cpus,
uptime,
owner
);
int i;
for (i = optind; i < argc; i++) {
char *name;
char *value;
name = argv[i];
value = strchr(name, '=');
if (!value) {
fatal("invalid name/value pair = %s", name);
} else {
*value++ = 0;
}
buffer_printf(&B, "%s %s\n", name, value);
}
text = buffer_tostring(&B, &text_size);
char address[DATAGRAM_ADDRESS_MAX];
if (domain_name_cache_lookup(host, address)) {
datagram_send(d, text, text_size, address, port);
} else {
fatal("unable to lookup address of host: %s", host);
}
buffer_free(&B);
datagram_delete(d);
return EXIT_SUCCESS;
}
