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; }