gwmain.cpp File Reference

#include <iostream>
#include <fstream>
#include <stdexcept>
#include <map>
#include <signal.h>
#include <epicsStdlib.h>
#include <epicsGetopt.h>
#include <iocsh.h>
#include <epicsTimer.h>
#include <libComRegister.h>
#include <pv/json.h>
#include <pv/pvAccess.h>
#include <pv/clientFactory.h>
#include <pv/configuration.h>
#include <pv/serverContext.h>
#include <pv/reftrack.h>
#include <pv/iocreftrack.h>
#include <pv/iocshelper.h>
#include <pv/logger.h>
#include "server.h"
#include "pva2pva.h"

Include dependency graph for gwmain.cpp:

Go to the source code of this file.

Macros
#define	USE_SIGNAL

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

Variables
int	p2pReadOnly

Macro Definition Documentation

#define USE_SIGNAL

Definition at line 9 of file gwmain.cpp.

Function Documentation

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

Definition at line 240 of file gwmain.cpp.

{
    try {
        pva::refTrackRegistrar();

        epics::iocshRegister<const char*, const char*, &iocsh_drop>("drop", "client", "channel");
        epics::iocshRegister<int, const char*, &gwsr>("gwsr", "level", "channel");
        epics::iocshRegister<int, const char*, const char*, &gwcr>("gwcr", "level", "client", "channel");

        libComRegister();
        registerReadOnly();
        epics::registerRefCounter("ChannelCacheEntry", &ChannelCacheEntry::num_instances);
        epics::registerRefCounter("ChannelCacheEntry::CRequester", &ChannelCacheEntry::CRequester::num_instances);
        epics::registerRefCounter("GWChannel", &GWChannel::num_instances);
        epics::registerRefCounter("MonitorCacheEntry", &MonitorCacheEntry::num_instances);
        epics::registerRefCounter("MonitorUser", &MonitorUser::num_instances);

        ServerConfig arg;
        theserver = &arg;
        getargs(arg, argc, argv);

        if(arg.debug>0)
            std::cout<<"Notice: This p2p gateway prototype has been superceded by the p4p.gw gateway\n"
                       "        which has exciting new features including granular access control,\n"
                       "        and status PVs including bandwidth usage reports.\n"
                       "        p2p is considered deprecated by its author, and will receive\n"
                       "        minimal maintainance effort going forward.\n"
                       "        Users are encouraged to migrate to p4p.gw.\n"
                       "\n"
                       "        https://mdavidsaver.github.io/p4p/gw.html\n"
                       "\n";

        pva::pvAccessLogLevel lvl;
        if(arg.debug<0)
            lvl = pva::logLevelError;
        else if(arg.debug==0)
            lvl = pva::logLevelWarn;
        else if(arg.debug==1)
            lvl = pva::logLevelInfo;
        else if(arg.debug==2)
            lvl = pva::logLevelDebug;
        else if(arg.debug==3)
            lvl = pva::logLevelTrace;
        else if(arg.debug>=4)
            lvl = pva::logLevelAll;
        SET_LOG_LEVEL(lvl);

        pva::ClientFactory::start();

        pvd::PVStructureArray::const_svector arr;

        arr = arg.conf->getSubFieldT<pvd::PVStructureArray>("clients")->view();

        for(size_t i=0; i<arr.size(); i++) {
            if(!arr[i]) continue;
            const pvd::PVStructurePtr& client = arr[i];

            std::string name(client->getSubFieldT<pvd::PVString>("name")->get());
            if(name.empty())
                throw std::runtime_error("Client with empty name not allowed");

            ServerConfig::clients_t::const_iterator it(arg.clients.find(name));
            if(it!=arg.clients.end())
                throw std::runtime_error(std::string("Duplicate client name not allowed : ")+name);

            arg.clients[name] = configure_client(arg, client);
        }

        arr = arg.conf->getSubFieldT<pvd::PVStructureArray>("servers")->view();

        for(size_t i=0; i<arr.size(); i++) {
            if(!arr[i]) continue;
            const pvd::PVStructurePtr& server = arr[i];

            std::string name(server->getSubFieldT<pvd::PVString>("name")->get());
            if(name.empty())
                throw std::runtime_error("Server with empty name not allowed");

            ServerConfig::servers_t::const_iterator it(arg.servers.find(name));
            if(it!=arg.servers.end())
                throw std::runtime_error(std::string("Duplicate server name not allowed : ")+name);

            arg.servers[name] = configure_server(arg, server);
        }

        int ret = 0;
        if(arg.interactive) {
            ret = iocsh(NULL);
        } else {
#ifdef USE_SIGNAL
            signal(SIGINT, sigdone);
            signal(SIGTERM, sigdone);
            signal(SIGQUIT, sigdone);
#endif

            while(!quit) {
                done.wait();
            }
        }

        theserver = 0;

        return ret;
    }catch(std::exception& e){
        std::cerr<<"Fatal Error : "<<e.what()<<"\n";
        return 1;
    }
}

Variable Documentation

int p2pReadOnly

Definition at line 21 of file channel.cpp.