pvcall.cpp File Reference

#include <stdio.h>
#include <epicsStdlib.h>
#include <epicsGetopt.h>
#include <pv/pvData.h>
#include <pv/json.h>
#include <pva/client.h>
#include "pvutils.h"

Include dependency graph for pvcall.cpp:

Go to the source code of this file.

Macros
#define	EXECNAME   "pvcall"
#define	MAIN   main

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

Macro Definition Documentation

#define EXECNAME   "pvcall"

Definition at line 18 of file pvcall.cpp.

#define MAIN   main

Definition at line 75 of file pvcall.cpp.

Function Documentation

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

Definition at line 78 of file pvcall.cpp.

{
    try {
        int opt;                    /* getopt() current option */
        std::string pv;

        args_t args;

        while ((opt = getopt(argc, argv, ":hvVM:r:w:p:ds:a:")) != -1) {
            switch (opt) {
            case 'h':               /* Print usage */
                callusage();
                return 0;
            case 'v':
                verbosity++;
                break;
            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;
            }
                break;
            case 'M':
                if(strcmp(optarg, "raw")==0) {
                    outmode = pvd::PVStructure::Formatter::Raw;
                } else if(strcmp(optarg, "nt")==0) {
                    outmode = pvd::PVStructure::Formatter::NT;
                } else if(strcmp(optarg, "json")==0) {
                    outmode = pvd::PVStructure::Formatter::JSON;
                } else {
                    fprintf(stderr, "Unknown output mode '%s'\n", optarg);
                    outmode = pvd::PVStructure::Formatter::Raw;
                }
                break;
            case 'w':               /* Set PVA timeout value */
            {
                double temp;
                if((epicsScanDouble(optarg, &temp)) != 1)
                {
                    fprintf(stderr, "'%s' is not a valid timeout value "
                                    "- ignored. ('" EXECNAME " -h' for help.)\n", optarg);
                } else {
                    timeout = temp;
                }
            }
                break;
            case 'r':               /* Set PVA timeout value */
                request = optarg;
                break;
            case 'p':               /* Set default provider */
                defaultProvider = optarg;
                break;
            case 'd':               /* Debug log level */
                debugFlag = true;
                break;
            case 's':
                pv = optarg;
                break;
            case 'a':
                try {
                args.push_back(parseArg(optarg));
            } catch(std::exception& e){
                    std::cerr<<"Error parsing argument '"<<optarg<<"'\n";
                    return 1;
                }
                break;
            case '?':
                fprintf(stderr,
                        "Unrecognized option: '-%c'. ('" EXECNAME " -h' for help.)\n",
                        optopt);
                return 1;
            case ':':
                fprintf(stderr,
                        "Option '-%c' requires an argument. ('" EXECNAME " -h' for help.)\n",
                        optopt);
                return 1;
            default :
                callusage();
                return 1;
            }
        }

        if(!pv.empty()) {
            // ok
        } else if (argc <= optind) {
            fprintf(stderr, "No pv name specified. ('pvput -h' for help.)\n");
            return 1;
        } else {
            pv = argv[optind++];
        }


        for(int i=optind; i<argc; i++) {
            try {
                args.push_back(parseArg(argv[i]));
            } catch(std::exception& e){
                std::cerr<<"Error parsing argument '"<<optarg<<"'\n";
                return 1;
            }
        }

        pvd::PVStructure::shared_pointer pvRequest;
        try {
            pvRequest = pvd::createRequest(request);
        } catch(std::exception& e){
            fprintf(stderr, "failed to parse request string: %s\n", e.what());
            return 1;
        }

        pvd::PVStructurePtr argument;
        {
            pvd::FieldBuilderPtr builder(pvd::getFieldCreate()->createFieldBuilder());
            builder = builder->setId("epics:nt/NTURI:1.0")
                    ->add("scheme", pvd::pvString)
                    ->add("authority", pvd::pvString)
                    ->add("path", pvd::pvString)
                    ->addNestedStructure("query");

            for(args_t::const_iterator it(args.begin()), end(args.end()); it!=end; ++it) {
                builder = builder->add(it->first, it->second->getField());
            }

            pvd::StructureConstPtr type(builder->endNested()
                                        ->createStructure());
            argument = pvd::getPVDataCreate()->createPVStructure(type);

            argument->getSubFieldT<pvd::PVString>("scheme")->put(defaultProvider);
            argument->getSubFieldT<pvd::PVString>("path")->put(pv);
            pvd::PVStructurePtr query(argument->getSubFieldT<pvd::PVStructure>("query"));

            for(args_t::const_iterator it(args.begin()), end(args.end()); it!=end; ++it) {
                query->getSubFieldT(it->first)->copy(*it->second);
            }
        }

        if(verbosity>=1)
            std::cout<<"# Argument\n"<<argument->stream().format(outmode);

        pvac::ClientProvider prov(defaultProvider);

        pvac::ClientChannel chan(prov.connect(pv));

        pvd::PVStructure::const_shared_pointer ret;
        try {
            ret = chan.rpc(timeout, argument, pvRequest);
        }catch(pvac::Timeout&){
            std::cerr<<"Timeout\n";
            return 1;
        }catch(std::exception& e) {
            std::cerr<<"Error: "<<e.what()<<"\n";
            return 1;
        }

        if(verbosity>=1)
            std::cout<<"# Result\n";
        if(ret)
            std::cout<<ret->stream().format(outmode);

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