/******************************************************************************
 *  orb2eworm_lookup( )   Look up important info from earthworm.h tables       *
 ******************************************************************************/
void 
orb2eworm_lookup( void )
{
	/*
	 * Look up keys to shared memory regions 
	 */
	if ( ( RingKey = GetKey( RingName ) ) == -1 ) 
	{
		fprintf( stderr,
		"orb2eworm:  Invalid ring name <%s>; exiting!\n", RingName );
		exit( -1 );
	}
	/*
	 * Look up installations of interest 
	 */
	if ( GetLocalInst( &InstId ) != 0 ) 
	{
		fprintf( stderr,
		"orb2eworm: error getting local installation id; exiting!\n" );
		exit( -1 );
	}
	/*
	 * Look up modules of interest 
	 */
	if ( GetModId( MyModName, &MyModId ) != 0 ) 
	{
		fprintf( stderr,
		"orb2eworm: Invalid module name <%s>; exiting!\n", MyModName );
		exit( -1 );
	}
	/*
	 * Look up message types of interest 
	 */
	if ( GetType( "TYPE_HEARTBEAT", &TypeHeartBeat ) != 0 ) 
	{
		fprintf( stderr,
		"orb2eworm: Invalid message type <TYPE_HEARTBEAT>; exiting!\n" );
		exit( -1 );
	}
	if ( GetType( "TYPE_ERROR", &TypeError ) != 0 ) 
	{
		fprintf( stderr,
		"orb2eworm: Invalid message type <TYPE_ERROR>; exiting!\n" );
		exit( -1 );
	}
	if ( GetType( "TYPE_TRACEBUF", &TypeTracebuf ) != 0 ) 
	{
		fprintf( stderr,
		"orb2eworm: Invalid message type <TYPE_TRACEBUF>; exiting!\n" );
		exit( -1 );
	}
	return;
}
Example #2
0
int main(int argc, char *argv[] )
{
	/* Change working directory to environment variable EW_PARAMS value
	 *    ****************************************************************/

	char *runPath;

	runPath = getenv( "EW_PARAMS" );

	if ( runPath == NULL )
	{
		fprintf(stderr, "status: Environment variable EW_PARAMS not defined." );
		fprintf(stderr, " Exiting.\n" );
		return -1;
	}

	if ( *runPath == '\0' )
	{
		fprintf(stderr, "status: Environment variable EW_PARAMS " );
		fprintf(stderr, "defined, but has no value. Exiting.\n" );
		return -1;
	}
	if ( chdir_ew( runPath ) == -1 )
	{
		fprintf(stderr, "status: Params directory not found: %s\n", runPath );
		fprintf(stderr, "status: Reset environment variable EW_PARAMS." );
		fprintf(stderr, " Exiting.\n" );
		return -1;
	}
	/* Look up ids in earthworm.d tables
	 *  ***********************************/
	if ( GetLocalInst( &InstId ) != 0 )
	{
		fprintf( stderr,
				"status: error getting local installation id; exiting!\n" );
		return -1;
	}

	if ( GetModId( "MOD_STATUS", &MyModId ) != 0 )
	{
		fprintf( stderr,
				"status: Invalid module id <MOD_STATUS> exiting!\n" );
		return -1;
	}

	if ( GetType( "TYPE_REQSTATUS", &TypeReqStatus ) != 0 )
	{
		fprintf( stderr,
				"status: Invalid message type <TYPE_REQSTATUS> exiting!\n" );
		return -1;
	}
	if ( GetType( "TYPE_STATUS", &TypeStatus ) != 0 )
	{
		fprintf( stderr,
				"status: Invalid message type <TYPE_STATUS> exiting!\n" );
		return -1;
	}	
	char  ringname[MAX_RING_STR];
	char configFile[FILENAME_MAX] = DEF_CONFIG;
	ReadRingName( ringname, configFile );

if( (ringKey = GetKey(ringname)) == -1 )
   {
       printf( "status: Invalid ring name <%s>. Exiting.\n",
                ringname );
       return -1;
   }


	  printf("RING NAME %s Ring key %d\n",ringname,ringKey);
	printf("nChild %d\n", metaring.statmgr_location);
int i;
//	printf("nChild %d\n",nChild);
	 for ( i = 0; i < nChild; i++ )
   {
#ifdef _SOLARIS
        /* To prevent starting statmgr a second time, we'll just skip over it
 *          If it's not there, then the index to skip defaults to one past MAXCHILD, so
 *                   no other modules will be skipped. */
         if (i != metaring.statmgr_location)
         {
#endif /* _SOLARIS */
            ConstructIds( child[i].use_uname,
                          child[i].use_gname,
                          &child[i].use_uid,
                          &child[i].use_gid );
		printf("Child \n");

#ifdef _SOLARIS
         }
#endif /* _SOLARIS */
   }





	return 0;
}
Example #3
0
main( int argc, char *argv[] )
{

	char *runPath;
	char  ringname[MAX_RING_STR];
	char configFile[FILENAME_MAX] = DEF_CONFIG;
	FILE *stream;

	/* Check the number of arguments.
	 ******************************/
	if ( argc == 3 )
	{
		strcpy ( configFile, argv[1] );
		if (strncasecmp(argv[2], "-r", 2) == 0 || strncasecmp(argv[2], "/r", 2) == 0)
		{
			redirect = 1;
		}
	}
	else if ( argc == 2 )
	{
		if (strncasecmp(argv[1], "-r", 2) == 0 || strncasecmp(argv[1], "/r", 2) == 0)
			redirect = 1;
		else
			strcpy ( configFile, argv[1] );
	}
	else
	{
		fprintf ( stderr, "using default config file %s\n", configFile );

	}

	/* Change working directory to environment variable EW_PARAMS value
	 ****************************************************************/
	runPath = getenv( "EW_PARAMS" );

	if ( runPath == NULL )
	{
		fprintf(stderr, "status: Environment variable EW_PARAMS not defined." );
		fprintf(stderr, " Exiting.\n" );
		return -1;
	}

	if ( *runPath == '\0' )
	{
		fprintf(stderr, "status: Environment variable EW_PARAMS " );
		fprintf(stderr, "defined, but has no value. Exiting.\n" );
		return -1;
	}

	if ( chdir_ew( runPath ) == -1 )
	{
		fprintf(stderr, "status: Params directory not found: %s\n", runPath );
		fprintf(stderr, "status: Reset environment variable EW_PARAMS." );
		fprintf(stderr, " Exiting.\n" );
		return -1;
	}

	/* Look up ids in earthworm.d tables
	 ***********************************/
	if ( GetLocalInst( &InstId ) != 0 )
	{
		fprintf( stderr,
				"status: error getting local installation id; exiting!\n" );
		return -1;
	}

	if ( GetModId( "MOD_STATUS", &MyModId ) != 0 )
	{
		fprintf( stderr,
				"status: Invalid module id <MOD_STATUS> exiting!\n" );
		return -1;
	}

	if ( GetType( "TYPE_REQSTATUS", &TypeReqStatus ) != 0 )
	{
		fprintf( stderr,
				"status: Invalid message type <TYPE_REQSTATUS> exiting!\n" );
		return -1;
	}
	if ( GetType( "TYPE_STATUS", &TypeStatus ) != 0 )
	{
		fprintf( stderr,
				"status: Invalid message type <TYPE_STATUS> exiting!\n" );
		return -1;
	}
	if ( GetType( "TYPE_RESTART", &TypeRestart ) != 0 )
	{
		fprintf( stderr,
				"restart: Invalid message type <TYPE_RESTART> exiting!\n" );
		return -1;
	}
/*
	if ( GetType( "Port", &Port ) != 0 )
	{
		fprintf( stderr,
				"status: Invalid module id <MOD_STATUS> exiting!\n" );
		return -1;
	}

*/
	/* Read startstop's config file to find a valid transport ring name
	 ******************************************************************/
	ReadRingName( ringname, configFile );
	if( (ringKey = GetKey(ringname)) == -1 )
	{
		printf( "status: Invalid ring name <%s>. Exiting.\n",
				ringname );
		return -1;
	}

	if (redirect != 0)
	{
		stream = freopen("status_output.log", "w", stdout);
		if (stream == NULL)
		{
			fprintf( stderr, "Unable to redirect output to 'status_output.log'\n");
		}
	}

	/* Attach to shared memory ring
	 *****************************/
	fprintf( stdout, "NOTE: If next line reads \"ERROR: tport_attach...\","
			" Earthworm is not running.\n" );
	tport_attach( &region, ringKey );
	SocketLoop();

	if (redirect != 0)
		fclose(stream);

	tport_detach( &region );
	return 0;
}
Example #4
0
int main( int argc, char **argv )
{
   SHM_INFO        region;
   long            RingKey;         /* Key to the transport ring to read from */
   MSG_LOGO        getlogo[NLOGO], logo;
   long            gotsize;
   char            msg[MAX_TRACEBUF_SIZ];
   char           *getSta, *getComp, *getNet, *getLoc, *inRing;
   char            wildSta, wildComp, wildNet, wildLoc;
   unsigned char   Type_Mseed;
   unsigned char   Type_TraceBuf,Type_TraceBuf2;
   unsigned char   Type_TraceComp, Type_TraceComp2;
   unsigned char   InstWildcard, ModWildcard;
   short          *short_data;
   int            *long_data;
   TRACE2_HEADER  *trh;
   char            orig_datatype[3];
   char            stime[256];
   char            etime[256];
   int             i;
   int             rc;
   int             nLogo = NLOGO;
   static unsigned char InstId;        /* local installation id              */
   char            ModName[MAX_MOD_STR];
   char		   *modid_name;
   unsigned char   sequence_number = 0;
   // int             statistics_flag;
   time_t monitor_start_time = 0;
   double start_time, end_time;
   unsigned long packet_total=0;
   unsigned long packet_total_size=0;
   MSRecord *msr = NULL;	/* mseed record */
   logit_init("ring2mongo", 200, 256, 1); 
   char *mongo_user = getenv("MONGO_USER");
   char *mongo_passwd=getenv("MONGO_PASSWD");
   char *mongo_host=getenv("MONGO_HOST");
   char *mongo_port=getenv("MONGO_PORT");
   if(mongo_user == NULL ||
      mongo_passwd==NULL ||
      mongo_host== NULL  ||
      mongo_port==NULL){
        printf("Ensure the following ENV varibles are set\n *MONGO_USER\n *MONGO_PASSWD\n *MONGO_HOST\n *MONGO_PORT\n");
        exit(1);
        return(1);
      }
   char mongo_str[128]="mongodb://";
   
   strcat(mongo_str, mongo_user);
   strcat(mongo_str, ":");
   strcat(mongo_str, mongo_passwd);
   strcat(mongo_str, "@");
   strcat(mongo_str, mongo_host);
   strcat(mongo_str, ":");
   strcat(mongo_str, mongo_port);   
   strcat(mongo_str, "/");
   //mongo stuff
   mongoc_client_t *m_client;
   mongoc_collection_t *m_collection;
   mongoc_init ();
   m_client = mongoc_client_new (mongo_str);
   m_collection = mongoc_client_get_collection (m_client, "waveforms", "ring");
  
   mongoc_bulk_operation_t *m_bulk;
   bson_error_t m_error;
   bson_t *m_doc;
   bson_t m_reply;
   bson_t *m_data;
   /*wait for this many messages before performing bulk write
   For real time continuous data it shoudl be ~ number of channels on ring*/
   int MONGO_BULK_MAX = 30; 
   int m_count = 0; /* counter for mongo bulk */
   bool m_ret;
   /*end mongo stuff*/
   
   
   

  /* Initialize pointers
  **********************/
  trh  = (TRACE2_HEADER *) msg;
  long_data  =  (int *)( msg + sizeof(TRACE2_HEADER) );
  short_data = (short *)( msg + sizeof(TRACE2_HEADER) );


  /* Check command line argument
  
  *****************************/
  if ( argc < 2 || argc > 6)
  {
     if(argc > 6)
     fprintf(stderr, "ring2mongo: Too many parameters\n");
     fprintf(stderr,"Usage: %s <ring name> [sta] [comp] [net] [loc] \n", argv[0]);
     fprintf(stderr, " Note: All parameters are positional, and all but first are optional.\n");
     fprintf(stderr, " the full data contained in the packet is printed out.\n");
     fprintf(stderr, " If sta comp net (but not loc) are specified then only TraceBuf\n");
     fprintf(stderr, " packets will be fetched (not TraceBuf2); otherwise both are fetched.\n");
     fprintf(stderr, " Example: %s WAVE_RING PHOB wild NC wild n\n", argv[0]);
     fprintf(stderr, " MSEED capability starting with version 2.5.1, prints mseed headers\n");
     fprintf(stderr, " of TYPE_MSEED packets (no filtering yet).\n");
     exit( 1 );
     return 1;
  }

  /* process given parameters */
  inRing  = argv[1];         /* first parameter is ring name */

  /* any parameters not given are set as wildcards */
  getSta = getComp = getNet = getLoc = "";
  wildSta = wildComp = wildNet = wildLoc = 1;
  if(argc > 2)
  {  /* at least station parameter given */
    getSta = argv[2];
    wildSta  = IsWild(getSta);
    if(argc > 3)
    {  /* channel (component) parameter given */
      getComp = argv[3];
      wildComp = IsWild(getComp);
      if(argc > 4)
      {  /* network parameter given */
        getNet = argv[4];
        wildNet = IsWild(getNet);
        if(argc > 5)
        {  /* location parameter given (SCNL) */
          getLoc  = argv[5];
          wildLoc = IsWild(getLoc);
        }
        else
        {  /* SCN without location parameter given */
          nLogo = 3;    /* do not include tracebuf2s in search */
        }
      }
    }
  }


  /* Attach to ring
  *****************/
  if ((RingKey = GetKey( inRing )) == -1 )
  {
    fprintf( stderr, "Invalid RingName; exiting!\n" );
    exit( -1 );
    return -1;
  }
  tport_attach( &region, RingKey );

/* Look up local installation id
   *****************************/
   if ( GetLocalInst( &InstId ) != 0 )
   {
      fprintf(stderr, "ring2mongo: error getting local installation id; exiting!\n" );
      exit( -1 );
      return -1;
   }

  /* Specify logos to get
  ***********************/
  if ( GetType( "TYPE_MSEED", &Type_Mseed ) != 0 ) {
     fprintf(stderr, "%s: WARNING: Invalid message type <TYPE_MSEED>! Missing from earthworm.d or earthworm_global.d\n", argv[0] );
     Type_Mseed = TYPE_NOTUSED;
  }
  if ( GetType( "TYPE_TRACEBUF", &Type_TraceBuf ) != 0 ) {
     fprintf(stderr, "%s: Invalid message type <TYPE_TRACEBUF>! Missing from earthworm.d or earthworm_global.d\n", argv[0] );
     exit( -1 );
     return -1;
  }
  if ( GetType( "TYPE_TRACE_COMP_UA", &Type_TraceComp ) != 0 ) {
     fprintf(stderr, "%s: Invalid message type <TYPE_TRACE_COMP_UA>! Missing from earthworm.d or earthworm_global.d\n", argv[0] );
     exit( -1 );
     return -1;
  }
  if ( GetType( "TYPE_TRACEBUF2", &Type_TraceBuf2 ) != 0 ) {
     fprintf(stderr, "%s: Invalid message type <TYPE_TRACEBUF2>! Missing from earthworm.d or earthworm_global.d\n", argv[0] );
     exit( -1 );
     return -1;
  }
  if ( GetType( "TYPE_TRACE2_COMP_UA", &Type_TraceComp2 ) != 0 ) {
     fprintf(stderr,"%s: Invalid message type <TYPE_TRACE2_COMP_UA>! Missing from earthworm.d or earthworm_global.d\n", argv[0] );
     exit( -1 );
     return -1;
  }
  if ( GetModId( "MOD_WILDCARD", &ModWildcard ) != 0 ) {
     fprintf(stderr, "%s: Invalid moduleid <MOD_WILDCARD>! Missing from earthworm.d or earthworm_global.d\n", argv[0] );
     exit( -1 );
     return -1;
  }
  if ( GetInst( "INST_WILDCARD", &InstWildcard ) != 0 ) {
     fprintf(stderr, "%s: Invalid instid <INST_WILDCARD>! Missing from earthworm.d or earthworm_global.d\n", argv[0] );
     exit( -1 );
     return -1;
  }

  for( i=0; i<nLogo; i++ ) {
      getlogo[i].instid = InstWildcard;
      getlogo[i].mod    = ModWildcard;
  }
  getlogo[0].type = Type_Mseed;
  getlogo[1].type = Type_TraceBuf;
  getlogo[2].type = Type_TraceComp;
  if (nLogo >= 4) {     /* if nLogo=5 then include TraceBuf2s */
      getlogo[3].type = Type_TraceBuf2;
      getlogo[4].type = Type_TraceComp2;
  }
  logit("", "Starting ring2mongo");
  /* Flush the ring
  *****************/
  while ( tport_copyfrom( &region, getlogo, nLogo, &logo, &gotsize,
            (char *)&msg, MAX_TRACEBUF_SIZ, &sequence_number ) != GET_NONE ){
         packet_total++;
         packet_total_size+=gotsize;
  }
  logit( "et",  "ring2mongo: inRing flushed %ld packets of %ld bytes total.\n",
	packet_total, packet_total_size);

  while (tport_getflag( &region ) != TERMINATE ) {
    rc = tport_copyfrom( &region, getlogo, nLogo,
               &logo, &gotsize, msg, MAX_TRACEBUF_SIZ, &sequence_number );

    if ( rc == GET_NONE ){
      sleep_ew( 200 );
      continue;
    }

    if ( rc == GET_TOOBIG ){
      logit("et", "ring2mongo: retrieved message too big (%ld) for msg\n",
        gotsize );
      continue;
    }
    if ( rc == GET_NOTRACK )
      logit("et", "ring2mongo: Tracking error.\n");

    if ( rc == GET_MISS_LAPPED )
      logit("et", "ring2mongo: Got lapped on the ring.\n");

    if ( rc == GET_MISS_SEQGAP )
      logit( "et", "ring2mongo: Gap in sequence numbers\n");

    if ( rc == GET_MISS )
      logit( "et", "ring2mongo: Missed messages\n");

    /* Check SCNL of the retrieved message */


    if (Type_Mseed != TYPE_NOTUSED && logo.type == Type_Mseed) {
      /* Unpack record header and not data samples */
      /*hard coded zero for dataflag(1) and verbose(0)for ring2mongo*/
      if ( msr_unpack (msg, gotsize, &msr, 1, 0) != MS_NOERROR) {
         logit("et", "Error parsing mseed record\n");
         continue;
      }

      /* Print record information */
      msr_print (msr, 0);

      msr_free (&msr);
      continue;
    }
    /*end Mseed*/
    
    if ( (wildSta  || (strcmp(getSta,trh->sta)  ==0)) &&
         (wildComp || (strcmp(getComp,trh->chan)==0)) &&
         (wildNet  || (strcmp(getNet,trh->net)  ==0)) &&
         (((logo.type == Type_TraceBuf2 ||
            logo.type == Type_TraceComp2) &&
         (wildLoc  || (strcmp(getLoc,trh->loc) == 0))) ||
         ( (logo.type == Type_TraceBuf ||
             logo.type == Type_TraceComp))))
    {
      
      
      strcpy(orig_datatype, trh->datatype);
      char scnl[20];     
      scnl[0] = 0;
      strcat( scnl, trh->sta);
      strcat( scnl, ".");
      strcat( scnl, trh->chan);
      strcat( scnl, ".");
      strcat( scnl, trh->net);
      strcat( scnl, ".");
      strcat( scnl, trh->loc);
      
      if(WaveMsg2MakeLocal( trh ) < 0){
        
        char  dt[3];        
        
        /* now put a space if there are any punctuation marks */

        for ( i=0; i<15; i++ ) {
          if ( !isalnum(scnl[i]) && !ispunct(scnl[i]))
            scnl[i] = ' ';
        }
        strncpy( dt, trh->datatype, 2 );
        for ( i=0; i<2; i++ ) {
          if ( !isalnum(dt[i]) && !ispunct(dt[i]))
            dt[i] = ' ';
        }
        dt[i] = 0;
        logit("et", "WARNING: WaveMsg2MakeLocal rejected tracebuf.  Discard (%s).\n",
          scnl );
        logit("et", "\tdatatype=[%s]\n", dt);
        continue;
      }
        
      /*lets get ready to mongo....*/
      if(m_count < MONGO_BULK_MAX){
        /*initialize when m_count ==0 */
        if(m_count==0){
          m_bulk = mongoc_collection_create_bulk_operation (m_collection, true, NULL);
        }       
        m_data = bson_new ();
        m_doc = BCON_NEW ("key",   BCON_UTF8 (scnl),
                          "nsamp", BCON_INT32 (trh->nsamp),
                          "starttime", BCON_DOUBLE (trh->starttime*1000),
                          "endtime", BCON_DOUBLE (trh->endtime*1000),
                          "samprate", BCON_DOUBLE (trh->samprate),
                          "datatype", BCON_UTF8 (trh->datatype)
        );
       char index[4];
       bson_append_array_begin (m_doc, "data", -1, m_data);
        for ( i = 0; i < trh->nsamp; i++ ){
          snprintf(index, 4, "%d", i);
          if ( (strcmp (trh->datatype, "s2")==0) || (strcmp (trh->datatype, "i2")==0) ){
            bson_append_int32 (m_data, index, -1, short_data[i]);
           }else{
             bson_append_int32 (m_data, index, -1, long_data[i]);
           }
          }
        bson_append_array_end (m_doc, m_data);                             
        mongoc_bulk_operation_insert (m_bulk, m_doc);
        bson_destroy (m_doc);
        bson_destroy (m_data);
        
        m_count++;
        if(m_count==MONGO_BULK_MAX){
          
          /*write and destroty above stuff */  
          m_ret = mongoc_bulk_operation_execute (m_bulk, &m_reply, &m_error);
          if (!m_ret){
             logit ("et", "Error: %s\n", m_error.message);
           }
          bson_destroy (&m_reply);
          mongoc_bulk_operation_destroy (m_bulk);
          m_count = 0;
        }
      } 
    }
  } /* end of while loop */
  logit("et", "signing off"); 
  exit (0);
  return 0;
}