#include "responseHandlers.h"

Inheritance diagram for epics::pvAccess::ServerMonitorRequesterImpl:

Collaboration diagram for epics::pvAccess::ServerMonitorRequesterImpl:

Public Types
typedef std::tr1::shared_ptr< ServerMonitorRequesterImpl >	shared_pointer

typedef std::tr1::shared_ptr< const ServerMonitorRequesterImpl >	const_shared_pointer

Public Types inherited from epics::pvAccess::MonitorRequester
typedef Monitor	operation_type

Public Member Functions
virtual	~ServerMonitorRequesterImpl ()

virtual void	monitorConnect (const epics::pvData::Status &status, Monitor::shared_pointer const &monitor, epics::pvData::StructureConstPtr const &structure) OVERRIDE FINAL

virtual void	unlisten (Monitor::shared_pointer const &monitor) OVERRIDE FINAL

virtual void	monitorEvent (Monitor::shared_pointer const &monitor) OVERRIDE FINAL

virtual void	destroy () OVERRIDE FINAL

Monitor::shared_pointer	getChannelMonitor ()

virtual std::tr1::shared_ptr< ChannelRequest >	getOperation () OVERRIDE FINAL
	The Operation associated with this Requester, except for GetField and Monitor (which are special snowflakes...) More...

virtual void	send (epics::pvData::ByteBuffer buffer, TransportSendControl control) OVERRIDE FINAL

void	ack (size_t cnt)

Public Member Functions inherited from epics::pvAccess::BaseChannelRequester
	POINTER_DEFINITIONS (BaseChannelRequester)

	BaseChannelRequester (ServerContextImpl::shared_pointer const &context, std::tr1::shared_ptr< ServerChannel > const &channel, const pvAccessID ioid, Transport::shared_pointer const &transport)

virtual	~BaseChannelRequester ()

bool	startRequest (epics::pvData::int32 qos)

void	stopRequest ()

epics::pvData::int32	getPendingRequest ()

virtual std::string	getRequesterName () OVERRIDE FINAL

virtual void	message (std::string const &message, epics::pvData::MessageType messageType) OVERRIDE FINAL

virtual void	stats (Stats &s) const OVERRIDE FINAL
	Query current counter values. More...

Public Member Functions inherited from epics::pvAccess::TransportSender
	POINTER_DEFINITIONS (TransportSender)

	TransportSender ()

virtual	~TransportSender ()

Public Member Functions inherited from epics::pvAccess::Lockable
	POINTER_DEFINITIONS (Lockable)

virtual	~Lockable ()

virtual void	lock ()

virtual void	unlock ()

Public Member Functions inherited from epics::pvAccess::fair_queue< T >::entry
	entry ()

	~entry ()

Public Member Functions inherited from epics::pvAccess::NetStats
virtual	~NetStats ()

Public Member Functions inherited from epics::pvAccess::Destroyable
	POINTER_DEFINITIONS (Destroyable)

Public Member Functions inherited from epics::pvAccess::MonitorRequester
	POINTER_DEFINITIONS (MonitorRequester)

virtual	~MonitorRequester ()

virtual void	monitorConnect (epics::pvData::Status const &status, MonitorPtr const &monitor, epics::pvData::StructureConstPtr const &structure)=0

virtual void	monitorEvent (MonitorPtr const &monitor)=0

virtual void	unlisten (MonitorPtr const &monitor)=0

Public Member Functions inherited from epics::pvAccess::ChannelBaseRequester
	POINTER_DEFINITIONS (ChannelBaseRequester)

	ChannelBaseRequester ()

virtual	~ChannelBaseRequester ()

virtual void	channelDisconnect (bool destroy)

Static Public Member Functions
static shared_pointer	create (ServerContextImpl::shared_pointer const &context, std::tr1::shared_ptr< ServerChannel > const &channel, const pvAccessID ioid, Transport::shared_pointer const &transport, epics::pvData::PVStructure::shared_pointer const &pvRequest)

Static Public Member Functions inherited from epics::pvAccess::BaseChannelRequester
static void	message (Transport::shared_pointer const &transport, const pvAccessID ioid, const std::string message, const epics::pvData::MessageType messageType)

static void	sendFailureMessage (const epics::pvData::int8 command, Transport::shared_pointer const &transport, const pvAccessID ioid, const epics::pvData::int8 qos, const epics::pvData::Status status)

Protected Member Functions
	ServerMonitorRequesterImpl (ServerContextImpl::shared_pointer const &context, std::tr1::shared_ptr< ServerChannel > const &channel, const pvAccessID ioid, Transport::shared_pointer const &transport)

void	activate (epics::pvData::PVStructure::shared_pointer const &pvRequest)

Protected Member Functions inherited from epics::pvAccess::Destroyable
virtual	~Destroyable ()

Additional Inherited Members
Public Attributes inherited from epics::pvAccess::TransportSender
size_t	bytesTX

size_t	bytesRX

Static Public Attributes inherited from epics::pvAccess::BaseChannelRequester
static const epics::pvData::Status	okStatus = Status()

static const epics::pvData::Status	badCIDStatus

static const epics::pvData::Status	badIOIDStatus

static const epics::pvData::Status	noReadACLStatus

static const epics::pvData::Status	noWriteACLStatus

static const epics::pvData::Status	noProcessACLStatus

static const epics::pvData::Status	otherRequestPendingStatus

static const epics::pvData::Status	notAChannelRequestStatus

Static Public Attributes inherited from epics::pvAccess::ChannelBaseRequester
static size_t	num_instances

Protected Attributes inherited from epics::pvAccess::BaseChannelRequester
const pvAccessID	_ioid

const Transport::shared_pointer	_transport

const std::tr1::shared_ptr< ServerChannel >	_channel

epics::pvData::Mutex	_mutex

Detailed Description

Definition at line 469 of file responseHandlers.h.

Member Typedef Documentation

typedef std::tr1::shared_ptr<const ServerMonitorRequesterImpl> epics::pvAccess::ServerMonitorRequesterImpl::const_shared_pointer

Definition at line 476 of file responseHandlers.h.

typedef std::tr1::shared_ptr<ServerMonitorRequesterImpl> epics::pvAccess::ServerMonitorRequesterImpl::shared_pointer

Definition at line 475 of file responseHandlers.h.

Constructor & Destructor Documentation

epics::pvAccess::ServerMonitorRequesterImpl::ServerMonitorRequesterImpl	(	ServerContextImpl::shared_pointer const &	context,
		std::tr1::shared_ptr< ServerChannel > const &	channel,
		const pvAccessID	ioid,
		Transport::shared_pointer const &	transport
	)

protected

Definition at line 1861 of file responseHandlers.cpp.

     :BaseChannelRequester(context, channel, ioid, transport)
     ,_window_open(0u)
     ,_unlisten(false)
     ,_pipeline(false)
 {}

virtual epics::pvAccess::ServerMonitorRequesterImpl::~ServerMonitorRequesterImpl ( )

inlinevirtual

Definition at line 486 of file responseHandlers.h.

486 {}

Member Function Documentation

void epics::pvAccess::ServerMonitorRequesterImpl::ack ( size_t cnt )

Definition at line 2075 of file responseHandlers.cpp.

 {
     typedef std::vector<MonitorElementPtr> acking_t;
     acking_t acking;
     Monitor::shared_pointer mon;
     {
         Lock guard(_mutex);
 
         // cnt will be larger if this is the initial window update,
         // or if the window is being enlarged.
         size_t nack = std::min(cnt, _window_closed.size());
 
         _window_open += cnt;
 
         window_t::iterator it, end(_window_closed.begin());
         std::advance(end, nack);
 
         acking.resize(nack);
 
         size_t i;
         for(i=0, it=_window_closed.begin(); i<nack; i++, ++it)
         {
             acking[i].swap(*it);
         }
 
         _window_closed.erase(_window_closed.begin(), end);
 
         mon = _channelMonitor;
     }
 
     for(acking_t::iterator it(acking.begin()), end(acking.end()); it!=end; ++it) {
         mon->release(*it);
     }
 
     mon->reportRemoteQueueStatus(cnt);
 }

void epics::pvAccess::ServerMonitorRequesterImpl::activate ( epics::pvData::PVStructure::shared_pointer const & pvRequest )

protected

Definition at line 1880 of file responseHandlers.cpp.

 {
     epics::pvData::PVScalar::const_shared_pointer O(pvRequest->getSubField<epics::pvData::PVScalar>("record._options.pipeline"));
     if(O) {
         try{
             _pipeline = O->getAs<epics::pvData::boolean>();
         }catch(std::exception& e){
             std::ostringstream strm;
             strm<<"Ignoring invalid pipeline= : "<<e.what();
             message(strm.str(), epics::pvData::errorMessage);
         }
     }
     startRequest(QOS_INIT);
     shared_pointer thisPointer(shared_from_this());
     _channel->registerRequest(_ioid, thisPointer);
     INIT_EXCEPTION_GUARD(CMD_MONITOR, _channelMonitor, _channel->getChannel()->createMonitor(thisPointer, pvRequest));
 }

ServerMonitorRequesterImpl::shared_pointer epics::pvAccess::ServerMonitorRequesterImpl::create	(	ServerContextImpl::shared_pointer const &	context,
		std::tr1::shared_ptr< ServerChannel > const &	channel,
		const pvAccessID	ioid,
		Transport::shared_pointer const &	transport,
		epics::pvData::PVStructure::shared_pointer const &	pvRequest
	)

static

Definition at line 1871 of file responseHandlers.cpp.

 {
     std::tr1::shared_ptr<ServerMonitorRequesterImpl> tp(new ServerMonitorRequesterImpl(context, channel, ioid, transport));
     tp->activate(pvRequest);
     return tp;
 }

void epics::pvAccess::ServerMonitorRequesterImpl::destroy ( )

virtual

Destroy this instance.

Implements epics::pvAccess::Destroyable.

Definition at line 1932 of file responseHandlers.cpp.

 {
     // keep a reference to ourselves as the owner
     // could release its reference and we don't want to be
     // destroyed prematurely
     shared_pointer self(shared_from_this());
 
     // hold a reference to channelMonitor so that _channelMonitor.reset()
     // does not call ~Monitor (external code) while we are holding a lock
     Monitor::shared_pointer monitor;
     window_t window;
     {
         Lock guard(_mutex);
         _channel->unregisterRequest(_ioid);
 
         window.swap(_window_closed);
 
         monitor.swap(_channelMonitor);
     }
     window.clear();
     if(monitor) {
         monitor->destroy();
     }
 }

Monitor::shared_pointer epics::pvAccess::ServerMonitorRequesterImpl::getChannelMonitor ( )

Definition at line 1957 of file responseHandlers.cpp.

 {
     Lock guard(_mutex);
     return _channelMonitor;
 }

virtual std::tr1::shared_ptr<ChannelRequest> epics::pvAccess::ServerMonitorRequesterImpl::getOperation ( )

inlinevirtual

The Operation associated with this Requester, except for GetField and Monitor (which are special snowflakes...)

Implements epics::pvAccess::BaseChannelRequester.

Definition at line 496 of file responseHandlers.h.

496 { return std::tr1::shared_ptr<ChannelRequest>(); }

void epics::pvAccess::ServerMonitorRequesterImpl::monitorConnect	(	const epics::pvData::Status &	status,
		Monitor::shared_pointer const &	monitor,
		epics::pvData::StructureConstPtr const &	structure
	)

virtual

Definition at line 1898 of file responseHandlers.cpp.

 {
     {
         Lock guard(_mutex);
         _status = status;
         _channelMonitor = monitor;
         _structure = structure;
     }
     TransportSender::shared_pointer thisSender = shared_from_this();
     _transport->enqueueSendRequest(thisSender);
 
     // self-destruction
     if (!status.isSuccess())
     {
         destroy();
     }
 }

void epics::pvAccess::ServerMonitorRequesterImpl::monitorEvent ( Monitor::shared_pointer const & monitor )

virtual

Definition at line 1926 of file responseHandlers.cpp.

 {
     TransportSender::shared_pointer thisSender = shared_from_this();
     _transport->enqueueSendRequest(thisSender);
 }

void epics::pvAccess::ServerMonitorRequesterImpl::send	(	epics::pvData::ByteBuffer *	buffer,
		TransportSendControl *	control
	)

virtual

Called by transport. By this call transport gives callee ownership over the buffer. Calls on TransportSendControl instance must be made from calling thread. Moreover, ownership is valid only for the time of call of this method. NOTE: these limitations allow efficient implementation.

Implements epics::pvAccess::TransportSender.

Definition at line 1963 of file responseHandlers.cpp.

 {
     const int32 request = getPendingRequest();
 
     if ((QOS_INIT & request) != 0)
     {
         control->startMessage((int32)CMD_MONITOR, sizeof(int32)/sizeof(int8) + 1);
         buffer->putInt(_ioid);
         buffer->putByte((int8)request);
 
         {
             Lock guard(_mutex);
             _status.serialize(buffer, control);
         }
 
         if (_status.isSuccess())
         {
             // valid due to _mutex lock above
             control->cachedSerialize(_structure, buffer);
         }
         stopRequest();
         startRequest(QOS_DEFAULT);
     }
     else
     {
         Monitor::shared_pointer monitor(getChannelMonitor());
         if (!monitor)
             return;
 
         // TODO asCheck ?
 
         bool busy = false;
         if(_pipeline) {
             Lock guard(_mutex);
             busy = _window_open==0;
         }
 
         MonitorElement::Ref element;
         if(!busy) {
             MonitorElement::Ref E(monitor);
             E.swap(element);
         }
         if (element)
         {
             control->startMessage((int8)CMD_MONITOR, sizeof(int32)/sizeof(int8) + 1);
             buffer->putInt(_ioid);
             buffer->putByte((int8)request);
 
             // changedBitSet and data, if not notify only (i.e. queueSize == -1)
             const BitSet::shared_pointer& changedBitSet = element->changedBitSet;
             if (changedBitSet)
             {
                 changedBitSet->serialize(buffer, control);
                 element->pvStructurePtr->serialize(buffer, control, changedBitSet.get());
 
                 // overrunBitset
                 element->overrunBitSet->serialize(buffer, control);
             }
 
             {
                 Lock guard(_mutex);
                 if(!_pipeline) {
                 } else if(_window_open==0) {
                     // This really shouldn't happen as the above ensures that _window_open *was* non-zero,
                     // and only we (the sender) will decrement.
                     message("Monitor Logic Error: send outside of window", epics::pvData::warningMessage);
                     LOG(logLevelError, "Monitor Logic Error: send outside of window %zu", _window_closed.size());
 
                 } else {
                     _window_closed.push_back(element.letGo());
                     _window_open--;
                 }
             }
 
             element.reset(); // calls Monitor::release() if not swap()'d
 
             // TODO if we try to proces several monitors at once, then fairness suffers
             // TODO compbine several monitors into one message (reduces payload)
             TransportSender::shared_pointer thisSender = shared_from_this();
             _transport->enqueueSendRequest(thisSender);
         }
         else
         {
             bool unlisten;
             window_t window;
             {
                 Lock guard(_mutex);
                 unlisten = _unlisten;
                 _unlisten = false;
                 if(unlisten) {
                     window.swap(_window_closed);
                     _window_open = 0u;
                 }
             }
 
             for(window_t::iterator it(window.begin()), end(window.end()); it!=end; ++it) {
                 monitor->release(*it);
             }
             window.clear();
 
             if (unlisten)
             {
                 control->startMessage((int8)CMD_MONITOR, sizeof(int32)/sizeof(int8) + 1);
                 buffer->putInt(_ioid);
                 buffer->putByte((int8)QOS_DESTROY);
                 Status::Ok.serialize(buffer, control);
             }
         }
 
     }
 }

void epics::pvAccess::ServerMonitorRequesterImpl::unlisten ( Monitor::shared_pointer const & monitor )

virtual

Definition at line 1916 of file responseHandlers.cpp.

 {
     {
         Lock guard(_mutex);
         _unlisten = true;
     }
     TransportSender::shared_pointer thisSender = shared_from_this();
     _transport->enqueueSendRequest(thisSender);
 }

The documentation for this class was generated from the following files:

modules/pvAccess/src/server/pv/responseHandlers.h
modules/pvAccess/src/server/responseHandlers.cpp

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation