EPICS_base/pvAccess
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

update pvlist to use RPCClient

Browse Source
This commit is contained in:
Michael Davidsaver
2017-06-28 20:36:31 +02:00
parent 858235fd0a
commit a6efd7ce6a
3 changed files with 65 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
pvtoolsSrc/pvlist.cpp
View File

@ -3,6 +3,7 @@
#include <iostream>
#include <map>
#include <iterator>
#include <vector>
#include <string>
#include <istream>
@ -39,6 +40,8 @@ using namespace std;
using namespace epics::pvData;
using namespace epics::pvAccess;
namespace {
/// Byte to hexchar mapping.
static const char lookup[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
@ -461,6 +464,7 @@ void usage (void)
, DEFAULT_TIMEOUT);
}
}//namespace
/*+**************************************************************************
*
@ -656,32 +660,53 @@ int main (int argc, char *argv[])
}
}
// TODO for now we call eget utility
// TODO timeOut
string cmd = "eget -";
if (debug)
cmd += 'd';
if (quiet)
cmd += 'q';
if (printInfo)
cmd += 'N';
cmd += "s pva://" + serverAddress + "/server?op=";
if (printInfo)
cmd += "info";
else
cmd += "channels";
StructureConstPtr argstype(getFieldCreate()->createFieldBuilder()
->setId("epics:nt/NTURI:1.0")
->add("scheme", pvString)
->add("path", pvString)
->addNestedStructure("query")
->add("op", pvString)
->endNested()
->createStructure());
FILE* egetpipe = popen (cmd.c_str(), "w");
if (!egetpipe)
{
char errStr[64];
epicsSocketConvertErrnoToString(errStr, sizeof(errStr));
fprintf(stderr, "Failed to exec 'eget': %s\n", errStr);
allOK = false;
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";
}
pclose(egetpipe);
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"));
return allOK ? 0 : 1;
}
std::cout<<ret<<"\n";
}
}

12
src/rpcClient/pv/rpcClient.h
View File

@ -51,11 +51,9 @@ public:
epics::pvData::PVStructure::shared_pointer const & pvRequest = epics::pvData::PVStructure::shared_pointer());
RPCClient(const std::string & serviceName,
epics::pvData::PVStructure::shared_pointer const & pvRequest);
RPCClient(const ChannelProvider::shared_pointer& provider,
const std::string & serviceName,
epics::pvData::PVStructure::shared_pointer const & pvRequest);
epics::pvData::PVStructure::shared_pointer const & pvRequest,
const ChannelProvider::shared_pointer& provider = ChannelProvider::shared_pointer(),
const std::string& address = std::string());
~RPCClient() {destroy();}
@ -138,11 +136,9 @@ public:
epics::pvData::PVStructure::shared_pointer waitResponse(double timeout = RPCCLIENT_DEFAULT_TIMEOUT);
private:
void construct(const ChannelProvider::shared_pointer& provider,
const std::string & serviceName,
epics::pvData::PVStructure::shared_pointer const & pvRequest);
const std::string m_serviceName;
ChannelProvider::shared_pointer m_provider;
Channel::shared_pointer m_channel;
ChannelRPC::shared_pointer m_rpc;
const epics::pvData::PVStructure::shared_pointer m_pvRequest;

79
src/rpcClient/rpcClient.cpp
View File

@ -29,37 +29,7 @@
namespace pvd = epics::pvData;
namespace pva = epics::pvAccess;
namespace {
struct DummyChannelRequester : public pva::ChannelRequester
{
POINTER_DEFINITIONS(DummyChannelRequester);
pvd::Mutex mutex;
pvd::Status status;
DummyChannelRequester()
:status(pvd::Status::error("Never created"))
{}
virtual ~DummyChannelRequester() {}
virtual std::string getRequesterName() { return "DummyChannelRequester"; }
virtual void channelCreated(const pvd::Status& status, pva::Channel::shared_pointer const & channel) {
TRACE("status="<<status);
pvd::Lock L(mutex);
this->status = status;
}
virtual void channelStateChange(pva::Channel::shared_pointer const & channel, pva::Channel::ConnectionState connectionState) {}
};
}// namespace
namespace epics
{
namespace pvAccess
{
namespace epics{namespace pvAccess{
struct RPCClient::RPCRequester : public pva::ChannelRPCRequester
{
@ -145,41 +115,24 @@ struct RPCClient::RPCRequester : public pva::ChannelRPCRequester
};
RPCClient::RPCClient(const std::string & serviceName,
pvd::PVStructure::shared_pointer const & pvRequest)
: m_serviceName(serviceName), m_pvRequest(pvRequest ? pvRequest : pvd::createRequest(""))
pvd::PVStructure::shared_pointer const & pvRequest,
const ChannelProvider::shared_pointer &provider,
const std::string &address)
: m_serviceName(serviceName)
, m_provider(provider)
, m_pvRequest(pvRequest ? pvRequest : pvd::createRequest(""))
{
ClientFactory::start();
ChannelProvider::shared_pointer provider(ChannelProviderRegistry::clients()->getProvider("pva"));
if(!provider)
if(!m_provider)
m_provider = ChannelProviderRegistry::clients()->getProvider("pva");
if(!m_provider)
throw std::logic_error("Unknown Provider");
construct(provider, serviceName, pvRequest);
}
RPCClient::RPCClient(const ChannelProvider::shared_pointer& provider,
const std::string & serviceName,
epics::pvData::PVStructure::shared_pointer const & pvRequest)
{
construct(provider, serviceName, pvRequest);
}
m_channel = m_provider->createChannel(serviceName, DefaultChannelRequester::build(),
ChannelProvider::PRIORITY_DEFAULT,
address);
void RPCClient::construct(const ChannelProvider::shared_pointer& provider,
const std::string & serviceName,
epics::pvData::PVStructure::shared_pointer const & pvRequest)
{
assert(provider);
DummyChannelRequester::shared_pointer dummy(new DummyChannelRequester);
m_channel = provider->createChannel(serviceName, dummy);
{
pvd::Lock L(dummy->mutex);
if(!dummy->status.isSuccess())
throw std::runtime_error(dummy->status.getMessage());
}
if(!m_channel)
throw std::logic_error("provider createChannel() succeeds w/ NULL Channel");
@ -189,7 +142,6 @@ void RPCClient::construct(const ChannelProvider::shared_pointer& provider,
throw std::logic_error("channel createChannelRPC() NULL");
}
void RPCClient::destroy()
{
if (m_channel)
@ -328,7 +280,4 @@ pvd::PVStructure::shared_pointer RPCClient::sendRequest(const std::string & serv
}
}
}
}}// namespace epics::pvAccess