agentclass.h

Go to the documentation of this file.

/********************************************************************
* Copyright (C) 2015 by Interstel Technologies, Inc.
*   and Hawaii Space Flight Laboratory.
*
* This file is part of the COSMOS/core that is the central
* module for COSMOS. For more information on COSMOS go to
* <http://cosmos-project.com>
*
* The COSMOS/core software is licenced under the
* GNU Lesser General Public License (LGPL) version 3 licence.
*
* You should have received a copy of the
* GNU Lesser General Public License
* If not, go to <http://www.gnu.org/licenses/>
*
* COSMOS/core is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* COSMOS/core is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* Refer to the "licences" folder for further information on the
* condititons and terms to use this software.
********************************************************************/

#ifndef COSMOSAGENT_H
#define COSMOSAGENT_H


#include "support/configCosmos.h"
#include "support/cosmos-errno.h"
#include "support/stringlib.h"
#include "support/timelib.h"
#include "support/jsondef.h"
#include "support/sliplib.h"
#include "support/socketlib.h"
#include "support/jsonlib.h"
#include "support/elapsedtime.h"
#include "device/cpu/devicecpu.h"

namespace Cosmos
{
    namespace Support
    {
        class Agent
        {
        public:
            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
            );

            ~Agent();

            vector<jsonentry*> sohtable;
            vector<jsonentry*> fullsohtable;

            enum class State : uint16_t {
                SHUTDOWN=0,
                INIT,
                IDLE,
                RUN,
                MONITOR,
                ASAFE,
                DEBUG,
                RESET
            };

#define AGENT_MULTIPLE true
#define AGENT_SINGLE false
#define AGENT_BLOCKING SOCKET_BLOCKING
#define AGENT_NONBLOCKING SOCKET_NONBLOCKING
#define AGENT_TALK SOCKET_TALK
#define AGENT_LISTEN SOCKET_LISTEN
#define AGENT_COMMUNICATE SOCKET_COMMUNICATE
#define AGENT_JABBER SOCKET_JABBER

#define AGENTBASE 10020
#define AGENTSENDPORT 10020
#define AGENTRECVPORT 10021
#define AGENTMCAST "225.1.1.1"
#define AGENTMAXLIST 500
#define AGENTMAXHEARTBEAT 200
#define AGENTRCVTIMEO 100000
#define AGENT_HEARTBEAT_PERIOD_MIN 0.01

#define MESSAGE_RING_SIZE 100

            enum class AgentMessage : uint8_t {
                ALL=1,
                BEAT=2,
                SOH=3,
                GENERIC=4,
                TIME=5,
                LOCATION=6,
                TRACK=7,
                IMU=8,
                EVENT=9,
                REQUEST=10,
                RESPONSE=11,
                BINARY=128,
                COMM=129
            };

            enum class Where : size_t {
                HEAD = 0,
                TAIL = 1
            };


#define MAXARGCOUNT 100



            struct beatstruc_list
            {
                int16_t count;
                beatstruc *heartbeat[AGENTMAXLIST];
            };

            struct pollstruc
            {
                AgentMessage type; // > 128 is binary, <128 is json, look for AGENT_MESSAGE in agentclass.h
                uint16_t jlength; // length of JSON header
                beatstruc beat; // all the information of the heartbeat (name, ip, etc.)
            };

            struct messstruc
            {
                pollstruc meta; // agent control information
                vector <uint8_t> bdata; // binary data if present
                string adata; // ascii data if present
                string jdata; // json header data, always present
            };

            typedef int32_t (*external_request_function)(string& request_string, string& output_string, Agent* agent);

            // agent functions
            int32_t start();
            int32_t start_active_loop();
            int32_t finish_active_loop();
            int32_t add_request(string token, external_request_function function, string synopsis="", string description="");
            int32_t send_request(beatstruc cbeat, string request, string &output, float waitsec=5.);
            int32_t send_request_jsonnode(beatstruc cbeat, jsonnode &jnode, float waitsec=5.);
            int32_t get_agent(string node, string agent, double waitsec, beatstruc &cbeat);
            int32_t check_agent(string node, string agent, double waitsec);
            beatstruc find_agent(string node, string agent, double waitsec=0.);
            vector<beatstruc> find_agents(double waitsec=0.);
            uint16_t running();
            int32_t wait(State state=State::RUN, double waitsec=10.);
            int32_t last_error();
            int32_t set_sohstring(string list);
            int32_t set_fullsohstring(string list);
            cosmosstruc *get_cosmosstruc();
            void get_ip(char* buffer, size_t buflen);
            void get_ip_list(uint16_t port);
            int32_t unpublish();
            int32_t post(messstruc mess);
            int32_t post(AgentMessage type, string message="");
            int32_t post(AgentMessage type, vector <uint8_t> message);
            int32_t post_beat();
            int32_t post_soh();
            int32_t publish(NetworkType type, uint16_t port);
            int32_t subscribe(NetworkType type, const char *address, uint16_t port);
            int32_t subscribe(NetworkType type, const char *address, uint16_t port, uint32_t usectimeo);
            int32_t unsubscribe();
            //    int32_t poll(pollstruc &meta, string &message, uint8_t type, float waitsec = 1.);
            //    int32_t poll(pollstruc &meta, vector <uint8_t> &message, uint8_t type, float waitsec = 1.);
            int32_t poll(messstruc &mess, AgentMessage type, float waitsec = 1.);
            int32_t readring(messstruc &message, AgentMessage type = Agent::AgentMessage::ALL, float waitsec = 1., Where where=Where::TAIL, string proc="", string node="");
            int32_t parsering(AgentMessage type = Agent::AgentMessage::ALL, float waitsec=1., Where where=Where::HEAD, string proc="", string node="");
            int32_t resizering(size_t newsize);
            int32_t clearring();
            //    timestruc poll_time(float waitsec);
            //    beatstruc poll_beat(float waitsec);
            //    locstruc poll_location(float waitsec);
            //    nodestruc poll_info(float waitsec);
            //    imustruc poll_imu(float waitsec);
            int json_map_agentstruc(agentstruc **agent);
            vector<socket_channel> find_addresses(NetworkType ntype);
            int32_t shutdown();
            int32_t send(uint8_t address, string message);
            int32_t receive(uint8_t address, string &message);
            int32_t receiveAll(uint8_t address, string &message);
            string getNode();
            string getAgent();
            int32_t getJson(string node, jsonnode &jnode);

            int32_t set_agent_time_producer(double (*source)());
            int32_t get_agent_time(double &agent_time, double &epsilon, double &delta, string agent, string node="any", double wait_sec=2.);

            // poll
            pollstruc metaRx;
            string metaHeader;

            void log(string log_entry);
            bool setSoh(string sohFields);
            cosmosstruc *cinfo;

            vector <beatstruc> agent_list;
            vector <jsonnode> node_list;

//            vector <messstruc> message_ring;
            deque <messstruc> message_queue;
            size_t message_head = MESSAGE_RING_SIZE;
            size_t message_tail = MESSAGE_RING_SIZE;

            uint16_t debug_level = 0;
            FILE *get_debug_fd(double mjd=0.);
            int32_t close_debug_fd();

            // agent variables
            string nodeName;
            string agentName;
            vector<beatstruc> slist;

        protected:
        private:

            NetworkType networkType = NetworkType::UDP;
            double activeTimeout = 0.0; // in MJD
            uint32_t bufferSize = AGENTMAXBUFFER;
            bool multiflag = false;
            int32_t portNumber = 0;
            FILE *debug_fd = nullptr;
            string debug_pathName;
            string version = "2.0";
            double timeoutSec = 2.0;
            bool logTime = true; // by default
            double timeStart; // UTC starting time for this agent in MJD
            string hbjstring;
            thread cthread;
            thread hthread;
            thread mthread;
            int32_t error_value;
            mutex process_mutex;

            double (*agent_time_producer)() = currentmjd;

            struct request_entry
            {
                string token;
                external_request_function efunction;
                string synopsis;
                string description;
            };

            vector <request_entry> reqs;

            void heartbeat_loop();
            void request_loop() noexcept;
            int32_t process_request(string &bufferin, string &bufferout);
            void message_loop();

            char* parse_request(char *input);
            DeviceCpu deviceCpu_;

            static int32_t req_forward(string &request, string &response, Agent *agent);
            static int32_t req_echo(string &request, string &response, Agent *agent);
            static int32_t req_help(string &request, string &response, Agent *agent);
            static int32_t req_help_json(string &request, string &response, Agent *agent);
            static int32_t req_shutdown(string &request, string &response, Agent *agent);
            static int32_t req_idle(string &request, string &response, Agent *agent);
            static int32_t req_init(string &request, string &response, Agent *agent);
            static int32_t req_monitor(string &request, string &response, Agent *agent);
            static int32_t req_reset(string &request, string &response, Agent *agent);
            static int32_t req_run(string &request, string &response, Agent *agent);
            static int32_t req_status(string &request, string &response, Agent *agent);
            static int32_t req_debug_level(string &request, string &response, Agent *agent);
            static int32_t req_getvalue(string &request, string &response, Agent *agent);
            static int32_t req_get_value(string &request, string &response, Agent *agent);
            static int32_t req_get_time(string &request, string &response, Agent *agent);
            static int32_t req_get_position(string &request, string &response, Agent *agent);
            static int32_t req_get_position_data(string &request, string &response, Agent *agent);
            static int32_t req_setvalue(string &request, string &response, Agent *agent);
            static int32_t req_set_value(string &request, string &response, Agent *agent);
            static int32_t req_listnames(string &request, string &response, Agent *agent);
            static int32_t req_nodejson(string &request, string &response, Agent *agent);
            static int32_t req_statejson(string &request, string &response, Agent *agent);
            static int32_t req_utcstartjson(string &request, string &response, Agent *agent);
            static int32_t req_piecesjson(string &request, string &response, Agent *agent);
            static int32_t req_vertexsjson(string &request, string &response, Agent *agent);
            static int32_t req_facesjson(string &request, string &response, Agent *agent);
            static int32_t req_devgenjson(string &request, string &response, Agent *agent);
            static int32_t req_devspecjson(string &request, string &response, Agent *agent);
            static int32_t req_portsjson(string &request, string &response, Agent *agent);
            static int32_t req_targetsjson(string &request, string &response, Agent *agent);
            static int32_t req_heartbeat(string &request, string &response, Agent *agent);
            static int32_t req_postsoh(string &request, string &response, Agent *agent);
            static int32_t req_utc(string &request, string &response, Agent *agent);
            static int32_t req_soh(string &, string &response, Agent *agent);
            static int32_t req_fullsoh(string &, string &response, Agent *agent);
            static int32_t req_jsondump(string &, string &response, Agent *agent);
        };
    } // end of namespace Support
} // end of namespace Cosmos

#endif // COSMOSAGENT_H