ServerConfig Struct Reference

#include "server.h"

Public Types
typedef std::map< std::string, GWServerChannelProvider::shared_pointer >	clients_t
typedef std::map< std::string, epics::pvAccess::ServerContext::shared_pointer >	servers_t

Public Member Functions
	ServerConfig ()
void	drop (const char *client, const char *channel)
void	status_server (int lvl, const char *server)
void	status_client (int lvl, const char *client, const char *channel)

Public Attributes
int	debug
bool	interactive
epics::pvData::PVStructure::shared_pointer	conf
clients_t	clients
servers_t	servers

Detailed Description

Definition at line 40 of file server.h.

Member Typedef Documentation

typedef std::map<std::string, GWServerChannelProvider::shared_pointer> ServerConfig::clients_t

Definition at line 45 of file server.h.

typedef std::map<std::string, epics::pvAccess::ServerContext::shared_pointer> ServerConfig::servers_t

Definition at line 48 of file server.h.

Constructor & Destructor Documentation

ServerConfig::ServerConfig ( )

inline

Definition at line 51 of file server.h.

:debug(1), interactive(true) {}

Member Function Documentation

void ServerConfig::drop	(	const char *	client,
		const char *	channel
	)

Definition at line 102 of file server.cpp.

{
    if(!client)
        client= "";
    if(!channel)
        channel = "";
    // TODO: channel glob match

    FOREACH(clients_t::const_iterator, it, end, clients)
    {
        if(client[0]!='\0' && client[0]!='*' && it->first!=client)
            continue;

        const GWServerChannelProvider::shared_pointer& prov(it->second);

        ChannelCacheEntry::shared_pointer entry;

        // find the channel, if it's there
        {
            Guard G(prov->cache.cacheLock);

            ChannelCache::entries_t::iterator it = prov->cache.entries.find(channel);
            if(it==prov->cache.entries.end())
                continue;

            std::cout<<"Drop from "<<it->first<<" : "<<it->second->channelName<<"\n";

            entry = it->second;
            prov->cache.entries.erase(it); // drop out of cache (TODO: not required)
        }

        // trigger client side disconnect (recursively calls call CRequester::channelStateChange())
        // TODO: shouldn't need this
        entry->channel->destroy();

    }
}

void ServerConfig::status_client	(	int	lvl,
		const char *	client,
		const char *	channel
	)

Definition at line 158 of file server.cpp.

{
    if(!client)
        client= "";
    if(!channel)
        channel = "";

    bool iswild = strchr(channel, '?') || strchr(channel, '*');

    FOREACH(clients_t::const_iterator, it, end, clients)
    {
        if(client[0]!='\0' && client[0]!='*' && it->first!=client)
            continue;

        const GWServerChannelProvider::shared_pointer& prov(it->second);

        std::cout<<"==> Client: "<<it->first<<"\n";

        ChannelCache::entries_t entries;

        size_t ncache, ncleaned, ndust;
        {
            Guard G(prov->cache.cacheLock);

            ncache = prov->cache.entries.size();
            ncleaned = prov->cache.cleanerRuns;
            ndust = prov->cache.cleanerDust;

            if(lvl>0) {
                if(!iswild) { // no string or some glob pattern
                    entries = prov->cache.entries; // copy of std::map
                } else { // just one channel
                    ChannelCache::entries_t::iterator it(prov->cache.entries.find(channel));
                    if(it!=prov->cache.entries.end())
                        entries[it->first] = it->second;
                }
            }
        }

        std::cout<<"Cache has "<<ncache<<" channels.  Cleaned "
                <<ncleaned<<" times closing "<<ndust<<" channels\n";

        if(lvl<=0)
            continue;

        FOREACH(ChannelCache::entries_t::const_iterator, it2, end2, entries)
        {
            const std::string& channame = it2->first;
            if(iswild && !epicsStrGlobMatch(channame.c_str(), channel))
                continue;

            ChannelCacheEntry& E = *it2->second;
            ChannelCacheEntry::mon_entries_t::lock_vector_type mons;
            size_t nsrv, nmon;
            bool dropflag;
            const char *chstate;
            {
                Guard G(E.mutex());
                chstate = pva::Channel::ConnectionStateNames[E.channel->getConnectionState()];
                nsrv = E.interested.size();
                nmon = E.mon_entries.size();
                dropflag = E.dropPoke;

                if(lvl>1)
                    mons = E.mon_entries.lock_vector();
            }

            std::cout<<chstate
                     <<" Client Channel '"<<channame
                     <<"' used by "<<nsrv<<" Server channel(s) with "
                     <<nmon<<" unique subscription(s) "
                     <<(dropflag?'!':'_')<<"\n";

            if(lvl<=1)
                continue;

            FOREACH(ChannelCacheEntry::mon_entries_t::lock_vector_type::const_iterator, it2, end2, mons) {
                MonitorCacheEntry& ME =  *it2->second;

                MonitorCacheEntry::interested_t::vector_type usrs;
                size_t nsrvmon;
#ifdef USE_MSTATS
                pvd::Monitor::Stats mstats;
#endif
                bool hastype, hasdata, isdone;
                {
                    Guard G(ME.mutex());

                    nsrvmon = ME.interested.size();
                    hastype = !!ME.typedesc;
                    hasdata = !!ME.lastelem;
                    isdone = ME.done;

#ifdef USE_MSTATS
                    if(ME.mon)
                        ME.mon->getStats(mstats);
#endif

                    if(lvl>2)
                        usrs = ME.interested.lock_vector();
                }

                // TODO: how to describe pvRequest in a compact way...
                std::cout<<"  Client Monitor used by "<<nsrvmon<<" Server monitors, "
                         <<"Has "<<(hastype?"":"not ")
                         <<"opened, Has "<<(hasdata?"":"not ")
                         <<"recv'd some data, Has "<<(isdone?"":"not ")<<"finalized\n"
                           "    "<<      epicsAtomicGetSizeT(&ME.nwakeups)<<" wakeups "
                         <<epicsAtomicGetSizeT(&ME.nevents)<<" events\n";
#ifdef USE_MSTATS
                if(mstats.nempty || mstats.nfilled || mstats.noutstanding)
                    std::cout<<"    US monitor queue "<<mstats.nfilled
                             <<" filled, "<<mstats.noutstanding
                             <<" outstanding, "<<mstats.nempty<<" empty\n";
#endif
                if(lvl<=2)
                    continue;

                FOREACH(MonitorCacheEntry::interested_t::vector_type::const_iterator, it3, end3, usrs) {
                    MonitorUser& MU = **it3;

                    size_t nempty, nfilled, nused, total;
                    std::string remote;
                    bool isrunning;
                    {
                        Guard G(MU.mutex());

                        nempty = MU.empty.size();
                        nfilled = MU.filled.size();
                        nused = MU.inuse.size();
                        isrunning = MU.running;

                        GWChannel::shared_pointer srvchan(MU.srvchan.lock());
                        if(srvchan)
                            remote = srvchan->address;
                        else
                            remote = "<unknown>";
                    }
                    total = nempty + nfilled + nused;

                    std::cout<<"    Server monitor from "
                             <<remote
                             <<(isrunning?"":" Paused")
                             <<" buffer "<<nfilled<<"/"<<total
                             <<" out "<<nused<<"/"<<total
                             <<" "<<epicsAtomicGetSizeT(&MU.nwakeups)<<" wakeups "
                             <<epicsAtomicGetSizeT(&MU.nevents)<<" events "
                             <<epicsAtomicGetSizeT(&MU.ndropped)<<" drops\n";
                }
            }



        }


        std::cout<<"<== Client: "<<it->first<<"\n\n";
    }
}

void ServerConfig::status_server	(	int	lvl,
		const char *	server
	)

Definition at line 140 of file server.cpp.

{
    if(!server)
        server = "";

    FOREACH(servers_t::const_iterator, it, end, servers)
    {
        if(server[0]!='\0' && server[0]!='*' && it->first!=server)
            continue;

        const pva::ServerContext::shared_pointer& serv(it->second);
        std::cout<<"==> Server: "<<it->first<<"\n";
        serv->printInfo(std::cout);
        std::cout<<"<== Server: "<<it->first<<"\n\n";
        // TODO: print client list somehow
    }
}

Member Data Documentation

clients_t ServerConfig::clients

Definition at line 46 of file server.h.

epics::pvData::PVStructure::shared_pointer ServerConfig::conf

Definition at line 43 of file server.h.

int ServerConfig::debug

Definition at line 41 of file server.h.

bool ServerConfig::interactive

Definition at line 42 of file server.h.

servers_t ServerConfig::servers

Definition at line 49 of file server.h.

---

The documentation for this struct was generated from the following files:

• modules/pva2pva/p2pApp/server.h
• modules/pva2pva/p2pApp/server.cpp