src/pipe_reader.c

   1 // vim: ts=4 sw=4 noet:
   2 /*
   3 --------------------------------------------------------------------------------
   4         Copyright (c) 2018-2019 AT&T Intellectual Property.
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10            http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17 --------------------------------------------------------------------------------
  18 */
  19
  20 /*
  21         Mnemonic:       pipe_reader.c
  22         Abstract:       Read a single pipe which was associated with a message type.  This
  23                                 programme is primarily for verification or example of how to use the
  24                                 read1() function in the mc-listener library.
  25
  26         Date:           22 August 2019
  27         Author:         E. Scott Daniels
  28 */
  29
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <time.h>
  35 #include <string.h>
  36 #include <signal.h>
  37
  38
  39 #include "mcl.h"
  40
  41 //---- support -----------------------------------------------------------------------------
  42
  43 static void bad_arg( char* what ) {
  44         fprintf( stderr, "[ERR] option is unrecognised or isn't followed by meaningful data: %s\n", what );
  45 }
  46
  47 static void usage( char* argv0 ) {
  48         fprintf( stderr, "usage: %s [-d fifo-dir] [-e] [-m msg-type] [-s]\n", argv0 );
  49         fprintf( stderr, "   -d  dir (default is /tmp/mcl/fifos)\n" );
  50         fprintf( stderr, "   -e  disable extended headers expectation in FIFO data\n" );
  51         fprintf( stderr, "   -m  msg-type (default is 0)\n" );
  52         fprintf( stderr, "   -M  max msg to read (default is all)\n" );
  53         fprintf( stderr, "   -s  stats only mode\n" );
  54 }
  55
  56 /*
  57         We exit on any trapped signal so that we can kill  -15 the proecss
  58         and still get gcoverage information to keep sonar happy.
  59 */
  60 static void sigh( int sig ) {
  61         fprintf( stderr, "\n[INFO] exiting on signal %d\n", sig );
  62         exit( 0 );
  63 }
  64
  65 //------------------------------------------------------------------------------------------
  66 int main( int argc,  char** argv ) {
  67         void*   ctx;                                                    // the mc listener library context
  68         char*   dname = "/tmp/mcl/fifos";               // default directory where we open fifos
  69         int             pidx = 1;                                               // parameter index
  70         int             error = 0;
  71         int             len;
  72         int             mtype = 0;
  73         char    buf[4096];
  74         int             flush_often = 0;
  75         int             long_hdrs = 1;                                  // -e is on command line turns this off, by default we expect long headers
  76         int             stats_only = 0;
  77         char    timestamp[MCL_TSTAMP_SIZE];             // we'll get the timestamp from this
  78         long    count = 0;
  79         int             blabber = 0;
  80         int             max = 0;                                                // we'll force one reader down early to simulate MC going away
  81
  82         signal( SIGINT, sigh );
  83         signal( SIGTERM, sigh );
  84
  85         while( pidx < argc && argv[pidx][0] == '-' ) {                  // simple argument parsing (-x  or -x value)
  86                 switch( argv[pidx][1] ) {
  87                         case 'd':
  88                                 if( pidx+1 < argc ) {
  89                                         dname = strdup( argv[pidx+1] );
  90                                         pidx++;
  91                                 } else {
  92                                         bad_arg( argv[pidx] );
  93                                         error = 1;
  94                                 }
  95                                 break;
  96
  97                         case 'e':
  98                                 long_hdrs = 0;
  99                                 break;
 100
 101                         case 'f':
 102                                 flush_often = 1;
 103                                 break;
 104
 105                         case 'm':
 106                                 if( pidx+1 < argc ) {
 107                                         mtype = atoi( argv[pidx+1] );
 108                                         pidx++;
 109                                 } else {
 110                                         bad_arg( argv[pidx] );
 111                                         error = 1;
 112                                 }
 113                                 break;
 114
 115                         case 'M':
 116                                 if( pidx+1 < argc ) {
 117                                         max = atoi( argv[pidx+1] );
 118                                         pidx++;
 119                                 } else {
 120                                         bad_arg( argv[pidx] );
 121                                         error = 1;
 122                                 }
 123                                 break;
 124
 125                         case 's':
 126                                 stats_only = 1;
 127                                 break;
 128
 129                         case 'h':
 130                         case '?':
 131                                 usage( argv[0] );
 132                                 exit( 0 );
 133
 134                         default:
 135                                 bad_arg( argv[pidx] );
 136                                 error = 1;
 137                                 break;
 138                 }
 139
 140                 pidx++;
 141         }
 142
 143         if( error ) {
 144                 usage( argv[0] );
 145                 exit( 1 );
 146         }
 147
 148         ctx = mcl_mk_context( dname );                  // initialise the library context
 149         if( ctx == NULL ) {
 150                 fprintf( stderr, "[FAIL] couldn't initialise the mc listener library" );
 151                 exit( 1 );
 152         }
 153
 154         fprintf( stderr, "[INFO] max = %d\n", max );
 155         while( max == 0 || count < max ) {
 156                 len = mcl_fifo_tsread1( ctx, mtype, buf, sizeof( buf ) -1, long_hdrs, timestamp );
 157                 if( len > 0 ) {
 158                         if( stats_only ) {
 159                                 if( time( NULL ) > blabber ) {
 160                                         fprintf( stdout, "[%d] %ld messages received\n", mtype, count );
 161                                         blabber = time( NULL ) + 2;
 162                                 }
 163                         } else {
 164                                 buf[len] = 0;
 165                                 fprintf( stdout, "[%d] ts=%s count=%ld len=%d  msg=%s\n",  mtype, timestamp,  count, len, buf );
 166                                 if( flush_often ) {
 167                                         fflush( stdout );
 168                                 }
 169                         }
 170
 171                         count++;
 172                 } else {
 173                         sleep( 1 );
 174                 }
 175         }
 176
 177         fprintf( stderr, "[INFO] max reached: %d\n", max );
 178 }
 179