425 lines
13 KiB
C++
425 lines
13 KiB
C++
// Copyright information and license terms for this software can be
|
|
// found in the file LICENSE that is included with the distribution
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string>
|
|
#include <algorithm>
|
|
#include <pv/lock.h>
|
|
#include <pv/pvData.h>
|
|
#include <pv/bitSet.h>
|
|
|
|
#define epicsExportSharedSymbols
|
|
#include "pv/dataDistributorPlugin.h"
|
|
|
|
using std::string;
|
|
using std::size_t;
|
|
using std::endl;
|
|
using std::tr1::static_pointer_cast;
|
|
using std::vector;
|
|
using namespace epics::pvData;
|
|
namespace epvd = epics::pvData;
|
|
|
|
namespace epics { namespace pvCopy {
|
|
|
|
// Utilities for manipulating strings
|
|
static std::string leftTrim(const std::string& s)
|
|
{
|
|
int i;
|
|
int n = s.length();
|
|
for (i = 0; i < n; i++) {
|
|
if (!isspace(s[i])) {
|
|
break;
|
|
}
|
|
}
|
|
return s.substr(i,n-i);
|
|
}
|
|
|
|
static std::string rightTrim(const std::string& s)
|
|
{
|
|
int i;
|
|
int n = s.length();
|
|
for (i = n; i > 0; i--) {
|
|
if (!isspace(s[i-1])) {
|
|
break;
|
|
}
|
|
}
|
|
return s.substr(0,i);
|
|
}
|
|
|
|
static std::string trim(const std::string& s)
|
|
{
|
|
return rightTrim(leftTrim(s));
|
|
}
|
|
|
|
static std::vector<std::string>& split(const std::string& s, char delimiter, std::vector<std::string>& elements)
|
|
{
|
|
std::stringstream ss(s);
|
|
std::string item;
|
|
while (std::getline(ss, item, delimiter)) {
|
|
elements.push_back(trim(item));
|
|
}
|
|
return elements;
|
|
}
|
|
|
|
static std::vector<std::string> split(const std::string& s, char delimiter)
|
|
{
|
|
std::vector<std::string> elements;
|
|
split(s, delimiter, elements);
|
|
return elements;
|
|
}
|
|
|
|
static std::string toLowerCase(const std::string& input)
|
|
{
|
|
std::stringstream ss;
|
|
for (unsigned int i = 0; i < input.size(); i++) {
|
|
char c = std::tolower(input.at(i));
|
|
ss << c;
|
|
}
|
|
return ss.str();
|
|
}
|
|
|
|
// Data distributor class
|
|
|
|
static std::string name("distributor");
|
|
bool DataDistributorPlugin::initialized(DataDistributorPlugin::initialize());
|
|
|
|
std::map<std::string, DataDistributorPtr> DataDistributor::dataDistributorMap;
|
|
epics::pvData::Mutex DataDistributor::dataDistributorMapMutex;
|
|
|
|
DataDistributorPtr DataDistributor::getInstance(const std::string& groupId)
|
|
{
|
|
epvd::Lock lock(dataDistributorMapMutex);
|
|
std::map<std::string,DataDistributorPtr>::iterator ddit = dataDistributorMap.find(groupId);
|
|
if (ddit != dataDistributorMap.end()) {
|
|
DataDistributorPtr ddPtr = ddit->second;
|
|
return ddPtr;
|
|
}
|
|
else {
|
|
DataDistributorPtr ddPtr(new DataDistributor(groupId));
|
|
dataDistributorMap[groupId] = ddPtr;
|
|
return ddPtr;
|
|
}
|
|
}
|
|
|
|
void DataDistributor::removeUnusedInstance(DataDistributorPtr dataDistributorPtr)
|
|
{
|
|
epvd::Lock lock(dataDistributorMapMutex);
|
|
std::string groupId = dataDistributorPtr->getGroupId();
|
|
std::map<std::string,DataDistributorPtr>::iterator ddit = dataDistributorMap.find(groupId);
|
|
if (ddit != dataDistributorMap.end()) {
|
|
DataDistributorPtr ddPtr = ddit->second;
|
|
int nSets = ddPtr->clientSetMap.size();
|
|
if (nSets == 0) {
|
|
dataDistributorMap.erase(ddit);
|
|
}
|
|
}
|
|
}
|
|
|
|
DataDistributor::DataDistributor(const std::string& groupId_)
|
|
: groupId(groupId_)
|
|
, mutex()
|
|
, clientSetMap()
|
|
, clientSetIdList()
|
|
, currentSetIdIter(clientSetIdList.end())
|
|
, lastUpdateValue()
|
|
{
|
|
}
|
|
|
|
DataDistributor::~DataDistributor()
|
|
{
|
|
epvd::Lock lock(mutex);
|
|
clientSetMap.clear();
|
|
clientSetIdList.clear();
|
|
}
|
|
|
|
std::string DataDistributor::addClient(int clientId, const std::string& setId, const std::string& triggerField, int nUpdatesPerClient, int updateMode)
|
|
{
|
|
epvd::Lock lock(mutex);
|
|
std::map<std::string,ClientSetPtr>::iterator git = clientSetMap.find(setId);
|
|
if (git != clientSetMap.end()) {
|
|
ClientSetPtr setPtr = git->second;
|
|
setPtr->clientIdList.push_back(clientId);
|
|
return setPtr->triggerField;
|
|
}
|
|
else {
|
|
ClientSetPtr setPtr(new ClientSet(setId, triggerField, nUpdatesPerClient, updateMode));
|
|
setPtr->clientIdList.push_back(clientId);
|
|
clientSetMap[setId] = setPtr;
|
|
clientSetIdList.push_back(setId);
|
|
return triggerField;
|
|
}
|
|
}
|
|
|
|
void DataDistributor::removeClient(int clientId, const std::string& setId)
|
|
{
|
|
epvd::Lock lock(mutex);
|
|
std::map<std::string,ClientSetPtr>::iterator git = clientSetMap.find(setId);
|
|
if (git != clientSetMap.end()) {
|
|
ClientSetPtr setPtr = git->second;
|
|
std::list<int>::iterator cit = std::find(setPtr->clientIdList.begin(), setPtr->clientIdList.end(), clientId);
|
|
if (cit != setPtr->clientIdList.end()) {
|
|
// If we are removing current client id, advance iterator
|
|
if (cit == setPtr->currentClientIdIter) {
|
|
setPtr->currentClientIdIter++;
|
|
}
|
|
|
|
// Find current client id
|
|
int currentClientId = -1;
|
|
if (setPtr->currentClientIdIter != setPtr->clientIdList.end()) {
|
|
currentClientId = *(setPtr->currentClientIdIter);
|
|
}
|
|
|
|
// Remove client id from the list
|
|
setPtr->clientIdList.erase(cit);
|
|
|
|
// Reset current client id iterator
|
|
setPtr->currentClientIdIter = setPtr->clientIdList.end();
|
|
if (currentClientId >= 0) {
|
|
std::list<int>::iterator cit2 = std::find(setPtr->clientIdList.begin(), setPtr->clientIdList.end(), currentClientId);
|
|
if (cit2 != setPtr->clientIdList.end()) {
|
|
setPtr->currentClientIdIter = cit2;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (setPtr->clientIdList.size() == 0) {
|
|
clientSetMap.erase(git);
|
|
std::list<std::string>::iterator git2 = std::find(clientSetIdList.begin(), clientSetIdList.end(), setId);
|
|
if (git2 == currentSetIdIter) {
|
|
currentSetIdIter++;
|
|
}
|
|
if (git2 != clientSetIdList.end()) {
|
|
clientSetIdList.erase(git2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool DataDistributor::updateClient(int clientId, const std::string& setId, const std::string& triggerFieldValue)
|
|
{
|
|
epvd::Lock lock(mutex);
|
|
bool proceedWithUpdate = false;
|
|
if (currentSetIdIter == clientSetIdList.end()) {
|
|
currentSetIdIter = clientSetIdList.begin();
|
|
}
|
|
std::string currentSetId = *currentSetIdIter;
|
|
if (setId != currentSetId) {
|
|
// We are not distributing data to this set at the moment
|
|
return proceedWithUpdate;
|
|
}
|
|
ClientSetPtr setPtr = clientSetMap[currentSetId];
|
|
if (setPtr->currentClientIdIter == setPtr->clientIdList.end()) {
|
|
// Move current client iterator to the beginning of the list
|
|
setPtr->currentClientIdIter = setPtr->clientIdList.begin();
|
|
}
|
|
if (lastUpdateValue == triggerFieldValue) {
|
|
// This update was already distributed.
|
|
return proceedWithUpdate;
|
|
}
|
|
switch (setPtr->updateMode) {
|
|
case(DD_UPDATE_ONE_PER_GROUP): {
|
|
if (clientId != *(setPtr->currentClientIdIter)) {
|
|
// Not this client's turn.
|
|
return proceedWithUpdate;
|
|
}
|
|
proceedWithUpdate = true;
|
|
lastUpdateValue = triggerFieldValue;
|
|
setPtr->lastUpdateValue = triggerFieldValue;
|
|
setPtr->updateCounter++;
|
|
if (setPtr->updateCounter >= setPtr->nUpdatesPerClient) {
|
|
// This client and set are done.
|
|
setPtr->currentClientIdIter++;
|
|
setPtr->updateCounter = 0;
|
|
currentSetIdIter++;
|
|
}
|
|
break;
|
|
}
|
|
case(DD_UPDATE_ALL_IN_GROUP): {
|
|
proceedWithUpdate = true;
|
|
static unsigned int nClientsUpdated = 0;
|
|
if (setPtr->lastUpdateValue != triggerFieldValue) {
|
|
setPtr->lastUpdateValue = triggerFieldValue;
|
|
setPtr->updateCounter++;
|
|
nClientsUpdated = 0;
|
|
}
|
|
nClientsUpdated++;
|
|
if (nClientsUpdated == setPtr->clientIdList.size() && setPtr->updateCounter >= setPtr->nUpdatesPerClient) {
|
|
// This set is done.
|
|
lastUpdateValue = triggerFieldValue;
|
|
setPtr->updateCounter = 0;
|
|
currentSetIdIter++;
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
proceedWithUpdate = true;
|
|
}
|
|
}
|
|
return proceedWithUpdate;
|
|
}
|
|
|
|
DataDistributorPlugin::DataDistributorPlugin()
|
|
{
|
|
}
|
|
|
|
DataDistributorPlugin::~DataDistributorPlugin()
|
|
{
|
|
}
|
|
|
|
void DataDistributorPlugin::create()
|
|
{
|
|
initialize();
|
|
}
|
|
|
|
bool DataDistributorPlugin::initialize()
|
|
{
|
|
DataDistributorPluginPtr pvPlugin = DataDistributorPluginPtr(new DataDistributorPlugin());
|
|
PVPluginRegistry::registerPlugin(name,pvPlugin);
|
|
return true;
|
|
}
|
|
|
|
PVFilterPtr DataDistributorPlugin::create(
|
|
const std::string& requestValue,
|
|
const PVCopyPtr& pvCopy,
|
|
const PVFieldPtr& master)
|
|
{
|
|
return DataDistributorFilter::create(requestValue,pvCopy,master);
|
|
}
|
|
|
|
DataDistributorFilter::~DataDistributorFilter()
|
|
{
|
|
dataDistributorPtr->removeClient(clientId, setId);
|
|
DataDistributor::removeUnusedInstance(dataDistributorPtr);
|
|
}
|
|
|
|
DataDistributorFilterPtr DataDistributorFilter::create(
|
|
const std::string& requestValue,
|
|
const PVCopyPtr& pvCopy,
|
|
const PVFieldPtr& master)
|
|
{
|
|
static int clientId = 0;
|
|
clientId++;
|
|
|
|
std::vector<std::string> configItems = split(requestValue, ';');
|
|
// Use lowercase keys if possible.
|
|
std::string requestValue2 = toLowerCase(requestValue);
|
|
std::vector<std::string> configItems2 = split(requestValue2, ';');
|
|
int nUpdatesPerClient = 1;
|
|
int updateMode = DataDistributor::DD_UPDATE_ONE_PER_GROUP;
|
|
std::string groupId = "default";
|
|
std::string setId = "default";
|
|
std::string triggerField = "timeStamp";
|
|
bool hasUpdateMode = false;
|
|
bool hasSetId = false;
|
|
for(unsigned int i = 0; i < configItems2.size(); i++) {
|
|
std::string configItem2 = configItems2[i];
|
|
size_t ind = configItem2.find(':');
|
|
if (ind == string::npos) {
|
|
continue;
|
|
}
|
|
if(configItem2.find("updates") == 0) {
|
|
std::string svalue = configItem2.substr(ind+1);
|
|
nUpdatesPerClient = atoi(svalue.c_str());
|
|
}
|
|
else if(configItem2.find("group") == 0) {
|
|
std::string configItem = configItems[i];
|
|
groupId = configItem.substr(ind+1);
|
|
}
|
|
else if(configItem2.find("set") == 0) {
|
|
std::string configItem = configItems[i];
|
|
setId = configItem.substr(ind+1);
|
|
hasSetId = true;
|
|
}
|
|
else if(configItem2.find("mode") == 0) {
|
|
std::string svalue = toLowerCase(configItem2.substr(ind+1));
|
|
if (svalue == "one") {
|
|
updateMode = DataDistributor::DD_UPDATE_ONE_PER_GROUP;
|
|
hasUpdateMode = true;
|
|
}
|
|
else if (svalue == "all") {
|
|
updateMode = DataDistributor::DD_UPDATE_ALL_IN_GROUP;
|
|
hasUpdateMode = true;
|
|
}
|
|
}
|
|
else if(configItem2.find("trigger") == 0) {
|
|
std::string configItem = configItems[i];
|
|
triggerField = configItem.substr(ind+1);
|
|
}
|
|
}
|
|
// If request does not have update mode specified, but has set id
|
|
// then use a different update mode
|
|
if(!hasUpdateMode && hasSetId) {
|
|
updateMode = DataDistributor::DD_UPDATE_ALL_IN_GROUP;
|
|
}
|
|
|
|
// Make sure request is valid
|
|
if(nUpdatesPerClient <= 0) {
|
|
return DataDistributorFilterPtr();
|
|
}
|
|
DataDistributorFilterPtr filter =
|
|
DataDistributorFilterPtr(new DataDistributorFilter(groupId, clientId, setId, triggerField, nUpdatesPerClient, updateMode, pvCopy, master));
|
|
return filter;
|
|
}
|
|
|
|
DataDistributorFilter::DataDistributorFilter(const std::string& groupId_, int clientId_, const std::string& setId_, const std::string& triggerField_, int nUpdatesPerClient, int updateMode, const PVCopyPtr& copyPtr_, const epvd::PVFieldPtr& masterFieldPtr_)
|
|
: dataDistributorPtr(DataDistributor::getInstance(groupId_))
|
|
, clientId(clientId_)
|
|
, setId(setId_)
|
|
, triggerField(triggerField_)
|
|
, masterFieldPtr(masterFieldPtr_)
|
|
, triggerFieldPtr()
|
|
, firstUpdate(true)
|
|
{
|
|
triggerField = dataDistributorPtr->addClient(clientId, setId, triggerField, nUpdatesPerClient, updateMode);
|
|
if(masterFieldPtr->getField()->getType() == epvd::structure) {
|
|
epvd::PVStructurePtr pvStructurePtr = static_pointer_cast<epvd::PVStructure>(masterFieldPtr);
|
|
if(pvStructurePtr) {
|
|
triggerFieldPtr = pvStructurePtr->getSubField(triggerField);
|
|
}
|
|
}
|
|
if(!triggerFieldPtr) {
|
|
triggerFieldPtr = masterFieldPtr;
|
|
}
|
|
}
|
|
|
|
|
|
bool DataDistributorFilter::filter(const PVFieldPtr& pvCopy, const BitSetPtr& bitSet, bool toCopy)
|
|
{
|
|
if(!toCopy) {
|
|
return false;
|
|
}
|
|
|
|
bool proceedWithUpdate = false;
|
|
if(firstUpdate) {
|
|
// Always send first update
|
|
firstUpdate = false;
|
|
proceedWithUpdate = true;
|
|
}
|
|
else {
|
|
std::stringstream ss;
|
|
ss << triggerFieldPtr;
|
|
std::string triggerFieldValue = ss.str();
|
|
proceedWithUpdate = dataDistributorPtr->updateClient(clientId, setId, triggerFieldValue);
|
|
}
|
|
|
|
if(proceedWithUpdate) {
|
|
pvCopy->copyUnchecked(*masterFieldPtr);
|
|
bitSet->set(pvCopy->getFieldOffset());
|
|
}
|
|
else {
|
|
// Clear all bits
|
|
//bitSet->clear(pvCopy->getFieldOffset());
|
|
bitSet->clear();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
string DataDistributorFilter::getName()
|
|
{
|
|
return name;
|
|
}
|
|
|
|
}}
|