int nvpair_parse_stream_limited(struct nvpair *n, FILE * stream, char ** attr_list, int attr_len)
{
int num_pairs = 0;
char line[NVPAIR_LINE_MAX];
char name[NVPAIR_LINE_MAX];
char value[NVPAIR_LINE_MAX];
while(fgets(line, sizeof(line), stream)) {
if(line[0] == '.') {
return -1;
} else if(line[0] == '\n') {
return num_pairs;
}
if(sscanf(line, "%s %[^\r\n]", name, value) == 2) {
int i, include = 0;
for(i=0; i<attr_len; i++){
if(strcmp(name,attr_list[i])==0){
include = 1;
break;
}
}
if ( include>0 || strcmp(name,"key")==0 ){
nvpair_insert_string(n, name, value);
num_pairs += 1;
}
} else {
debug(D_DEBUG,"corrupt log data: %s",line);
//return 0;
}
}
return 0;
}
int my_foreman(int *space, const char *host, int port, time_t stoptime)
{
int i = 0; //global_catalog iterator
char full_address[1024];
if(!domain_name_cache_lookup(host, full_address) || !full_address)
{
debug(D_WQ,"Could not resolve %s into an ip address\n",host);
return 0;
}
sprintf(full_address, "%s:%d", full_address, port);
while(global_catalog[i] != NULL){
const char *temp_my_master = nvpair_lookup_string(global_catalog[i], "my_master");
if(temp_my_master && !strcmp(temp_my_master, full_address)){
char modified_proj[50];
memset(modified_proj,0,sizeof(modified_proj));
space_relations(*space, modified_proj); //append '->' for proper recursive depth
sprintf(modified_proj,"%s%s",modified_proj,nvpair_lookup_string(global_catalog[i], "project")); //prepare modified project name with proper depth
nvpair_remove(global_catalog[i], nvpair_lookup_string(global_catalog[i], "project")); //remove old project look
nvpair_insert_string(global_catalog[i], "project", modified_proj); //replace with the modified relation version
if(resource_mode){
nvpair_print_table(global_catalog[i], stdout, master_resource_headers);
}else if(format_mode == FORMAT_TABLE){
nvpair_print_table(global_catalog[i], stdout, queue_headers);
}
int new_space = *space + 1; //so that spaces are preserved in recursive calls
my_foreman(&new_space,nvpair_lookup_string(global_catalog[i], "name"),atoi(nvpair_lookup_string(global_catalog[i], "port")),stoptime);
}
i++;
}
return 1;
}
struct nvpair * jx_to_nvpair( struct jx *object )
{
struct nvpair *nv = nvpair_create();
struct jx_pair *p;
for(p=object->pairs;p;p=p->next) {
if(p->value->type==JX_STRING) {
nvpair_insert_string(nv,p->key->string_value,p->value->string_value);
} else {
char *s = jx_print_string(p->value);
nvpair_insert_string(nv,p->key->string_value,s);
free(s);
}
}
return nv;
}
static int log_replay( struct nvpair_database *db, const char *filename, time_t snapshot)
{
FILE *file = fopen(filename,"r");
if(!file) return 0;
time_t current = 0;
struct nvpair *nv;
char line[NVPAIR_LINE_MAX];
char key[NVPAIR_LINE_MAX];
char name[NVPAIR_LINE_MAX];
char value[NVPAIR_LINE_MAX];
char oper;
while(fgets(line,sizeof(line),file)) {
int n = sscanf(line,"%c %s %s %[^\n]",&oper,key,name,value);
if(n<1) continue;
switch(oper) {
case 'C':
nv = nvpair_create();
nvpair_parse_stream(nv,file);
nvpair_delete(hash_table_remove(db->table,name));
hash_table_insert(db->table,key,nv);
break;
case 'D':
nv = hash_table_remove(db->table,key);
if(nv) nvpair_delete(nv);
break;
case 'U':
nv = hash_table_lookup(db->table,key);
if(nv) nvpair_insert_string(nv,name,value);
break;
case 'R':
nv = hash_table_lookup(db->table,key);
if(nv) nvpair_remove(nv,name);
break;
case 'T':
current = atol(key);
if(current>snapshot) break;
break;
default:
debug(D_NOTICE,"corrupt log data in %s: %s",filename,line);
break;
}
}
fclose(file);
return 1;
}
int nvpair_parse_stream(struct nvpair *n, FILE * stream)
{
int num_pairs = 0;
char line[NVPAIR_LINE_MAX];
char name[NVPAIR_LINE_MAX];
char value[NVPAIR_LINE_MAX];
char key[NVPAIR_LINE_MAX];
key[0] = '\0';
while(fgets(line, sizeof(line), stream)) {
if(line[0] == '\n') {
if (strlen(key)==0){
sprintf(key,"%s:%s:%s",nvpair_lookup_string(n,"address"),nvpair_lookup_string(n,"port"),nvpair_lookup_string(n,"name"));
nvpair_insert_string(n, "key", key);
}
if (num_pairs){
return num_pairs;
} else {
continue;
}
}
if(sscanf(line, "%s %[^\r\n]", name, value) == 2) {
if (strcmp(name,"key")==0)
strcpy(key,value);
//printf("-----%s,%s\n",name,value);
nvpair_insert_string(n, name, value);
num_pairs += 1;
} else {
debug(D_DEBUG,"corrupt log data: %s",line);
//return 0;
}
}
return 0;
}
void nvpair_parse(struct nvpair *n, const char *data)
{
char *text = xxstrdup(data);
char *name, *value;
name = strtok(text, " ");
while(name) {
value = strtok(0, "\n");
if(value) {
nvpair_insert_string(n, name, value);
} else {
break;
}
name = strtok(0, " ");
}
free(text);
}
struct nvpair * dag_node_env_create( struct dag *d, struct dag_node *n )
{
struct dag_variable_lookup_set s = { d, n->category, n, NULL };
char *key;
struct nvpair *nv = 0;
set_first_element(d->export_vars);
while((key = set_next_element(d->export_vars))) {
char *value = dag_variable_lookup_string(key, &s);
if(value) {
if(!nv) nv = nvpair_create();
nvpair_insert_string(nv,key,value);
debug(D_MAKEFLOW_RUN, "export %s=%s", key, value);
}
}
return nv;
}
static void handle_updates(struct datagram *update_port)
{
char data[DATAGRAM_PAYLOAD_MAX * 2];
char addr[DATAGRAM_ADDRESS_MAX];
char key[LINE_MAX];
int port;
int result;
struct nvpair *nv;
while(1) {
result = datagram_recv(update_port, data, DATAGRAM_PAYLOAD_MAX, addr, &port, 0);
if(result <= 0)
return;
data[result] = 0;
nv = nvpair_create();
nvpair_parse(nv, data);
nvpair_insert_string(nv, "address", addr);
nvpair_insert_integer(nv, "lastheardfrom", time(0));
/* If the server reports unbelievable numbers, simply reset them */
if(max_server_size > 0) {
INT64_T total = nvpair_lookup_integer(nv, "total");
INT64_T avail = nvpair_lookup_integer(nv, "avail");
if(total > max_server_size || avail > max_server_size) {
nvpair_insert_integer(nv, "total", max_server_size);
nvpair_insert_integer(nv, "avail", max_server_size);
}
}
/* Do not believe the server's reported name, just resolve it backwards. */
char name[DOMAIN_NAME_MAX];
if(domain_name_cache_lookup_reverse(addr, name)) {
nvpair_insert_string(nv, "name", name);
} else if (nvpair_lookup_string(nv, "name") == NULL) {
/* If rDNS is unsuccessful, then we use the name reported if given.
* This allows for hostnames that are only valid in the subnet of
* the reporting server. Here we set the "name" field to the IP
* Address, addr, because it was not set by the reporting server.
*/
nvpair_insert_string(nv, "name", addr);
}
make_hash_key(nv, key);
if(logfile) {
if(!nvpair_database_lookup(table,key)) {
nvpair_print_text(nv,logfile);
fflush(logfile);
}
}
nvpair_database_insert(table, key, nv);
debug(D_DEBUG, "received udp update from %s", key);
}
}
void nvpair_insert_float(struct nvpair *n, const char *name, double fvalue)
{
char value[256];
sprintf(value, "%lf", fvalue);
nvpair_insert_string(n, name, (char *) value);
}
void nvpair_insert_integer(struct nvpair *n, const char *name, INT64_T ivalue)
{
char value[256];
sprintf(value, INT64_FORMAT, ivalue);
nvpair_insert_string(n, name, (char *) value);
}
static int log_play( struct deltadb *db, FILE *stream )
{
time_t current = 0;
time_t previous_time = 0;
int line_number = 0;
char line[NVPAIR_LINE_MAX];
char key[NVPAIR_LINE_MAX];
char name[NVPAIR_LINE_MAX];
char value[NVPAIR_LINE_MAX];
char oper;
while(fgets(line,sizeof(line),stream)) {
//debug(D_NOTICE,"Processed line: %s",line);
line_number += 1;
if (line[0]=='\n') break;
int n = sscanf(line,"%c %s %s %[^\n]",&oper,key,name,value);
if(n<1) continue;
struct nvpair *nv;
switch(oper) {
case 'C':
nv = nvpair_create();
int num_pairs = nvpair_parse_stream(nv,stream);
if(num_pairs>0) {
nvpair_delete(hash_table_remove(db->table,key));
hash_table_insert(db->table,key,nv);
} else if (num_pairs == -1) {
nvpair_delete(nv);
break;
} else {
nvpair_delete(nv);
}
break;
case 'D':
nv = hash_table_remove(db->table,key);
if(nv) nvpair_delete(nv);
break;
case 'U':
nv = hash_table_lookup(db->table,key);
if(nv) nvpair_insert_string(nv,name,value);
break;
case 'R':
nv = hash_table_lookup(db->table,key);
if(nv) nvpair_remove(nv,name);
break;
case 'T':
previous_time = current;
current = atol(key);
emit_table_values(db,previous_time);
break;
default:
debug(D_NOTICE,"corrupt log data[%i]: %s",line_number,line);
fflush(stderr);
break;
}
}
emit_table_values(db,current);
return 1;
}
/*
Replay a given log file into the hash table, up to the given snapshot time.
Return true if the stoptime was reached.
*/
static int log_play( struct deltadb *db, FILE *stream )
{
struct nvpair *nv;
char line[NVPAIR_LINE_MAX];
char key[NVPAIR_LINE_MAX];
char name[NVPAIR_LINE_MAX];
char value[NVPAIR_LINE_MAX];
char oper;
int first_output = 1;
time_t previous_time = 0;
while(fgets(line,sizeof(line),stream)) {
//debug(D_NOTICE,"Processed line: %s",line);
int n = sscanf(line,"%c %s %s %[^\n]",&oper,key,name,value);
if(n<1) continue;
if(line[0]=='\n') break;
switch(oper) {
case 'C':
nv = nvpair_create();
nvpair_parse_stream(nv,stream);
nvpair_delete(hash_table_remove(db->table,name));
hash_table_insert(db->table,key,nv);
break;
case 'D':
nv = hash_table_remove(db->table,key);
if(nv) nvpair_delete(nv);
break;
case 'U':
nv = hash_table_lookup(db->table,key);
if(nv) nvpair_insert_string(nv,name,value);
break;
case 'R':
nv = hash_table_lookup(db->table,key);
if(nv) nvpair_remove(nv,name);
break;
case 'T':
current = atol(key);
break;
default:
debug(D_NOTICE,"corrupt log data: %s",line);
break;
}
if (previous_time==0){
previous_time = current;
} else if(previous_time!=current) {
emit_all_deltadb_reductions(db,previous_time,first_output);
first_output = 0;
previous_time = current;
}
}
emit_all_deltadb_reductions(db,previous_time,first_output);
return 0;
}
