static PyObject *
python_pf2string( PyObject *self, PyObject *args ) {
char *usage = "Usage: _stock._pf2string( pfname )\n";
char *pfname;
Pf *pf;
char *value;
PyObject *obj;
char errmsg[STRSZ];
if( ! PyArg_ParseTuple( args, "s", &pfname ) ) {
USAGE;
return NULL;
}
if( ( pf = getPf( pfname ) ) == (Pf *) NULL ) {
sprintf( errmsg, "Failure opening parameter file '%s'\n", pfname );
raise_elog( ELOG_COMPLAIN, errmsg );
return NULL;
}
value = pf2string( pf );
obj = Py_BuildValue( "s", value );
free( value );
return obj;
}
int
main( int argc, char **argv )
{
int c;
int errflag = 0;
int orb;
int stop = 0;
long nrecs;
char *match = ".*/pf/st";
char *from = 0;
char *statefile = 0;
char *pfname = "orb2rrdc";
char *orbname;
char *dbcache;
char *rrdtool;
char command[STRSZ];
char net[STRSZ];
char sta[STRSZ];
char rrdvar[STRSZ];
char key[STRSZ];
char path[FILENAME_MAX];
Dbptr db;
Dbptr dbt;
Pf *pf;
char *Default_network;
Tbl *dlslines;
Arr *Dls_vars_dsparams;
Arr *Dls_vars_rras;
Tbl *Dls_vars_keys;
char *line;
char *dls_var;
char *dsparams;
Tbl *rras;
int i;
int j;
OrbreapThr *ort;
int pktid;
char srcname[ORBSRCNAME_SIZE];
double time = 0;
char *packet = 0;
int nbytes = 0;
int bufsize = 0;
Packet *pkt = 0;
int rc;
char *s;
Pf *dlspf;
Tbl *dlspfkeys;
char *element;
Tbl *parts;
double val;
Pf *pfval = 0;
elog_init( argc, argv );
while( ( c = getopt( argc, argv, "vVd:s:p:m:f:" ) ) != -1 ) {
switch( c ) {
case 'd':
CacheDaemon = optarg;
break;
case 'f':
from = optarg;
break;
case 'm':
match = optarg;
break;
case 'p':
pfname = optarg;
break;
case 's':
statefile = optarg;
break;
case 'v':
Verbose++;
break;
case 'V':
VeryVerbose++;
Verbose++;
break;
default:
elog_complain( 0, "Unknown option '%c'\n", c );
errflag++;
break;
}
}
if( errflag || argc - optind != 2 ) {
usage();
}
if( Verbose ) {
elog_notify( 0, "Starting at %s (%s $Revision$ $Date$)\n",
zepoch2str( str2epoch( "now" ), "%D %T %Z", "" ),
Program_Name );
}
orbname = argv[optind++];
dbcache = argv[optind++];
pfread( pfname, &pf );
rrdtool = pfget_string( pf, "rrdtool" );
if( rrdtool == NULL || ! strcmp( rrdtool, "" ) ) {
elog_die( 0, "Error: no rrdtool executable name specified in parameter file\n" );
} else if( ( rrdtool[0] == '/' && ! is_present( rrdtool ) ) || ( rrdtool[0] != '/' && ! datafile( "PATH", rrdtool ) ) ) {
elog_die( 0, "Error: can't find rrdtool executable by name of '%s' (check PATH environment "
"variable, or absolute path name if given)\n", rrdtool );
} else if( rrdtool[0] == '/' ) {
sprintf( command, "%s -", rrdtool );
} else {
sprintf( command, "rrdtool -" );
}
Suppress_egrep = pfget_string( pf, "suppress_egrep" );
if( Suppress_egrep != NULL && strcmp( Suppress_egrep, "" ) ) {
if( ! datafile( "PATH", "egrep" ) ) {
elog_complain( 0, "Ignoring suppress_egrep parameter: can't find egrep on path\n" );
} else {
sprintf( command, "%s 2>&1 | egrep -v '%s'", command, Suppress_egrep );
}
}
if( VeryVerbose ) {
elog_notify( 0, "Executing command: %s\n", command );
}
Rrdfp = popen( command, "w" );
if( Rrdfp == (FILE *) NULL ) {
elog_die( 0, "Failed to open socket to rrdtool command\n" );
}
orb = orbopen( orbname, "r&" );
if( orb < 0 ) {
elog_die( 0, "Failed to open orb '%s' for reading. Bye.\n", orbname );
}
orbselect( orb, match );
if( from != NULL && statefile == NULL ) {
pktid = orbposition( orb, from );
if( Verbose ) {
elog_notify( 0, "Positioned to packet %d\n", pktid );
}
} else if( from != NULL ) {
elog_complain( 0, "Ignoring -f in favor of existing state file\n" );
}
if( statefile != NULL ) {
stop = 0;
exhume( statefile, &stop, 15, 0 );
orbresurrect( orb, &pktid, &time );
if( Verbose ) {
elog_notify( 0, "Resurrecting state to pktid %d, time %s\n",
pktid, s = strtime( time ) );
free( s );
}
orbseek( orb, pktid );
}
dbopen( dbcache, "r+", &db );
if( db.database < 0 ) {
elog_die( 0, "Failed to open cache database '%s'. Bye.\n", dbcache );
} else {
db = dblookup( db, "", "rrdcache", "", "" );
if( db.table < 0 ) {
elog_die( 0, "Failed to lookup 'rrdcache' table in '%s'. Bye.\n", dbcache );
}
}
dbcrunch( db );
dbt = dbsubset( db, "endtime == NULL", NULL );
Rrd_files = newarr( 0 );
dbquery( dbt, dbRECORD_COUNT, &nrecs );
for( dbt.record = 0; dbt.record < nrecs; dbt.record++ ) {
dbgetv( dbt, 0, "net", &net, "sta", &sta, "rrdvar", &rrdvar, NULL );
dbfilename( dbt, (char *) &path );
sprintf( key, "%s:%s:%s", net, sta, rrdvar );
if( ! is_present( path ) ) {
elog_complain( 0, "WARNING: rrd file '%s', listed in database, does not exist. "
"Removing database entry.\n", path );
dbmark( dbt );
} else {
setarr( Rrd_files, key, strdup( path ) );
if( VeryVerbose ) {
elog_notify( 0, "Re-using rrd file '%s' for '%s'\n", path, key );
}
}
}
Rrdfile_pattern = pfget_string( pf, "rrdfile_pattern" );
Status_stepsize_sec = pfget_double( pf, "status_stepsize_sec" );
Default_network = pfget_string( pf, "default_network" );
dlslines = pfget_tbl( pf, "dls_vars" );
Dls_vars_dsparams = newarr( 0 );
Dls_vars_rras = newarr( 0 );
for( i = 0; i < maxtbl( dlslines ); i++ ) {
line = gettbl( dlslines, i );
strtr( line, "\t", " " );
rras = split( line, ' ' );
dls_var = shifttbl( rras );
dsparams = shifttbl( rras );
setarr( Dls_vars_dsparams, dls_var, dsparams );
setarr( Dls_vars_rras, dls_var, rras );
}
ort = orbreapthr_new( orb, -1., 0 );
for( ; stop == 0; ) {
orbreapthr_get( ort, &pktid, srcname, &time, &packet, &nbytes, &bufsize );
if( statefile ) {
rc = bury();
if( rc < 0 ) {
elog_complain( 0, "Unexpected failure of bury command! "
"(are there two orb2rrdc's running with the same state"
"file?)\n" );
clear_register( 1 );
}
}
rc = unstuffPkt( srcname, time, packet, nbytes, &pkt );
if( rc == Pkt_pf ) {
if( VeryVerbose ) {
/* Parameter files generally too big for elog */
fprintf( stderr, "Received a parameter-file '%s' at %s\n%s\n\n",
srcname,
s = strtime( time ),
pf2string( pkt->pf ) );
free( s );
} else if( Verbose ) {
elog_notify( 0, "Received a parameter-file '%s' at %s\n",
srcname, s = strtime( time ) );
free( s );
}
pfmorph( pkt->pf );
if( VeryVerbose ) {
fprintf( stderr, "Morphed parameter-file '%s' to interpret 'opt':\n%s\n\n",
srcname,
pf2string( pkt->pf ) );
}
pfget( pkt->pf, "dls", (void **) &dlspf );
dlspfkeys = pfkeys( dlspf );
Dls_vars_keys = keysarr( Dls_vars_dsparams );
for( i = 0; i < maxtbl( dlspfkeys ); i++ ) {
element = gettbl( dlspfkeys, i );
if( strcontains( element, "_", 0, 0, 0 ) ) {
parts = split( (s = strdup( element )), '_' );
sprintf( net, "%s", (char *) gettbl( parts, 0 ) );
sprintf( sta, "%s", (char *) gettbl( parts, 1 ) );
free( s );
freetbl( parts, 0 );
} else {
sprintf( net, "%s", Default_network );
sprintf( sta, "%s", element );
}
for( j = 0; j < maxtbl( Dls_vars_keys ); j++ ) {
dls_var = gettbl( Dls_vars_keys, j );
sprintf( key, "%s{%s}", element, dls_var );
if( pfresolve( dlspf, key, 0, &pfval ) < 0 ) {
elog_complain( 0, "Unable to extract variable '%s' "
"(not present or wrong type) from element '%s' "
"in packet from '%s', timestamped '%s'; Skipping\n",
key, element, srcname, s = strtime( time ) );
free( s );
pfval = 0;
continue;
} else if( pfval != (Pf *) NULL &&
pfval->value.s != (char *) NULL &&
! strcmp( pfval->value.s, "-" ) ) {
if( VeryVerbose ) {
elog_notify( 0, "Non-floating point value '-' in variable '%s', "
"in packet from '%s', timestamped '%s'; Skipping data point\n",
key, srcname, s = strtime( time ) );
free( s );
}
continue;
} else {
val = pfget_double( dlspf, key );
}
archive_dlsvar( db, net, sta, dls_var,
(char *) getarr( Dls_vars_dsparams, dls_var ),
(Tbl *) getarr( Dls_vars_rras, dls_var ),
time, val );
}
}
freetbl( dlspfkeys, 0 );
freetbl( Dls_vars_keys, 0 );
} else if( rc == Pkt_stash ) {
; /* Do nothing */
} else {
if( Verbose ) {
elog_notify( 0, "Received a packet that's not a parameter file "
"(type '%d' from unstuffPkt); skipping\n", rc );
}
}
}
}
Pf *
pforbstat( int orbfd, int flags )
{
Pf *pf = 0;
Pf *pfans;
Orbstat *orbstatus = 0;
Orbsrc *sources = 0;
Orbclient *clients = 0;
double atime;
int orbversion;
int nsources = 0;
int nclients = 0;
char *s;
if( orbfd <= 0 ) {
return (Pf *) NULL;
}
if( flags & PFORBSTAT_CONNECTIONS ) {
flags |= PFORBSTAT_CLIENTS;
}
if( flags & PFORBSTAT_DATABASES ) {
flags |= PFORBSTAT_CLIENTS;
}
orbping( orbfd, &orbversion );
pf = pfnew( PFFILE );
pfput_double( pf, "pforbstat_version", PFORBSTAT_VERSION );
if( flags & PFORBSTAT_SERVER ) {
orbstat( orbfd, &orbstatus );
pfans = orbstat2pf( orbstatus, orbversion );
pfput( pf, "server", pfans, PFPF );
}
if( flags & PFORBSTAT_SOURCES ) {
orbsources( orbfd, &atime, &sources, &nsources );
pfans = orbsources2pf( atime, sources, nsources );
pfcompile( s = pf2string( pfans ), &pf );
free( s );
pffree( pfans );
}
if( flags & PFORBSTAT_CLIENTS ) {
orbclients( orbfd, &atime, &clients, &nclients );
pfans = orbclients2pf( atime, clients, nclients );
pfcompile( s = pf2string( pfans ), &pf );
free( s );
id_clients( pf );
pffree( pfans );
}
if( flags & PFORBSTAT_CONNECTIONS ) {
pfans = orbconnections2pf( pf );
pfcompile( s = pf2string( pfans ), &pf );
free( s );
pffree( pfans );
}
if( flags & PFORBSTAT_DATABASES ) {
pfans = orbdatabases2pf( pf );
pfcompile( s = pf2string( pfans ), &pf );
free( s );
pffree( pfans );
}
return pf;
}
/* This little routine dumps the parameter space of pf and the output
tbls of ggnloc to a log file tagged by orid. Note, however, that
if ggnloc failed for some reason, it is assumed that orid will be set
to a NEGATIVE number. When this occurs, the results are written to
a "failures" directory defined in rtopts.
IMPORTANT: multiple instances of orbgenloc should arrange to write
in seperate failure directories or they can collide.
*/
int write_to_logfile(RTlocate_Options rtopts, int orid, int evid,
Pf *pf, Tbl *converge_history, Tbl *reason_converged,Tbl *residual)
{
char fname[256];
FILE *fp;
/* We write the logfile output as a pf object copying
code from sgnloc */
Pf *pflog;
Tbl *t; /* formatted output tbl of hypo convergence history */
char *line;
int i;
Hypocenter *hypos;
/* This can fail for very long directory entries, but it
isn't worth messing with in my mind. Note switch for
orid */
if(orid > 0)
{
sprintf(fname,"%s/orid%d.pf",rtopts.logdir,orid);
}
else
{
sprintf(fname,"%s/%s/evid%d.pf",rtopts.logdir,
rtopts.failure_sdir,evid);
}
pfwrite(fname,pf);
/* Here we encapsulate the convergence history information into
a second pf object, and write this onto the same pf file */
t = newtbl(maxtbl(converge_history));
for(i=0;i<maxtbl(converge_history);++i)
{
hypos = (Hypocenter *)gettbl(converge_history,i);
line = format_hypo(hypos);
pushtbl(t,line);
}
pflog = pfnew(PFFILE);
pfput_tbl(pflog,"convergence_history",t);
printf("Reasons for convergence:\n");
for(i=0;i<maxtbl(reason_converged);++i)
printf("%s\n",gettbl(reason_converged,i));
pfput_tbl(pflog,"convergence_criteria",reason_converged);
pfput_tbl(pflog,"residuals",residual);
/* We use pf2string rather than pfwrite since I'm not
sure what pfwrite will do when the file already exists.
Here we just append the new pf info to the end of the
stuff written above. */
if((fp=fopen(fname,"a")) == NULL)
{
elog_complain(1,"Cannot open log file %s\n",fname);
return(1);
}
fseek(fp,0L,SEEK_END);
line = pf2string(pflog);
fwrite(line,1,strlen(line),fp);
fclose(fp);
free(line);
pffree(pflog);
freetbl(t,free);
return(0);
}
