BotSense bsProxy server load tester client(s). More...

#include <sys/time.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <libgen.h>
#include <pthread.h>
#include <time.h>
#include <string.h>
#include <errno.h>
#include "rnr/rnrconfig.h"
#include "rnr/new.h"
#include "rnr/opts.h"
#include "rnr/log.h"
#include "botsense/BotSense.h"
#include "botsense/libBotSense.h"
#include "botsense/bsProxyMsgs.h"
#include "botsense/bsI2C.h"
#include "botsense/bsI2CMsgs.h"
#include "botsense/bsNull.h"
#include "botsense/bsNullMsgs.h"
#include "botsense/bsSerial.h"
#include "botsense/bsSerialMsgs.h"
#include "version.h"

Macros
#define	APP_EC_OK 0
	success exit code

#define	APP_EC_USAGE 2
	usage error exit code

#define	APP_EC_EXEC 4
	execution error exit code

#define	LT_MAX_CLIENTS 256
	maximum number of load testing clients

#define	LT_MAX_VCONN 4
	maximum number of virtual conn. / client

#define	LT_N_CLIENT_DFT 1
	default option load testing client count

#define	LT_DEVICES_DFT "server,null"
	default option list of proxied devices

#define	LT_DEV_SERVER 0x0001
	load test server-terminated requests

#define	LT_DEV_I2C 0x0002
	load test proxied I²C device requests

#define	LT_DEV_NULL 0x0004
	load test proxied /dev/null requests

#define	LT_DEV_SERIAL 0x0008
	load test proxied serial device requests

#define	LT_T_MIN 1000
	minimum thread sleep time

#define	LT_T_MAX 2000000
	minimum thread sleep time

Functions
static int	OptsCvtArgServerAddr (const char argv0, const char sOptName, char optarg, void pOptVal)
	Convert command-line server option IP address string to network name/number and port number. More...

static int	OptsCvtArgClientCnt (const char argv0, const char sOptName, char optarg, void pOptVal)
	Convert command-line client count option. More...

static int	OptsCvtArgDevices (const char argv0, const char sOptName, char optarg, void pOptVal)
	Convert command-line devices option string to bitmap. More...

static void	RandSeed ()
	Seed random number generator.

static uint_t	RandN (uint_t n)
	Generate random integer between [0,n). More...

static void	RandSleep (uint_t tmin, uint_t tmax)
	Sleep for a random μs duration between [tmin, tmax]. More...

static BsVConnHnd_T	RandVConn (BsVecHandles_T *pVConnList)
	Randomly pick a virtual connection in list. More...

static void *	LtThreadI2C (void *pArg)
	Load test proxied I²C device thread. More...

static void	ClientStartTestThreadI2C (BsClient_P pClient)
	Start proxied I²C device load test thread. More...

static void *	LtThreadNull (void *pArg)
	Load test proxied /dev/null device thread. More...

static void	ClientStartTestThreadNull (BsClient_P pClient)
	Start proxied /dev/null device load test thread. More...

static void *	LtThreadSerial (void *pArg)
	Load test proxied serial device thread. More...

static void	ClientStartTestThreadSerial (BsClient_P pClient)
	Start proxied serial device load test thread. More...

static void *	LtThreadServer (void *pArg)
	Load test server-terminated messages thread. More...

static void	ClientStartTestThreadServer (BsClient_P pClient)
	Start server-terminated requests load test thread. More...

static BsClient_P	CreateTestClient (int i)
	Get and pretty print all the versions from all proxied entities. More...

static int	MainInit (int argc, char *argv[])
	Initialize application. More...

int	main (int argc, char *argv[])
	Application main. More...

Variables
static char *	Argv0
	this command basename

static char *	OptsProxyServer = "localhost"
	proxy server addr/port

static int	OptsClientCnt = 1
	number of clients

static char *	OptsDevices = "server,null"
	number of clients

static bool_t	OptsFixedDiag = false
	fixed diagnostics

static char *	OptsDevSerial = "/dev/ttyS0"
	serial device

static char *	OptsDevI2C = "/dev/i2c-0"
	i2c device

static OptsPgmInfo_T	PgmInfo
	Program information. More...

static OptsInfo_T	OptsInfo []
	Command-line options information.

static char *	ProxyIPAddr = "localhost"
	default bsProxy IP addr

static int	ProxyIPPort = BSPROXY_LISTEN_PORT_DFT
	default bsProxy port

static BsClient_P	Client [256]
	array of clients

static uint_t	ProxiedDevices
	proxied devices More...

union {
ulong_t seed
	the initial seed

ushort_t xsubi [3]
	successive x_i'th 48-bit value

}	RandomSeq
	Random seed.

Detailed Description

BotSense bsProxy server load tester client(s).

LastChangedDate: 2010-09-13 10:25:05 -0600 (Mon, 13 Sep 2010)

Rev: 581

Author: Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright: © 2010-2017. RoadNarrows LLC.
http://www.roadnarrows.com
All Rights Reserved

Definition in file bsLoadTest.c.

Function Documentation

static void ClientStartTestThreadI2C ( BsClient_P pClient )

static

Start proxied I²C device load test thread.

Parameters

pClient BotSense client.

Definition at line 429 of file bsLoadTest.c.

References BS_ECODE_NO_EXEC, BSCLIENT_LOG_SYSERROR, and LtThreadI2C().

Referenced by CreateTestClient().

 {
   pthread_t thread;
 
   if( pthread_create(&thread, NULL, LtThreadI2C, (void *)pClient) )
   {
     BSCLIENT_LOG_SYSERROR(pClient, BS_ECODE_NO_EXEC,
         "pthread_create(\"/dev/null\")");
     return;
   }
 }

static void ClientStartTestThreadNull ( BsClient_P pClient )

static

Start proxied /dev/null device load test thread.

Parameters

pClient BotSense client.

Definition at line 568 of file bsLoadTest.c.

References BS_ECODE_NO_EXEC, BSCLIENT_LOG_SYSERROR, and LtThreadNull().

Referenced by CreateTestClient().

 {
   pthread_t thread;
 
   if( pthread_create(&thread, NULL, LtThreadNull, (void *)pClient) )
   {
     BSCLIENT_LOG_SYSERROR(pClient, BS_ECODE_NO_EXEC,
         "pthread_create(\"/dev/null\")");
     return;
   }
 }

static void ClientStartTestThreadSerial ( BsClient_P pClient )

static

Start proxied serial device load test thread.

Parameters

pClient BotSense client.

Definition at line 714 of file bsLoadTest.c.

References BS_ECODE_NO_EXEC, BSCLIENT_LOG_SYSERROR, and LtThreadSerial().

Referenced by CreateTestClient().

 {
   pthread_t thread;
 
   if( pthread_create(&thread, NULL, LtThreadSerial, (void *)pClient) )
   {
     BSCLIENT_LOG_SYSERROR(pClient, BS_ECODE_NO_EXEC,
         "pthread_create(\"serial\")");
     return;
   }
 }

static void ClientStartTestThreadServer ( BsClient_P pClient )

static

Start server-terminated requests load test thread.

Parameters

pClient BotSense client.

Definition at line 896 of file bsLoadTest.c.

References BS_ECODE_NO_EXEC, BSCLIENT_LOG_SYSERROR, and LtThreadServer().

Referenced by CreateTestClient().

 {
   pthread_t thread;
 
   if( pthread_create(&thread, NULL, LtThreadServer, (void *)pClient) )
   {
     BSCLIENT_LOG_SYSERROR(pClient, BS_ECODE_NO_EXEC,
         "pthread_create(\"server\")");
     return;
   }
 }

static BsClient_P CreateTestClient ( int i )

static

Get and pretty print all the versions from all proxied entities.

The returned BotSense allocatated string is multi-lined.

Parameters

i	Test client instance.

Definition at line 915 of file bsLoadTest.c.

References BS_OK, ClientStartTestThreadI2C(), ClientStartTestThreadNull(), ClientStartTestThreadSerial(), ClientStartTestThreadServer(), LT_DEV_I2C, LT_DEV_NULL, LT_DEV_SERIAL, LT_DEV_SERVER, ProxiedDevices, ProxyIPAddr, and ProxyIPPort.

Referenced by main().

 {
   char        buf[256];
   BsClient_P  pClient;
   int         rc;
 
   sprintf_s(buf, sizeof(buf), "TestClient%d", i);
 
   pClient = bsClientNew(buf);
 
   // connect to bsProxy server
   if( (rc = bsServerConnect(pClient, ProxyIPAddr, ProxyIPPort)) < 0 )
   {
     LOGERROR("bsProxy @%s:%d: %s\n", ProxyIPAddr, ProxyIPPort, bsStrError(rc));
   }
 
   // success
   else
   {
     LOGDIAG1("Created client %s.", bsClientAttrGetName(pClient));
     rc = BS_OK;
 
     if( ProxiedDevices & LT_DEV_SERVER )
     {
       ClientStartTestThreadServer(pClient);
     }
     if( ProxiedDevices & LT_DEV_I2C )
     {
       ClientStartTestThreadI2C(pClient);
     }
     if( ProxiedDevices & LT_DEV_NULL )
     {
       ClientStartTestThreadNull(pClient);
     }
     if( ProxiedDevices & LT_DEV_SERIAL )
     {
       ClientStartTestThreadSerial(pClient);
     }
   }
 
   // Error clean up.
   if( rc < 0 )
   {
     bsClientDelete(pClient);
     pClient = NULL;
   }
 
   return pClient;
 }

static void* LtThreadI2C ( void * pArg )

static

Load test proxied I²C device thread.

Parameters

pArg	BotSense client (casted as a NULL).

Returns: Returns NULL on thread exit.

Definition at line 315 of file bsLoadTest.c.

References BS_OK, BSCLIENT_LOG_ERROR, BsI2CMsgIdNumOf, BsI2CMsgIdReqScan, LT_T_MAX, LT_T_MIN, OptsDevI2C, RandN(), and RandSleep().

Referenced by ClientStartTestThreadI2C().

 {
   enum ActionOps
   {
     ActionScan      = BsI2CMsgIdReqScan,
     ActionOpenClose = BsI2CMsgIdNumOf
   };
 
   static uint_t actions[] = 
   {
     ActionOpenClose, ActionScan
   };
 
   static uint_t uNumActions = (uint_t)arraysize(actions);
 
   BsClient_P        pClient = (BsClient_P)pArg;
   const char       *sClientName = bsClientAttrGetName(pClient);
   uint_t            uCloseFreq = 50;
   BsVConnHnd_T      hndVConn;
   bool_t            bIsOpen;
   i2c_addr_t        addrs[256];
   uint_t            i;
   int               rc;
 
   // open proxied device
   hndVConn = bsI2CReqOpen(pClient, OptsDevI2C, false);
 
   if( hndVConn < 0 )
   {
     BSCLIENT_LOG_ERROR(pClient, hndVConn, "%s", OptsDevI2C);
     return NULL;
   }
 
   printf("<%s>: i2copen: %s\n", sClientName, OptsDevI2C);
 
   bIsOpen = true;
 
   printf("<%s>: i2c load test thread started.\n", sClientName);
 
   while( true )
   {
     // randomly sleep between minimum and maximum times
     RandSleep(LT_T_MIN, LT_T_MAX);
 
     // choose random request to send
     switch( actions[RandN(uNumActions)] )
     {
       case ActionOpenClose:
         if( bIsOpen )
         {
           if( RandN(uCloseFreq) == 0 )
           {
             rc = bsI2CReqClose(pClient, hndVConn);
             if( rc == BS_OK )
             {
               printf("<%s>: i2cclose: %s\n", sClientName, OptsDevI2C);
               bIsOpen = false;
             }
             else
             {
               printf("<%s>: i2cclose: failed: rc=%d\n", sClientName, rc);
             }
           }
         }
         else
         {
           // open proxied device
           hndVConn = bsI2CReqOpen(pClient, OptsDevI2C, false);
 
           if( hndVConn >= 0 )
           {
             printf("<%s>: i2copen: %s\n", sClientName, OptsDevI2C);
             bIsOpen = true;
           }
           else
           {
             printf("<%s>: i2copen: failed: rc=%d\n", sClientName, hndVConn);
           }
         }
         break;
       case ActionScan:
         if( bIsOpen )
         {
           rc = bsI2CReqScan(pClient, hndVConn, addrs, arraysize(addrs));
           if( rc > 0 )
           {
             printf("<%s>: i2cscan: %d addresses:", sClientName, rc);
             for(i=0; i<rc; ++i)
             {
               printf(" 0x%02x", addrs[i]);
             }
             printf(".\n");
           } 
           else
           {
             printf("<%s>: i2cscan: failed: rc=%d\n", sClientName, rc);
           }
         }
         break;
       default:
         break;
     }
   }
 
   printf("<%s>: i2c load test thread terminated.\n", sClientName);
 
   return NULL;
 }

static void* LtThreadNull ( void * pArg )

static

Load test proxied /dev/null device thread.

Parameters

pArg	BotSense client (casted as a NULL).

Returns: Returns NULL on thread exit.

Definition at line 448 of file bsLoadTest.c.

References BS_NULL_DEV_NAME, BS_OK, BSCLIENT_LOG_ERROR, BsNullMsgIdNumOf, BsNullMsgIdReqWrite, LT_T_MAX, LT_T_MIN, RandN(), and RandSleep().

Referenced by ClientStartTestThreadNull().

 {
   enum ActionOps
   {
     ActionWrite     = BsNullMsgIdReqWrite,
     ActionOpenClose = BsNullMsgIdNumOf
   };
 
   static uint_t actions[] = 
   {
     ActionOpenClose, ActionWrite
   };
 
   static uint_t uNumActions = (uint_t)arraysize(actions);
 
   static char *wrPhrase[] = 
   {
     "It just so happens that your friend here is only MOSTLY dead.",
     "Rest well and dream of large women.",
     "Hello. My name is Inigo Montoya. You killed my father. Prepare to die."
   };
   static uint_t uNumWrPhrases = (uint_t)arraysize(wrPhrase);
 
   BsClient_P        pClient = (BsClient_P)pArg;
   const char       *sClientName = bsClientAttrGetName(pClient);
   uint_t            uCloseFreq = 50;
   BsVConnHnd_T      hndVConn;
   bool_t            bIsOpen;
   byte_t            buf[1024];
   uint_t            i;
   int               rc;
 
   // open proxied device
   hndVConn = bsNullReqOpen(pClient, false);
 
   if( hndVConn < 0 )
   {
     BSCLIENT_LOG_ERROR(pClient, hndVConn, "%s", BS_NULL_DEV_NAME);
     return NULL;
   }
 
   printf("<%s>: nullopen: %s\n", sClientName, BS_NULL_DEV_NAME);
 
   bIsOpen = true;
 
   printf("<%s>: devnull load test thread started.\n", sClientName);
 
   while( true )
   {
     // randomly sleep between minimum and maximum times
     RandSleep(LT_T_MIN, LT_T_MAX);
 
     // choose random request to send
     switch( actions[RandN(uNumActions)] )
     {
       case ActionOpenClose:
         if( bIsOpen )
         {
           if( RandN(uCloseFreq) == 0 )
           {
             rc = bsNullReqClose(pClient, hndVConn);
             if( rc == BS_OK )
             {
               printf("<%s>: nullclose: %s\n", sClientName, BS_NULL_DEV_NAME);
               bIsOpen = false;
             }
             else
             {
               printf("<%s>: nullclose: failed: rc=%d\n", sClientName, rc);
             }
           }
         }
         else
         {
           // open proxied device
           hndVConn = bsNullReqOpen(pClient, false);
 
           if( hndVConn >= 0 )
           {
             printf("<%s>: nullopen: %s\n", sClientName, BS_NULL_DEV_NAME);
             bIsOpen = true;
           }
           else
           {
             printf("<%s>: nullopen: failed: rc=%d\n", sClientName, hndVConn);
           }
         }
         break;
       case ActionWrite:
         if( bIsOpen )
         {
           i = RandN(uNumWrPhrases);
           memcpy(buf, wrPhrase[i], strlen(wrPhrase[i]));
           rc = bsNullReqWrite(pClient, hndVConn, buf, strlen(wrPhrase[i]));
           if( rc > 0 )
           {
             printf("<%s>: nullwrite: %d bytes: \"%*s\"\n",
                 sClientName, rc, rc, wrPhrase[i]);
           } 
           else
           {
             printf("<%s>: nullwrite: failed: rc=%d\n", sClientName, rc);
           }
         }
         break;
       default:
         break;
     }
   }
 
   printf("<%s>: devnull load test thread terminated.\n", sClientName);
 
   return NULL;
 }

static void* LtThreadSerial ( void * pArg )

static

Load test proxied serial device thread.

Parameters

pArg	BotSense client (casted as a NULL).

Returns: Returns NULL on thread exit.

Definition at line 587 of file bsLoadTest.c.

References BS_OK, BSCLIENT_LOG_ERROR, BsSerialMsgIdNumOf, BsSerialMsgIdReqRead, BsSerialMsgIdReqTrans, BsSerialMsgIdReqWrite, LT_T_MAX, LT_T_MIN, OptsDevSerial, RandN(), and RandSleep().

Referenced by ClientStartTestThreadSerial().

 {
   enum ActionOps
   {
     ActionRead      = BsSerialMsgIdReqRead,
     ActionTrans     = BsSerialMsgIdReqTrans,
     ActionWrite     = BsSerialMsgIdReqWrite,
     ActionOpenClose = BsSerialMsgIdNumOf
   };
 
   static uint_t actions[] = 
   {
     ActionOpenClose, ActionWrite
   };
 
   static uint_t uNumActions = (uint_t)arraysize(actions);
 
   static char *wrPhrase[] = 
   {
     "hello",
     "eat me", 
     "This is the end / Beautiful friend / This is the end / "
     "My only friend, the end"
   };
   static uint_t uNumWrPhrases = (uint_t)arraysize(wrPhrase);
 
   BsClient_P        pClient = (BsClient_P)pArg;
   const char       *sClientName = bsClientAttrGetName(pClient);
   uint_t            uCloseFreq = 50;
   BsVConnHnd_T      hndVConn;
   bool_t            bIsOpen;
   byte_t            buf[1024];
   uint_t            i;
   int               rc;
 
   // open proxied device
   hndVConn = bsSerialReqOpen(pClient, OptsDevSerial,
                             115200, 8, 'N', 1, false, false, false);
 
   if( hndVConn < 0 )
   {
     BSCLIENT_LOG_ERROR(pClient, hndVConn, "%s", OptsDevSerial);
     return NULL;
   }
 
   printf("<%s>: serialopen: %s\n", sClientName, OptsDevSerial);
 
   bIsOpen     = true;
 
   printf("<%s>: serial load test thread started.\n", sClientName);
 
   while( true )
   {
     // randomly sleep between minimum and maximum times
     RandSleep(LT_T_MIN, LT_T_MAX);
 
     // choose random request to send
     switch( actions[RandN(uNumActions)] )
     {
       case ActionOpenClose:
         if( bIsOpen )
         {
           if( RandN(uCloseFreq) == 0 )
           {
             rc = bsSerialReqClose(pClient, hndVConn);
             if( rc == BS_OK )
             {
               printf("<%s>: serialclose: %s\n", sClientName, OptsDevSerial);
               bIsOpen = false;
             }
             else
             {
               printf("<%s>: serialclose: failed: rc=%d\n", sClientName, rc);
             }
           }
         }
         else
         {
           // open proxied device
           hndVConn = bsSerialReqOpen(pClient, OptsDevSerial,
                             115200, 8, 'N', 1, false, false, false);
 
           if( hndVConn >= 0 )
           {
             printf("<%s>: serialopen: %s\n", sClientName, OptsDevSerial);
             bIsOpen = true;
           }
           else
           {
             printf("<%s>: serialopen: failed: rc=%d\n", sClientName, hndVConn);
           }
         }
         break;
       case ActionWrite:
         if( bIsOpen )
         {
           i = RandN(uNumWrPhrases);
           memcpy(buf, wrPhrase[i], strlen(wrPhrase[i]));
           rc = bsSerialReqWrite(pClient, hndVConn, buf, strlen(wrPhrase[i]));
           if( rc > 0 )
           {
             printf("<%s>: serialwrite: %d bytes: \"%*s\"\n",
                 sClientName, rc, rc, wrPhrase[i]);
           } 
           else
           {
             printf("<%s>: serialwrite: failed: rc=%d\n", sClientName, rc);
           }
         }
         break;
       case ActionRead:
       case ActionTrans:
       default:
         break;
     }
   }
 
   printf("<%s>: serial load test thread terminated.\n", sClientName);
 
   return NULL;
 }

static void* LtThreadServer ( void * pArg )

static

Load test server-terminated messages thread.

Parameters

pArg	BotSense client (casted as a NULL).

Returns: Returns NULL on thread exit.

Definition at line 733 of file bsLoadTest.c.

References BS_OK, BSPROXY_VCONN_SERVER, BSPROXY_VCONN_UNDEF, BsProxyMsgIdReqGetVConnInfo, BsProxyMsgIdReqGetVConnList, BsProxyMsgIdReqGetVersion, BsProxyMsgIdReqLoopback, BsProxyMsgIdReqMsgTrace, BsProxyMsgIdReqSetLogging, LT_MAX_VCONN, LT_T_MAX, LT_T_MIN, BsVConnInfo_T::m_client, BsVConnInfo_T::m_devuri, BsVConnInfo_T::m_moddate, BsVConnInfo_T::m_moduri, BsVConnInfo_T::m_modver, BsVConnInfo_T::m_rd, BsVecHandles_T::m_uCount, BsVConnInfo_T::m_vconn, BsVecHandles_T::m_vecHnd, OptsFixedDiag, RandN(), RandSleep(), and RandVConn().

Referenced by ClientStartTestThreadServer().

 {
   enum ActionOps
   {
     ActionLoopback      = BsProxyMsgIdReqLoopback,
     ActionSetLogging    = BsProxyMsgIdReqSetLogging,
     ActionGetVersion    = BsProxyMsgIdReqGetVersion,
     ActionMsgTrace      = BsProxyMsgIdReqMsgTrace,
     ActionGetVConnList  = BsProxyMsgIdReqGetVConnList,
     ActionGetVConnInfo  = BsProxyMsgIdReqGetVConnInfo
   };
 
   static uint_t actions[] = 
   {
     ActionLoopback,     ActionSetLogging,    ActionGetVersion,
     ActionMsgTrace,     ActionGetVConnList,  ActionGetVConnInfo
   };
 
   static uint_t uNumActions = (uint_t)arraysize(actions);
 
   BsClient_P        pClient = (BsClient_P)pArg;
   const char       *sClientName = bsClientAttrGetName(pClient);
   BsVecHandles_T    vconnlist = {0, {0, }};
   BsVConnInfo_T     vconninfo;
   char              buf[1024];
   uint_t            i, j;
   BsVConnHnd_T      hndVConn;
   int               rc;
 
   printf("<%s>: server load test thread started.\n", sClientName);
 
   //bsServerReqMsgTrace(pClient, (BsVConnHnd_T)BSPROXY_VCONN_SERVER, true);
  
   while( true )
   {
     // randomly sleep between minimum and maximum times
     RandSleep(LT_T_MIN, LT_T_MAX);
 
     // choose random request to send
     switch( actions[RandN(uNumActions)] )
     {
       case ActionLoopback:
         sprintf(buf, "%s wants loopback.", sClientName);
         rc = bsServerReqLoopback(pClient, buf);
         if( rc == BS_OK )
         {
           printf("<%s>: loopback: \"%s\"\n", sClientName, buf);
         }
         else
         {
           printf("<%s>: loopback: failed: rc=%d\n", sClientName, rc);
         }
         break;
       case ActionSetLogging:
         if( !OptsFixedDiag )
         {
           i = RandN(5);
           rc = bsServerReqSetLogging(pClient, (int)i);
           if( rc == BS_OK )
           {
             printf("<%s>: setlogging: %d\n", sClientName, (int)i);
           }
           else
           {
             printf("<%s>: setlogging: failed: rc=%d\n", sClientName, rc);
           }
         }
         break;
       case ActionGetVersion:
         rc = bsServerReqGetVersion(pClient, buf, sizeof(buf));
         if( rc == BS_OK )
         {
           printf("<%s>: getversion: \"%s\"\n", sClientName, buf);
         }
         else
         {
           printf("<%s>: getversion: failed: rc=%d\n", sClientName, rc);
         }
         break;
       case ActionMsgTrace:
         if( !OptsFixedDiag )
         {
           i = RandN(LT_MAX_VCONN+1); // n dev handles/client + 1 server handle
           if( i == LT_MAX_VCONN )
           {
             hndVConn = BSPROXY_VCONN_SERVER;
           }
           else
           {
             hndVConn = RandVConn(&vconnlist);
           }
           if( hndVConn != BSPROXY_VCONN_UNDEF )
           {
             j = RandN(2); // do [not] trace
             rc = bsServerReqMsgTrace(pClient, hndVConn, (bool_t)j);
             if( rc == BS_OK )
             {
               printf("<%s>: msgtrace: vconn=%d, trace=%d\n",
                     sClientName, hndVConn, (int)j);
             }
             else
             {
               vconnlist.m_uCount = 0;
               printf("<%s>: msgtrace: failed: rc=%d\n", sClientName, rc);
             }
           }
         }
         break;
       case ActionGetVConnList:
         rc = bsServerReqGetVConnList(pClient, &vconnlist);
         if( rc == BS_OK )
         {
           printf("<%s>: getvconnlist: (%zu)", sClientName, vconnlist.m_uCount);
           for(i=0; i<vconnlist.m_uCount; ++i)
           {
             printf(" %d", vconnlist.m_vecHnd[i]);
           }
           printf("\n");
         }
         else
         {
           vconnlist.m_uCount = 0;
           printf("<%s>: getvconnlist: failed: rc=%d\n", sClientName, rc);
         }
         break;
       case ActionGetVConnInfo:
         hndVConn = RandVConn(&vconnlist);
         if( hndVConn != BSPROXY_VCONN_UNDEF )
         {
           rc = bsServerReqGetVConnInfo(pClient, hndVConn, &vconninfo);
           if( rc == BS_OK )
           {
             printf("<%s>: getvconninfo:\n", sClientName);
             printf("  vconn   = %d\n", vconninfo.m_vconn);
             printf("  rd      = %d\n", vconninfo.m_rd);
             printf("  client  = %s\n", vconninfo.m_client);
             printf("  devuri  = %s\n", vconninfo.m_devuri);
             printf("  moduri  = %s\n", vconninfo.m_moduri);
             printf("  modver  = %s\n", vconninfo.m_modver);
             printf("  moddate = %s\n", vconninfo.m_moddate);
           }
           else
           {
             vconnlist.m_uCount = 0;
             printf("<%s>: getvconninfo: failed: rc=%d\n", sClientName, rc);
           }
         }
         break;
       default:
         break;
     }
   }
 
   printf("<%s>: server load test thread terminated.\n", sClientName);
 
   return NULL;
 }

int main	(	int	argc,
		char *	argv[]
	)

Application main.

Parameters

argc	Command-line argument count.
argv	Command-line argument list.

Exit Status:: Program exits with 0 success, > 0 on failure.

Definition at line 1142 of file bsLoadTest.c.

References APP_EC_OK, CreateTestClient(), MainInit(), and OptsClientCnt.

 {
   int   i;
 
   // Initialize command.
   MainInit(argc, argv);
 
   //
   // Create client load tester
   //
   for(i=0; i<OptsClientCnt; ++i)
   {
     Client[i] = CreateTestClient(i);
   }
 
   //
   // Wait for interrupt.
   //
   while( true )
   {
     sleep(5);
   }
 
   //
   // Disonnect from server. All opened proxied devices are automatically closed.
   // Then delete client, freeing up all resources.
   //
   for(i=0; i<OptsClientCnt; ++i)
   {
     bsServerDisconnect(Client[i]);
     bsClientDelete(Client[i]);
   }
 
   return APP_EC_OK;
 }

static int MainInit	(	int	argc,
		char *	argv[]
	)

static

Initialize application.

Any command-line error immediately terminates application.

Parameters

argc	Command-line argument count.
argv	Command-line argument list.

Returns: Returns APP_EC_OK on success, >0 exit code on failure.

Definition at line 1117 of file bsLoadTest.c.

References APP_EC_OK, Argv0, OptsInfo, PgmInfo, PkgInfo, and RandSeed().

Referenced by main().

 {
   // Name of this process.
   Argv0 = basename(argv[0]);
 
     // 
   // Parse input options.
   //
   argv = OptsGet(Argv0, &PkgInfo, &PgmInfo, OptsInfo, true, &argc, argv);
 
   RandSeed();
 
   return APP_EC_OK;
 }

static int OptsCvtArgClientCnt	(	const char *	argv0,
		const char *	sOptName,
		char *	optarg,
		void *	pOptVal
	)

static

Convert command-line client count option.

Parameters

	argv0	Command name.
	sOptName	Option name.
	optarg	Parsed option argument to convert (optional).
[out]	pOptVal	Pointer to converted option value (not used).

Exceptions

OptsInvalid()

Returns: If returns, then returns BS_OK.

Definition at line 1036 of file bsLoadTest.c.

References Argv0, BS_OK, LT_MAX_CLIENTS, and OptsClientCnt.

 {
   OptsCvtArgInt(argv0, sOptName, optarg, &OptsClientCnt);
 
   if( (OptsClientCnt < 0) || (OptsClientCnt > LT_MAX_CLIENTS) )
   {
     OptsInvalid(Argv0, "'%s': Client '%s' argument out-of-range.",
         optarg, sOptName);
   }
 
   return BS_OK;
 }

static int OptsCvtArgDevices	(	const char *	argv0,
		const char *	sOptName,
		char *	optarg,
		void *	pOptVal
	)

static

Convert command-line devices option string to bitmap.

Option Argument Syntax:: list: dev[,dev...]
behavior: server i2c null serial

Parameters

	argv0	Command name.
	sOptName	Option name.
	optarg	Parsed option argument to convert (optional).
[out]	pOptVal	Pointer to converted option value (not used).

Returns: If returns, then returns BS_OK.

Definition at line 1064 of file bsLoadTest.c.

References Argv0, BS_OK, LT_DEV_I2C, LT_DEV_NULL, LT_DEV_SERIAL, LT_DEV_SERVER, and ProxiedDevices.

 {
   char               *sList;          // pointer to list string
   char               *sDev;           // pointer to device string
   
   ProxiedDevices = 0;
 
   sList = new_strdup(optarg);
 
   for(sDev=strtok(sList, ",");
       sDev!=NULL;
       sDev=strtok(NULL, ","))
   {
     if( !strcmp(sDev, "server") )
     {
       ProxiedDevices |= LT_DEV_SERVER;
     }
     else if( !strcmp(sDev, "i2c") )
     {
       ProxiedDevices |= LT_DEV_I2C;
     }
     else if( !strcmp(sDev, "null") )
     {
       ProxiedDevices |= LT_DEV_NULL;
     }
     else if( !strcmp(sDev, "serial") )
     {
       ProxiedDevices |= LT_DEV_SERIAL;
     }
     else
     {
       OptsInvalid(Argv0, "'%s': Option '%s': Unknown device '%s'.",
         optarg, sOptName, sDev);
     }
   }
 
   delete(sList);
 
   return BS_OK;
 }

static int OptsCvtArgServerAddr	(	const char *	argv0,
		const char *	sOptName,
		char *	optarg,
		void *	pOptVal
	)

static

Convert command-line server option IP address string to network name/number and port number.

Option Argument Syntax:: proxy: addr[:port]

Parameters

	argv0	Command name.
	sOptName	Option name.
	optarg	Parsed option argument to convert (optional).
[out]	pOptVal	Pointer to converted option value (not used).

Exceptions

OptsInvalid()

Returns: If returns, then returns BS_OK.

Definition at line 986 of file bsLoadTest.c.

References Argv0, BS_OK, BSPROXY_LISTEN_PORT_DFT, ProxyIPAddr, and ProxyIPPort.

 {
   char  *sSepField;
   char  *sPort;
 
   ProxyIPAddr = NULL;
   ProxyIPPort = 0;
 
   ProxyIPAddr = new_strdup(optarg);
 
   sSepField = strchr(ProxyIPAddr, ':');
 
   if( sSepField )
   {
     *sSepField    = 0;
     sPort         = sSepField+1;
     ProxyIPPort = (int)atol(sPort);
     if( ProxyIPPort <= 0 )
     {
       OptsInvalid(Argv0, "'%s': Invalid '%s' argument port value.",
           optarg, sOptName);
     }
   }
   else
   {
     ProxyIPPort = BSPROXY_LISTEN_PORT_DFT;
   }
 
   if( *ProxyIPAddr == 0 )
   {
     OptsInvalid(Argv0, "'%s': Invalid '%s' argument address value.",
         optarg, sOptName);
   }
 
   return BS_OK;
 }

static uint_t RandN ( uint_t n )

static

Generate random integer between [0,n).

Parameters

n	Upper value.

Returns: Random unsigned integer.

Definition at line 269 of file bsLoadTest.c.

References RandomSeq.

Referenced by LtThreadI2C(), LtThreadNull(), LtThreadSerial(), LtThreadServer(), RandSleep(), and RandVConn().

 {
   double  r;
 
   r = erand48( RandomSeq.xsubi );
 
   return (uint_t)(n * r);
 }

static void RandSleep	(	uint_t	tmin,
		uint_t	tmax
	)

static

Sleep for a random μs duration between [tmin, tmax].

Parameters

tmin	Minimum sleep value.
tmax	Maximum sleep value.

Definition at line 284 of file bsLoadTest.c.

References RandN().

Referenced by LtThreadI2C(), LtThreadNull(), LtThreadSerial(), and LtThreadServer().

 {
   usleep( tmin + RandN(tmax-tmin) );
 }

static BsVConnHnd_T RandVConn ( BsVecHandles_T * pVConnList )

static

Randomly pick a virtual connection in list.

Parameters

pVConnList Virtual connection list.

Returns: Virtual connection handle.

Definition at line 296 of file bsLoadTest.c.

References BSPROXY_VCONN_UNDEF, BsVecHandles_T::m_uCount, BsVecHandles_T::m_vecHnd, and RandN().

Referenced by LtThreadServer().

 {
   if( pVConnList->m_uCount == 0 )
   {
     return (BsVConnHnd_T)BSPROXY_VCONN_UNDEF;
   }
   else
   {
     return pVConnList->m_vecHnd[RandN((uint_t)pVConnList->m_uCount)];
   }
 }

Variable Documentation

OptsPgmInfo_T PgmInfo

static

Initial value:

=
{
  .synopsis =
    "BotSense bsProxy server load tester client.",
  .long_desc = 
    "The %P application creates a multi-client, multi-thread application to "
    "load test both the bsProxy server and the libbotsense client library."
}

Program information.

Definition at line 127 of file bsLoadTest.c.

Referenced by MainInit().

uint_t ProxiedDevices

static

Initial value:

= 0x0001 |

0x0004

proxied devices

Definition at line 240 of file bsLoadTest.c.

Referenced by CreateTestClient(), and OptsCvtArgDevices().

Macros

Functions

Variables

Detailed Description

Function Documentation

Variable Documentation