Agent Server and Client functions

Collaboration diagram for Agent Server and Client functions:

Functions
	Cosmos::Support::Agent::Agent (const string &node_name="", const string &agent_name="", double bprd=0., uint32_t bsize=AGENTMAXBUFFER, bool mflag=false, int32_t portnum=0, NetworkType ntype=NetworkType::UDP, uint16_t dlevel=1)
	Cosmos::Support::Agent::~Agent ()
int32_t	Cosmos::Support::Agent::add_request (string token, external_request_function function, string synopsis="", string description="")
	Add internal request to Agent request list with description and synopsis. More...
int32_t	Cosmos::Support::Agent::start ()
	Start Agent Request and Heartbeat loops. More...
int32_t	Cosmos::Support::Agent::start_active_loop ()
int32_t	Cosmos::Support::Agent::finish_active_loop ()
int32_t	Cosmos::Support::Agent::shutdown ()
	Shutdown agent gracefully. More...
uint16_t	Cosmos::Support::Agent::running ()
	Check if we're supposed to be running. More...
int32_t	Cosmos::Support::Agent::wait (State state=State::RUN, double waitsec=10.)
int32_t	Cosmos::Support::Agent::last_error ()
int32_t	Cosmos::Support::Agent::send_request (beatstruc cbeat, string request, string &output, float waitsec=5.)
	Send a request over AGENT. More...
int32_t	Cosmos::Support::Agent::send_request_jsonnode (beatstruc cbeat, jsonnode &jnode, float waitsec=5.)
	Send request for Node JSON. More...
int32_t	Cosmos::Support::Agent::get_agent (string node, string agent, double waitsec, beatstruc &cbeat)
	Get specific server. More...
int32_t	Cosmos::Support::Agent::check_agent (string node, string agent, double waitsec)
	Check agent. More...
beatstruc	Cosmos::Support::Agent::find_agent (string node, string agent, double waitsec=0.)
	Find agent. More...
vector< beatstruc >	Cosmos::Support::Agent::find_agents (double waitsec=0.)
	Find single server. More...
int32_t	Cosmos::Support::Agent::set_sohstring (string list)
	Set Limited SOH string. More...
int32_t	Cosmos::Support::Agent::set_fullsohstring (string list)
	Set Full SOH string. More...
cosmosstruc *	Cosmos::Support::Agent::get_cosmosstruc ()
	Return Agent cosmosstruc. More...
void	Cosmos::Support::Agent::heartbeat_loop ()
	Heartbeat Loop. More...
void	Cosmos::Support::Agent::request_loop () noexcept
	Request Loop. More...
int32_t	Cosmos::Support::Agent::process_request (string &bufferin, string &bufferout)
void	Cosmos::Support::Agent::message_loop ()
static int32_t	Cosmos::Support::Agent::req_forward (string &request, string &response, Agent *agent)
	Built-in Forward request. More...
static int32_t	Cosmos::Support::Agent::req_echo (string &request, string &response, Agent *agent)
	Built-in Echo request. More...
static int32_t	Cosmos::Support::Agent::req_help_json (string &request, string &response, Agent *agent)
	Built-in Help request. More...
static int32_t	Cosmos::Support::Agent::req_help (string &request, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_run (string &request, string &response, Agent *agent)
	Built-in Set state to Run request. More...
static int32_t	Cosmos::Support::Agent::req_init (string &request, string &response, Agent *agent)
	Built-in Set state to Init request. More...
static int32_t	Cosmos::Support::Agent::req_idle (string &request, string &response, Agent *agent)
	Built-in Set state to Idle request. More...
static int32_t	Cosmos::Support::Agent::req_monitor (string &request, string &response, Agent *agent)
	Built-in Set state to Monitor request. More...
static int32_t	Cosmos::Support::Agent::req_reset (string &request, string &response, Agent *agent)
	Built-in Set state to Reset request. More...
static int32_t	Cosmos::Support::Agent::req_shutdown (string &request, string &response, Agent *agent)
	Built-in Set state to Shutdown request. More...
static int32_t	Cosmos::Support::Agent::req_status (string &request, string &response, Agent *agent)
	Built-in Status request. More...
static int32_t	Cosmos::Support::Agent::req_debug_level (string &request, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_getvalue (string &request, string &response, Agent *agent)
	Built-in Get Internal Value request. More...
static int32_t	Cosmos::Support::Agent::req_get_value (string &request, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_get_time (string &request, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_get_position_data (string &request, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_get_position (string &request, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_setvalue (string &request, string &response, Agent *agent)
	Built-in Set Internal Value request. More...
static int32_t	Cosmos::Support::Agent::req_set_value (string &request, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_listnames (string &request, string &response, Agent *agent)
	Built-in List Name Space Names request. More...
static int32_t	Cosmos::Support::Agent::req_nodejson (string &request, string &response, Agent *agent)
	Built-in Return Node JSON request. More...
static int32_t	Cosmos::Support::Agent::req_statejson (string &request, string &response, Agent *agent)
	Built-in Return State Vector JSON request. More...
static int32_t	Cosmos::Support::Agent::req_utcstartjson (string &request, string &response, Agent *agent)
	Built-in Return UTC Start Time JSON request. More...
static int32_t	Cosmos::Support::Agent::req_piecesjson (string &request, string &response, Agent *agent)
	Built-in Return Pieces JSON request. More...
static int32_t	Cosmos::Support::Agent::req_facesjson (string &request, string &response, Agent *agent)
	Built-in Return Face JSON request. More...
static int32_t	Cosmos::Support::Agent::req_vertexsjson (string &request, string &response, Agent *agent)
	Built-in Return Vertex JSON request. More...
static int32_t	Cosmos::Support::Agent::req_devgenjson (string &request, string &response, Agent *agent)
	Built-in Return devgen JSON request. More...
static int32_t	Cosmos::Support::Agent::req_devspecjson (string &request, string &response, Agent *agent)
	Built-in Return devspec JSON request. More...
static int32_t	Cosmos::Support::Agent::req_portsjson (string &request, string &response, Agent *agent)
	Built-in Return Ports JSON request. More...
static int32_t	Cosmos::Support::Agent::req_targetsjson (string &request, string &response, Agent *agent)
	Built-in Return Target JSON request. More...
static int32_t	Cosmos::Support::Agent::req_heartbeat (string &request, string &response, Agent *agent)
	Built-in Send Heartbeat request. More...
static int32_t	Cosmos::Support::Agent::req_postsoh (string &request, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_utc (string &request, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_soh (string &, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_fullsoh (string &, string &response, Agent *agent)
static int32_t	Cosmos::Support::Agent::req_jsondump (string &, string &response, Agent *agent)
int32_t	Cosmos::Support::Agent::publish (NetworkType type, uint16_t port)
	Open COSMOS output channel. More...
vector< socket_channel >	Cosmos::Support::Agent::find_addresses (NetworkType ntype)
	Discover interfaces. More...
int32_t	Cosmos::Support::Agent::post (messstruc mess)
	Post a Cosmos::Agent::messstruc. More...
int32_t	Cosmos::Support::Agent::post (AgentMessage type, string message="")
	Post a JSON message. More...
int32_t	Cosmos::Support::Agent::post (AgentMessage type, vector< uint8_t > message)
	Post a binary message. More...
int32_t	Cosmos::Support::Agent::post_beat ()
int32_t	Cosmos::Support::Agent::post_soh ()
int32_t	Cosmos::Support::Agent::unpublish ()
	Close COSMOS output channel. More...
int32_t	Cosmos::Support::Agent::subscribe (NetworkType type, const char *address, uint16_t port, uint32_t usectimeo)
	Open COSMOS channel for polling. More...
int32_t	Cosmos::Support::Agent::subscribe (NetworkType type, const char *address, uint16_t port)
	Open COSMOS channel for polling with 100 usec timeout. More...
int32_t	Cosmos::Support::Agent::unsubscribe ()
	Close COSMOS subscription channel. More...
int32_t	Cosmos::Support::Agent::poll (messstruc &mess, AgentMessage type, float waitsec=1.)
	Listen for message. More...
int32_t	Cosmos::Support::Agent::readring (messstruc &message, AgentMessage type=Agent::AgentMessage::ALL, float waitsec=1., Where where=Where::TAIL, string proc="", string node="")
	Check Ring for message. More...
int32_t	Cosmos::Support::Agent::parsering (AgentMessage type=Agent::AgentMessage::ALL, float waitsec=1., Where where=Where::HEAD, string proc="", string node="")
	Parse next message from ring. More...
int32_t	Cosmos::Support::Agent::resizering (size_t newsize)
int32_t	Cosmos::Support::Agent::clearring ()
string	Cosmos::Support::Agent::getNode ()
	Listen for heartbeat. More...
string	Cosmos::Support::Agent::getAgent ()
int32_t	Cosmos::Support::Agent::getJson (string node, jsonnode &jnode)
FILE *	Cosmos::Support::Agent::get_debug_fd (double mjd=0.)
int32_t	Cosmos::Support::Agent::close_debug_fd ()
int32_t	Cosmos::Support::Agent::set_agent_time_producer (double(*source)())
int32_t	Cosmos::Support::Agent::get_agent_time (double &agent_time, double &epsilon, double &delta, string agent, string node="any", double wait_sec=2.)

Detailed Description

Function Documentation

Cosmos::Support::Agent::Agent	(	const string &	node_name = "",
		const string &	agent_name = "",
		double	bprd = 0.,
		uint32_t	bsize = AGENTMAXBUFFER,
		bool	mflag = false,
		int32_t	portnum = 0,
		NetworkType	ntype = NetworkType::UDP,
		uint16_t	dlevel = 1
	)

Add COSMOS awareness. Sets up minimum framework for COSMOS awareness. The minimum call makes a nodeless client, setting up the message ring buffer thread, and a main thread of execution. Additional parameters are related to making the program a true Agent by tieing it to a node, and starting the request and heartbeat threads.

Parameters

ntype	Transport Layer protocol to be used, taken from NetworkType. Defaults to UDP Broadcast.
node_name	Node name. Defaults to empty.
agent_name	Agent name. Defaults to empty. If this is defined, the full Agent code will be started.
bprd	Period, in seconds, for heartbeat. Defaults to 1.
bsize	Size of interagent communication buffer. Defaults to AGENTMAXBUFFER.
mflag	Boolean controlling whether or not multiple instances of the same Agent can start. If true, then Agent names will have an index number appended (eg: myname_001). If false, agent will listen for 5 seconds and terminate if it senses the Agent already running.
portnum	The network port to listen on for requests. Defaults to 0 whereupon it will use whatever th OS assigns.
dlevel	debug level. Defaults to 1 so that if there is an error the user can immediately see it. also initialized in the namespace variables

Set up initial requests

    {
        int32_t iretn;
        debug_level = dlevel;

        // Initialize COSMOS data space
        cinfo = json_init();

        if (cinfo == nullptr) {
            error_value = AGENT_ERROR_JSON_CREATE;
            shutdown();
            return;
        }

        cinfo->agent[0].stateflag = static_cast<uint16_t>(State::INIT);

        // Establish subscribe channel
        iretn = subscribe(ntype, AGENTMCAST, AGENTSENDPORT, 1000);
        if (iretn) {
            error_value = iretn;
            shutdown();
            return;
        }

        // Set up node: shorten if too long, use hostname if it's empty.
        nodeName = node_name;
        if ((iretn=json_setup_node(nodeName, cinfo)) != 0) {
            error_value = iretn;
            shutdown();
            return;
        }

        strcpy(cinfo->node.name, nodeName.c_str());

        cinfo->agent[0].client = 1;
        cinfo->node.utc = 0.;
        strncpy(cinfo->agent[0].beat.node, cinfo->node.name ,COSMOS_MAX_NAME);

        // Establish publish channel
        cinfo->agent[0].beat.ntype = ntype;
        iretn = publish(cinfo->agent[0].beat.ntype, AGENTSENDPORT);
        if (iretn) {
            error_value = iretn;
            shutdown();
            return;
        }

        // Start message listening thread
        mthread = thread([=] { message_loop(); });
        COSMOS_SLEEP(.1);

        // Return if all we are doing is setting up client.
        if (agent_name.empty()) {
            strcpy(cinfo->agent[0].beat.proc, "");
            cinfo->agent[0].stateflag = static_cast <uint16_t>(Agent::State::RUN);
            return;
        }

        if (strlen(cinfo->node.name)>COSMOS_MAX_NAME || agent_name.length()>COSMOS_MAX_NAME) {
            error_value = JSON_ERROR_NAME_LENGTH;
            shutdown();
            return;
        }


        // If not Multi, check if this Agent is already running
        char tname[COSMOS_MAX_NAME+1];
        if (!mflag) {
            if (check_agent(cinfo->node.name, agent_name, timeoutSec)) {
                error_value = AGENT_ERROR_SERVER_RUNNING;
                shutdown();
                return;
            }
            strcpy(tname,agent_name.c_str());
        } else {
            // then there is an agent running with the given name, so let's make the name unique
            if (strlen(cinfo->node.name)>COSMOS_MAX_NAME-4 || agent_name.size()>COSMOS_MAX_NAME-4) {
                error_value = JSON_ERROR_NAME_LENGTH;
                shutdown();
                return;
            }

            uint32_t i=0;
            do
            {
                sprintf(tname,"%s_%03d",agent_name.c_str(),i);
                if (!check_agent(cinfo->node.name, tname, timeoutSec))
                {
                    break;
                }
            } while (++i<100);
        }

        // Initialize important server variables

        strncpy(cinfo->agent[0].beat.node, cinfo->node.name, COSMOS_MAX_NAME);
        strncpy(cinfo->agent[0].beat.proc, tname, COSMOS_MAX_NAME);
        agentName = cinfo->agent[0].beat.proc;

        if (debug_level>2) {
            double timeStart = currentmjd();
            fprintf(get_debug_fd(), "------------------------------------------------------\n");
            fprintf(get_debug_fd(), "COSMOS AGENT '%s' on node '%s'\n", agent_name.c_str(), node_name.c_str());
            fprintf(get_debug_fd(), "Version %s built on %s %s\n", version.c_str(),  __DATE__, __TIME__);
            fprintf(get_debug_fd(), "Agent started at %s\n", mjdToGregorian(timeStart).c_str());
            fprintf(get_debug_fd(), "Debug level %u\n", debug_level);
            fprintf(get_debug_fd(), "------------------------------------------------------\n");
        }

        if (bprd >= AGENT_HEARTBEAT_PERIOD_MIN) {
            cinfo->agent[0].beat.bprd = bprd;
        } else {
            cinfo->agent[0].beat.bprd = 0.;
        }
        cinfo->agent[0].stateflag = static_cast<uint16_t>(State::INIT);
        cinfo->agent[0].beat.port = static_cast<uint16_t>(portnum);
        cinfo->agent[0].beat.bsz = (bsize<=AGENTMAXBUFFER-4?bsize:AGENTMAXBUFFER-4);

#ifdef COSMOS_WIN_BUILD_MSVC
        cinfo->agent[0].pid = _getpid();
#else
        cinfo->agent[0].pid = getpid();
#endif
        cinfo->agent[0].aprd = 1.;
        strncpy(cinfo->agent[0].beat.user, "cosmos", COSMOS_MAX_NAME);

        // Start the heartbeat and request threads running
        //    iretn = start();
        hthread = thread([=] { heartbeat_loop(); });
        cthread = thread([=] { request_loop(); });
        if (!hthread.joinable() || !cthread.joinable()) {
            // TODO: create error value
            //error_value = iretn;
            shutdown();
            return;
        }

        add_request("help",req_help,"","list of available requests for this agent");
        add_request("help_json",req_help_json,"","list of available requests for this agent (but in json)");
        add_request("shutdown",req_shutdown,"","request to shutdown this agent");
        add_request("idle",req_idle,"","request to transition this agent to idle state");
        add_request("init",req_init,"","request to transition this agent to init state");
        add_request("monitor",req_monitor,"","request to transition this agent to monitor state");
        add_request("reset",req_reset,"","request to transition this agent to reset state");
        add_request("run",req_run,"","request to transition this agent to run state");
        add_request("status",req_status,"","request the status of this agent");
        add_request("debug_level",req_debug_level,"{\"name1\",\"name2\",...}","get/set debug_level of agent");
        add_request("getvalue",req_getvalue,"{\"name1\",\"name2\",...}","get specified value(s) from agent");
        add_request("get_value",req_get_value,"[{] \"name1\",\"name2\",... [}]","get specified value(s) from agent");
        add_request("get_time",req_get_time,"","return the current time of the agent");
        add_request("get_position",req_get_position,"","return the current perifocal position of the agent");
        add_request("get_position_data",req_get_position_data,"","return the current perifocal position of the agent");
        add_request("setvalue",req_setvalue,"{\"name1\":value},{\"name2\":value},...","set specified value(s) in agent");
        add_request("set_value",req_set_value,"{\"name1\":value} [,] {\"name2\":value} [,] ...","set specified value(s) in agent");
        add_request("listnames",req_listnames,"","list the Namespace of the agent");
        add_request("forward",req_forward,"nbytes packet","Broadcast JSON packet to the default SEND port on local network");
        add_request("echo",req_echo,"utc crc nbytes bytes","echo array of nbytes bytes, sent at time utc, with CRC crc.");
        add_request("nodejson",req_nodejson,"","return description JSON for Node");
        add_request("statejson",req_statejson,"","return description JSON for State vector");
        add_request("utcstartjson",req_utcstartjson,"","return description JSON for UTC Start time");
        add_request("piecesjson",req_piecesjson,"","return description JSON for Pieces");
        add_request("vertexsjson",req_vertexsjson,"","return description JSON for Pieces");
        add_request("facesjson",req_facesjson,"","return description JSON for Pieces");
        add_request("devgenjson",req_devgenjson,"","return description JSON for General Devices");
        add_request("devspecjson",req_devspecjson,"","return description JSON for Specific Devices");
        add_request("portsjson",req_portsjson,"","return description JSON for Ports");
        add_request("targetsjson",req_targetsjson,"","return description JSON for Targets");
        add_request("heartbeat",req_heartbeat,"","Post a hearbeat");
        add_request("postsoh",req_postsoh,"","Post a SOH");
        add_request("utc",req_utc,"","Get UTC as both Modified Julian Day and Unix Time");
        add_request("soh",req_soh,"","Get Limited SOH string");
        add_request("fullsoh",req_fullsoh,"","Get Full SOH string");
        add_request("jsondump",req_jsondump,"","Dump JSON ini files to node folder");

        // Set up Full SOH string
//            set_fullsohstring(json_list_of_fullsoh(cinfo));

        cinfo->agent[0].server = 1;
        cinfo->agent[0].stateflag = static_cast<uint16_t>(Agent::State::RUN);
        activeTimeout = currentmjd() + cinfo->agent[0].aprd / 86400.;
    }

Cosmos::Support::Agent::~Agent

(

)

{ Agent::shutdown(); }

int32_t Cosmos::Support::Agent::add_request	(	string	token,
		Agent::external_request_function	function,
		string	synopsis = "",
		string	description = ""
	)

Add internal request to Agent request list with description and synopsis.

Adds access to the indicated function by way of the given token. The provided function, internal to the agent, will be called with the request string as its argument. Any result will then be returned in the output pointer.

Parameters

token	A string of maximum length COSMOS_MAX_NAME containing the token for the request. This should be the first word in the request.
function	The user supplied function to parse the specified request.
description	A brief description of the function performed.
synopsis	A usage synopsis for the request.

Returns

Error, if any, otherwise zero.Add external request to Agent request list with description and synopsis.

    Adds access to the indicated function by way of the given token. The provided

function, external to the agent, will be called with the request string as its argument. Any result will then be returned in the output pointer.

Parameters

token	A string of maximum length COSMOS_MAX_NAME containing the token for the request. This should be the first word in the request.
function	The user supplied function to parse the specified request.
description	A brief description of the function performed.
synopsis	A usage synopsis for the request.

Returns

Error, if any, otherwise zero.

      {
        if (reqs.size() > AGENTMAXREQUESTCOUNT) return (AGENT_ERROR_REQ_COUNT);

        request_entry tentry;
        if (token.size() > COSMOS_MAX_NAME) { token.resize(COSMOS_MAX_NAME); }
        tentry.token = token;
//            tentry.ifunction = nullptr;
        tentry.efunction = function;
        tentry.synopsis = synopsis;
        tentry.description = description;
        reqs.push_back(tentry);
        return 0;
    }

int32_t Cosmos::Support::Agent::start

(

)

Start Agent Request and Heartbeat loops.

Starts the request and heartbeat threads for an Agent server initialized with Cosmos::Agent::Agent. The Agent will open its request and heartbeat channels using the address and port supplied in cinfo. The heartbeat will cycle with the period requested in cinfo.

Returns

value returned by request thread create

                         {
        // start heartbeat thread
        hthread = thread([=] { heartbeat_loop(); });
        cthread = thread([=] { request_loop(); });
        return 0;
    }

int32_t Cosmos::Support::Agent::start_active_loop

(

)

Begin Active Loop Initializes timer for active loop using ::aprd

Returns

Zero or negative error.

                                     {
        activeTimeout = currentmjd() + cinfo->agent[0].aprd / 86400.;
        return 0;
    }

int32_t Cosmos::Support::Agent::finish_active_loop

(

)

Finish active loop Sleep for the remainder of this loops ::aprd as initialized in ::start_active_loop.

Returns

Zero or negative error.

                                      {
        double sleepsec = 86400.*(activeTimeout - currentmjd());
        activeTimeout += cinfo->agent[0].aprd / 86400.;
        COSMOS_SLEEP(sleepsec);
        return 0;
    }

int32_t Cosmos::Support::Agent::shutdown

(

)

Shutdown agent gracefully.

Waits for threads to stop running if we are a server, then releases everything.

Returns

0 or negative error.

    {
        if (debug_level) {
            fprintf(get_debug_fd(), "Shutting down Agent. Last error: %s\n", cosmos_error_string(error_value).c_str());
            fflush(stdout);
        }

        if (cinfo != nullptr) { cinfo->agent[0].stateflag = static_cast <uint16_t>(Agent::State::SHUTDOWN); }

        if (agentName.size()) {
            if (hthread.joinable()) { hthread.join(); }
            if (cthread.joinable()) { cthread.join(); }
            Agent::unpublish();
        }
        if (mthread.joinable()) { mthread.join(); }
        Agent::unsubscribe();
        json_destroy(cinfo);
        return 0;
    }

uint16_t Cosmos::Support::Agent::running

(

)

Check if we're supposed to be running.

Returns the value of the internal variable that indicates that the threads are running.

Returns

Value of internal state variable, as enumerated in Cosmos::Agent:State.

{ return cinfo->agent[0].stateflag; }

int32_t Cosmos::Support::Agent::wait	(	State	state = State::RUN,
		double	waitsec = 10.
	)

Wait on state Wait for up to waitsec seconds for Agent to enter requested state

Parameters

state	Desired ::Agent::State.
waitsec	Maximum number of seconds to wait.

Returns

Zero, or timeout error.

                                                   {
        if (cinfo == nullptr) { return AGENT_ERROR_NULL; }

        ElapsedTime et;
        while (cinfo->agent[0].stateflag != static_cast <uint16_t>(state) && et.split() < waitsec) {
            COSMOS_SLEEP(.1);
        }
        if (cinfo->agent[0].stateflag == static_cast <uint16_t>(state)) {
            return 0;
        } else {
            return GENERAL_ERROR_TIMEOUT;
        }
    }

int32_t Cosmos::Support::Agent::last_error

(

)

Last error value. Get value of last error returned by any function.

{ return (error_value); }

int32_t Cosmos::Support::Agent::send_request	(	beatstruc	hbeat,
		string	request,
		string &	output,
		float	waitsec = 5.
	)

Send a request over AGENT.

Send a request string to the process at the provided address

Parameters

hbeat	The agent beatstruc
request	the request and its arguments
output	any output returned by the request
waitsec	Maximum number of seconds to wait

Returns

Either the number of bytes returned, or an error number.

                                                                                              {
        socket_channel sendchan;
        int32_t iretn;
        int32_t nbytes;
        vector <char> toutput;
        toutput.resize(AGENTMAXBUFFER+1);

        if (hbeat.utc == 0. || hbeat.addr[0] == 0 || hbeat.port == 0) return (AGENT_ERROR_SOCKET);

        ElapsedTime ep;
        ep.start();

        if ((iretn=socket_open(&sendchan, NetworkType::UDP, hbeat.addr, hbeat.port, SOCKET_TALK, SOCKET_BLOCKING, AGENTRCVTIMEO)) < 0) { return (-errno); }
        //nbytes = strnlen(request.c_str(), hbeat.bsz);
        nbytes = std::min(request.size(), (size_t)hbeat.bsz);

        if ((nbytes=sendto(sendchan.cudp, request.c_str(), nbytes, 0, (struct sockaddr *)&sendchan.caddr, sizeof(struct sockaddr_in))) < 0) {
            CLOSE_SOCKET(sendchan.cudp);
#ifdef COSMOS_WIN_OS
            return(-WSAGetLastError());
#else
            return (-errno);
#endif
        }

        do { 
            nbytes = recvfrom(sendchan.cudp, toutput.data(), AGENTMAXBUFFER, 0, static_cast<struct sockaddr *>(nullptr), static_cast<socklen_t *>(nullptr));
        } while ( (nbytes <= 0) && (ep.split() <= waitsec) );

        CLOSE_SOCKET(sendchan.cudp);

        if (nbytes < 0) {
#ifdef COSMOS_WIN_OS
            return(-WSAGetLastError());
#else
            return (-errno);
#endif
        } else {
            //toutput[nbytes] = 0;
            toutput.resize(nbytes);
            string reply(toutput.begin(), toutput.end());
            output = reply;
            return (nbytes);
        }
    }

int32_t Cosmos::Support::Agent::send_request_jsonnode	(	beatstruc	hbeat,
		jsonnode &	jnode,
		float	waitsec = 5.
	)

Send request for Node JSON.

Send a set of requests to return the various JSON strings that make up a jsonnode.

Parameters

hbeat	The agent beatstruc
jnode	jsonnode cotaining Node information.
waitsec	Maximum number of seconds to wait.

Returns

Either the number of bytes returned, or an error number.

                                                                                        {
        int32_t iretn;

        jnode.name = hbeat.node;
        iretn = send_request(hbeat, "nodejson", jnode.node, waitsec);
        if (iretn < 0) { return iretn; }
        iretn = send_request(hbeat, "statejson", jnode.state, waitsec);
        if (iretn < 0) { return iretn; }
        iretn = send_request(hbeat, "utcstartjson", jnode.utcstart, waitsec);
        if (iretn < 0) { return iretn; }
        iretn = send_request(hbeat, "piecesjson", jnode.pieces, waitsec);
        if (iretn < 0) { return iretn; }
        iretn = send_request(hbeat, "facesjson", jnode.faces, waitsec);
        if (iretn < 0) { return iretn; }
        iretn = send_request(hbeat, "vertexsjson", jnode.vertexs, waitsec);
        if (iretn < 0) { return iretn; }
        iretn = send_request(hbeat, "devgenjson", jnode.devgen, waitsec);
        if (iretn < 0) { return iretn; }
        iretn = send_request(hbeat, "devspecjson", jnode.devspec, waitsec);
        if (iretn < 0) { return iretn; }
        iretn = send_request(hbeat, "portsjson", jnode.ports, waitsec);
        if (iretn < 0) { return iretn; }
        iretn = send_request(hbeat, "targetsjson", jnode.targets, waitsec);
        return iretn;
    }

int32_t Cosmos::Support::Agent::get_agent	(	string	node,
		string	agent,
		double	waitsec,
		beatstruc &	rbeat
	)

Get specific server.

Listen to the multicast/broadcast traffic for a set amount of time, waiting for a specific named server to appear, then return its heartbeat.

Parameters

node	Node for the server.
name	Name of the server.
waitsec	Maximum number of seconds to wait
rbeat	pointer to a location to store the heartbeat

Returns

1 if found, otherwise 0, or an error number

    {

        post(AgentMessage::REQUEST, "heartbeat");
        COSMOS_SLEEP(.1);

        ElapsedTime ep;
        ep.start();
        do {
            for (beatstruc &it : agent_list)
            {
                if ((node == "any" || string(it.node) == node) && string(it.proc) == agent)
                {
                    it.exists = true;
                    rbeat = it;
                    return 1;
                }
            }
            COSMOS_SLEEP(.1);
        } while (ep.split() < waitsec);

        rbeat.exists = false;
        rbeat.node[0] = '\0';
        return 0;
    }

int32_t Cosmos::Support::Agent::check_agent	(	string	node,
		string	agent,
		double	waitsec
	)

Check agent.

Check the Cosmos::Agent::agent_list for the particular agent

Parameters

agent	Name of agent.
node	Node that agent is in.
waitsec	Number of seconds to wait

Returns

1 if found, otherwise 0, or an error number

    {
        beatstruc tbeat;
        return get_agent(node, agent, waitsec, tbeat);
    }

beatstruc Cosmos::Support::Agent::find_agent	(	string	node,
		string	agent,
		double	waitsec = 0.
	)

Find agent.

Check the Cosmos::Agent::agent_list for the particular agent, returning its heartbeat if found.

Parameters

agent	Name of agent.
node	Node that agent is in.

Returns

beatstruc of located agent, otherwise empty beatstruc.

    {
        beatstruc rbeat;
        get_agent(node, agent, waitsec, rbeat);
        return rbeat;

        // ask all existing agents to send out a heartbeat
//        post(AgentMessage::REQUEST, "heartbeat");
//        COSMOS_SLEEP(.1);

//        ElapsedTime ep;
//        ep.start();
//        do {
//            for (beatstruc &it : agent_list)
//            {
//                if ((node == "any" || it.node == node) && it.proc == agent)
//                {
//                    it.exists = true;
//                    return it;
//                }
//            }
//            COSMOS_SLEEP(.1);
//        } while (ep.split() < waitsec);

//        beatstruc nobeat;
//        nobeat.exists = false;
//        nobeat.node[0] = '\0';
        
//        return nobeat;
    }

vector< beatstruc > Cosmos::Support::Agent::find_agents

(

double

waitsec = 0.

)

Find single server.

Listen to the local subnet for a set amount of time, collecting heartbeats, searching for a particular agent.

Parameters

node	Node that agent is in.
proc	Name of agent.
waitsec	Maximum number of seconds to wait.

Returns

beatstruc of located agent, otherwise empty ::beatstruc.Generate a list of request servers.

    Listen to the local subnet for a set amount of time,

collecting heartbeats. Return a list of heartbeats collected.

Parameters

waitsec

Maximum number of seconds to wait.

Returns

A vector of beatstruc entries listing the unique servers found.

Loop for waitsec seconds, filling list with any discovered heartbeats.

                                                       {
        beatstruc tbeat;


        ElapsedTime ep;
        ep.start();

        do {
            for (size_t k=0; k<agent_list.size(); ++k) {
                size_t i;
                for (i=0; i<slist.size(); i++) {
                    if (!strcmp(agent_list[k].node, slist[i].node) && !strcmp(agent_list[k].proc, slist[i].proc))
                        break;
                }
                if (i == slist.size()) {
                    slist.push_back(agent_list[k]);
                    for (size_t j=i; j>0; j--) {
                        if (slist[j].port > slist[j-1].port) { break; }
                        tbeat = slist[j];
                        slist[j] = slist[j-1];
                        slist[j-1] = tbeat;
                    }
                }
            }
        } while (ep.split() <= waitsec);
        return(slist);
    }

int32_t Cosmos::Support::Agent::set_sohstring

(

string

list

)

Set Limited SOH string.

Set the Limited SOH string to a JSON list of JSON Name Space names. A proper JSON list will begin and end with matched curly braces, be comma separated, and have all strings in double quotes.

Parameters

list	Properly formatted list of JSON names.

Returns

0, otherwise a negative error.

                                            {
        if (!sohtable.empty()) { sohtable.clear(); }
        json_table_of_list(sohtable, list, cinfo);
        return 0;
    }

int32_t Cosmos::Support::Agent::set_fullsohstring

(

string

list

)

Set Full SOH string.

Set the Full SOH string to a JSON list of JSON Name Space names. A proper JSON list will begin and end with matched curly braces, be comma separated, and have all strings in double quotes.

Parameters

list	Properly formatted list of JSON names.

Returns

0, otherwise a negative error.

                                                {
        if (!fullsohtable.empty()) { fullsohtable.clear(); }
        json_table_of_list(fullsohtable, list, cinfo);
        return 0;
    }

cosmosstruc * Cosmos::Support::Agent::get_cosmosstruc

(

)

Return Agent cosmosstruc.

Return a pointer to the Agent's internal copy of the cosmosstruc.

Returns

A pointer to the cosmosstruc, otherwise NULL.

{ return (cinfo); }

void Cosmos::Support::Agent::heartbeat_loop ( )

private

Heartbeat Loop.

This function is run as a thread to provide the Heartbeat for the Agent. The Heartbeat will consist of the contents of Agent::AGENT_MESSAG::BEAT in Cosmos::Agent::poll, plus the contents of the Cosmos::Agent::sohstring. It will come every beatstruc::bprd seconds.

                               {
        ElapsedTime timer_beat;

        while (cinfo->agent[0].stateflag) {

            // compute the jitter
            if (cinfo->agent[0].beat.bprd == 0.) {
                cinfo->agent[0].beat.jitter = timer_beat.split() - 1.;
            } else {
                cinfo->agent[0].beat.jitter = timer_beat.split() - cinfo->agent[0].beat.bprd;
            }
            timer_beat.start();

            // post comes first
            if (cinfo->agent[0].beat.bprd != 0.) { post_beat(); }

            // TODO: move the monitoring calculations to another thread with its own loop time that can be controlled
            // Compute other monitored quantities if monitoring
            if (cinfo->agent[0].stateflag == static_cast <uint16_t>(Agent::State::MONITOR)) {
                // TODO: rename beat.cpu to beat.cpu_percent
                // add beat.cpu_load
                cinfo->agent[0].beat.cpu    = deviceCpu_.getPercentUseForCurrentProcess();//cpu.getLoad();
                cinfo->agent[0].beat.memory = deviceCpu_.getVirtualMemoryUsed();
            }

            if (cinfo->agent[0].stateflag == static_cast <uint16_t>(Agent::State::SHUTDOWN)) {
                cinfo->agent[0].beat.cpu = 0;
                cinfo->agent[0].beat.memory = 0;
            }


            if (cinfo->agent[0].beat.bprd < AGENT_HEARTBEAT_PERIOD_MIN) {
                cinfo->agent[0].beat.bprd = 0.;
            }

            if (cinfo->agent[0].beat.bprd == 0.) {
                COSMOS_SLEEP(1.);
            } else {
                if (timer_beat.split() <= cinfo->agent[0].beat.bprd) {
                    COSMOS_SLEEP(cinfo->agent[0].beat.bprd - timer_beat.split());
                }
            }
        }
        Agent::unpublish();
    }

void Cosmos::Support::Agent::request_loop ( )

privatenoexcept

Request Loop.

This function is run as a thread to service requests to the Agent. It receives requests on it assigned port number, matches the first word of the request against its set of requests, and then either performs the matched function, or returns [NOK].

                                      {
        int32_t iretn;
        string bufferin;

        if ((iretn = socket_open(&cinfo->agent[0].req, NetworkType::UDP, (char *)"", cinfo->agent[0].beat.port, SOCKET_LISTEN, SOCKET_BLOCKING, 2000000)) < 0) { return; }

        cinfo->agent[0].beat.port = cinfo->agent[0].req.cport;

        while (cinfo->agent[0].stateflag) {
            bufferin.resize(cinfo->agent[0].beat.bsz);
            iretn = recvfrom(cinfo->agent[0].req.cudp, &bufferin[0], bufferin.size(), 0, (struct sockaddr *)&cinfo->agent[0].req.caddr, (socklen_t *)&cinfo->agent[0].req.addrlen);

            if (iretn > 0) {
                string bufferout;
                bufferin.resize(iretn);
                process_request(bufferin, bufferout);
            }
        }
        return;
    }

int32_t Cosmos::Support::Agent::process_request ( string &  bufferin, string &  bufferout  )

private

                                                                      {
        size_t i;
        int32_t iretn;

        process_mutex.lock();

        if (cinfo->agent[0].stateflag == static_cast <uint16_t>(Agent::State::DEBUG)) {
            printf("Request: [%lu] %s ",bufferin.size(), &bufferin[0]);
            fflush(stdout);
        }

        string variable;
        string request;
        request.resize(AGENTMAXBUFFER+1);
        for (i=0; i<COSMOS_MAX_NAME; i++) {
            if (bufferin[i] == ' ' || bufferin[i] == 0) {
                break;
            }   
            request[i] = bufferin[i];
        }
        //request[i] = 0;
        request.resize(i);

        for (i=0; i<reqs.size(); i++) { if (!strcmp(request.c_str(),reqs[i].token.c_str())) break; }

        if (i < reqs.size()) {
            iretn = -1;
//                if (reqs[i].ifunction)
//                {
//                    iretn = (this->*reqs[i].ifunction)(&bufferin[0], &request[0]);
//                }
//                else
//                {
//                    if (reqs[i].efunction != nullptr)
//                    {
//                        iretn = reqs[i].efunction(&bufferin[0], &request[0], this);
//                    }
//                }
            if (reqs[i].efunction != nullptr) {
                iretn = reqs[i].efunction(bufferin, request, this);
            }
            if (iretn >= 0) {
                request.resize(strlen(&request[0]));
                bufferout = request;
            } else {
                bufferout = "[NOK] " + std::to_string(iretn);
            }
        } else {
            iretn = AGENT_ERROR_NULL;
            bufferout = "[NOK] " + std::to_string(iretn);
        }

        iretn = sendto(cinfo->agent[0].req.cudp, bufferout.data(), bufferout.size(), 0, (struct sockaddr *)&cinfo->agent[0].req.caddr, sizeof(struct sockaddr_in));
        if (cinfo->agent[0].stateflag == static_cast <uint16_t>(Agent::State::DEBUG)) {
            printf("[%d] %s\n", iretn, bufferout.data());
        }

        process_mutex.unlock();

        return iretn;
    }

void Cosmos::Support::Agent::message_loop ( )

private

                             {
        messstruc mess;
        int32_t iretn;
        // Initialize things
//            message_ring.resize(MESSAGE_RING_SIZE);
        while (Agent::running()) {
            iretn = Agent::poll(mess, AgentMessage::ALL, 0.);
            if (iretn > 0) {
                if (!strcmp(mess.meta.beat.proc, "") && mess.adata.empty()) { continue; }
                bool agent_found = false;

                for (beatstruc &i : agent_list) {
                    if (!strcmp(i.node, mess.meta.beat.node) && !strcmp(i.proc, mess.meta.beat.proc)) {
                        agent_found = true;
                        // update all information for the last contact with given (node, agent)...
                        i = mess.meta.beat;
                        break;
                    }
                }

                if (!agent_found) { agent_list.push_back(mess.meta.beat); }

                if (mess.meta.type == AgentMessage::REQUEST && strcmp(cinfo->agent[0].beat.proc, "")) {
                    string response;
                    process_request(mess.adata, response);
                    Agent::post(AgentMessage::RESPONSE, response);
                } else {
//                        size_t new_position;
//                        new_position = message_head + 1;
//                        if (new_position >= message_ring.size())
//                        {
//                            new_position = 0;
//                        }
//                        message_ring[new_position] = mess;
//                        message_head = new_position;
                    message_queue.push_back(mess);
                    if (message_queue.size() > MESSAGE_RING_SIZE) { message_queue.pop_front(); }
                }
            }
        }
    }

int32_t Cosmos::Support::Agent::req_forward ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Forward request.

Resends the received request, less count bytes, to all Publication channels of the Agent.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                            {
        uint16_t count;
        int32_t iretn=-1;

//            sscanf(request.c_str(),"%*s %hu",&count);
        sscanf(request.c_str(),"%*s %hu",&count);
        for (uint16_t i=0; i<agent->cinfo->agent[0].ifcnt; ++i)
        {
//                iretn = sendto(agent->cinfo->agent[0].pub[i].cudp,(const char *)&request[request.length()-count],count,0,(struct sockaddr *)&agent->cinfo->agent[0].pub[i].baddr,sizeof(struct sockaddr_in));
            iretn = sendto(agent->cinfo->agent[0].pub[i].cudp,(const char *)&request[request.size()-count],count,0,(struct sockaddr *)&agent->cinfo->agent[0].pub[i].baddr,sizeof(struct sockaddr_in));
        }
//            sprintf(output,"%.17g %d ",currentmjd(0),iretn);
        output = std::to_string(currentmjd()) + ' ' + std::to_string(iretn);
        return(0);
    }

int32_t Cosmos::Support::Agent::req_echo ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Echo request.

Returns the received packet, reaclculating the CRC, and adding the time.

Parameters

request	Text of echo packet.
output	Text of echoed packet.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                   {
        double mjd;
        uint16_t crc, count;

//            sscanf(request.c_str(),"%*s %lf %hx %hu",&mjd,&crc,&count);
//            sprintf(output,"%.17g %x %u ",currentmjd(0),slip_calc_crc((uint8_t *)&request[request.length()-count],count),count);
//            strncpy(&output[strlen(output)],&request[request.length()-count],count+1);
        sscanf(request.c_str(),"%*s %lf %hx %hu",&mjd,&crc,&count);
        output = to_mjd(currentmjd()) + ' ' + to_hex(crc) + ' ' + std::to_string(count) + ' ' + request;
        return 0;
    }

int32_t Cosmos::Support::Agent::req_help_json ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Help request.

Send help response.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                       {
        string help_string, s;
        size_t qpos, prev_qpos = 0;
        //        help_string += "\n";
        help_string += "{\"requests\": [";
        for(uint32_t i = 0; i < agent->reqs.size(); ++i) {
            //            help_string += "        ";
            if(i>0) help_string+=",";
            help_string += "{\"token\": \"";
            help_string += agent->reqs[i].token;
            //            help_string += " ";
            help_string += "\", \"synopsis\": \"";
            //            help_string += agent->reqs[i].synopsis;
            qpos = 0;
            prev_qpos = 0;
            s = agent->reqs[i].synopsis;
            while((qpos=s.substr(prev_qpos).find("\""))!= string::npos)
            {
                s.replace(qpos+prev_qpos, 1, "\\\"");
                prev_qpos +=qpos+2;
            }
            help_string+= s;
            //            help_string += "\n";
            //size_t blanks = (20 - (signed int)strlen(agent->reqs[i].token)) > 0 ? 20 - strlen(agent->reqs[i].token) : 4;
            //string blank(blanks,' ');
            //help_string += blank;
            //            help_string += "                ";
            help_string += "\", \"description\": \"";
            qpos = 0;
            prev_qpos = 0;
            s = agent->reqs[i].description;
            while((qpos=s.substr(prev_qpos).find("\""))!= string::npos){
                s.replace(qpos+prev_qpos, 1, "\\\"");
                prev_qpos +=qpos+2;
            }
            help_string+= s;
            //            help_string += agent->reqs[i].description;
            //            help_string += "\n\n";
            help_string +="\"}";
        }
        //        help_string += "\n";
        help_string += "]}";
//            strcpy(output, (char*)help_string.c_str());
        output = help_string;
        return 0;
    }

int32_t Cosmos::Support::Agent::req_help ( string &  request, string &  response, Agent *  agent  )

staticprivate

                                                                  {
        string help_string;
        help_string += "\n";
        for(uint32_t i = 0; i < agent->reqs.size(); ++i)
        {
            help_string += "        ";
            help_string += agent->reqs[i].token;
            help_string += " ";
            help_string += agent->reqs[i].synopsis;
            help_string += "\n";
            //size_t blanks = (20 - (signed int)strlen(agent->reqs[i].token)) > 0 ? 20 - strlen(agent->reqs[i].token) : 4;
            //string blank(blanks,' ');
            //help_string += blank;
            help_string += "                ";
            help_string += agent->reqs[i].description;
            help_string += "\n\n";
        }
        help_string += "\n";
        output = help_string;
        return 0;
    }

int32_t Cosmos::Support::Agent::req_run ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Set state to Run request.

Resends the received request, less count bytes, to all Publication channels of the Agent.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                 {
        agent->cinfo->agent[0].stateflag = static_cast <uint16_t>(Agent::State::RUN);
        output[0] = 0;
        return(0);
    }

int32_t Cosmos::Support::Agent::req_init ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Set state to Init request.

Resends the received request, less count bytes, to all Publication channels of the Agent.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                  {
        agent->cinfo->agent[0].stateflag = static_cast <uint16_t>(Agent::State::INIT);
        output[0] = 0;
        return(0);
    }

int32_t Cosmos::Support::Agent::req_idle ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Set state to Idle request.

Resends the received request, less count bytes, to all Publication channels of the Agent.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                  {
        agent->cinfo->agent[0].stateflag = static_cast <uint16_t>(Agent::State::IDLE);
        output[0] = 0;
        return(0);
    }

int32_t Cosmos::Support::Agent::req_monitor ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Set state to Monitor request.

Resends the received request, less count bytes, to all Publication channels of the Agent.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                     {
        agent->cinfo->agent[0].stateflag = static_cast <uint16_t>(Agent::State::MONITOR);
        output[0] = 0;
        return(0);
    }

int32_t Cosmos::Support::Agent::req_reset ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Set state to Reset request.

Resends the received request, less count bytes, to all Publication channels of the Agent.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                   {
        agent->cinfo->agent[0].stateflag = static_cast <uint16_t>(Agent::State::RESET);
        output[0] = 0;
        return(0);
    }

int32_t Cosmos::Support::Agent::req_shutdown ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Set state to Shutdown request.

Resends the received request, less count bytes, to all Publication channels of the Agent.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                      {
        agent->cinfo->agent[0].stateflag = static_cast <uint16_t>(Agent::State::SHUTDOWN);
//            output[0] = 0;
        output.clear();
        return(0);
    }

int32_t Cosmos::Support::Agent::req_status ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Status request.

Returns agent status.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                    {
        string jstring;

        if (json_of_agent(jstring, agent->cinfo) != NULL)
        {
//                strncpy(output, jstring.c_str(),agent->cinfo->agent[0].beat.bsz);
//                output[agent->cinfo->agent[0].beat.bsz-1] = 0;
            output = jstring;
            if (output.length() > agent->cinfo->agent[0].beat.bsz)
            {
                output[agent->cinfo->agent[0].beat.bsz-1] = 0;
            }
            return 0;
        } else {
            output = "error";
            return(JSON_ERROR_SCAN);
        }
    }

int32_t Cosmos::Support::Agent::req_debug_level ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Get Debug Level request Returns or sets the debug_level value.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                                {
        if (request != "debug_level") {
            sscanf(request.c_str(), "debug_level %hu", &agent->debug_level);
        }
        output = std::to_string(agent->debug_level);
        return 0;
    }

int32_t Cosmos::Support::Agent::req_getvalue ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Get Internal Value request.

Returns the current value of the requested Name Space values. Names are expressed as a JSON object.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

    {
    cout<<"req_getvalue(): incoming request          = <"<<request<<">"<<endl;
    cout<<"req_getvalue(): incoming request.size()   = "<<request.size()<<endl;
    cout<<"req_getvalue(): incoming request.length() = "<<request.length()<<endl;
        string jstring;
        if (json_of_list(jstring, request, agent->cinfo) != NULL) {
            output = jstring;
            if (output.length() > agent->cinfo->agent[0].beat.bsz) {
                output[agent->cinfo->agent[0].beat.bsz-1] = 0;
            }
    cout<<"req_getvalue(): outgoing response         = <"<<output<<">"<<endl;
            return 0;
        } else {
            return (JSON_ERROR_EOS);
        }
    }

int32_t Cosmos::Support::Agent::req_get_value ( string &  request, string &  response, Agent *  agent  )

staticprivate

                                                                            {
    string req = request;
    cout<<"req_get_value():incoming request          = <"<<request<<">"<<endl;
    cout<<"req_get_value():incoming request.size()   = "<<request.size()<<endl;
    cout<<"req_get_value():incoming request.length() = "<<request.length()<<endl;
    // remove function call and space
    req.erase(0,10);
    // strip out all names from request
    vector<string> names;
    for(size_t i = 0; i < req.size(); ++i)   {
        if(req[i]=='"')  {
            string name("");
            while(req[++i]!='"'&&i<req.size())    { name.push_back(req[i]); }
            names.push_back(name);
        }
    }
    // response comes to here with the request function name inside it? it that a bug or a feature?
    response.clear();
    for(size_t i = 0; i < names.size(); ++i)   {
        response += agent->cinfo->get_json(names[i]);
    }
    cout<<"req_get_value():outgoing response         = <"<<response<<">"<<endl;
    return 0;
}

int32_t Cosmos::Support::Agent::req_get_time ( string &  request, string &  response, Agent *  agent  )

staticprivate

                                                                            {
    stringstream ss;
    ss<<setprecision(numeric_limits<double>::digits10)<<currentmjd();
    response = ss.str();
    return 0;
}

int32_t Cosmos::Support::Agent::req_get_position_data ( string &  request, string &  response, Agent *  agent  )

staticprivate

                                                                                    {

    //cout<<"\tincoming request          = <"<<request<<">"<<endl;
    //cout<<"req_get_position():incoming request.size()   = "<<request.size()<<endl;
    //cout<<"req_get_position():incoming request.length() = "<<request.length()<<endl;

    // remove function call and space
    request.erase(0,18);

    // read in mjdtime
    stringstream ss;
    ss<<request;
    double timemjd;
    ss>>timemjd;
    //cout<<"timemjd = <"<<setprecision(numeric_limits<double>::digits10)<<timemjd<<">"<<endl;
    // use mjd to calculate position
        cosmosstruc* c = agent->cinfo;
       // orbital equations

c->set_PQW(timemjd);
//cout<<setprecision(numeric_limits<double>::digits10)<<timemjd<<", "<<c->P_pos_t<<", "<<c->Q_pos_t<<", "<<c->W_pos_t<<", "<<c->P_vel_t<<", "<<c->Q_vel_t<<", "<<c->W_vel_t<<endl;
c->set_IJK_from_PQW();
cout<<setprecision(numeric_limits<double>::digits10)<<timemjd<<", "<<c->I_pos_t<<", "<<c->J_pos_t<<", "<<c->K_pos_t<<", "<<c->I_vel_t<<", "<<c->J_vel_t<<", "<<c->K_vel_t<<endl;

/*
        // to find position and velocity at time t
            // 0    Make sure all necessary orbital elements are set
            c->t = timemjd;
            c->l = c->a*(1.0-pow(c->e,2.0));
            // 1    Calculate mean anamoly (M)
            c->M = fmod(c->n * (c->t - c->tau), 2*M_PI);
            // 2    Calculate true anamoly (v)
            c->v = c->M + (2.0*c->e-0.25*pow(c->e,3.0))*sin(c->M) + 1.25*pow(c->e,2.0)*sin(2.0*c->M) + (13.0/12.0)*pow(c->e,3.0)*sin(3.0*c->M); 
            // 3    Calculate radius (r)
            c->r = c->l / (1.0 + c->e*cos(c->v));
            // 4    Calculate position vector <P_pos_t, Q_pos_t, W_pos_t>
            c->P_pos_t = c->r * cos(c->v);
            c->Q_pos_t = c->r * sin(c->v);
            c->W_pos_t = 0.0;
            c->P_vel_t = sqrt(c->mu/c->l) * -sin(c->v);
            //c->Q_vel_t = sqrt(c->mu/c->l) * (c->e+cos(c->v))*sin(c->v);
            c->Q_vel_t = sqrt(c->mu/c->l) * (c->e+cos(c->v));
            c->W_vel_t = 0.0;
*/

            response.clear();

            //response =    "\t\ttime:     [ " + request + " ]";
            response =    request + "\t";
            //response += "\n\t\tposition: [ ";
            stringstream sss;
            sss<<setprecision(numeric_limits<double>::digits10)<<c->P_pos_t;
            response += sss.str();
            sss.str("");
            //response += " ";
            response += "\t";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->Q_pos_t;
            response += sss.str();
            sss.str("");
            //response += " ";
            response += "\t";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->W_pos_t;
            response += sss.str();
            sss.str("");
            //response += " ]";
            response += "\t";

            // 5    Calculate velocity vector <P_vel_t, Q_vel_t, W_vel_t>
            //response += "\n\t\tvelocity: [ ";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->P_vel_t;
            response += sss.str();
            sss.str("");
            //response += " ";
            response += "\t";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->Q_vel_t;
            response += sss.str();
            sss.str("");
            //response += " ";
            response += "\t";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->W_vel_t;
            response += sss.str();
            sss.str("");
            //response += " ]";

            // 6    Transform perifocal (PQW) co-ords to geocentric equatorial (IJK) co-ords

            // also calculate distance from mothership?

    // ...

    //response = request;
    //cout<<"req_get_position():outgoing response         = <"<<response<<">"<<endl;
    return 0;
}

int32_t Cosmos::Support::Agent::req_get_position ( string &  request, string &  response, Agent *  agent  )

staticprivate

                                                                                {

    cout<<"\tincoming request          = <"<<request<<">"<<endl;
    //cout<<"req_get_position():incoming request.size()   = "<<request.size()<<endl;
    //cout<<"req_get_position():incoming request.length() = "<<request.length()<<endl;

    // remove function call and space
    request.erase(0,13);

    // read in mjdtime
    stringstream ss;
    ss<<request;
    double timemjd;
    ss>>timemjd;
    //cout<<"timemjd = <"<<setprecision(numeric_limits<double>::digits10)<<timemjd<<">"<<endl;

    // use mjd to calculate position
        cosmosstruc* c = agent->cinfo;
       // orbital equations

        // to find position and velocity at time t
            // 0    Make sure all necessary orbital elements are set
            c->t = timemjd;
            c->l = c->a*(1.0-pow(c->e,2.0));
            // 1    Calculate mean anamoly (M)
            c->M = fmod(c->n * (c->t - c->tau), 2*M_PI);
            // 2    Calculate true anamoly (v)
            c->v = c->M + (2.0*c->e-0.25*pow(c->e,3.0))*sin(c->M) + 1.25*pow(c->e,2.0)*sin(2.0*c->M) + (13.0/12.0)*pow(c->e,3.0)*sin(3.0*c->M); 
            // 3    Calculate radius (r)
            c->r = c->l / (1.0 + c->e*cos(c->v));
            // 4    Calculate position vector <P_pos_t, Q_pos_t, W_pos_t>
            c->P_pos_t = c->r * cos(c->v);
            c->Q_pos_t = c->r * sin(c->v);
            c->W_pos_t = 0.0;
            c->P_vel_t = sqrt(c->mu/c->l) * -sin(c->v);
            //c->Q_vel_t = sqrt(c->mu/c->l) * (c->e+cos(c->v))*sin(c->v);
            c->Q_vel_t = sqrt(c->mu/c->l) * (c->e+cos(c->v));
            c->W_vel_t = 0.0;

            response.clear();

            response =    "\t\ttime:     [ " + request + " ]";
            response += "\n\t\tposition: [ ";
            stringstream sss;
            sss<<setprecision(numeric_limits<double>::digits10)<<c->P_pos_t;
            response += sss.str();
            sss.str("");
            response += " ";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->Q_pos_t;
            response += sss.str();
            sss.str("");
            response += " ";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->W_pos_t;
            response += sss.str();
            sss.str("");
            response += " ]";

            // 5    Calculate velocity vector <P_vel_t, Q_vel_t, W_vel_t>
            response += "\n\t\tvelocity: [ ";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->P_vel_t;
            response += sss.str();
            sss.str("");
            response += " ";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->Q_vel_t;
            response += sss.str();
            sss.str("");
            response += " ";
            sss<<setprecision(numeric_limits<double>::digits10)<<c->W_vel_t;
            response += sss.str();
            sss.str("");
            response += " ]";

            // 6    Transform perifocal (PQW) co-ords to geocentric equatorial (IJK) co-ords

            // also calculate distance from mothership?

    // ...

    //response = request;
    //cout<<"req_get_position():outgoing response         = <"<<response<<">"<<endl;
    return 0;
}

int32_t Cosmos::Support::Agent::req_setvalue ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Set Internal Value request.

Sets the current value of the requested Name Space values. Names and values are expressed as a JSON object.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                             {
        int32_t iretn;
        iretn = json_parse(request, agent->cinfo);
        output = std::to_string(iretn);
        return(iretn);
    }

int32_t Cosmos::Support::Agent::req_set_value ( string &  request, string &  response, Agent *  agent  )

staticprivate

                                                                            {
    // remove function call and space ('set_value ')
    request.erase(0,10);
    cout<<"req_set_value():incoming request          = <"<<request<<">"<<endl;
    cout<<"req_set_value():incoming request.size()   = "<<request.size()<<endl;
    cout<<"req_set_value():incoming request.length() = "<<request.length()<<endl;
    cout<<"req_set_value():incoming response         = <"<<response<<">"<<endl;

    // set the value from json string
    agent->cinfo->set_json(request);

    cout<<"req_set_value():outgoing response         = <"<<response<<">"<<endl;
    return 0;
}

int32_t Cosmos::Support::Agent::req_listnames ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in List Name Space Names request.

Returns a list of all names in the JSON Name Space.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                       {
        output = json_list_of_all(agent->cinfo);
        if (output.length() > agent->cinfo->agent[0].beat.bsz) { output[agent->cinfo->agent[0].beat.bsz-1] = 0; }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_nodejson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return Node JSON request.

Returns a JSON string representing the Node description.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                      {
        output = agent->cinfo->json.node.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz) { output[agent->cinfo->agent[0].beat.bsz-1] = 0; }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_statejson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return State Vector JSON request.

Returns a JSON string representing the State Vector.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                       {
        output = agent->cinfo->json.state.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz) { output[agent->cinfo->agent[0].beat.bsz-1] = 0; }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_utcstartjson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return UTC Start Time JSON request.

Returns a JSON string representing the UTC Start Time.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                          {
        output = agent->cinfo->json.utcstart.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz) { output[agent->cinfo->agent[0].beat.bsz-1] = 0; }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_piecesjson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return Pieces JSON request.

Returns a JSON string representing the Piece information.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                        {
        output = agent->cinfo->json.pieces.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz) { output[agent->cinfo->agent[0].beat.bsz-1] = 0; }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_facesjson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return Face JSON request.

Returns a JSON string representing the Face information.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                       {
        output = agent->cinfo->json.faces.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz) { output[agent->cinfo->agent[0].beat.bsz-1] = 0; }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_vertexsjson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return Vertex JSON request.

Returns a JSON string representing the Vertex information.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                         {
        output = agent->cinfo->json.vertexs.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz) { output[agent->cinfo->agent[0].beat.bsz-1] = 0; }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_devgenjson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return devgen JSON request.

Returns a JSON string representing the generic device information.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                        {
        output = agent->cinfo->json.devgen.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz) { output[agent->cinfo->agent[0].beat.bsz-1] = 0; }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_devspecjson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return devspec JSON request.

Returns a JSON string representing the special device information.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                         {
        output = agent->cinfo->json.devspec.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz) { output[agent->cinfo->agent[0].beat.bsz-1] = 0; }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_portsjson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return Ports JSON request.

Returns a JSON string representing the Port information.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                       {
//            strncpy(output, agent->cinfo->json.ports.c_str(), agent->cinfo->json.ports.size()<agent->cinfo->agent[0].beat.bsz-1?agent->cinfo->json.ports.size():agent->cinfo->agent[0].beat.bsz-1);
//            output[agent->cinfo->agent[0].beat.bsz-1] = 0;
        output = agent->cinfo->json.ports.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz)
        {
            output[agent->cinfo->agent[0].beat.bsz-1] = 0;
        }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_targetsjson ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Return Target JSON request.

Returns a JSON string representing the Target information.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                         {
//            strncpy(output, agent->cinfo->json.targets.c_str(), agent->cinfo->json.targets.size()<agent->cinfo->agent[0].beat.bsz-1?agent->cinfo->json.targets.size():agent->cinfo->agent[0].beat.bsz-1);
//            output[agent->cinfo->agent[0].beat.bsz-1] = 0;
        output = agent->cinfo->json.targets.c_str();
        if (output.length() > agent->cinfo->agent[0].beat.bsz)
        {
            output[agent->cinfo->agent[0].beat.bsz-1] = 0;
        }
        return 0;
    }

int32_t Cosmos::Support::Agent::req_heartbeat ( string &  request, string &  output, Agent *  agent  )

staticprivate

Built-in Send Heartbeat request.

Send a Heartbeat out of the regular time for heartbeats.

Parameters

request	Text of request.
output	Text of response to request.
agent	Pointer to Cosmos::Agent to use.

Returns

0, or negative error.

                                                                       {
//            output[0] = 0;
        output.clear();
        int32_t iretn = 0;
        iretn = agent->post_beat();
        return iretn;
    }

int32_t Cosmos::Support::Agent::req_postsoh ( string &  request, string &  response, Agent *  agent  )

staticprivate

                                                                     {
//            output[0] = 0;
        output.clear();
        int32_t iretn = 0;
        iretn = agent->post_soh();
        return iretn;
    }

int32_t Cosmos::Support::Agent::req_utc ( string &  request, string &  response, Agent *  agent  )

staticprivate

                                                                   {
//            response =  " %.15g %lf ", agent->agent_time_producer(), utc2unixseconds(agent->agent_time_producer()));
        response = to_mjd(agent->agent_time_producer()) + ' ' + std::to_string(utc2unixseconds(agent->agent_time_producer()));
        return 0;
    }

int32_t Cosmos::Support::Agent::req_soh ( string &  , string &  response, Agent *  agent  )

staticprivate

                                                                   {
        string rjstring;
        response = json_of_table(rjstring, agent->sohtable, agent->cinfo);

        return 0;
    }

int32_t Cosmos::Support::Agent::req_fullsoh ( string &  , string &  response, Agent *  agent  )

staticprivate

                                                                       {
        string rjstring;
        response = json_of_table(rjstring, agent->fullsohtable, agent->cinfo);
        return 0;
    }

int32_t Cosmos::Support::Agent::req_jsondump ( string &  , string &  response, Agent *  agent  )

staticprivate

                                                                {
        json_dump_node(agent->cinfo);
        return 0;
    }

int32_t Cosmos::Support::Agent::publish	(	NetworkType	type,
		uint16_t	port
	)

Open COSMOS output channel.

Establish a multicast socket for publishing COSMOS messages using the specified address and port.

Parameters

type	One of NetworkType.
port	Port number to publish on.

Returns

0, otherwise negative error.

    {
        int32_t iretn = 0;
        int on = 1;

        // Return immediately if we've already done this
        if (cinfo->agent[0].pub[0].cport)
            return 0;

        switch (type)
        {
        case NetworkType::MULTICAST:
        case NetworkType::UDP:
        case NetworkType::BROADCAST:
            {
                for (uint32_t i=0; i<AGENTMAXIF; i++) { cinfo->agent[0].pub[i].cudp = -1; }

                if ((cinfo->agent[0].pub[0].cudp=socket(AF_INET,SOCK_DGRAM,0)) < 0) { return (AGENT_ERROR_SOCKET); }

#ifdef COSMOS_WIN_OS
                u_long nonblocking = 1;;
                if (ioctlsocket(cinfo->agent[0].pub[0].cudp, FIONBIO, &nonblocking) != 0) { iretn = -WSAGetLastError(); }
#else
                if (fcntl(cinfo->agent[0].pub[0].cudp, F_SETFL,O_NONBLOCK) < 0) { iretn = -errno; }
#endif
                if (iretn < 0) {
                    CLOSE_SOCKET(cinfo->agent[0].pub[0].cudp);
                    cinfo->agent[0].pub[0].cudp = iretn;
                    return iretn;
                }

                // Use above socket to find available interfaces and establish
                // publication on each.
                cinfo->agent[0].ifcnt = 0;

#if defined(COSMOS_WIN_OS)
                struct sockaddr_storage ss;
                int sslen;
                INTERFACE_INFO ilist[20];
                unsigned long nbytes;
                uint32_t nif;
                if (WSAIoctl(cinfo->agent[0].pub[0].cudp, SIO_GET_INTERFACE_LIST, 0, 0, &ilist,sizeof(ilist), &nbytes, 0, 0) == SOCKET_ERROR) {
                    CLOSE_SOCKET(cinfo->agent[0].pub[0].cudp);
                    return (AGENT_ERROR_DISCOVERY);
                }

                nif = nbytes / sizeof(INTERFACE_INFO);
                for (uint32_t i=0; i<nif; i++) {
                    inet_ntop(ilist[i].iiAddress.AddressIn.sin_family,&ilist[i].iiAddress.AddressIn.sin_addr,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address,sizeof(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address));
                    //            strcpy(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address,inet_ntoa(((struct sockaddr_in*)&(ilist[i].iiAddress))->sin_addr));
                    if (!strcmp(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address,"127.0.0.1")) {
                        if (cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp >= 0) {
                            CLOSE_SOCKET(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp);
                            cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp = -1;
                        }
                        continue;
                    }

                    // No need to open first socket again
                    if (cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp < 0) {
                        if ((cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp=socket(AF_INET,SOCK_DGRAM,0)) < 0) {
                            continue;
                        }
                        u_long nonblocking = 1;
                        if (ioctlsocket(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp, FIONBIO, &nonblocking) != 0) {
                            continue;
                        }
                    }

                    memset(&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr,0,sizeof(struct sockaddr_in));
                    cinfo->agent[0].pub[i].caddr.sin_family = AF_INET;
                    cinfo->agent[0].pub[i].baddr.sin_family = AF_INET;
                    if (type == NetworkType::MULTICAST) {
                        sslen = sizeof(ss);
                        WSAStringToAddressA((char *)AGENTMCAST,AF_INET,NULL,(struct sockaddr*)&ss,&sslen);
                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_addr = ((struct sockaddr_in *)&ss)->sin_addr;
                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr = ((struct sockaddr_in *)&ss)->sin_addr;
                    } else {
                        if ((iretn = setsockopt(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp,SOL_SOCKET,SO_BROADCAST,(char*)&on,sizeof(on))) < 0)
                        {
                            CLOSE_SOCKET(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp);
                            continue;
                        }

                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_addr = ((struct sockaddr_in *)&ilist[i].iiAddress)->sin_addr;
                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr = ((struct sockaddr_in *)&ilist[i].iiAddress)->sin_addr;

                        uint32_t ip, net, bcast;
                        ip = ((struct sockaddr_in*)&(ilist[i].iiAddress))->sin_addr.S_un.S_addr;
                        net = ((struct sockaddr_in*)&(ilist[i].iiNetmask))->sin_addr.S_un.S_addr;
                        bcast = ip | (~net);
                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr.S_un.S_addr = bcast;
                    }
                    cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_port = htons(port);
                    cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_port = htons(port);
                    cinfo->agent[0].pub[cinfo->agent[0].ifcnt].type = type;
                    cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cport = port;
                    cinfo->agent[0].ifcnt++;
                }
#elif defined(COSMOS_MAC_OS)
                struct ifaddrs *if_addrs = NULL;
                struct ifaddrs *if_addr = NULL;
                if (0 == getifaddrs(&if_addrs)) {
                    for (if_addr = if_addrs; if_addr != NULL; if_addr = if_addr->ifa_next) {
                        if (if_addr->ifa_addr->sa_family != AF_INET) { continue; }
                        inet_ntop(if_addr->ifa_addr->sa_family,&((struct sockaddr_in*)if_addr->ifa_addr)->sin_addr,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address,sizeof(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address));
                        memcpy((char *)&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr, (char *)if_addr->ifa_addr, sizeof(if_addr->ifa_addr));

                        if ((if_addr->ifa_flags & IFF_POINTOPOINT) || (if_addr->ifa_flags & IFF_UP) == 0 || (if_addr->ifa_flags & IFF_LOOPBACK) || (if_addr->ifa_flags & (IFF_BROADCAST)) == 0)
                        {
                            continue;
                        }

                        // No need to open first socket again
                        if (cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp < 0) {
                            if ((cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp=socket(AF_INET,SOCK_DGRAM,0)) < 0) {
                                continue;
                            }

                            if (fcntl(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp, F_SETFL,O_NONBLOCK) < 0) {
                                iretn = -errno;
                                CLOSE_SOCKET(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp);
                                cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp = iretn;
                                continue;
                            }
                        }

                        if (type == NetworkType::MULTICAST) {
                            inet_pton(AF_INET,AGENTMCAST,&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_addr);
                            inet_pton(AF_INET,AGENTMCAST,&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr);
                        } else {
                            if ((iretn = setsockopt(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp,SOL_SOCKET,SO_BROADCAST,(char*)&on,sizeof(on))) < 0) {
                                CLOSE_SOCKET(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp);
                                continue;
                            }

                            //                    if (ioctl(cinfo->agent[0].pub[0].cudp,SIOCGIFBRDADDR,(char *)ifra) < 0)
                            //                    {
                            //                        continue;
                            //                    }
                            //                    cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr = cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr;
                            memcpy((char *)&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr, (char *)if_addr->ifa_netmask, sizeof(if_addr->ifa_netmask));

                            uint32_t ip, net, bcast;
                            ip = cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_addr.s_addr;
                            net = cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr.s_addr;
                            bcast = ip | (~net);
                            cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr.s_addr = bcast;
                            inet_ntop(if_addr->ifa_netmask->sa_family,&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddress,sizeof(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddress));
                        }
                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_port = htons(port);
                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_port = htons(port);
                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].type = type;
                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cport = port;
                        cinfo->agent[0].ifcnt++;
                    }
                    freeifaddrs(if_addrs);
                    if_addrs = NULL;
                }
#else
                struct ifconf confa;
                struct ifreq *ifra;
                char data[512];

                confa.ifc_len = sizeof(data);
                confa.ifc_buf = (caddr_t)data;
                if (ioctl(cinfo->agent[0].pub[0].cudp,SIOCGIFCONF,&confa) < 0)
                {
                    CLOSE_SOCKET(cinfo->agent[0].pub[0].cudp);
                    return (AGENT_ERROR_DISCOVERY);
                }
                // Use result to discover interfaces.
                ifra = confa.ifc_req;
                bool found_bcast = false;
                int16_t lo_index = -1;
                for (int32_t n=confa.ifc_len/sizeof(struct ifreq); --n >= 0; ifra++) {

                    if (ifra->ifr_addr.sa_family != AF_INET)
                    {
                        continue;
                    }

                    inet_ntop(ifra->ifr_addr.sa_family,&((struct sockaddr_in*)&ifra->ifr_addr)->sin_addr,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address,sizeof(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address));
                    memcpy((char *)&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr, (char *)&ifra->ifr_addr, sizeof(ifra->ifr_addr));

                    if (ioctl(cinfo->agent[0].pub[0].cudp,SIOCGIFFLAGS, (char *)ifra) < 0) continue;

//                            if ((ifra->ifr_flags & IFF_POINTOPOINT) || (ifra->ifr_flags & IFF_UP) == 0 || (ifra->ifr_flags & IFF_LOOPBACK) || (ifra->ifr_flags & (IFF_BROADCAST)) == 0)
                    if ((ifra->ifr_flags & IFF_UP) == 0)
                    {
                        continue;
                    }
                    else if (ifra->ifr_flags & IFF_LOOPBACK)
                    {
                        // Don't enable loopback if we found broadcast interface
                        if (found_bcast)
                        {
                            continue;
                        }
                        lo_index = cinfo->agent[0].ifcnt;
                    }
                    else if (ifra->ifr_flags & IFF_BROADCAST)
                    {
                        found_bcast = true;
                        if (lo_index >= 0)
                        {
                            // Remove loopback if we found broadcast interface
                            if (cinfo->agent[0].pub[lo_index].cudp >= 0)
                            {
                                CLOSE_SOCKET(cinfo->agent[0].pub[lo_index].cudp);
                            }
                            for (uint16_t i=lo_index+1; i<cinfo->agent[0].ifcnt+1; ++i)
                            {
                                cinfo->agent[0].pub[i-1] = cinfo->agent[0].pub[i];
                            }
                            lo_index = -1;
                            --cinfo->agent[0].ifcnt;
                        }
                    }


                    // Open socket again if we had to close it
                    if (cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp < 0)
                    {
                        if ((cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp=socket(AF_INET,SOCK_DGRAM,0)) < 0)
                        {
                            continue;
                        }

                        if (fcntl(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp, F_SETFL,O_NONBLOCK) < 0)
                        {
                            iretn = -errno;
                            CLOSE_SOCKET(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp);
                            cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp = iretn;
                            continue;
                        }
                    }

                    if (type == NetworkType::MULTICAST)
                    {
                        inet_pton(AF_INET,AGENTMCAST,&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_addr);
                        inet_pton(AF_INET,AGENTMCAST,&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr);
                    }
                    else
                    {
//                            int val = IP_PMTUDISC_DO;
//                            if ((iretn = setsockopt(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp, IPPROTO_IP, IP_MTU_DISCOVER, &val, sizeof(val))) < 0)
//                            {
//                                CLOSE_SOCKET(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp);
//                                continue;
//                            }

                        if ((ifra->ifr_flags & IFF_POINTOPOINT))
                        {
                            if (ioctl(cinfo->agent[0].pub[0].cudp,SIOCGIFDSTADDR,(char *)ifra) < 0)
                            {
                                continue;
                            }
                            cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr = cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr;
                            inet_ntop(ifra->ifr_dstaddr.sa_family,&((struct sockaddr_in*)&ifra->ifr_dstaddr)->sin_addr,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddress,sizeof(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddress));
                            inet_pton(AF_INET,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddress,&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr);

                        }
                        else
                        {
                            if ((iretn = setsockopt(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp, SOL_SOCKET, SO_BROADCAST, (char*)&on, sizeof(on))) < 0)
                            {
                                CLOSE_SOCKET(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp);
                                continue;
                            }

                            if (ioctl(cinfo->agent[0].pub[0].cudp,SIOCGIFBRDADDR,(char *)ifra) < 0)
                            {
                                continue;
                            }
                            cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr = cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr;
                            inet_ntop(ifra->ifr_broadaddr.sa_family,&((struct sockaddr_in*)&ifra->ifr_broadaddr)->sin_addr,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddress,sizeof(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddress));
                            inet_pton(AF_INET,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddress,&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_addr);
                        }

                        if (ioctl(cinfo->agent[0].pub[0].cudp,SIOCGIFADDR,(char *)ifra) < 0)
                        {
                            continue;
                        }
                        inet_ntop(ifra->ifr_addr.sa_family,&((struct sockaddr_in*)&ifra->ifr_addr)->sin_addr,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address,sizeof(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address));
                        inet_pton(AF_INET,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address,&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_addr);
                    }

                    iretn = sendto(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp,       // socket
                            (const char *)nullptr,                         // buffer to send
                            0,                      // size of buffer
                            0,                                          // flags
                            (struct sockaddr *)&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr, // socket address
                            sizeof(struct sockaddr_in)                  // size of address to socket pointer
                            );
                    // Find assigned port, place in cport, and set caddr to requested port
                    socklen_t namelen = sizeof(struct sockaddr_in);
                    if ((iretn = getsockname(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp, (sockaddr*)&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr, &namelen)) == -1)
                    {
                        CLOSE_SOCKET(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp);
                        cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cudp = -errno;
                        return (-errno);
                    }
                    cinfo->agent[0].pub[cinfo->agent[0].ifcnt].cport = ntohs(cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_port);
                    cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_port = htons(port);
                    inet_pton(AF_INET,cinfo->agent[0].pub[cinfo->agent[0].ifcnt].address,&cinfo->agent[0].pub[cinfo->agent[0].ifcnt].caddr.sin_addr);
                    cinfo->agent[0].pub[cinfo->agent[0].ifcnt].baddr.sin_port = htons(port);
                    cinfo->agent[0].pub[cinfo->agent[0].ifcnt].type = type;


                    cinfo->agent[0].ifcnt++;
                }
#endif // COSMOS_WIN_OS
            }
            break;
        default:
            return SOCKET_ERROR_PROTOCOL;
            break;
        }

        return 0;
    }

vector< socket_channel > Cosmos::Support::Agent::find_addresses

(

NetworkType

ntype

)

Discover interfaces.

Return a vector of socket_channel containing info on each valid interface. For IPV4 this will include the address and broadcast address, in both string sockaddr_in format.

Parameters

ntype

Type of network (Multicast, Broadcast UDP, CSP)

Returns

Vector of interfaces

    {
        vector<socket_channel> iface;
        socket_channel tiface;

#ifdef COSMOS_WIN_OS
        struct sockaddr_storage ss;
        int sslen;
        INTERFACE_INFO ilist[20];
        unsigned long nbytes;
        size_t nif, ssize;
        uint32_t ip, net, bcast;
#else
        struct ifconf confa;
        struct ifreq *ifra;
        char data[512];
#endif // COSMOS_WIN_OS
        int32_t iretn;
        int on = 1;
        int32_t cudp;

        switch (ntype)
        {
        case NetworkType::MULTICAST:
        case NetworkType::UDP:
            {
                if ((cudp=socket(AF_INET,SOCK_DGRAM,0)) < 0) { return (iface); }

                // Use above socket to find available interfaces and establish
                // publication on each.
#ifdef COSMOS_WIN_OS
                if (WSAIoctl(cudp, SIO_GET_INTERFACE_LIST, 0, 0, &ilist,sizeof(ilist), &nbytes, 0, 0) == SOCKET_ERROR) {
                    CLOSE_SOCKET(cudp);
                    return (iface);
                }

                nif = nbytes / sizeof(INTERFACE_INFO);
                PIP_ADAPTER_ADDRESSES pAddresses = NULL;
                PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
                pAddresses = (IP_ADAPTER_ADDRESSES *) calloc(sizeof(IP_ADAPTER_ADDRESSES), 2*nif);
                ULONG outBufLen = sizeof(IP_ADAPTER_ADDRESSES) * 2 * nif;
                DWORD dwRetVal;
                if ((dwRetVal=GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, NULL, pAddresses, &outBufLen)) == ERROR_BUFFER_OVERFLOW)
                {
                    free(pAddresses);
                    return (iface);
                }

                for (uint32_t i=0; i<nif; i++)
                {
                    inet_ntop(ilist[i].iiAddress.AddressIn.sin_family,&ilist[i].iiAddress.AddressIn.sin_addr,tiface.address,sizeof(tiface.address));
                    //            strcpy(tiface.address,inet_ntoa(((struct sockaddr_in*)&(ilist[i].iiAddress))->sin_addr));
                    if (!strcmp(tiface.address,"127.0.0.1")) { continue; }

                    pCurrAddresses = pAddresses;
                    while (pAddresses) {
                        if (((struct sockaddr_in *)(pCurrAddresses->FirstUnicastAddress->Address.lpSockaddr))->sin_addr.s_addr == ((struct sockaddr_in*)&(ilist[i].iiAddress))->sin_addr.s_addr)
                        {
                            strcpy(tiface.name, pCurrAddresses->AdapterName);
                            break;
                        }
                        pCurrAddresses = pCurrAddresses->Next;
                    }
                    memset(&tiface.caddr,0,sizeof(struct sockaddr_in));
                    memset(&tiface.baddr,0,sizeof(struct sockaddr_in));
                    tiface.caddr.sin_family = AF_INET;
                    tiface.baddr.sin_family = AF_INET;
                    if (ntype == NetworkType::MULTICAST)
                    {
                        sslen = sizeof(ss);
                        WSAStringToAddressA((char *)AGENTMCAST,AF_INET,NULL,(struct sockaddr*)&ss,&sslen);
                        tiface.caddr.sin_addr = ((struct sockaddr_in *)&ss)->sin_addr;
                        tiface.baddr.sin_addr = ((struct sockaddr_in *)&ss)->sin_addr;
                    } else {
                        if ((iretn = setsockopt(cudp,SOL_SOCKET,SO_BROADCAST,(char*)&on,sizeof(on))) < 0)
                        {
                            continue;
                        }
                        ip = ((struct sockaddr_in*)&(ilist[i].iiAddress))->sin_addr.S_un.S_addr;
                        net = ((struct sockaddr_in*)&(ilist[i].iiNetmask))->sin_addr.S_un.S_addr;
                        bcast = ip | (~net);

                        tiface.caddr.sin_addr = ((struct sockaddr_in *)&ilist[i].iiAddress)->sin_addr;
                        tiface.caddr.sin_addr.S_un.S_addr = ip;
                        tiface.baddr.sin_addr = ((struct sockaddr_in *)&ilist[i].iiAddress)->sin_addr;
                        tiface.baddr.sin_addr.S_un.S_addr = bcast;
                    }
                    ((struct sockaddr_in *)&ss)->sin_addr = tiface.caddr.sin_addr;
                    ssize = strlen(tiface.address);
                    WSAAddressToStringA((struct sockaddr *)&tiface.caddr.sin_addr, sizeof(struct sockaddr_in), 0, tiface.address, (LPDWORD)&ssize);
                    ssize = strlen(tiface.baddress);
                    WSAAddressToStringA((struct sockaddr *)&tiface.baddr.sin_addr, sizeof(struct sockaddr_in), 0, tiface.baddress, (LPDWORD)&ssize);
                    tiface.type = ntype;
                    iface.push_back(tiface);
                }
#else
                confa.ifc_len = sizeof(data);
                confa.ifc_buf = (caddr_t)data;
                if (ioctl(cudp,SIOCGIFCONF,&confa) < 0)
                {
                    CLOSE_SOCKET(cudp);
                    return (iface);
                }
                // Use result to discover interfaces.
                ifra = confa.ifc_req;
                for (int32_t n=confa.ifc_len/sizeof(struct ifreq); --n >= 0; ifra++)
                {
                    if (ifra->ifr_addr.sa_family != AF_INET) { continue; }
                    inet_ntop(ifra->ifr_addr.sa_family,&((struct sockaddr_in*)&ifra->ifr_addr)->sin_addr,tiface.address,sizeof(tiface.address));

                    if (ioctl(cudp,SIOCGIFFLAGS, (char *)ifra) < 0) { continue; }

                    if ((ifra->ifr_flags & IFF_UP) == 0 || (ifra->ifr_flags & IFF_LOOPBACK) || (ifra->ifr_flags & (IFF_BROADCAST)) == 0)
                    {
                        continue;
                    }

                    // Open socket again if we had to close it
                    if (cudp < 0) {
                        if ((cudp=socket(AF_INET,SOCK_DGRAM,0)) < 0) { continue; }
                    }

                    if (ntype == NetworkType::MULTICAST) {
                        inet_pton(AF_INET,AGENTMCAST,&tiface.caddr.sin_addr);
                        //                        strcpy(tiface.baddress, AGENTMCAST);
                        inet_pton(AF_INET,AGENTMCAST,&tiface.baddr.sin_addr);
                    } else {
                        if ((iretn = setsockopt(cudp,SOL_SOCKET,SO_BROADCAST,(char*)&on,sizeof(on))) < 0) {
                            CLOSE_SOCKET(cudp);
                            continue;
                        }

                        //                        strncpy(tiface.name, ifra->ifr_name, COSMOS_MAX_NAME);
                        if (ioctl(cudp,SIOCGIFBRDADDR,(char *)ifra) < 0) { continue; }
                        memcpy((char *)&tiface.baddr, (char *)&ifra->ifr_broadaddr, sizeof(ifra->ifr_broadaddr));
                        if (ioctl(cudp,SIOCGIFADDR,(char *)ifra) < 0) { continue; }
                        memcpy((char *)&tiface.caddr, (char *)&ifra->ifr_addr, sizeof(ifra->ifr_addr));
                        inet_ntop(tiface.baddr.sin_family,&tiface.baddr.sin_addr,tiface.baddress,sizeof(tiface.baddress));
                    }
                    tiface.type = ntype;
                    iface.push_back(tiface);
                }

#endif // COSMOS_WIN_OS
            }
            break;
        default:
            break;
        }
        return (iface);
    }

int32_t Cosmos::Support::Agent::post

(

messstruc

mess

)

Post a Cosmos::Agent::messstruc.

Post an already defined message on the previously opened publication channel.

Parameters

mess	Cosmos::Agent::messstruc containing everything necessary, including type, header and data.

Returns

0, otherwise negative error.

                                      {
        int32_t iretn;
        if (mess.meta.type < Agent::AgentMessage::BINARY) {
            iretn = post(mess.meta.type, mess.adata);
        } else {
            iretn = post(mess.meta.type, mess.bdata);
        }
        return iretn;
    }

int32_t Cosmos::Support::Agent::post	(	AgentMessage	type,
		string	message = ""
	)

Post a JSON message.

Post a vector of bytes on the previously opened publication channel.

Parameters

type	A byte indicating the type of message.
message	A NULL terminated JSON text string to post.

Returns

0, otherwise negative error.

    {
        int32_t iretn;
        vector<uint8_t> bytes(message.begin(), message.end());
        //        bytes.push_back(0);
        iretn = post(type, bytes);
        return iretn;
    }

int32_t Cosmos::Support::Agent::post	(	AgentMessage	type,
		vector< uint8_t >	message
	)

Post a binary message.

Post a vector of bytes on the previously opened publication channel.

Parameters

type	A byte indicating the type of message.
message	An array of bytes to post.

Returns

0, otherwise negative error.

    {
        size_t nbytes;
        int32_t iretn=0;
        uint8_t post[AGENTMAXBUFFER];

        cinfo->agent[0].beat.utc = currentmjd();
        post[0] = (uint8_t)type;
        // this will broadcast messages to all external interfaces (ifcnt = interface count)
        for (size_t i=0; i<cinfo->agent[0].ifcnt; i++)
        {
            sprintf((char *)&post[3],"{\"agent_utc\":%.15g,\"agent_node\":\"%s\",\"agent_proc\":\"%s\",\"agent_addr\":\"%s\",\"agent_port\":%u,\"agent_bprd\":%f,\"agent_bsz\":%u,\"agent_cpu\":%f,\"agent_memory\":%f,\"agent_jitter\":%f,\"node_utcoffset\":%.15g}",
                    cinfo->agent[0].beat.utc,
                    cinfo->agent[0].beat.node,
                    cinfo->agent[0].beat.proc,
                    cinfo->agent[0].pub[i].address,
                    cinfo->agent[0].beat.port,
                    cinfo->agent[0].beat.bprd,
                    cinfo->agent[0].beat.bsz,
                    cinfo->agent[0].beat.cpu,
                    cinfo->agent[0].beat.memory,
                    cinfo->agent[0].beat.jitter,
                    cinfo->node.utcoffset);
            size_t hlength = strlen((char *)&post[3]);
            post[1] = hlength%256;
            post[2] = hlength / 256;
            nbytes = hlength + 3;

            if (message.size())
            {
                if (nbytes+message.size() > AGENTMAXBUFFER)
                    return (AGENT_ERROR_BUFLEN);
                memcpy(&post[nbytes], &message[0], message.size());
            }
            iretn = sendto(cinfo->agent[0].pub[i].cudp,       // socket
                    (const char *)post,                         // buffer to send
                    nbytes+message.size(),                      // size of buffer
                    0,                                          // flags
                    (struct sockaddr *)&cinfo->agent[0].pub[i].baddr, // socket address
                    sizeof(struct sockaddr_in)                  // size of address to socket pointer
                    );
            if (iretn < 0)
            {
#ifdef COSMOS_WIN_OS
                if (WSAGetLastError() != EAGAIN && WSAGetLastError() != EWOULDBLOCK)
                {
                    iretn = -WSAGetLastError();
                }
#else
                if (errno != EAGAIN && errno != EWOULDBLOCK)
                {
                    iretn = -errno;
                }
#endif
                else
                {
                    iretn= 0;
                }
            }
            //            printf("Post: Type: %d Port: %d %d\n", type, cinfo->agent[0].pub[i].cport, htons(cinfo->agent[0].pub[i].caddr.sin_port));
        }

        if (iretn<0)
        {
#ifdef COSMOS_WIN_OS
            return(-WSAGetLastError());
#else
            return (-errno);
#endif
        }
        return 0;
    }

int32_t Cosmos::Support::Agent::post_beat

(

)

    {
        int32_t iretn = 0;
        cinfo->agent[0].beat.utc = currentmjd(0.);
        iretn = post(AgentMessage::BEAT);
//            if (!sohtable.empty())
//            {
//                iretn = post(AgentMessage::BEAT, json_of_table(hbjstring, sohtable, (cosmosstruc *)cinfo));
//            }
//            else
//            {
//                iretn = post(AgentMessage::BEAT,"");
//            }
        return iretn;
    }

int32_t Cosmos::Support::Agent::post_soh

(

)

                            {
        int32_t iretn = 0;
        cinfo->agent[0].beat.utc = currentmjd(0.);
        iretn = post(AgentMessage::SOH, json_of_table(hbjstring, sohtable, (cosmosstruc *)cinfo));
        return iretn;
    }

int32_t Cosmos::Support::Agent::unpublish

(

)

Close COSMOS output channel.

Close previously opened publication channels and recover any allocated resources.

Returns

0, otherwise negative error.

                             {
        if (cinfo == nullptr) { return 0; }
        for (size_t i=0; i<cinfo->agent[0].ifcnt; ++i) { CLOSE_SOCKET(cinfo->agent[0].pub[i].cudp); }
        return 0;
    }

int32_t Cosmos::Support::Agent::subscribe	(	NetworkType	type,
		const char *	address,
		uint16_t	port,
		uint32_t	usectimeo
	)

Open COSMOS channel for polling.

This establishes a multicast channel for subscribing to COSMOS messages.

Parameters

type	0=Multicast, 1=Broadcast UDP, 2=Broadcast CSP.
address	The IP Multicast address of the channel.
port	The port to use for the channel.
usectimeo	Blocking read timeout in micro seconds.

Returns

0, otherwise negative error.

    {
        int32_t iretn = 0;

        // ?? this is preventing from running socket_open if
        // for some reason cinfo->agent[0].sub.cport was ill initialized
#ifndef COSMOS_WIN_BUILD_MSVC
        if (cinfo->agent[0].sub.cport) { return 0; }
#endif
        if ((iretn=socket_open(&cinfo->agent[0].sub,type,address,port,SOCKET_LISTEN,SOCKET_BLOCKING, usectimeo)) < 0) {
            return iretn;
        }
        return 0;
    }

int32_t Cosmos::Support::Agent::subscribe	(	NetworkType	type,
		const char *	address,
		uint16_t	port
	)

Open COSMOS channel for polling with 100 usec timeout.

This establishes a multicast channel for subscribing to COSMOS messages. The timeout is set to 100 usec.

Parameters

type	0=Multicast, 1=Broadcast UDP, 2=Broadcast CSP.
address	The IP Multicast address of the channel.
port	The port to use for the channel.

Returns

0, otherwise negative error.

                                                                                 {
        int32_t iretn = 0;
        if ((iretn=Agent::subscribe(type, address, port, 100)) < 0) { return iretn; }
        return 0;
    }

int32_t Cosmos::Support::Agent::unsubscribe

(

)

Close COSMOS subscription channel.

Close channel previously opened for polling for messages and recover resources.

Returns

0, otherwise negative error.

                               {
        if (cinfo != nullptr) { CLOSE_SOCKET(cinfo->agent[0].sub.cudp); }
        return 0;
    }

int32_t Cosmos::Support::Agent::poll	(	messstruc &	mess,
		AgentMessage	type,
		float	waitsec = 1.
	)

Listen for message.

Poll the subscription channel for the requested amount of time. Return as soon as a single message comes in, or the timer runs out.

Parameters

mess	Cosmos::Agent::messstruc for storing incoming message.
type	Type of message to look for, taken from Cosmos::Agent::AgentMessage.
waitsec	Number of seconds in timer.

Returns

If a message comes in, return its type. If none comes in, return zero, otherwise negative error.

    {
        int nbytes;
        uint8_t input[AGENTMAXBUFFER+1];

        if (cinfo == nullptr) { return AGENT_ERROR_NULL; }

        if (!cinfo->agent[0].sub.cport) { return (AGENT_ERROR_CHANNEL); }

        ElapsedTime ep;
        ep.start();
        do
        {
            nbytes = 0;
            switch (cinfo->agent[0].sub.type)
            {
            case NetworkType::MULTICAST:
            case NetworkType::UDP:

                nbytes = recvfrom(cinfo->agent[0].sub.cudp, (char *)input,AGENTMAXBUFFER, 0, (struct sockaddr *)&cinfo->agent[0].sub.caddr, (socklen_t *)&cinfo->agent[0].sub.addrlen);

                // Return if error
                if (nbytes < 0) { return nbytes; }

                //                printf("Poll: %f %f Type: %d Port %d %d\n", 86400.*(currentmjd()-58496), ep.split(), input[0], cinfo->agent[0].sub.cport, htons(cinfo->agent[0].sub.caddr.sin_port));

                // Return if port and address are our own
                for (uint16_t i=0; i<cinfo->agent[0].ifcnt; ++i) {
                    if (cinfo->agent[0].sub.caddr.sin_port == ntohs(cinfo->agent[0].pub[i].cport) &&
                        cinfo->agent[0].sub.caddr.sin_addr.s_addr == cinfo->agent[0].pub[i].caddr.sin_addr.s_addr) {
                        return 0;
                    }
                }
                break;
            default:
                break;
            }

            if (nbytes > 0) {
                if (type == Agent::AgentMessage::ALL || type == (AgentMessage)input[0]) {
                    // Determine if old or new message
                    uint8_t start_byte;
                    if (input[1] == '{') {
                        start_byte = 1;
                    } else {
                        start_byte = 3;
                    }
                    // Provide support for older messages that did not include jlength
                    if (start_byte > 1) {
                        mess.meta.type = (AgentMessage)input[0];
                        mess.meta.jlength = input[1] + 256 * input[2];
                    } else {
                        mess.meta.type = (AgentMessage)(input[0] + 1);
                        mess.meta.jlength = nbytes;
                    }

                    // Copy message parts to ring, placing in appropriate buffers.
                    // First: JSON header
                    mess.jdata.assign((const char *)&input[start_byte], mess.meta.jlength);

                    // Next: ASCII or BINARY message, depending on message type.
                    if (mess.meta.type < Agent::AgentMessage::BINARY) {
                        mess.adata.clear();
                        mess.adata.assign((const char *)&input[start_byte+mess.meta.jlength], nbytes - (start_byte + mess.meta.jlength));
                    } else {
                        mess.bdata.resize(nbytes - (start_byte + mess.meta.jlength));
                        memcpy(mess.bdata.data(), &input[start_byte + mess.meta.jlength], nbytes - (start_byte + mess.meta.jlength));
                    }

                    // Extract meta data
                    if (mess.jdata.find("}{") == string::npos)
                    {
                        sscanf((const char *)mess.jdata.data(), "{\"agent_utc\":%lg,\"agent_node\":\"%40[^\"]\",\"agent_proc\":\"%40[^\"]\",\"agent_addr\":\"%17[^\"]\",\"agent_port\":%hu,\"agent_bprd\":%lf,\"agent_bsz\":%u,\"agent_cpu\":%f,\"agent_memory\":%f,\"agent_jitter\":%lf}",
                               &mess.meta.beat.utc,
                               mess.meta.beat.node,
                               mess.meta.beat.proc,
                               mess.meta.beat.addr,
                               &mess.meta.beat.port,
                               &mess.meta.beat.bprd,
                               &mess.meta.beat.bsz,
                               &mess.meta.beat.cpu,
                               &mess.meta.beat.memory,
                               &mess.meta.beat.jitter);
                    }
                    else if (mess.jdata.find("agent_bprd") == string::npos)
                    {
                        sscanf((const char *)mess.jdata.data(), "{\"agent_utc\":%lg}{\"agent_node\":\"%40[^\"]\"}{\"agent_proc\":\"%40[^\"]\"}{\"agent_addr\":\"%17[^\"]\"}{\"agent_port\":%hu}{\"agent_bsz\":%u}{\"agent_cpu\":%f}{\"agent_memory\":%f}{\"agent_jitter\":%lf}",
                               &mess.meta.beat.utc,
                               mess.meta.beat.node,
                               mess.meta.beat.proc,
                               mess.meta.beat.addr,
                               &mess.meta.beat.port,
                               &mess.meta.beat.bsz,
                               &mess.meta.beat.cpu,
                               &mess.meta.beat.memory,
                               &mess.meta.beat.jitter);
                    } else {
                        sscanf((const char *)mess.jdata.data(), "{\"agent_utc\":%lg}{\"agent_node\":\"%40[^\"]\"}{\"agent_proc\":\"%40[^\"]\"}{\"agent_addr\":\"%17[^\"]\"}{\"agent_port\":%hu}{\"agent_bprd\":%lf}{\"agent_bsz\":%u}{\"agent_cpu\":%f}{\"agent_memory\":%f}{\"agent_jitter\":%lf}",
                               &mess.meta.beat.utc,
                               mess.meta.beat.node,
                               mess.meta.beat.proc,
                               mess.meta.beat.addr,
                               &mess.meta.beat.port,
                               &mess.meta.beat.bprd,
                               &mess.meta.beat.bsz,
                               &mess.meta.beat.cpu,
                               &mess.meta.beat.memory,
                               &mess.meta.beat.jitter);
                    }
                    return ((int)mess.meta.type);
                }
            }
            if (ep.split() >= waitsec) {
                nbytes = 0;
            } else {
                COSMOS_SLEEP(.1);
            }
        } while (nbytes != 0);

        return 0;
    }

int32_t Cosmos::Support::Agent::readring	(	messstruc &	message,
		AgentMessage	type = Agent::AgentMessage::ALL,
		float	waitsec = 1.,
		Where	where = Where::TAIL,
		string	proc = "",
		string	node = ""
	)

Check Ring for message.

Check the message ring for the requested amount of time. Return as soon as a message of the right type is available, or the timer runs out.

Parameters

message	Vector for storing incoming message.
type	Type of message to look for, taken from Cosmos::Agent::AgentMessage.
waitsec	Number of seconds in timer. If 0, return last message in ring immediatelly.
where	One of Where::HEAD or Where::TAIL, indicating whether to start at the head or tail of the ring.

Returns

If a message comes in, return its type. If none comes in, return zero, otherwise negative error.

    {
        if (waitsec < 0.f) { waitsec = 0.; }
        if (cinfo == nullptr) { return AGENT_ERROR_NULL; }
        if (where == Where::HEAD) { message_queue.clear(); }
        ElapsedTime ep;
        ep.start();
        do {
            while (message_queue.size()) {
                message = message_queue.front();
                message_queue.pop_front();
                if (type == Agent::AgentMessage::ALL || type == static_cast<Agent::AgentMessage>(message.meta.type)) {
                    if (proc.empty() || !strcmp(proc.c_str(), message.meta.beat.proc)) {
                        if (node.empty() || !strcmp(node.c_str(), message.meta.beat.node)) {
                            return (static_cast<int32_t>(message.meta.type));
                        }
                    }
                }
            }

            if (ep.split() < waitsec) {
                if (waitsec - ep.split() > .1) {
                    COSMOS_SLEEP(.1);
                } else {
                    COSMOS_SLEEP(.05);
                }
            }
        } while (ep.split() < waitsec);

        return 0;
    }

int32_t Cosmos::Support::Agent::parsering	(	AgentMessage	type = Agent::AgentMessage::ALL,
		float	waitsec = 1.,
		Where	where = Where::HEAD,
		string	proc = "",
		string	node = ""
	)

Parse next message from ring.

    {
        int32_t iretn;
        messstruc message;

        if (where == Where::HEAD) { message_queue.clear(); }
        post(Agent::AgentMessage::REQUEST, "heartbeat");
        ElapsedTime et;
        do {
            iretn = readring(message, type, waitsec, where, proc, node);
        } while (et.split() < waitsec);

        if (iretn >= 0 && iretn < static_cast <int32_t>(Agent::AgentMessage::BINARY))
        {
            json_parse(message.adata, cinfo);
            return iretn;
        }

        return GENERAL_ERROR_TIMEOUT;
    }

int32_t Cosmos::Support::Agent::resizering

(

size_t

newsize

)

Change size of message ring. Resize the message ring to hold a new maximum number of messages. Adjust the message pointers in the ring to be appropriate.

Parameters

newsize

New maximum message count.

Returns

Negative error, or zero.

    {
        if (message_head >= newsize) { message_head = 0; }
        if (message_tail >= newsize) { message_tail = newsize - 1; }
        return 0;
    }

int32_t Cosmos::Support::Agent::clearring

(

)

Empty message ring. Set the internal pointers such that it appears that we have read any messages that are in the message ring. This has the effect of emptying the message ring as far as Cosmos::Agent::readring is concerned.

Returns

Negative error or zero.

    {
        message_tail = message_head;
        return 0;
    }

string Cosmos::Support::Agent::getNode

(

)

Listen for heartbeat.

Poll the subscription channel until you receive a heartbeat message, or the timer runs out.

Parameters

waitsec

Number of seconds to wait before timing out.

Returns

beatstruc with acquired heartbeat. The UTC will be set to 0 if no heartbeat was acquired.Listen for Time

    Poll the subscription channel until you receive a time message, or the timer runs out.

Parameters

waitsec

Number of seconds to wait before timing out.

Returns

timestruc with acquired time. The UTC will be set to 0 if no heartbeat was acquired.Listen for Location

    Poll the subscription channel until you receive a location message, or the timer runs out.

Parameters

waitsec

Number of seconds to wait before timing out.

Returns

locstruc with acquired location. The UTC will be set to 0 if no heartbeat was acquired.Listen for Beacon

    Poll the subscription channel until you receive a info message, or the timer runs out.

Parameters

waitsec

Number of seconds to wait before timing out.

Returns

nodestruc with acquired info. The UTC will be set to 0 if no info was acquired.Listen for IMU device

    Poll the subscription channel until you receive a IMU device message, or the timer runs out.

Parameters

waitsec

Number of seconds to wait before timing out.

Returns

beatstruc with acquired heartbeat. The UTC will be set to 0 if no heartbeat was acquired.

{ return nodeName; }

string Cosmos::Support::Agent::getAgent

(

)

{ return agentName; }

int32_t Cosmos::Support::Agent::getJson	(	string	node,
		jsonnode &	jnode
	)

    {
        int32_t iretn=0;

        bool node_found = false;
        for (jsonnode json : node_list)
        {
            if (!node.compare(json.name))
            {
                node_found = true;
            }
        }

        if (!node_found)
        {
            for (beatstruc beat : agent_list)
            {
                if (!node.compare(beat.node))
                {
                    if ((iretn=send_request_jsonnode(beat, jnode)) >= 0)
                    {
                        node_list.push_back(jnode);
                        node_found = true;
                    }
                }
            }
        }

        if (!node_found) { iretn = GENERAL_ERROR_UNDEFINED; }

        return iretn;
    }

FILE * Cosmos::Support::Agent::get_debug_fd

(

double

mjd = 0.

)

                                        {
        static double oldmjd=0.;
        if (debug_level == 0) {
            debug_fd = nullptr;
            debug_pathName.clear();
        }
        else if (debug_level == 1) {
            if (debug_fd != stdout) {
                if (debug_fd != nullptr) {
                    fclose(debug_fd);
                }
                debug_fd = stdout;
                debug_pathName.clear();
            }
        } else {
            if (mjd == 0.) {
                mjd = currentmjd();
                oldmjd = mjd;
            }
            mjd = mjd - fmod(mjd, 1./24.);
            string pathName = data_type_path(nodeName, "temp", agentName, mjd, agentName, "debug");

            if (debug_fd != nullptr) {
                if (pathName != debug_pathName) {
                    FILE *fd = fopen(pathName.c_str(), "a");
                    if (fd != nullptr) {
                        if (debug_fd != stdout) {
                            fclose(debug_fd);
                            string final_filepath = data_type_path(nodeName, "outgoing", agentName, oldmjd, agentName, "debug");
                            rename(debug_pathName.c_str(), final_filepath.c_str());
                        }
                        debug_fd = fd;
                        debug_pathName = pathName;
                    }
                    oldmjd = mjd;
                }
            } else {
                FILE *fd = fopen(pathName.c_str(), "a");
                if (fd != nullptr) {
                    debug_fd = fd;
                    debug_pathName = pathName;
                }
            }
        }
        return debug_fd;
    }

int32_t Cosmos::Support::Agent::close_debug_fd

(

)

                                  {
        int32_t iretn;
        if (debug_fd != nullptr && debug_fd != stdout)
        {
            iretn = fclose(debug_fd);
            if (iretn != 0) { return -errno; }
            debug_fd = nullptr;
        }
        return 0;
    }

int32_t Cosmos::Support::Agent::set_agent_time_producer

(

double(*)()

source

)

                                                             {
        this->agent_time_producer = source;
        return 0;
    }

int32_t Cosmos::Support::Agent::get_agent_time	(	double &	agent_time,
		double &	epsilon,
		double &	delta,
		string	agent,
		string	node = "any",
		double	wait_sec = 2.
	)

                                                                                                                                {
        static beatstruc agent_beat;
        string agent_response;
        double mjd_0, mjd_1;
        int32_t iretn;

        if (!agent_beat.exists) {
            agent_beat = find_agent(node, agent, wait_sec);
        } else {
            if (strcmp(node.c_str(), agent_beat.node) || (strcmp(agent.c_str(), agent_beat.proc))) {
                agent_beat = find_agent(node, agent, wait_sec);
            }
        }

        // Do not proceed if we cannot find the agent.
        if (!agent_beat.exists) return AGENT_ERROR_DISCOVERY;

        mjd_0 = currentmjd();
        iretn = send_request(agent_beat, "utc", agent_response, 0);
        if (iretn >= 0) {
            mjd_1 = currentmjd();

            epsilon = (mjd_1 - mjd_0) / 2.0;  // RTT / 2.0
            agent_time = stod(agent_response.substr(0, agent_response.find("["))) + epsilon;
            delta = agent_time - mjd_1; // We do not have a lower bound on the time to transmit a message one way.

            return 0;
        } else {
            agent_time = 0.;
            epsilon = 0.;
            return GENERAL_ERROR_TIMEOUT;
        }
    }