/** Connect, get value, disconnect */
void getValue(string const &name, string const &request, double timeout)
{
ChannelProvider::shared_pointer channelProvider =
ChannelProviderRegistry::clients()->getProvider("pva");
//getChannelProviderRegistry()->getProvider("pva"); This is the old way.
if (! channelProvider)
THROW_EXCEPTION2(runtime_error, "No channel provider");
shared_ptr<MyChannelRequester> channelRequester(new MyChannelRequester());
shared_ptr<Channel> channel(channelProvider->createChannel(name, channelRequester));
channelRequester->waitUntilConnected(timeout);
shared_ptr<PVStructure> pvRequest = CreateRequest::create()->createRequest(request);
shared_ptr<MyChannelGetRequester> channelGetRequester(new MyChannelGetRequester());
// This took me 3 hours to figure out:
shared_ptr<ChannelGet> channelGet = channel->createChannelGet(channelGetRequester, pvRequest);
// We don't care about the value of 'channelGet', so why assign it to a variable?
// But when we _don't_ assign it to a shared_ptr<>, the one
// returned from channel->createChannelGet() will be deleted
// right away, and then the server(!) crashes because it receives a NULL GetRequester...
channelGetRequester->waitUntilDone(timeout);
}
/** Monitor values */
void doMonitor(string const &name, string const &request, double timeout, short priority, int limit, bool quiet)
{
ChannelProvider::shared_pointer channelProvider =
getChannelProviderRegistry()->getProvider("pva");
if (! channelProvider)
THROW_EXCEPTION2(runtime_error, "No channel provider");
shared_ptr<MyChannelRequester> channelRequester(new MyChannelRequester());
shared_ptr<Channel> channel(channelProvider->createChannel(name, channelRequester, priority));
channelRequester->waitUntilConnected(timeout);
shared_ptr<PVStructure> pvRequest = CreateRequest::create()->createRequest(request);
shared_ptr<MyMonitorRequester> monitorRequester(new MyMonitorRequester(limit, quiet));
shared_ptr<Monitor> monitor = channel->createMonitor(monitorRequester, pvRequest);
// Wait until limit or forever..
monitorRequester->waitUntilDone();
// What to do for graceful shutdown of monitor?
Status stat = monitor->stop();
if (! stat.isSuccess())
cout << "Cannot stop monitor, " << stat << endl;
monitor->destroy();
channel->destroy();
}
bool ExampleLink::init()
{
initPVRecord();
PVStructurePtr pvStructure = getPVRecordStructure()->getPVStructure();
pvValue = pvStructure->getSubField<PVDoubleArray>("value");
if(!pvValue) {
return false;
}
ChannelProvider::shared_pointer provider =
getChannelProviderRegistry()->getProvider(providerName);
if(!provider) {
cout << getRecordName() << " provider "
<< providerName << " does not exist" << endl;
return false;
}
ChannelRequester::shared_pointer channelRequester =
dynamic_pointer_cast<ChannelRequester>(getPtrSelf());
channel = provider->createChannel(channelName,channelRequester);
event.wait();
if(!status.isOK()) {
cout << getRecordName() << " createChannel failed "
<< status.getMessage() << endl;
return false;
}
PVStructurePtr pvRequest = CreateRequest::create()->createRequest(
"value");
MonitorRequester::shared_pointer monitorRequester =
dynamic_pointer_cast<MonitorRequester>(getPtrSelf());
monitor = channel->createMonitor(monitorRequester,pvRequest);
return true;
}
bool ExampleLink::init()
{
initPVRecord();
PVStructurePtr pvStructure = getPVRecordStructure()->getPVStructure();
pvTimeStamp.attach(pvStructure->getSubField("timeStamp"));
pvAlarm.attach(pvStructure->getSubField("alarm"));
pvValue = static_pointer_cast<PVDoubleArray>(
pvStructure->getScalarArrayField("value",pvDouble));
if(!pvValue) {
return false;
}
ChannelProvider::shared_pointer provider =
getChannelProviderRegistry()->getProvider(providerName);
if(!provider) {
cout << getRecordName() << " provider "
<< providerName << " does not exist" << endl;
return false;
}
ChannelRequester::shared_pointer channelRequester =
dynamic_pointer_cast<ChannelRequester>(getPtrSelf());
channel = provider->createChannel(channelName,channelRequester);
event.wait();
if(!status.isOK()) {
cout << getRecordName() << " createChannel failed "
<< status.getMessage() << endl;
return false;
}
ChannelGetRequester::shared_pointer channelGetRequester =
dynamic_pointer_cast<ChannelGetRequester>(getPtrSelf());
PVStructurePtr pvRequest = CreateRequest::create()->createRequest(
"value,alarm,timeStamp");
channelGet = channel->createChannelGet(channelGetRequester,pvRequest);
event.wait();
if(!status.isOK()) {
cout << getRecordName() << " createChannelGet failed "
<< status.getMessage() << endl;
return false;
}
getPVValue = static_pointer_cast<PVDoubleArray>(
getPVStructure->getScalarArrayField("value",pvDouble));
if(!getPVValue) {
cout << getRecordName() << " get value not PVDoubleArray" << endl;
return false;
}
return true;
}
void get_all()
{
for (vector<ChannelGet::shared_pointer>::const_iterator i = channelGetList.begin();
i != channelGetList.end();
i++)
(*i)->get();
// we assume all channels are from the same provider
if (bulkMode) provider->flush();
}
int main (int argc, char *argv[])
{
size_t nChannels = N_CHANNELS_DEFAULT;
int runs = N_RUNS_DEFAULT;
int opt; // getopt() current option
setvbuf(stdout,NULL,_IOLBF,BUFSIZ); // Set stdout to line buffering
while ((opt = getopt(argc, argv, ":hr:w:i:c:s:l:bf:v")) != -1) {
switch (opt) {
case 'h': // Print usage
usage();
return 0;
case 'i': // iterations
runs = atoi(optarg);
break;
case 'c': // channels
{
int tmp = atoi(optarg);
if (tmp < 0) tmp = 1;
// note: possible overflow (size_t is not always unsigned int)
nChannels = static_cast<size_t>(tmp);
break;
}
case '?':
fprintf(stderr,
"Unrecognized option: '-%c'. ('testChannelConnect -h' for help.)\n",
optopt);
return 1;
case ':':
fprintf(stderr,
"Option '-%c' requires an argument. ('testChannelConnect -h' for help.)\n",
optopt);
return 1;
default :
usage();
return 1;
}
}
{
Event g_event;
ClientFactory::start();
ChannelProvider::shared_pointer provider = getChannelProviderRegistry()->getProvider("pva");
int run = 0;
while (runs < 0 || run++ < runs)
{
vector<Channel::shared_pointer> channels(nChannels);
ChannelRequester::shared_pointer channelRequester(new ChannelRequesterImpl(nChannels, g_event));
char buf[16];
for (size_t i = 0; i < nChannels; i++)
{
sprintf(buf, "test%zu", (i+1));
channels.push_back(provider->createChannel(buf, channelRequester));
}
g_event.wait();
cout << "connected to all" << endl;
}
ClientFactory::stop();
}
epicsThreadSleep ( 2.0 );
//std::cout << "-----------------------------------------------------------------------" << std::endl;
//epicsExitCallAtExits();
return(0);
}
void runTest()
{
reset();
if (verbose)
printf("%d channel(s) of double array size of %d element(s) (0==scalar), %d iteration(s) per run, %d run(s) (0==forever)\n", channels, arraySize, iterations, runs);
vector<string> channelNames;
char buf[64];
for (int i = 0; i < channels; i++)
{
if (arraySize > 0)
sprintf(buf, "testArray%d_%d", arraySize, i);
else
sprintf(buf, "test%d", i);
channelNames.push_back(buf);
}
vector<Channel::shared_pointer> channels;
for (vector<string>::const_iterator i = channelNames.begin();
i != channelNames.end();
i++)
{
TR1::shared_ptr<ChannelRequesterImpl> channelRequesterImpl(
new ChannelRequesterImpl()
);
Channel::shared_pointer channel = provider->createChannel(*i, channelRequesterImpl);
channels.push_back(channel);
}
bool differentConnectionsWarningIssued = false;
string theRemoteAddress;
for (vector<Channel::shared_pointer>::iterator i = channels.begin();
i != channels.end();
i++)
{
Channel::shared_pointer channel = *i;
TR1::shared_ptr<ChannelRequesterImpl> channelRequesterImpl =
TR1::dynamic_pointer_cast<ChannelRequesterImpl>(channel->getChannelRequester());
if (channelRequesterImpl->waitUntilConnected(5.0))
{
string remoteAddress = channel->getRemoteAddress();
if (theRemoteAddress.empty())
{
theRemoteAddress = remoteAddress;
}
else if (theRemoteAddress != remoteAddress)
{
if (!differentConnectionsWarningIssued)
{
std::cout << "not all channels are hosted by the same connection: " <<
theRemoteAddress << " != " << remoteAddress << std::endl;
differentConnectionsWarningIssued = true;
// we assumes same connection (thread-safety)
exit(2);
}
}
TR1::shared_ptr<ChannelMonitorRequesterImpl> getRequesterImpl(
new ChannelMonitorRequesterImpl(channel->getChannelName())
);
Monitor::shared_pointer monitor = channel->createMonitor(getRequesterImpl, pvRequest);
bool allOK = getRequesterImpl->waitUntilConnected(timeOut);
if (!allOK)
{
std::cout << "[" << channel->getChannelName() << "] failed to get all the monitors" << std::endl;
exit(1);
}
channelMonitorList.push_back(monitor);
}
else
{
std::cout << "[" << channel->getChannelName() << "] connection timeout" << std::endl;
exit(1);
}
}
if (verbose)
std::cout << "all connected" << std::endl;
{
Lock guard(waitLoopPtrMutex);
waitLoopEvent.reset(new Event());
}
epicsTimeGetCurrent(&startTime);
monitor_all();
waitLoopEvent->wait();
}
void runTest()
{
reset();
if (verbose)
printf("%d channel(s) of double array size of %d element(s) (0==scalar), %d iteration(s) per run, %d run(s) (0==forever)\n", channels, arraySize, iterations, runs);
/*
StringArray fieldNames;
fieldNames.push_back("strategy");
FieldConstPtrArray fields;
fields.push_back(getFieldCreate()->createScalar(pvInt));
PVStructure::shared_pointer configuration =
getPVDataCreate()->createPVStructure(getFieldCreate()->createStructure(fieldNames, fields));
configuration->getIntField("strategy")->put(bulkMode ? USER_CONTROLED : DELAYED);
provider->configure(configuration);
*/
vector<string> channelNames;
char buf[64];
for (int i = 0; i < channels; i++)
{
if (arraySize > 0)
sprintf(buf, "testArray%d_%d", arraySize, i);
else
sprintf(buf, "test%d", i);
channelNames.push_back(buf);
}
vector<Channel::shared_pointer> channels;
for (vector<string>::const_iterator i = channelNames.begin();
i != channelNames.end();
i++)
{
shared_ptr<ChannelRequesterImpl> channelRequesterImpl(
new ChannelRequesterImpl()
);
Channel::shared_pointer channel = provider->createChannel(*i, channelRequesterImpl);
channels.push_back(channel);
}
if (bulkMode) provider->flush();
bool differentConnectionsWarningIssued = false;
string theRemoteAddress;
for (vector<Channel::shared_pointer>::iterator i = channels.begin();
i != channels.end();
i++)
{
Channel::shared_pointer channel = *i;
shared_ptr<ChannelRequesterImpl> channelRequesterImpl =
dynamic_pointer_cast<ChannelRequesterImpl>(channel->getChannelRequester());
if (channelRequesterImpl->waitUntilConnected(5.0))
{
string remoteAddress = channel->getRemoteAddress();
if (theRemoteAddress.empty())
{
theRemoteAddress = remoteAddress;
}
else if (theRemoteAddress != remoteAddress)
{
if (!differentConnectionsWarningIssued)
{
std::cout << "not all channels are hosted by the same connection: " <<
theRemoteAddress << " != " << remoteAddress << std::endl;
differentConnectionsWarningIssued = true;
// we assumes same connection (thread-safety)
exit(2);
}
}
shared_ptr<ChannelGetRequesterImpl> getRequesterImpl(
new ChannelGetRequesterImpl(channel->getChannelName())
);
ChannelGet::shared_pointer channelGet = channel->createChannelGet(getRequesterImpl, pvRequest);
if (bulkMode) provider->flush();
bool allOK = getRequesterImpl->waitUntilConnected(timeOut);
if (!allOK)
{
std::cout << "[" << channel->getChannelName() << "] failed to get all the gets" << std::endl;
exit(1);
}
channelGetList.push_back(channelGet);
}
else
{
std::cout << "[" << channel->getChannelName() << "] connection timeout" << std::endl;
exit(1);
}
}
if (verbose)
std::cout << "all connected" << std::endl;
{
Lock guard(waitLoopPtrMutex);
waitLoopEvent.reset(new Event());
}
epicsTimeGetCurrent(&startTime);
get_all();
waitLoopEvent->wait();
}
int main()
{
for (int i = 0; i < 10; i++) {
{
/*
ClientContextImpl::shared_pointer context = createClientContextImpl();
context->printInfo();
context->initialize();
context->printInfo();
epicsThreadSleep ( SLEEP_TIME );
ChannelProvider::shared_pointer provider = context->getProvider();
*/
ClientFactory::start();
ChannelProvider::shared_pointer provider = getChannelProviderRegistry()->getProvider("pva");
ChannelFindRequester::shared_pointer findRequester(new ChannelFindRequesterImpl());
ChannelFind::shared_pointer channelFind = provider->channelFind("testSomething", findRequester);
epicsThreadSleep ( SLEEP_TIME );
//channelFind->destroy();
ChannelRequester::shared_pointer channelRequester(new ChannelRequesterImpl());
Channel::shared_pointer channel = provider->createChannel("testStructureArrayTest", channelRequester);
epicsThreadSleep ( SLEEP_TIME );
channel->printInfo();
{
GetFieldRequester::shared_pointer getFieldRequesterImpl(new GetFieldRequesterImpl());
channel->getField(getFieldRequesterImpl, "");
epicsThreadSleep ( SLEEP_TIME );
}
{
ChannelProcessRequester::shared_pointer channelProcessRequester(new ChannelProcessRequesterImpl());
PVStructure::shared_pointer pvRequest;
ChannelProcess::shared_pointer channelProcess = channel->createChannelProcess(channelProcessRequester, pvRequest);
epicsThreadSleep ( SLEEP_TIME );
channelProcess->process();
epicsThreadSleep ( SLEEP_TIME );
channelProcess->destroy();
epicsThreadSleep ( SLEEP_TIME );
}
{
ChannelGetRequester::shared_pointer channelGetRequesterImpl(new ChannelGetRequesterImpl());
PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("field()");
ChannelGet::shared_pointer channelGet = channel->createChannelGet(channelGetRequesterImpl, pvRequest);
epicsThreadSleep ( 3.0 );
channelGet->get();
epicsThreadSleep ( 3.0 );
channelGet->destroy();
}
{
ChannelPutRequester::shared_pointer channelPutRequesterImpl(new ChannelPutRequesterImpl());
PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("field(value,timeStamp)");
ChannelPut::shared_pointer channelPut = channel->createChannelPut(channelPutRequesterImpl, pvRequest);
epicsThreadSleep ( SLEEP_TIME );
channelPut->get();
epicsThreadSleep ( SLEEP_TIME );
// TODO !!!
//channelPut->put();
//epicsThreadSleep ( SLEEP_TIME );
channelPut->destroy();
}
{
ChannelPutGetRequester::shared_pointer channelPutGetRequesterImpl(new ChannelPutGetRequesterImpl());
PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("putField(value,timeStamp)getField(timeStamp)");
ChannelPutGet::shared_pointer channelPutGet = channel->createChannelPutGet(channelPutGetRequesterImpl, pvRequest);
epicsThreadSleep ( SLEEP_TIME );
channelPutGet->getGet();
epicsThreadSleep ( SLEEP_TIME );
channelPutGet->getPut();
epicsThreadSleep ( SLEEP_TIME );
// TODO !!!
//channelPutGet->putGet();
//epicsThreadSleep ( SLEEP_TIME );
channelPutGet->destroy();
}
{
ChannelRPCRequester::shared_pointer channelRPCRequesterImpl(new ChannelRPCRequesterImpl());
PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("record[]field(arguments)");
ChannelRPC::shared_pointer channelRPC = channel->createChannelRPC(channelRPCRequesterImpl, pvRequest);
epicsThreadSleep ( SLEEP_TIME );
// for test simply use pvRequest as arguments
channelRPC->request(pvRequest);
epicsThreadSleep ( SLEEP_TIME );
channelRPC->destroy();
}
{
ChannelArrayRequester::shared_pointer channelArrayRequesterImpl(new ChannelArrayRequesterImpl());
StringArray fieldNames; fieldNames.push_back("field");
FieldConstPtrArray fields; fields.push_back(getFieldCreate()->createScalar(pvString));
PVStructure::shared_pointer pvRequest(getPVDataCreate()->createPVStructure(getFieldCreate()->createStructure(fieldNames, fields)));
ChannelArray::shared_pointer channelArray = channel->createChannelArray(channelArrayRequesterImpl, pvRequest);
epicsThreadSleep ( SLEEP_TIME );
channelArray->getArray(0,0,1);
epicsThreadSleep ( SLEEP_TIME );
// TODO !!!
//channelArray->putArray(0,0,1);
//epicsThreadSleep ( SLEEP_TIME );
channelArray->setLength(3);
epicsThreadSleep ( SLEEP_TIME );
channelArray->getLength();
epicsThreadSleep ( SLEEP_TIME );
channelArray->destroy();
}
{
MonitorRequester::shared_pointer monitorRequesterImpl(new MonitorRequesterImpl());
PVStructure::shared_pointer pvRequest = CreateRequest::create()->createRequest("field()");
Monitor::shared_pointer monitor = channel->createMonitor(monitorRequesterImpl, pvRequest);
epicsThreadSleep( SLEEP_TIME );
Status status = monitor->start();
std::cout << "monitor->start() = " << status << std::endl;
epicsThreadSleep( 3*SLEEP_TIME );
status = monitor->stop();
std::cout << "monitor->stop() = " << status << std::endl;
monitor->destroy();
}
epicsThreadSleep ( 3*SLEEP_TIME );
printf("Destroying channel... \n");
channel->destroy();
printf("done.\n");
epicsThreadSleep ( 3*SLEEP_TIME );
}
ClientFactory::stop();
/*
printf("Destroying context... \n");
context->destroy();
printf("done.\n");
*/
epicsThreadSleep ( SLEEP_TIME ); }
//std::cout << "-----------------------------------------------------------------------" << std::endl;
//epicsExitCallAtExits();
return(0);
}
