pvlist.cpp File Reference

#include <stdio.h>
#include <iostream>
#include <map>
#include <iterator>
#include <vector>
#include <string>
#include <istream>
#include <fstream>
#include <sstream>
#include <epicsStdlib.h>
#include <epicsGetopt.h>
#include <pv/logger.h>
#include <epicsExit.h>
#include <osiSock.h>
#include <pv/byteBuffer.h>
#include <pv/serializeHelper.h>
#include <pv/pvaConstants.h>
#include <pv/inetAddressUtil.h>
#include <pv/configuration.h>
#include <pv/remote.h>
#include <pv/rpcClient.h>

Include dependency graph for pvlist.cpp:

Go to the source code of this file.

Macros
#define	DEFAULT_TIMEOUT   3.0

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

Macro Definition Documentation

#define DEFAULT_TIMEOUT   3.0

Definition at line 480 of file pvlist.cpp.

Function Documentation

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

Definition at line 519 of file pvlist.cpp.

{
    int opt;                    /* getopt() current option */
    bool debug = false;
    double timeOut = DEFAULT_TIMEOUT;
    bool printInfo = false;

    /*
    istream* inputStream = 0;
    ifstream ifs;
    bool fromStream = false;
    */
    setvbuf(stdout,NULL,_IOLBF,BUFSIZ);    /* Set stdout to line buffering */

    while ((opt = getopt(argc, argv, ":hVw:qdF:f:i")) != -1) {
        switch (opt) {
        case 'h':               /* Print usage */
            usage();
            return 0;
        case 'V':               /* Print version */
        {
            fprintf(stdout, "pvAccess %u.%u.%u%s\n",
                    EPICS_PVA_MAJOR_VERSION,
                    EPICS_PVA_MINOR_VERSION,
                    EPICS_PVA_MAINTENANCE_VERSION,
                    (EPICS_PVA_DEVELOPMENT_FLAG)?"-SNAPSHOT":"");
            fprintf(stdout, "pvData %u.%u.%u%s\n",
                    EPICS_PVD_MAJOR_VERSION,
                    EPICS_PVD_MINOR_VERSION,
                    EPICS_PVD_MAINTENANCE_VERSION,
                    (EPICS_PVD_DEVELOPMENT_FLAG)?"-SNAPSHOT":"");
            fprintf(stdout, "Base %s\n", EPICS_VERSION_FULL);
            return 0;
        }
        case 'w':               /* Set PVA timeout value */
            if((epicsScanDouble(optarg, &timeOut)) != 1 || timeOut <= 0.0)
            {
                fprintf(stderr, "'%s' is not a valid timeout value "
                        "- ignored. ('pvlist -h' for help.)\n", optarg);
                timeOut = DEFAULT_TIMEOUT;
            }
            break;
        case 'q':               /* Quiet mode */
            break;
        case 'd':               /* Debug log level */
            debug = true;
            break;
        case 'i':               /* Print server info */
            printInfo = true;
            break;
        case '?':
            fprintf(stderr,
                    "Unrecognized option: '-%c'. ('pvlist -h' for help.)\n",
                    optopt);
            return 1;
        case ':':
            fprintf(stderr,
                    "Option '-%c' requires an argument. ('pvlist -h' for help.)\n",
                    optopt);
            return 1;
        default :
            usage();
            return 1;
        }
    }

    SET_LOG_LEVEL(debug ? logLevelDebug : logLevelError);

    bool noArgs = (optind == argc);

    bool byGUIDSearch = false;
    for (int i = optind; i < argc; i++)
    {
        string serverAddress = argv[i];

        // by GUID search
        if (serverAddress.length() == 26 &&
                serverAddress[0] == '0' &&
                serverAddress[1] == 'x')
        {
            byGUIDSearch = true;
            break;
        }
    }

    bool allOK = true;

    if (noArgs || byGUIDSearch)
        discoverServers(timeOut);

    // just list all the discovered servers
    if (noArgs)
    {
        for (ServerMap::const_iterator iter = serverMap.begin();
                iter != serverMap.end();
                iter++)
        {
            const ServerEntry& entry = iter->second;

            cout << "GUID 0x" << entry.guid << " version " << (int)entry.version << ": "
                 << entry.protocol << "@[ ";

            size_t count = entry.addresses.size();
            for (size_t i = 0; i < count; i++)
            {
                cout << inetAddressToString(entry.addresses[i]);
                if (i < (count-1))
                    cout << " ";
            }
            cout << " ]" << endl;
        }
    }
    else
    {
        for (int i = optind; i < argc; i++)
        {
            string serverAddress = argv[i];

            // by GUID search
            if (serverAddress.length() == 26 &&
                    serverAddress[0] == '0' &&
                    serverAddress[1] == 'x')
            {
                bool resolved = false;
                for (ServerMap::const_iterator iter = serverMap.begin();
                        iter != serverMap.end();
                        iter++)
                {
                    const ServerEntry& entry = iter->second;

                    if (strncmp(entry.guid.c_str(), &(serverAddress[2]), 24) == 0)
                    {
                        // found match

                        // TODO for now we take only first server address
                        serverAddress = inetAddressToString(entry.addresses[0]);
                        resolved = true;
                        break;
                    }
                }

                if (!resolved)
                {
                    fprintf(stderr, "Failed to resolve GUID '%s'!\n", serverAddress.c_str());
                    allOK = false;
                    continue;
                }
            }

            StructureConstPtr argstype(getFieldCreate()->createFieldBuilder()
                                       ->setId("epics:nt/NTURI:1.0")
                                       ->add("scheme", pvString)
                                       ->add("path", pvString)
                                       ->addNestedStructure("query")
                                           ->add("op", pvString)
                                       ->endNested()
                                       ->createStructure());

            PVStructure::shared_pointer args(getPVDataCreate()->createPVStructure(argstype));

            args->getSubFieldT<PVString>("scheme")->put("pva");
            args->getSubFieldT<PVString>("path")->put("server");
            args->getSubFieldT<PVString>("query.op")->put(printInfo ? "info" : "channels");

            if(debug) {
                std::cerr<<"Query to "<<serverAddress<<"\n"<<args<<"\n";
            }

            PVStructure::shared_pointer ret;
            try {
                RPCClient rpc("server",
                              createRequest("field()"),
                              ChannelProvider::shared_pointer(),
                              serverAddress);

                if(debug)
                    std::cerr<<"Execute\n";
                ret = rpc.request(args, timeOut, true);
            } catch(std::exception& e) {
                std::cerr<<"Error: "<<e.what()<<"\n";
                return 1;
            }

            if(!printInfo) {
                PVStringArray::shared_pointer pvs(ret->getSubField<PVStringArray>("value"));

                PVStringArray::const_svector val(pvs->view());

                std::copy(val.begin(),
                          val.end(),
                          std::ostream_iterator<std::string>(std::cout, "\n"));
            }
            else {
                std::cout<<ret<<"\n";
            }
        }
    }

    return allOK ? 0 : 1;
}