X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2Frmr%2Fcommon%2Fsrc%2Frt_generic_static.c;h=9aa58f1b562d2cc46fcfc857cff4c9595b53a9fd;hb=b0a8a9c1d7bb07d2708a8c1a7b580592756d012e;hp=f93963c4a65584158dfd0ba5042b3da5ef6404da;hpb=84423e66ad5d4ed313548b3705ec925a934b0f2e;p=ric-plt%2Flib%2Frmr.git

diff --git a/src/rmr/common/src/rt_generic_static.c b/src/rmr/common/src/rt_generic_static.c
index f93963c..9aa58f1 100644
--- a/src/rmr/common/src/rt_generic_static.c
+++ b/src/rmr/common/src/rt_generic_static.c
@@ -323,6 +323,50 @@ static void send_rt_ack( uta_ctx_t* ctx, rmr_mbuf_t* smsg, char* table_id, int s
 	}
 }
 
+// ---- alarm generation --------------------------------------------------------------------------
+
+/*
+	Given the user's context (not the thread private context) look to see if the application isn't
+	working fast enough and we're dropping messages. If the drop counter has changed since the last
+	peeked, and we have not raised an alarm, then we will alarm. If the counter hasn't changed, then we
+	set a timer and if the counter still hasn't changed when it expires we will clear the alarm.
+
+	The private context is what we use to send so as not to interfere with the user flow.
+*/
+static void alarm_if_drops( uta_ctx_t* uctx, uta_ctx_t* pctx ) {
+	static	int alarm_raised = 0;
+	static	int ok2clear = 0;					// time that we can clear
+	static	int lastd = 0;						// the last counter value so we can compute delta
+	static	int prob_id = 0;					// problem ID we assume alarm manager handles dups between processes
+
+	rmr_vlog( RMR_VL_DEBUG, "checking for drops... raised=%d 0k2clear=%d lastd=%d probid=%d\n", alarm_raised, ok2clear, lastd, prob_id );
+	if( ! alarm_raised ) {
+		if( uctx->dcount - lastd == 0 ) {			// not actively dropping, ok to do nothing
+			return;
+		}
+
+		alarm_raised = 1;
+		uta_alarm( pctx, ALARM_DROPS | ALARM_RAISE, prob_id, "application running slow; RMR is dropping messages" );
+		rmr_vlog( RMR_VL_INFO, "drop alarm raised" );
+	} else {
+		if( uctx->dcount - lastd != 0 ) {			// still dropping or dropping again; we've alarmed so nothing to do
+			lastd = uctx->dcount;
+			ok2clear = 0;							// reset the timer
+			return;
+		}
+
+		if( ok2clear == 0 ) {						// first round where not dropping
+			ok2clear = time( NULL ) + 60;			// we'll clear the alarm in 60s
+		} else {
+			if( time( NULL ) > ok2clear ) {			// things still stable after expiry
+				rmr_vlog( RMR_VL_INFO, "drop alarm cleared\n" );
+				alarm_raised = 0;
+				uta_alarm( pctx, ALARM_DROPS | ALARM_CLEAR, prob_id++, "RMR message dropping has stopped" );
+			}
+		}
+	}
+}
+
 // ---- utility -----------------------------------------------------------------------------------
 /*
 	Little diddy to trim whitespace and trailing comments. Like shell, trailing comments
@@ -787,6 +831,70 @@ static void meid_parser( uta_ctx_t* ctx, uta_ctx_t* pctx, rmr_mbuf_t* mbuf, char
 	}
 }
 
+/*
+	This will close the current table snarf file (in *.inc) and open a new one.
+	The curent one is renamed. The final file name is determined by the setting of
+	RMR_SNARF_RT, and if not set then the variable RMR_SEED_RT is used and given
+	an additional extension of .snarf.  If neither seed or snarf environment vars are
+	set then this does nothing.
+
+	If this is called before the tmp snarf file is opened, then this just opens the file.
+*/
+static void cycle_snarfed_rt( uta_ctx_t* ctx ) {
+	static int		ok2warn = 0;	// some warnings squelched on first call
+
+	char*	seed_fname;				// the filename from env
+	char	tfname[512];			// temp fname
+	char	wfname[512];			// working buffer for filename
+	char*	snarf_fname = NULL;		// prevent overlay of the static table if snarf_rt not given
+
+	if( ctx == NULL ) {
+		return;
+	}
+
+	if( (snarf_fname = getenv(  ENV_STASH_RT )) == NULL ) {			// specific place to stash the rt not given
+		if( (seed_fname = getenv( ENV_SEED_RT )) != NULL ) {			// no seed, we leave in the default file
+			memset( wfname, 0, sizeof( wfname ) );
+			snprintf( wfname, sizeof( wfname ) - 1, "%s.stash", seed_fname );
+			snarf_fname = wfname;
+		}
+	}
+
+	if( snarf_fname == NULL ) {
+		return;
+	}
+
+	memset( tfname, 0, sizeof( tfname ) );
+	snprintf( tfname, sizeof( tfname ) -1, "%s.inc", snarf_fname );		// must ensure tmp file is moveable
+
+	if( ctx->snarf_rt_fd >= 0 ) {
+		char* msg= "### captured from route manager\n";
+		write( ctx->snarf_rt_fd, msg, strlen( msg ) );
+		if( close( ctx->snarf_rt_fd ) < 0 ) {
+			rmr_vlog( RMR_VL_WARN, "rmr_rtc: unable to close working rt snarf file: %s\n", strerror( errno ) );
+			return;
+		}
+
+		if( unlink( snarf_fname ) < 0  && ok2warn ) {					// first time through this can fail and we ignore it
+			rmr_vlog( RMR_VL_WARN, "rmr_rtc: unable to unlink old static table: %s: %s\n", snarf_fname, strerror( errno ) );
+		}
+
+		if( rename( tfname, snarf_fname ) ) {
+			rmr_vlog( RMR_VL_WARN, "rmr_rtc: unable to move new route table to seed aname : %s -> %s: %s\n", tfname, snarf_fname, strerror( errno ) );
+		} else {
+			rmr_vlog( RMR_VL_INFO, "latest route table info saved in: %s\n", snarf_fname );
+		}
+	}
+	ok2warn = 1;
+
+	ctx->snarf_rt_fd = open( tfname, O_WRONLY | O_CREAT | O_TRUNC, 0660 );
+	if( ctx->snarf_rt_fd < 0 ) {
+		rmr_vlog( RMR_VL_WARN, "rmr_rtc: unable to open trt file: %s: %s\n", tfname, strerror( errno ) );
+	} else {
+		if( DEBUG ) rmr_vlog( RMR_VL_DEBUG, "rmr_rtc: rt snarf file opened: %s: %s\n", tfname );
+	}
+}
+
 /*
 	Parse a single record recevied from the route table generator, or read
 	from a static route table file.  Start records cause a new table to
@@ -848,6 +956,11 @@ static void parse_rt_rec( uta_ctx_t* ctx,  uta_ctx_t* pctx, char* buf, int vleve
 		return;
 	}
 
+	if( ctx && ctx->snarf_rt_fd  >= 0 ) {								// if snarfing table as it arrives, write this puppy
+		write( ctx->snarf_rt_fd, buf, strlen( buf ) );
+		write( ctx->snarf_rt_fd, "\n", 1 );
+	}
+
 	while( *buf && isspace( *buf ) ) {							// skip leading whitespace
 		buf++;
 	}
@@ -880,6 +993,10 @@ static void parse_rt_rec( uta_ctx_t* ctx,  uta_ctx_t* pctx, char* buf, int vleve
 			case 'n':												// newrt|{start|end}
 				tokens[1] = clip( tokens[1] );
 				if( strcmp( tokens[1], "end" ) == 0 ) {				// wrap up the table we were building
+					if( ctx && ctx->snarf_rt_fd >= 0 ) {
+						cycle_snarfed_rt( ctx );					// make it available and open a new one
+					}
+
 					if( ntoks >2 ) {
 						if( ctx->new_rtable->updates != atoi( tokens[2] ) ) {	// count they added didn't match what we received
 							rmr_vlog( RMR_VL_ERR, "rmr_rtc: RT update had wrong number of records: received %d expected %s\n",
@@ -967,6 +1084,9 @@ static void parse_rt_rec( uta_ctx_t* ctx,  uta_ctx_t* pctx, char* buf, int vleve
 					if( ctx->new_rtable == NULL ) {					// update table not in progress
 						break;
 					}
+					if( ctx && ctx->snarf_rt_fd >= 0 ) {
+						cycle_snarfed_rt( ctx );					// make it available and open a new one
+					}
 
 					if( ntoks >2 ) {
 						if( ctx->new_rtable->updates != atoi( tokens[2] ) ) {	// count they added didn't match what we received