This abstract class is the remote context client. More...

#include <RemoteContextClient.h>

Inheritance diagram for CPN::RemoteContextClient:

Collaboration diagram for CPN::RemoteContextClient:

Classes
struct	GenericWaiter

struct	WaiterInfo

Public Member Functions
virtual	~RemoteContextClient ()

virtual int	LogLevel () const

virtual int	LogLevel (int level)

virtual void	Log (int level, const std::string &logmsg)
	Log a message to this outputer. More...

virtual CPN::Key_t	SetupKernel (const std::string &name, const std::string &hostname, const std::string &servname, CPN::KernelBase *kernel)
	Called by the Kernel when it has successfully set it self up. This gives the Context a way to notify the Kernel of events and lets other Kernels look up the connection information for this Kernel. More...

virtual CPN::Key_t	SetupKernel (const std::string &name, KernelBase *kernel)
	Called by the kernel when it is not in remote mode. More...

virtual CPN::Key_t	GetKernelKey (const std::string &kernel)

virtual std::string	GetKernelName (CPN::Key_t kernelkey)

virtual void	GetKernelConnectionInfo (CPN::Key_t kernelkey, std::string &hostname, std::string &servname)
	obtain the connection information for the given kernel More...

virtual CPN::Key_t	WaitForKernelStart (const std::string &kernel)
	Does not return until the given kernel has started. More...

virtual void	SignalKernelStart (CPN::Key_t kernelkey)
	Signal to the context that the given kernel has started. More...

virtual void	SignalKernelEnd (CPN::Key_t kernelkey)
	Signal to the Context that the given kernel is dead. More...

virtual void	SendCreateWriter (CPN::Key_t kernelkey, const CPN::SimpleQueueAttr &attr)
	Tell a given kernel that it needs to create a queue write end. More...

virtual void	SendCreateReader (CPN::Key_t kernelkey, const CPN::SimpleQueueAttr &attr)
	Tell a given kernel that it needs to create a queue read end. More...

virtual void	SendCreateQueue (CPN::Key_t kernelkey, const CPN::SimpleQueueAttr &attr)
	Tell a given kernel that it needs to create a queue. More...

virtual void	SendCreateNode (CPN::Key_t kernelkey, const CPN::NodeAttr &attr)
	Tell a given kernel that it needs to create a node. More...

virtual CPN::Key_t	CreateNodeKey (CPN::Key_t kernelkey, const std::string &nodename)
	Tell the context to allocate a new node key and data structure for a node with nodename which is on kernelkey. More...

virtual CPN::Key_t	GetNodeKey (const std::string &nodename)

virtual std::string	GetNodeName (CPN::Key_t nodekey)

virtual CPN::Key_t	GetNodeKernel (CPN::Key_t nodekey)

virtual void	SignalNodeStart (CPN::Key_t nodekey)
	Called by the node startup routine to indicate that the node has started. More...

virtual void	SignalNodeEnd (CPN::Key_t nodekey)
	Called by the node cleanup routine to indicate that the node has ended. More...

virtual CPN::Key_t	WaitForNodeStart (const std::string &nodename)
	Waits until the node starts and returns the key, if the node is already started returns the key. More...

virtual void	WaitForNodeEnd (const std::string &nodename)
	Waits for the given node to signal end. More...

virtual void	WaitForAllNodeEnd ()
	Convenience method which waits until there are no nodes running. If no node have started then this will return immediately. More...

virtual CPN::Key_t	GetCreateReaderKey (CPN::Key_t nodekey, const std::string &portname)
	Get the key associated with the given endpoint for the given node. Creates the information if it does not exist. More...

virtual CPN::Key_t	GetReaderNode (CPN::Key_t portkey)

virtual CPN::Key_t	GetReaderKernel (CPN::Key_t portkey)

virtual std::string	GetReaderName (CPN::Key_t portkey)

virtual CPN::Key_t	GetCreateWriterKey (CPN::Key_t nodekey, const std::string &portname)

virtual CPN::Key_t	GetWriterNode (CPN::Key_t portkey)

virtual CPN::Key_t	GetWriterKernel (CPN::Key_t portkey)

virtual std::string	GetWriterName (CPN::Key_t portkey)

virtual void	ConnectEndpoints (CPN::Key_t writerkey, CPN::Key_t readerkey, const std::string &qname)
	Called by the kernel when a queue is created. Note that the endpoints may have been created when the node requests them but the queue may be created long after that. More...

virtual CPN::Key_t	GetReadersWriter (CPN::Key_t readerkey)

virtual CPN::Key_t	GetWritersReader (CPN::Key_t writerkey)

virtual void	Terminate ()
	Signal to the Context that the network is terminating. After this call most methods will throw a ShutdownException. More...

virtual bool	IsTerminated ()

virtual bool	RequireRemote ()
	Lets the kernel know that this context type requires remote activity. This overrides the kernel option for remote activity. Default value is false. More...

void	DispatchMessage (const Variant &msg)

void	CheckTerminated ()
	Convenience method that checks IsTerminated and if so throws a ShutdownException. More...

virtual unsigned	CalculateGrowSize (unsigned currentsize, unsigned request)
	Calculate the new queue size when a queue needs to grow. More...

Static Public Member Functions
static shared_ptr< Context >	Local ()
	Create a local context. More...

Protected Member Functions
	RemoteContextClient ()

virtual void	SendMessage (const Variant &msg)=0

Protected Attributes
PthreadMutex	lock

Private Types
typedef shared_ptr< GenericWaiter >	GenericWaiterPtr

typedef std::map< unsigned, WaiterInfo * >	WaiterMap

typedef std::list< weak_ptr < GenericWaiter > >	WaiterList

typedef std::map< CPN::Key_t, CPN::KernelBase * >	KernelMap

Private Member Functions
void	SendQueueMsg (CPN::Key_t kernelkey, RCTXMT_t msgtype, const CPN::SimpleQueueAttr &attr)

unsigned	NewTranID ()

void	AddWaiter (WaiterInfo *info)

GenericWaiterPtr	NewGenericWaiter ()

void	InternalTerminate ()

void	InternalCheckTerminated ()

void *	TerminateThread ()

Variant	RemoteCall (Variant msg)

CPN::Key_t	GetCreateEndpointKey (RCTXMT_t msgtype, CPN::Key_t nodekey, const std::string &portname)

Variant	GetEndpointInfo (RCTXMT_t msgtype, CPN::Key_t portkey)

Private Attributes
auto_ptr< Pthread >	terminateThread

WaiterMap	callwaiters

WaiterList	waiters

KernelMap	kernels

unsigned	trancounter

bool	shutdown

int	loglevel

Detailed Description

This abstract class is the remote context client.

An implementor only needs to override SendMessage to send the necessary messages to the RemoteContextServer and then call DispatchMessage for the replies from the server.

Definition at line 48 of file RemoteContextClient.h.

Member Typedef Documentation

typedef shared_ptr<GenericWaiter> CPN::RemoteContextClient::GenericWaiterPtr

private

Definition at line 139 of file RemoteContextClient.h.

typedef std::map<CPN::Key_t, CPN::KernelBase*> CPN::RemoteContextClient::KernelMap

private

Definition at line 158 of file RemoteContextClient.h.

typedef std::list<weak_ptr<GenericWaiter> > CPN::RemoteContextClient::WaiterList

private

Definition at line 156 of file RemoteContextClient.h.

typedef std::map<unsigned, WaiterInfo*> CPN::RemoteContextClient::WaiterMap

private

Definition at line 154 of file RemoteContextClient.h.

Constructor & Destructor Documentation

CPN::RemoteContextClient::~RemoteContextClient ( )

virtual

Definition at line 40 of file RemoteContextClient.cc.

References terminateThread.

                                               {
         if (terminateThread.get()) {
             terminateThread->Join();
         }
     }

CPN::RemoteContextClient::RemoteContextClient ( )

protected

Definition at line 35 of file RemoteContextClient.cc.

         : trancounter(0), shutdown(false), loglevel(Logger::WARNING)
     {
     }

Member Function Documentation

void CPN::RemoteContextClient::AddWaiter ( WaiterInfo * info )

private

Definition at line 566 of file RemoteContextClient.cc.

References callwaiters, and CPN::RemoteContextClient::WaiterInfo::waiterid.

Referenced by RemoteCall().

                                                         {
         callwaiters.insert(std::make_pair(info->waiterid, info));
     }

Here is the caller graph for this function:

virtual unsigned CPN::Context::CalculateGrowSize	(	unsigned	currentsize,
		unsigned	request
	)

inlinevirtualinherited

Calculate the new queue size when a queue needs to grow.

Returns: the new queue size

Definition at line 275 of file Context.h.

275 { return currentsize + request; }

void CPN::Context::CheckTerminated ( )

inherited

Convenience method that checks IsTerminated and if so throws a ShutdownException.

Exceptions

ShutdownException

Definition at line 44 of file Context.cc.

References CPN::Context::IsTerminated().

                                   {
         if (IsTerminated()) {
             throw ShutdownException();
         }
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::ConnectEndpoints	(	CPN::Key_t	writerkey,
		CPN::Key_t	readerkey,
		const std::string &	qname
	)

virtual

Called by the kernel when a queue is created. Note that the endpoints may have been created when the node requests them but the queue may be created long after that.

Parameters

writerkey	the unique key for the writer endpoint
readerkey	the unique key for the reader endpoint

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 481 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_CONNECT_ENDPOINTS, and SendMessage().

                                                                                                        {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_CONNECT_ENDPOINTS;
         msg["readerkey"] = readerkey;
         msg["writerkey"] = writerkey;
         msg["qname"] = qname;
         SendMessage(msg);
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::CreateNodeKey	(	CPN::Key_t	kernelkey,
		const std::string &	nodename
	)

virtual

Tell the context to allocate a new node key and data structure for a node with nodename which is on kernelkey.

Parameters

kernelkey	the id of the kernel that the node will run on
nodename	the name of the node

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 266 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_CREATE_NODE_KEY, and RemoteCall().

                                                                                        {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_CREATE_NODE_KEY;
         msg["kernelkey"] = kernelkey;
         msg["name"] = nodename;
         Variant reply = RemoteCall(msg);
         if (!reply.Get("success", false).IsTrue()) {
             throw std::invalid_argument("Node " + nodename + " already exists.");
         }
         return reply["nodeinfo"]["key"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::DispatchMessage ( const Variant & msg )

Handle a message from the RemoteContextServer.

Parameters

msg	the message

Definition at line 580 of file RemoteContextClient.cc.

References ASSERT, callwaiters, InternalTerminate(), kernels, lock, CPN::MsgToNodeAttr(), CPN::MsgToQueueAttr(), CPN::RCTXMT_CREATE_NODE, CPN::RCTXMT_CREATE_QUEUE, CPN::RCTXMT_CREATE_READER, CPN::RCTXMT_CREATE_WRITER, CPN::RCTXMT_TERMINATE, CPN::KernelBase::RemoteCreateNode(), CPN::KernelBase::RemoteCreateQueue(), CPN::KernelBase::RemoteCreateReader(), CPN::KernelBase::RemoteCreateWriter(), AutoLock< Lockable >::Unlock(), and waiters.

Referenced by CPN::RemoteContext::EntryPoint().

                                                                 {
         if (!msg.IsMap()) { return; }
         AutoLock<PthreadMutex> plock(lock);
         if (msg.Contains("type") && msg["type"].AsNumber<RCTXMT_t>() == RCTXMT_TERMINATE) {
             InternalTerminate();
             return;
         }
         // Need to add for the general informative messages.
         //
         // The specific reply messages
         std::string msgtype = msg["msgtype"].AsString();
         if (msgtype == "reply") {
             unsigned tranid = msg["msgid"].AsUnsigned();
             WaiterMap::iterator entry;
             entry = callwaiters.find(tranid);
             ASSERT(entry != callwaiters.end());
             entry->second->msg = msg;
             entry->second->signaled = true;
             entry->second->cond.Signal();
             callwaiters.erase(entry);
         } else if (msgtype == "broadcast") {
             WaiterList::iterator entry;
             entry = waiters.begin();
             while (entry != waiters.end()) {
                 GenericWaiterPtr waiter = entry->lock();
                 if (waiter) {
                     waiter->messages.push_back(msg);
                     waiter->cond.Signal();
                     ++entry;
                 } else {
                     entry = waiters.erase(entry);
                 }
             }
         } else if (msgtype == "kernel") {
             Key_t kernelkey = msg["kernelkey"].AsNumber<Key_t>();
             KernelMap::iterator entry = kernels.find(kernelkey);
             if (entry != kernels.end()) {
                 KernelBase *kernel = entry->second;
                 // Cannot call a kernel method with the lock.
                 plock.Unlock();
                 ASSERT(kernel);
                 switch (msg["type"].AsNumber<RCTXMT_t>()) {
                 case RCTXMT_CREATE_NODE:
                     kernel->RemoteCreateNode(MsgToNodeAttr(msg["nodeattr"]));
                     break;
                 case RCTXMT_CREATE_QUEUE:
                     kernel->RemoteCreateQueue(MsgToQueueAttr(msg["queueattr"]));
                     break;
                 case RCTXMT_CREATE_WRITER:
                     kernel->RemoteCreateWriter(MsgToQueueAttr(msg["queueattr"]));
                     break;
                 case RCTXMT_CREATE_READER:
                     kernel->RemoteCreateReader(MsgToQueueAttr(msg["queueattr"]));
                     break;
                 default:
                     ASSERT(false, "Unknown kernel message type");
                 }
             } else {
                 ASSERT(false, "Message for kernel %llu but said kernel doesn't exist!", kernelkey);
             }
         } else {
             ASSERT(false);
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Key_t CPN::RemoteContextClient::GetCreateEndpointKey	(	RCTXMT_t	msgtype,
		CPN::Key_t	nodekey,
		const std::string &	portname
	)

private

Definition at line 645 of file RemoteContextClient.cc.

References InternalCheckTerminated(), and RemoteCall().

Referenced by GetCreateReaderKey(), and GetCreateWriterKey().

                                                                                                               {
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = msgtype;
         msg["nodekey"] = nodekey;
         msg["name"] = portname;
         Variant reply = RemoteCall(msg);
         if (!reply.Get("success", false).IsTrue()) {
             throw std::invalid_argument("No such port");
         }
         return reply["endpointinfo"]["key"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Key_t CPN::RemoteContextClient::GetCreateReaderKey	(	CPN::Key_t	nodekey,
		const std::string &	portname
	)

virtual

Get the key associated with the given endpoint for the given node. Creates the information if it does not exist.

Parameters

nodekey	the unique id for the node
portname	the name of the endpoint.

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 435 of file RemoteContextClient.cc.

References GetCreateEndpointKey(), lock, and CPN::RCTXMT_GET_CREATE_READER_KEY.

                                                                                           {
         PthreadMutexProtected plock(lock);
         return GetCreateEndpointKey(RCTXMT_GET_CREATE_READER_KEY, nodekey, portname);
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetCreateWriterKey	(	CPN::Key_t	nodekey,
		const std::string &	portname
	)

virtual

See Also: GetCreateReaderKey

Implements CPN::Context.

Definition at line 458 of file RemoteContextClient.cc.

References GetCreateEndpointKey(), lock, and CPN::RCTXMT_GET_CREATE_WRITER_KEY.

                                                                                           {
         PthreadMutexProtected plock(lock);
         return GetCreateEndpointKey(RCTXMT_GET_CREATE_WRITER_KEY, nodekey, portname);
     }

Here is the call graph for this function:

Variant CPN::RemoteContextClient::GetEndpointInfo	(	RCTXMT_t	msgtype,
		CPN::Key_t	portkey
	)

private

Definition at line 658 of file RemoteContextClient.cc.

References ASSERT, InternalCheckTerminated(), and RemoteCall().

Referenced by GetReaderKernel(), GetReaderName(), GetReaderNode(), GetReadersWriter(), GetWriterKernel(), GetWriterName(), GetWriterNode(), and GetWritersReader().

                                                                                 {
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = msgtype;
         msg["key"] = portkey;
         Variant reply = RemoteCall(msg);
         ASSERT(reply.Get("success", false).IsTrue(), "msg: %s", libvariant::SerializeJSON(reply).c_str());
         return reply["endpointinfo"];
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void CPN::RemoteContextClient::GetKernelConnectionInfo	(	CPN::Key_t	kernelkey,
		std::string &	hostname,
		std::string &	servname
	)

virtual

obtain the connection information for the given kernel

Parameters

kernelkey	the unique id for the kernel
hostname	(output) string to be filled with the hostname
servname	(output) string to be filled with the service name

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 111 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_GET_KERNEL_INFO, and RemoteCall().

                                                                                                                {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_KERNEL_INFO;
         msg["key"] = kernelkey;
         Variant reply = RemoteCall(msg);
         if (!reply.Get("success", false).IsTrue()) {
             throw std::invalid_argument("No such kernel");
         }
         Variant kernelinfo = reply["kernelinfo"];
         hostname = kernelinfo["hostname"].AsString();
         servname = kernelinfo["servname"].AsString();
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetKernelKey ( const std::string & kernel )

virtual

Parameters

kernel the name of the kernel

Returns: the key for the given kernel.

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 85 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_GET_KERNEL_INFO, and RemoteCall().

                                                                    {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_KERNEL_INFO;
         msg["name"] = kernel;
         Variant reply = RemoteCall(msg);
         if (!reply.Get("success", false).IsTrue()) {
             throw std::invalid_argument("No such kernel");
         }
         return reply["kernelinfo"]["key"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

std::string CPN::RemoteContextClient::GetKernelName ( CPN::Key_t kernelkey )

virtual

Parameters

kernelkey the key to the kernel

Returns: the name for the kernel

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 98 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_GET_KERNEL_INFO, and RemoteCall().

                                                                 {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_KERNEL_INFO;
         msg["key"] = kernelkey;
         Variant reply = RemoteCall(msg);
         if (!reply.Get("success", false).IsTrue()) {
             throw std::invalid_argument("No such kernel");
         }
         return reply["kernelinfo"]["name"].AsString();
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetNodeKernel ( CPN::Key_t nodekey )

virtual

Parameters

nodekey the unique key for the node

Returns: the key for the kernel the node is running on

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 421 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_GET_NODE_INFO, and RemoteCall().

                                                           {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_NODE_INFO;
         msg["key"] = nodekey;
         Variant reply = RemoteCall(msg);
         if (!reply.Get("success", false).IsTrue()) {
             throw std::invalid_argument("No such node");
         }
         return reply["nodeinfo"]["kernelkey"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetNodeKey ( const std::string & nodename )

virtual

Returns: the unique key associated with the given node name.

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 280 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_GET_NODE_INFO, and RemoteCall().

                                                                    {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_NODE_INFO;
         msg["name"] = nodename;
         Variant reply = RemoteCall(msg);
         if (!reply.Get("success", false).IsTrue()) {
             throw std::invalid_argument("No such node");
         }
         return reply["nodeinfo"]["key"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

std::string CPN::RemoteContextClient::GetNodeName ( CPN::Key_t nodekey )

virtual

Returns: the name associated with the given node key

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 293 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_GET_NODE_INFO, and RemoteCall().

                                                             {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_NODE_INFO;
         msg["key"] = nodekey;
         Variant reply = RemoteCall(msg);
         if (!reply.Get("success", false).IsTrue()) {
             throw std::invalid_argument("No such node");
         }
         return reply["nodeinfo"]["name"].AsString();
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetReaderKernel ( CPN::Key_t portkey )

virtual

Parameters

portkey the unique id for the port

Returns: the key for the kernel this port is on

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 446 of file RemoteContextClient.cc.

References GetEndpointInfo(), lock, and CPN::RCTXMT_GET_READER_INFO.

                                                             {
         PthreadMutexProtected plock(lock);
         Variant info = GetEndpointInfo(RCTXMT_GET_READER_INFO, portkey);
         return info["kernelkey"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

std::string CPN::RemoteContextClient::GetReaderName ( CPN::Key_t portkey )

virtual

Parameters

portkey the unique id for the port

Returns: the name of the port

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 452 of file RemoteContextClient.cc.

References GetEndpointInfo(), lock, and CPN::RCTXMT_GET_READER_INFO.

                                                               {
         PthreadMutexProtected plock(lock);
         Variant info = GetEndpointInfo(RCTXMT_GET_READER_INFO, portkey);
         return info["name"].AsString();
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetReaderNode ( CPN::Key_t portkey )

virtual

Parameters

portkey the unique id for the port

Returns: the key for the node this port is on

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 440 of file RemoteContextClient.cc.

References GetEndpointInfo(), lock, and CPN::RCTXMT_GET_READER_INFO.

                                                           {
         PthreadMutexProtected plock(lock);
         Variant info = GetEndpointInfo(RCTXMT_GET_READER_INFO, portkey);
         return info["nodekey"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetReadersWriter ( CPN::Key_t readerkey )

virtual

Parameters

readerkey a unique reader key

Returns: the writer key associated with this reader key if there is one

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 492 of file RemoteContextClient.cc.

References GetEndpointInfo(), lock, and CPN::RCTXMT_GET_READER_INFO.

                                                                {
         PthreadMutexProtected plock(lock);
         Variant info = GetEndpointInfo(RCTXMT_GET_READER_INFO, readerkey);
         return info["writerkey"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetWriterKernel ( CPN::Key_t portkey )

virtual

See Also: GetReaderKernel

Implements CPN::Context.

Definition at line 469 of file RemoteContextClient.cc.

References GetEndpointInfo(), lock, and CPN::RCTXMT_GET_WRITER_INFO.

                                                             {
         PthreadMutexProtected plock(lock);
         Variant info = GetEndpointInfo(RCTXMT_GET_WRITER_INFO, portkey);
         return info["kernelkey"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

std::string CPN::RemoteContextClient::GetWriterName ( CPN::Key_t portkey )

virtual

See Also: GetReaderName

Implements CPN::Context.

Definition at line 475 of file RemoteContextClient.cc.

References GetEndpointInfo(), lock, and CPN::RCTXMT_GET_WRITER_INFO.

                                                               {
         PthreadMutexProtected plock(lock);
         Variant info = GetEndpointInfo(RCTXMT_GET_WRITER_INFO, portkey);
         return info["name"].AsString();
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetWriterNode ( CPN::Key_t portkey )

virtual

See Also: GetReaderNode

Implements CPN::Context.

Definition at line 463 of file RemoteContextClient.cc.

References GetEndpointInfo(), lock, and CPN::RCTXMT_GET_WRITER_INFO.

                                                           {
         PthreadMutexProtected plock(lock);
         Variant info = GetEndpointInfo(RCTXMT_GET_WRITER_INFO, portkey);
         return info["nodekey"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::GetWritersReader ( CPN::Key_t writerkey )

virtual

Parameters

writerkey a unique writer key

Returns: the reader key associated with this writer

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 498 of file RemoteContextClient.cc.

References GetEndpointInfo(), lock, and CPN::RCTXMT_GET_WRITER_INFO.

                                                                {
         PthreadMutexProtected plock(lock);
         Variant info = GetEndpointInfo(RCTXMT_GET_WRITER_INFO, writerkey);
         return info["readerkey"].AsNumber<Key_t>();
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::InternalCheckTerminated ( )

private

Definition at line 560 of file RemoteContextClient.cc.

References shutdown.

Referenced by ConnectEndpoints(), CreateNodeKey(), GetCreateEndpointKey(), GetEndpointInfo(), GetKernelConnectionInfo(), GetKernelKey(), GetKernelName(), GetNodeKernel(), GetNodeKey(), GetNodeName(), RemoteCall(), SendCreateNode(), SendCreateQueue(), SendCreateReader(), SendCreateWriter(), SetupKernel(), SignalKernelStart(), SignalNodeStart(), WaitForKernelStart(), and WaitForNodeStart().

                                                       {
         if (shutdown) {
             throw ShutdownException();
         }
     }

Here is the caller graph for this function:

void CPN::RemoteContextClient::InternalTerminate ( )

private

Definition at line 530 of file RemoteContextClient.cc.

References callwaiters, CreatePthreadFunctional(), shutdown, TerminateThread(), terminateThread, and waiters.

Referenced by DispatchMessage(), and Terminate().

                                                 {
         if (shutdown) return;
         shutdown = true;
         WaiterMap::iterator cwitr = callwaiters.begin();
         while (cwitr != callwaiters.end()) {
             cwitr->second->cond.Signal();
             ++cwitr;
         }
         WaiterList::iterator gwitr;
         gwitr = waiters.begin();
         while (gwitr != waiters.end()) {
             GenericWaiterPtr ptr = gwitr->lock();
             if (ptr) {
                 ptr->cond.Signal();
             }
             ++gwitr;
         }
         terminateThread.reset(CreatePthreadFunctional(this, &RemoteContextClient::TerminateThread));
         terminateThread->Start();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CPN::RemoteContextClient::IsTerminated ( )

virtual

Returns: true if Terminate has been called

Implements CPN::Context.

Definition at line 551 of file RemoteContextClient.cc.

References lock, and shutdown.

                                            {
         PthreadMutexProtected plock(lock);
         return shutdown;
     }

shared_ptr< Context > CPN::Context::Local ( )

staticinherited

Create a local context.

Returns: a new local context.

Definition at line 29 of file Context.cc.

Referenced by CPN::Kernel::Kernel(), and CPN::VariantCPNLoader::LoadContext().

                                        {
         return shared_ptr<Context>(new LocalContext);
     }

Here is the caller graph for this function:

void CPN::RemoteContextClient::Log	(	int	level,
		const std::string &	msg
	)

virtual

Log a message to this outputer.

Parameters

level	the level of this message
msg	the message

Implements LoggerOutput.

Definition at line 56 of file RemoteContextClient.cc.

References lock, loglevel, CPN::RCTXMT_LOG, and SendMessage().

                                                                     {
         PthreadMutexProtected plock(lock);
         if (level >= loglevel) {
             Variant msg(Variant::MapType);
             msg["type"] = RCTXMT_LOG;
             msg["msg"] = logmsg;
             SendMessage(msg);
         }
     }

Here is the call graph for this function:

int CPN::RemoteContextClient::LogLevel ( ) const

virtual

Returns: the current log level

Implements LoggerOutput.

Definition at line 46 of file RemoteContextClient.cc.

References lock, and loglevel.

                                             {
         PthreadMutexProtected plock(lock);
         return loglevel;
     }

int CPN::RemoteContextClient::LogLevel ( int level )

virtual

Parameters

level the new log level

Returns: the new log level

Implements LoggerOutput.

Definition at line 51 of file RemoteContextClient.cc.

References lock, and loglevel.

                                                 {
         PthreadMutexProtected plock(lock);
         return loglevel = level;
     }

RemoteContextClient::GenericWaiterPtr CPN::RemoteContextClient::NewGenericWaiter ( )

private

Definition at line 570 of file RemoteContextClient.cc.

References waiters.

Referenced by WaitForAllNodeEnd(), WaitForKernelStart(), WaitForNodeEnd(), and WaitForNodeStart().

                                                                               {
         GenericWaiterPtr gw = GenericWaiterPtr(new GenericWaiter);
         waiters.push_back(gw);
         return gw;
     }

Here is the caller graph for this function:

unsigned CPN::RemoteContextClient::NewTranID ( )

private

Definition at line 576 of file RemoteContextClient.cc.

References trancounter.

Referenced by RemoteCall().

                                             {
         return ++trancounter;
     }

Here is the caller graph for this function:

Variant CPN::RemoteContextClient::RemoteCall ( Variant msg )

private

Definition at line 668 of file RemoteContextClient.cc.

References AddWaiter(), CPN::RemoteContextClient::WaiterInfo::cond, InternalCheckTerminated(), lock, CPN::RemoteContextClient::WaiterInfo::msg, NewTranID(), SendMessage(), CPN::RemoteContextClient::WaiterInfo::signaled, PthreadCondition::Wait(), and CPN::RemoteContextClient::WaiterInfo::waiterid.

Referenced by CreateNodeKey(), GetCreateEndpointKey(), GetEndpointInfo(), GetKernelConnectionInfo(), GetKernelKey(), GetKernelName(), GetNodeKernel(), GetNodeKey(), GetNodeName(), SetupKernel(), WaitForAllNodeEnd(), WaitForKernelStart(), WaitForNodeEnd(), and WaitForNodeStart().

                                                        {
         WaiterInfo winfo(NewTranID());
         AddWaiter(&winfo);
         msg["msgid"] = winfo.waiterid;
         SendMessage(msg);
         while (!winfo.signaled) {
             winfo.cond.Wait(lock);
             InternalCheckTerminated();
         }
         return winfo.msg;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool CPN::RemoteContextClient::RequireRemote ( )

virtual

Lets the kernel know that this context type requires remote activity. This overrides the kernel option for remote activity. Default value is false.

Returns: true or false

Reimplemented from CPN::Context.

Definition at line 556 of file RemoteContextClient.cc.

                                             {
         return true;
     }

void CPN::RemoteContextClient::SendCreateNode	(	CPN::Key_t	kernelkey,
		const CPN::NodeAttr &	attr
	)

virtual

Tell a given kernel that it needs to create a node.

Parameters

kernelkey	the id of the kernel
attr	the node attribute

Exceptions

ShutdownException

Implements CPN::Context.

Definition at line 193 of file RemoteContextClient.cc.

References CPN::NodeAttr::GetKernel(), CPN::NodeAttr::GetKey(), CPN::NodeAttr::GetName(), CPN::NodeAttr::GetParams(), CPN::NodeAttr::GetTypeName(), InternalCheckTerminated(), lock, CPN::RCTXMT_CREATE_NODE, and SendMessage().

                                                                                   {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["msgtype"] = "kernel";
         msg["type"] = RCTXMT_CREATE_NODE;
         msg["kernelkey"] = kernelkey;
         Variant nodeattr;
         nodeattr["kernelkey"] = kernelkey;
         nodeattr["kernel"] = attr.GetKernel();
         nodeattr["name"] = attr.GetName();
         nodeattr["nodetype"] = attr.GetTypeName();
         const std::map<std::string, std::string> &params = attr.GetParams();
         for (std::map<std::string, std::string>::const_iterator i = params.begin(),
                 e = params.end(); i != e; ++i) {
             nodeattr["param"][i->first] = i->second;
         }
         nodeattr["key"] = attr.GetKey();
         msg["nodeattr"] = nodeattr;
         SendMessage(msg);
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::SendCreateQueue	(	CPN::Key_t	kernelkey,
		const CPN::SimpleQueueAttr &	attr
	)

virtual

Tell a given kernel that it needs to create a queue.

Parameters

kernelkey	the id of the kernel
attr	the queue attribute

Exceptions

ShutdownException

Implements CPN::Context.

Definition at line 187 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_CREATE_QUEUE, and SendQueueMsg().

                                                                                           {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         SendQueueMsg(kernelkey, RCTXMT_CREATE_QUEUE, attr);
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::SendCreateReader	(	CPN::Key_t	kernelkey,
		const CPN::SimpleQueueAttr &	attr
	)

virtual

Tell a given kernel that it needs to create a queue read end.

Parameters

kernelkey	the id of the kernel
attr	the queue attribute

Exceptions

ShutdownException

Implements CPN::Context.

Definition at line 181 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_CREATE_READER, and SendQueueMsg().

                                                                                            {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         SendQueueMsg(kernelkey, RCTXMT_CREATE_READER, attr);
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::SendCreateWriter	(	CPN::Key_t	kernelkey,
		const CPN::SimpleQueueAttr &	attr
	)

virtual

Tell a given kernel that it needs to create a queue write end.

Parameters

kernelkey	the id of the kernel
attr	the queue attribute

Exceptions

ShutdownException

Implements CPN::Context.

Definition at line 175 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_CREATE_WRITER, and SendQueueMsg().

                                                                                            {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         SendQueueMsg(kernelkey, RCTXMT_CREATE_WRITER, attr);
     }

Here is the call graph for this function:

virtual void CPN::RemoteContextClient::SendMessage ( const Variant & msg )

protectedpure virtual

Called by the functions to send a message to the RemoteContextServer.

Parameters

msg	the message

Implemented in CPN::RemoteContext.

Referenced by ConnectEndpoints(), Log(), RemoteCall(), SendCreateNode(), SendQueueMsg(), SignalKernelEnd(), SignalKernelStart(), SignalNodeEnd(), SignalNodeStart(), and Terminate().

Here is the caller graph for this function:

void CPN::RemoteContextClient::SendQueueMsg	(	CPN::Key_t	kernelkey,
		RCTXMT_t	msgtype,
		const CPN::SimpleQueueAttr &	attr
	)

private

Definition at line 229 of file RemoteContextClient.cc.

References CPN::SimpleQueueAttr::GetAlpha(), CPN::SimpleQueueAttr::GetDatatype(), CPN::SimpleQueueAttr::GetHint(), CPN::SimpleQueueAttr::GetLength(), CPN::SimpleQueueAttr::GetMaxThreshold(), CPN::SimpleQueueAttr::GetMaxWriteThreshold(), CPN::SimpleQueueAttr::GetNumChannels(), CPN::SimpleQueueAttr::GetReaderKey(), CPN::SimpleQueueAttr::GetReaderNodeKey(), CPN::SimpleQueueAttr::GetWriterKey(), CPN::SimpleQueueAttr::GetWriterNodeKey(), and SendMessage().

Referenced by SendCreateQueue(), SendCreateReader(), and SendCreateWriter().

                                                                                                          {
         Variant msg(Variant::MapType);
         msg["msgtype"] = "kernel";
         msg["type"] = msgtype;
         msg["kernelkey"] = kernelkey;
         Variant queueattr;
         queueattr["queuehint"] = attr.GetHint();
         queueattr["datatype"] = attr.GetDatatype();
         queueattr["queueLength"] = attr.GetLength();
         queueattr["maxThreshold"] = attr.GetMaxThreshold();
         queueattr["numChannels"] = attr.GetNumChannels();
         queueattr["readerkey"] = attr.GetReaderKey();
         queueattr["writerkey"] = attr.GetWriterKey();
         queueattr["readernodekey"] = attr.GetReaderNodeKey();
         queueattr["writernodekey"] = attr.GetWriterNodeKey();
         queueattr["alpha"] = attr.GetAlpha();
         queueattr["maxwritethreshold"] = attr.GetMaxWriteThreshold();
         msg["queueattr"] = queueattr;
         SendMessage(msg);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Key_t CPN::RemoteContextClient::SetupKernel	(	const std::string &	name,
		const std::string &	hostname,
		const std::string &	servname,
		CPN::KernelBase *	kernel
	)

virtual

Called by the Kernel when it has successfully set it self up. This gives the Context a way to notify the Kernel of events and lets other Kernels look up the connection information for this Kernel.

Parameters

name	the kernel name
hostname	the hostname to use to connect to this kernel
servname	the service name the kernel is listening on
kernel	callback reference

Returns: the unique key for the new kernel

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 66 of file RemoteContextClient.cc.

References InternalCheckTerminated(), kernels, lock, CPN::RCTXMT_SETUP_KERNEL, and RemoteCall().

                                                            {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         if (!kernel) { throw std::invalid_argument("Must have non null Kernel."); }
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_SETUP_KERNEL;
         msg["name"] = name;
         msg["hostname"] = hostname;
         msg["servname"] = servname;
         Variant reply = RemoteCall(msg);
         if (!reply.Get("success", false).IsTrue()) {
            throw std::invalid_argument("Cannot create two kernels with the same name");
         }
         Key_t key = reply["kernelinfo"]["key"].AsNumber<Key_t>();
         kernels.insert(std::make_pair(key, kernel));
         return key;
     }

Here is the call graph for this function:

virtual CPN::Key_t CPN::RemoteContextClient::SetupKernel	(	const std::string &	name,
		KernelBase *	kernel
	)

inlinevirtual

Called by the kernel when it is not in remote mode.

Parameters

name	the kernel name
kernel	callback reference

Returns: the unique key for the new kernel

Implements CPN::Context.

Definition at line 58 of file RemoteContextClient.h.

References ASSERT.

58 { ASSERT(false, "RemoteContextClient requires remote operation is turned on."); }

ASSERT

#define ASSERT(exp,...)

Definition: ThrowingAssert.h:62

void CPN::RemoteContextClient::SignalKernelEnd ( CPN::Key_t kernelkey )

virtual

Signal to the Context that the given kernel is dead.

Parameters

kernelkey id of the kernel that died

Exceptions

std::invalid_argument

Implements CPN::Context.

Definition at line 126 of file RemoteContextClient.cc.

References kernels, lock, CPN::RCTXMT_SIGNAL_KERNEL_END, and SendMessage().

                                                              {
         PthreadMutexProtected plock(lock);
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_SIGNAL_KERNEL_END;
         msg["key"] = kernelkey;
         SendMessage(msg);
         kernels.erase(kernelkey);
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::SignalKernelStart ( CPN::Key_t kernelkey )

virtual

Signal to the context that the given kernel has started.

Parameters

kernelkey the id for the kernel

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 166 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_SIGNAL_KERNEL_START, and SendMessage().

                                                                {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["key"] = kernelkey;
         msg["type"] = RCTXMT_SIGNAL_KERNEL_START;
         SendMessage(msg);
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::SignalNodeEnd ( CPN::Key_t nodekey )

virtual

Called by the node cleanup routine to indicate that the node has ended.

Parameters

nodekey the unique key for the node

Exceptions

std::invalid_argument

Implements CPN::Context.

Definition at line 315 of file RemoteContextClient.cc.

References lock, CPN::RCTXMT_SIGNAL_NODE_END, and SendMessage().

                                                          {
         PthreadMutexProtected plock(lock);
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_SIGNAL_NODE_END;
         msg["key"] = nodekey;
         SendMessage(msg);
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::SignalNodeStart ( CPN::Key_t nodekey )

virtual

Called by the node startup routine to indicate that the node has started.

Parameters

nodekey the unique key for the node

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 306 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, CPN::RCTXMT_SIGNAL_NODE_START, and SendMessage().

                                                            {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_SIGNAL_NODE_START;
         msg["key"] = nodekey;
         SendMessage(msg);
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::Terminate ( )

virtual

Signal to the Context that the network is terminating. After this call most methods will throw a ShutdownException.

Implements CPN::Context.

Definition at line 504 of file RemoteContextClient.cc.

References InternalTerminate(), lock, CPN::RCTXMT_TERMINATE, SendMessage(), and shutdown.

Referenced by CPN::RemoteContext::EntryPoint().

                                         {
         PthreadMutexProtected plock(lock);
         if (!shutdown) {
             InternalTerminate();
             Variant msg(Variant::MapType);
             msg["type"] = RCTXMT_TERMINATE;
             SendMessage(msg);
         }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void * CPN::RemoteContextClient::TerminateThread ( )

private

Definition at line 514 of file RemoteContextClient.cc.

References kernels, and lock.

Referenced by InternalTerminate().

                                                {
         KernelMap mapcopy;
         {
             PthreadMutexProtected plock(lock);
             mapcopy = kernels;
         }
         KernelMap::iterator itr, end;
         itr = mapcopy.begin();
         end = mapcopy.end();
         while (itr != end) {
             itr->second->NotifyTerminate();
             ++itr;
         }
         return 0;
     }

Here is the caller graph for this function:

void CPN::RemoteContextClient::WaitForAllNodeEnd ( )

virtual

Convenience method which waits until there are no nodes running. If no node have started then this will return immediately.

Exceptions

ShutdownException

Implements CPN::Context.

Definition at line 391 of file RemoteContextClient.cc.

References ASSERT, lock, NewGenericWaiter(), CPN::RCTXMT_GET_NUM_NODE_LIVE, RemoteCall(), and shutdown.

                                                 {
         PthreadMutexProtected plock(lock);
         if (shutdown) { return; }
         GenericWaiterPtr genwait = NewGenericWaiter();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_NUM_NODE_LIVE;
         Variant reply;
         try {
             reply = RemoteCall(msg);
         } catch (const ShutdownException &e) {
             return;
         }
         ASSERT(reply.Get("success", false).IsTrue(), "msg: %s", libvariant::SerializeJSON(reply).c_str());
         if (reply["numlivenodes"].AsUnsigned() == 0) {
             return;
         }
         while (true) {
             if (genwait->messages.empty()) {
                 genwait->cond.Wait(lock);
                 if (shutdown) { return; }
             } else {
                 Variant msg = genwait->messages.front();
                 genwait->messages.pop_front();
                 if (msg.Get("numlivenodes", -1).AsUnsigned() == 0) {
                     return;
                 }
             }
         }
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::WaitForKernelStart ( const std::string & kernel )

virtual

Does not return until the given kernel has started.

Parameters

kernel the name of the kernel (the key may not be known yet)

Exceptions

ShutdownException

Implements CPN::Context.

Definition at line 135 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, NewGenericWaiter(), CPN::RCTXMT_GET_KERNEL_INFO, and RemoteCall().

                                                                          {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         GenericWaiterPtr genwait = NewGenericWaiter();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_KERNEL_INFO;
         msg["name"] = kernel;
         Variant reply = RemoteCall(msg);
         if (reply.Get("success", false).IsTrue()) {
             Variant kernelinfo = reply["kernelinfo"];
             if (kernelinfo.Get("live", false).IsTrue()) {
                 return kernelinfo["key"].AsNumber<Key_t>();
             }
         }
         while (true) {
             if (genwait->messages.empty()) {
                 genwait->cond.Wait(lock);
                 InternalCheckTerminated();
             } else {
                 Variant msg = genwait->messages.front();
                 genwait->messages.pop_front();
                 if (msg.Contains("kernelinfo")) {
                     Variant kernelinfo = msg["kernelinfo"];
                     if (kernelinfo["name"].AsString() == kernel && kernelinfo["live"].IsTrue()) {
                         return kernelinfo["key"].AsNumber<Key_t>();
                     }
                 }
             }
         }
     }

Here is the call graph for this function:

void CPN::RemoteContextClient::WaitForNodeEnd ( const std::string & nodename )

virtual

Waits for the given node to signal end.

Parameters

nodename the name of the node

Exceptions

ShutdownException

Implements CPN::Context.

Definition at line 355 of file RemoteContextClient.cc.

References lock, NewGenericWaiter(), CPN::RCTXMT_GET_NODE_INFO, RemoteCall(), and shutdown.

                                                                       {
         PthreadMutexProtected plock(lock);
         if (shutdown) { return; }
         GenericWaiterPtr genwait = NewGenericWaiter();
 
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_NODE_INFO;
         msg["name"] = nodename;
         Variant reply;
        try {
           reply  = RemoteCall(msg);
        } catch (const ShutdownException &e) {
            return;
        }
         if (reply.Get("success", false).IsTrue()) {
             if (reply["nodeinfo"]["dead"].IsTrue()) {
                 return;
             }
         }
         while (true) {
             if (genwait->messages.empty()) {
                 genwait->cond.Wait(lock);
                 if (shutdown) { return; }
             } else {
                 Variant msg = genwait->messages.front();
                 genwait->messages.pop_front();
                 if (msg.Contains("nodeinfo")) {
                     Variant nodeinfo = msg["nodeinfo"];
                     if (nodeinfo["dead"].IsTrue() && nodeinfo["name"].AsString() == nodename) {
                         return;
                     }
                 }
             }
         }
     }

Here is the call graph for this function:

Key_t CPN::RemoteContextClient::WaitForNodeStart ( const std::string & nodename )

virtual

Waits until the node starts and returns the key, if the node is already started returns the key.

Parameters

nodename the name of the node to wait for

Returns: the key for the node

Exceptions

ShutdownException

Implements CPN::Context.

Definition at line 323 of file RemoteContextClient.cc.

References InternalCheckTerminated(), lock, NewGenericWaiter(), CPN::RCTXMT_GET_NODE_INFO, and RemoteCall().

                                                                          {
         PthreadMutexProtected plock(lock);
         InternalCheckTerminated();
         GenericWaiterPtr genwait = NewGenericWaiter();
         Variant msg(Variant::MapType);
         msg["type"] = RCTXMT_GET_NODE_INFO;
         msg["name"] = nodename;
         Variant reply = RemoteCall(msg);
 
         if (reply.Get("success", false).IsTrue()) {
             Variant nodeinfo = reply["nodeinfo"];
             if (nodeinfo["started"].IsTrue()) {
                 return nodeinfo["key"].AsNumber<Key_t>();
             }
         }
         while (true) {
             if (genwait->messages.empty()) {
                 genwait->cond.Wait(lock);
                 InternalCheckTerminated();
             } else {
                 Variant msg = genwait->messages.front();
                 genwait->messages.pop_front();
                 if (msg.Contains("nodeinfo")) {
                     Variant nodeinfo = msg["nodeinfo"];
                     if (nodeinfo["started"].IsTrue() && nodeinfo["name"].AsString() == nodename) {
                         return nodeinfo["key"].AsNumber<Key_t>();
                     }
                 }
             }
         }
     }