A local implementation of the Context interface. More...

#include <LocalContext.h>

Inheritance diagram for CPN::LocalContext:

Collaboration diagram for CPN::LocalContext:

Classes
struct	KernelInfo

struct	NodeInfo

struct	PortInfo

Public Types
typedef std::map< std::string, Key_t >	NameMap

typedef std::map< Key_t, shared_ptr< KernelInfo > >	KernelMap

typedef std::map< Key_t, shared_ptr< NodeInfo > >	NodeMap

typedef std::map< Key_t, shared_ptr< PortInfo > >	PortMap

Public Member Functions
	LocalContext ()

virtual	~LocalContext ()

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

virtual int	LogLevel () const

virtual int	LogLevel (int level)

virtual Key_t	SetupKernel (const std::string &name, const std::string &hostname, const std::string &servname, 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 Key_t	SetupKernel (const std::string &name, KernelBase *kernel)
	Called by the kernel when it is not in remote mode. More...

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

virtual std::string	GetKernelName (Key_t kernelkey)

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

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

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

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

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

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

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

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

virtual Key_t	CreateNodeKey (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 Key_t	GetNodeKey (const std::string &nodename)

virtual std::string	GetNodeName (Key_t nodekey)

virtual Key_t	GetNodeKernel (Key_t nodekey)

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

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

virtual 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 Key_t	GetCreateReaderKey (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 Key_t	GetReaderNode (Key_t portkey)

virtual Key_t	GetReaderKernel (Key_t portkey)

virtual std::string	GetReaderName (Key_t portkey)

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

virtual Key_t	GetWriterNode (Key_t portkey)

virtual Key_t	GetWriterKernel (Key_t portkey)

virtual std::string	GetWriterName (Key_t portkey)

virtual void	ConnectEndpoints (Key_t writerkey, 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 Key_t	GetReadersWriter (Key_t readerkey)

virtual Key_t	GetWritersReader (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 ()

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

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...

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...

Private Member Functions
void	InternalCheckTerminated ()

Key_t	NewKey ()

Private Attributes
int	loglevel

PthreadMutex	lock

PthreadCondition	nodelivedead

PthreadCondition	kernellivedead

NameMap	kernelnames

NameMap	nodenames

KernelMap	kernelmap

NodeMap	nodemap

PortMap	readports

PortMap	writeports

unsigned	numlivenodes

bool	shutdown

Key_t	counter

Detailed Description

A local implementation of the Context interface.

Definition at line 40 of file LocalContext.h.

Member Typedef Documentation

typedef std::map< Key_t, shared_ptr<KernelInfo> > CPN::LocalContext::KernelMap

Definition at line 74 of file LocalContext.h.

typedef std::map< std::string, Key_t > CPN::LocalContext::NameMap

Definition at line 42 of file LocalContext.h.

typedef std::map< Key_t, shared_ptr<NodeInfo> > CPN::LocalContext::NodeMap

Definition at line 75 of file LocalContext.h.

typedef std::map< Key_t, shared_ptr<PortInfo> > CPN::LocalContext::PortMap

Definition at line 76 of file LocalContext.h.

Constructor & Destructor Documentation

CPN::LocalContext::LocalContext ( )

Definition at line 34 of file LocalContext.cc.

35 : loglevel(Logger::WARNING), numlivenodes(0), shutdown(false), counter(0)

36 {}

CPN::LocalContext::numlivenodes

unsigned numlivenodes

Definition: LocalContext.h:140

CPN::LocalContext::loglevel

int loglevel

Definition: LocalContext.h:130

CPN::LocalContext::counter

Key_t counter

Definition: LocalContext.h:144

Logger::WARNING

Definition: Logger.h:61

CPN::LocalContext::shutdown

bool shutdown

Definition: LocalContext.h:141

CPN::LocalContext::~LocalContext ( )

virtual

Definition at line 38 of file LocalContext.cc.

38 {

39 }

Member Function Documentation

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::LocalContext::ConnectEndpoints	(	Key_t	writerkey,
		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 428 of file LocalContext.cc.

References InternalCheckTerminated(), lock, readports, and writeports.

                                                                                                 {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         PortMap::iterator writeentry = writeports.find(writerkey);
         if (writeentry == writeports.end()) {
             throw std::invalid_argument("Write port does not exist.");
         }
         PortMap::iterator readentry = readports.find(readerkey);
         if (readentry == readports.end()) {
             throw std::invalid_argument("Read port does not exist.");
         }
 
         writeentry->second->opposingport = readerkey;
         readentry->second->opposingport = writerkey;
 
         readentry->second->qname = qname;
         writeentry->second->qname = qname;
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::CreateNodeKey	(	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 217 of file LocalContext.cc.

References InternalCheckTerminated(), lock, NewKey(), nodemap, and nodenames.

                                                                                 {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         NameMap::iterator nameentry = nodenames.find(nodename);
         Key_t key;
         if (nameentry == nodenames.end()) {
             shared_ptr<NodeInfo> ninfo = shared_ptr<NodeInfo>(new NodeInfo);
             ninfo->name = nodename;
             ninfo->started = false;
             ninfo->dead = false;
             ninfo->kernelkey = kernelkey;
             key = NewKey();
             nodenames.insert(std::make_pair(nodename, key));
             nodemap.insert(std::make_pair(key, ninfo));
         } else {
             throw std::invalid_argument("Node " + nodename + " already exists.");
         }
         return key;
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::GetCreateReaderKey	(	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 334 of file LocalContext.cc.

References InternalCheckTerminated(), lock, NewKey(), nodemap, and readports.

                                                                                    {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         NodeMap::iterator entry = nodemap.find(nodekey);
         if (entry == nodemap.end()) {
             throw std::invalid_argument("No such node");
         }
         NameMap::iterator portentry = entry->second->readers.find(portname);
         if (portentry == entry->second->readers.end()) {
             Key_t key = NewKey();
             entry->second->readers.insert(std::make_pair(portname, key));
             shared_ptr<PortInfo> pinfo = shared_ptr<PortInfo>(new PortInfo);
             pinfo->name = portname;
             pinfo->nodekey = nodekey;
             pinfo->opposingport = 0;
             pinfo->dead = false;
             readports.insert(std::make_pair(key, pinfo));
             return key;
         } else {
             return portentry->second;
         }
     }

Here is the call graph for this function:

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

virtual

See Also: GetCreateReaderKey

Implements CPN::Context.

Definition at line 381 of file LocalContext.cc.

References InternalCheckTerminated(), lock, NewKey(), nodemap, and writeports.

                                                                                    {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         NodeMap::iterator entry = nodemap.find(nodekey);
         if (entry == nodemap.end()) {
             throw std::invalid_argument("No such node");
         }
         NameMap::iterator portentry = entry->second->writers.find(portname);
         if (portentry == entry->second->writers.end()) {
             Key_t key = NewKey();
             entry->second->writers.insert(std::make_pair(portname, key));
             shared_ptr<PortInfo> pinfo = shared_ptr<PortInfo>(new PortInfo);
             pinfo->name = portname;
             pinfo->nodekey = nodekey;
             pinfo->opposingport = 0;
             pinfo->dead = false;
             writeports.insert(std::make_pair(key, pinfo));
             return key;
         } else {
             return portentry->second;
         }
     }

Here is the call graph for this function:

void CPN::LocalContext::GetKernelConnectionInfo	(	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 120 of file LocalContext.cc.

References ASSERT, InternalCheckTerminated(), kernelmap, and lock.

                                                                                                         {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         KernelMap::iterator entry = kernelmap.find(kernelkey);
         if (entry == kernelmap.end()) {
             throw std::invalid_argument("No such kernel");
         }
         ASSERT(entry->second->allowremote, "Kernel does not have remote configured.");
         hostname = entry->second->hostname;
         servname = entry->second->servname;
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::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 100 of file LocalContext.cc.

References InternalCheckTerminated(), kernelnames, and lock.

                                                             {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         NameMap::iterator entry = kernelnames.find(kernel);
         if (entry == kernelnames.end()) {
             throw std::invalid_argument("No such kernel");
         }
         return entry->second;
     }

Here is the call graph for this function:

std::string CPN::LocalContext::GetKernelName ( 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 110 of file LocalContext.cc.

References InternalCheckTerminated(), kernelmap, and lock.

                                                          {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         KernelMap::iterator entry = kernelmap.find(kernelkey);
         if (entry == kernelmap.end()) {
             throw std::invalid_argument("No such kernel");
         }
         return entry->second->name;
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::GetNodeKernel ( 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 324 of file LocalContext.cc.

References InternalCheckTerminated(), lock, and nodemap.

Referenced by GetReaderKernel(), and GetWriterKernel().

                                                    {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         NodeMap::iterator entry = nodemap.find(nodekey);
         if (entry == nodemap.end()) {
             throw std::invalid_argument("No such node");
         }
         return entry->second->kernelkey;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Key_t CPN::LocalContext::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 237 of file LocalContext.cc.

References InternalCheckTerminated(), lock, and nodenames.

                                                             {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         NameMap::iterator nameentry = nodenames.find(nodename);
         if (nameentry == nodenames.end()) {
             throw std::invalid_argument("No such node");
         } else {
             return nameentry->second;
         }
     }

Here is the call graph for this function:

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

virtual

Returns: the name associated with the given node key

Exceptions

ShutdownException
std::invalid_argument

Implements CPN::Context.

Definition at line 248 of file LocalContext.cc.

References lock, and nodemap.

                                                      {
         PthreadMutexProtected pl(lock);
         NodeMap::iterator entry = nodemap.find(nodekey);
         if (entry == nodemap.end()) {
             throw std::invalid_argument("No such node");
         }
         return entry->second->name;
     }

Key_t CPN::LocalContext::GetReaderKernel ( 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 366 of file LocalContext.cc.

References GetNodeKernel(), and GetReaderNode().

                                                      {
         Key_t nodekey = GetReaderNode(portkey);
         return GetNodeKernel(nodekey);
     }

Here is the call graph for this function:

std::string CPN::LocalContext::GetReaderName ( 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 371 of file LocalContext.cc.

References InternalCheckTerminated(), lock, and readports.

                                                        {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         PortMap::iterator entry = readports.find(portkey);
         if (entry == readports.end()) {
             throw std::invalid_argument("No such port");
         }
         return entry->second->name;
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::GetReaderNode ( 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 356 of file LocalContext.cc.

References InternalCheckTerminated(), lock, and readports.

Referenced by GetReaderKernel().

                                                    {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         PortMap::iterator entry = readports.find(portkey);
         if (entry == readports.end()) {
             throw std::invalid_argument("No such port");
         }
         return entry->second->nodekey;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Key_t CPN::LocalContext::GetReadersWriter ( 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 447 of file LocalContext.cc.

References InternalCheckTerminated(), lock, and readports.

                                                         {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         PortMap::iterator readentry = readports.find(readerkey);
         if (readentry == readports.end()) {
             throw std::invalid_argument("Read port does not exist.");
         }
         return readentry->second->opposingport;
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::GetWriterKernel ( Key_t portkey )

virtual

See Also: GetReaderKernel

Implements CPN::Context.

Definition at line 413 of file LocalContext.cc.

References GetNodeKernel(), and GetWriterNode().

                                                      {
         Key_t nodekey = GetWriterNode(portkey);
         return GetNodeKernel(nodekey);
     }

Here is the call graph for this function:

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

virtual

See Also: GetReaderName

Implements CPN::Context.

Definition at line 418 of file LocalContext.cc.

References InternalCheckTerminated(), lock, and writeports.

                                                        {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         PortMap::iterator entry = writeports.find(portkey);
         if (entry == writeports.end()) {
             throw std::invalid_argument("No such port");
         }
         return entry->second->name;
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::GetWriterNode ( Key_t portkey )

virtual

See Also: GetReaderNode

Implements CPN::Context.

Definition at line 403 of file LocalContext.cc.

References InternalCheckTerminated(), lock, and writeports.

Referenced by GetWriterKernel().

                                                    {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         PortMap::iterator entry = writeports.find(portkey);
         if (entry == writeports.end()) {
             throw std::invalid_argument("No such port");
         }
         return entry->second->nodekey;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Key_t CPN::LocalContext::GetWritersReader ( 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 457 of file LocalContext.cc.

References InternalCheckTerminated(), lock, and writeports.

                                                         {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         PortMap::iterator writeentry = writeports.find(writerkey);
         if (writeentry == writeports.end()) {
             throw std::invalid_argument("Write port does not exist.");
         }
         return writeentry->second->opposingport;
     }

Here is the call graph for this function:

void CPN::LocalContext::InternalCheckTerminated ( )

private

Definition at line 490 of file LocalContext.cc.

References shutdown.

Referenced by ConnectEndpoints(), CreateNodeKey(), GetCreateReaderKey(), GetCreateWriterKey(), GetKernelConnectionInfo(), GetKernelKey(), GetKernelName(), GetNodeKernel(), GetNodeKey(), GetReaderName(), GetReaderNode(), GetReadersWriter(), GetWriterName(), GetWriterNode(), GetWritersReader(), SendCreateNode(), SendCreateQueue(), SendCreateReader(), SendCreateWriter(), SetupKernel(), SignalKernelStart(), SignalNodeStart(), WaitForKernelStart(), and WaitForNodeStart().

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

Here is the caller graph for this function:

bool CPN::LocalContext::IsTerminated ( )

virtual

Returns: true if Terminate has been called

Implements CPN::Context.

Definition at line 485 of file LocalContext.cc.

References lock, and shutdown.

                                     {
         PthreadMutexProtected pl(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::LocalContext::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 41 of file LocalContext.cc.

References lock, and loglevel.

                                                           {
         PthreadMutexProtected pl(lock);
         if (level >= loglevel) {
             std::cerr << level << ":" << msg << std::endl;
         }
     }

int CPN::LocalContext::LogLevel ( ) const

virtual

Returns: the current log level

Implements LoggerOutput.

Definition at line 48 of file LocalContext.cc.

References lock, and loglevel.

                                      {
         PthreadMutexProtected pl(lock);
         return loglevel;
     }

int CPN::LocalContext::LogLevel ( int level )

virtual

Parameters

level the new log level

Returns: the new log level

Implements LoggerOutput.

Definition at line 53 of file LocalContext.cc.

References lock, and loglevel.

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

Key_t CPN::LocalContext::NewKey ( )

inlineprivate

Definition at line 143 of file LocalContext.h.

Referenced by CreateNodeKey(), GetCreateReaderKey(), GetCreateWriterKey(), and SetupKernel().

143 { return ++counter; }

CPN::LocalContext::counter

Key_t counter

Definition: LocalContext.h:144

Here is the caller graph for this function:

bool CPN::Context::RequireRemote ( )

virtualinherited

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 in CPN::RemoteContextClient.

Definition at line 40 of file Context.cc.

                                 {
         return false;
     }

void CPN::LocalContext::SendCreateNode	(	Key_t	kernelkey,
		const 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 205 of file LocalContext.cc.

References ASSERT, InternalCheckTerminated(), kernelmap, lock, and CPN::KernelBase::RemoteCreateNode().

                                                                            {
         KernelBase *kernel;
         {
             PthreadMutexProtected pl(lock);
             InternalCheckTerminated();
             shared_ptr<KernelInfo> hinfo = kernelmap[kernelkey];
             kernel = hinfo->kernel;
         }
         ASSERT(kernel);
         kernel->RemoteCreateNode(attr);
     }

Here is the call graph for this function:

void CPN::LocalContext::SendCreateQueue	(	Key_t	kernelkey,
		const 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 193 of file LocalContext.cc.

References ASSERT, InternalCheckTerminated(), kernelmap, lock, and CPN::KernelBase::RemoteCreateQueue().

                                                                                    {
         KernelBase *kernel;
         {
             PthreadMutexProtected pl(lock);
             InternalCheckTerminated();
             shared_ptr<KernelInfo> hinfo = kernelmap[kernelkey];
             kernel = hinfo->kernel;
         }
         ASSERT(kernel);
         kernel->RemoteCreateQueue(attr);
     }

Here is the call graph for this function:

void CPN::LocalContext::SendCreateReader	(	Key_t	kernelkey,
		const 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 LocalContext.cc.

References ASSERT, InternalCheckTerminated(), kernelmap, lock, and CPN::KernelBase::RemoteCreateReader().

                                                                                     {
         KernelBase *kernel;
         {
             PthreadMutexProtected pl(lock);
             InternalCheckTerminated();
             shared_ptr<KernelInfo> hinfo = kernelmap[kernelkey];
             kernel = hinfo->kernel;
         }
         ASSERT(kernel);
         kernel->RemoteCreateReader(attr);
     }

Here is the call graph for this function:

void CPN::LocalContext::SendCreateWriter	(	Key_t	kernelkey,
		const 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 169 of file LocalContext.cc.

References ASSERT, InternalCheckTerminated(), kernelmap, lock, and CPN::KernelBase::RemoteCreateWriter().

                                                                                     {
         KernelBase *kernel;
         {
             PthreadMutexProtected pl(lock);
             InternalCheckTerminated();
             shared_ptr<KernelInfo> hinfo = kernelmap[kernelkey];
             kernel = hinfo->kernel;
         }
         ASSERT(kernel);
         kernel->RemoteCreateWriter(attr);
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::SetupKernel	(	const std::string &	name,
		const std::string &	hostname,
		const std::string &	servname,
		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 58 of file LocalContext.cc.

References InternalCheckTerminated(), kernelmap, kernelnames, lock, and NewKey().

                                                            {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         if (!kernel) { throw std::invalid_argument("Must have non null Kernel."); }
         if (kernelnames.find(name) != kernelnames.end()) {
            throw std::invalid_argument("Cannot create two kernels with the same name");
         }
         shared_ptr<KernelInfo> hinfo = shared_ptr<KernelInfo>(new KernelInfo);
         hinfo->name = name;
         hinfo->hostname = hostname;
         hinfo->servname = servname;
         hinfo->kernel = kernel;
         hinfo->dead = false;
         hinfo->live = false;
         hinfo->allowremote = true;
         Key_t key = NewKey();
         kernelmap.insert(std::make_pair(key, hinfo));
         kernelnames.insert(std::make_pair(name, key));
         return key;
     }

Here is the call graph for this function:

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

virtual

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 80 of file LocalContext.cc.

References InternalCheckTerminated(), kernelmap, kernelnames, lock, and NewKey().

                                                                              {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         if (!kernel) { throw std::invalid_argument("Must have non null Kernel."); }
         if (kernelnames.find(name) != kernelnames.end()) {
            throw std::invalid_argument("Cannot create two kernels with the same name");
         }
         shared_ptr<KernelInfo> hinfo = shared_ptr<KernelInfo>(new KernelInfo);
         hinfo->name = name;
         hinfo->kernel = kernel;
         hinfo->dead = false;
         hinfo->live = false;
         hinfo->allowremote = false;
         Key_t key = NewKey();
         kernelmap.insert(std::make_pair(key, hinfo));
         kernelnames.insert(std::make_pair(name, key));
         return key;
 
     }

Here is the call graph for this function:

void CPN::LocalContext::SignalKernelEnd ( 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 132 of file LocalContext.cc.

References PthreadCondition::Broadcast(), kernellivedead, kernelmap, and lock.

                                                       {
         PthreadMutexProtected pl(lock);
         KernelMap::iterator entry = kernelmap.find(kernelkey);
         if (entry == kernelmap.end()) {
             throw std::invalid_argument("No such kernel");
         }
         entry->second->dead = true;
         kernellivedead.Broadcast();
     }

Here is the call graph for this function:

void CPN::LocalContext::SignalKernelStart ( 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 158 of file LocalContext.cc.

References PthreadCondition::Broadcast(), InternalCheckTerminated(), kernellivedead, kernelmap, and lock.

                                                         {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         KernelMap::iterator entry = kernelmap.find(kernelkey);
         if (entry == kernelmap.end()) {
             throw std::invalid_argument("No such kernel");
         }
         entry->second->live = true;
         kernellivedead.Broadcast();
     }

Here is the call graph for this function:

void CPN::LocalContext::SignalNodeEnd ( 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 270 of file LocalContext.cc.

References PthreadCondition::Broadcast(), lock, nodelivedead, nodemap, and numlivenodes.

                                                   {
         PthreadMutexProtected pl(lock);
         NodeMap::iterator entry = nodemap.find(nodekey);
         if (entry == nodemap.end()) {
             throw std::invalid_argument("No such node");
         } else {
             entry->second->dead = true;
             --numlivenodes;
             nodelivedead.Broadcast();
         }
     }

Here is the call graph for this function:

void CPN::LocalContext::SignalNodeStart ( 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 257 of file LocalContext.cc.

References PthreadCondition::Broadcast(), InternalCheckTerminated(), lock, nodelivedead, nodemap, and numlivenodes.

                                                     {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         NodeMap::iterator entry = nodemap.find(nodekey);
         if (entry == nodemap.end()) {
             throw std::invalid_argument("No such node");
         } else {
             entry->second->started = true;
             ++numlivenodes;
             nodelivedead.Broadcast();
         }
     }

Here is the call graph for this function:

void CPN::LocalContext::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 467 of file LocalContext.cc.

References PthreadCondition::Broadcast(), kernellivedead, kernelmap, lock, nodelivedead, and shutdown.

                                  {
         KernelMap mapcopy;
         {
             PthreadMutexProtected pl(lock);
             shutdown = true;
             nodelivedead.Broadcast();
             kernellivedead.Broadcast();
             mapcopy = kernelmap;
         }
         KernelMap::iterator itr = mapcopy.begin();
         while (itr != mapcopy.end()) {
             if (!itr->second->dead) {
                 itr->second->kernel->NotifyTerminate();
             }
             ++itr;
         }
 }

Here is the call graph for this function:

void CPN::LocalContext::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 317 of file LocalContext.cc.

References lock, nodelivedead, numlivenodes, shutdown, and PthreadCondition::Wait().

                                          {
         PthreadMutexProtected pl(lock);
         while (numlivenodes > 0 && !shutdown) {
             nodelivedead.Wait(lock);
         }
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::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 142 of file LocalContext.cc.

References InternalCheckTerminated(), kernellivedead, kernelmap, kernelnames, lock, and PthreadCondition::Wait().

                                                                   {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         while (true) {
             NameMap::iterator entry = kernelnames.find(kernel);
             if (entry != kernelnames.end()) {
                 KernelMap::iterator hentry = kernelmap.find(entry->second);
                 if (hentry->second->live) {
                     return entry->second;
                 }
             }
             kernellivedead.Wait(lock);
             InternalCheckTerminated();
         }
     }

Here is the call graph for this function:

void CPN::LocalContext::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 300 of file LocalContext.cc.

References ASSERT, lock, nodelivedead, nodemap, nodenames, shutdown, and PthreadCondition::Wait().

                                                                {
         PthreadMutexProtected pl(lock);
         while (!shutdown) {
             NameMap::iterator nameentry = nodenames.find(nodename);
             if (nameentry != nodenames.end()) {
                 NodeMap::iterator entry = nodemap.find(nameentry->second);
                 if (entry != nodemap.end()) {
                     if (entry->second->dead) {
                         ASSERT(entry->second->started, "Node died before it started!?");
                         return;
                     }
                 }
             }
             nodelivedead.Wait(lock);
         }
     }

Here is the call graph for this function:

Key_t CPN::LocalContext::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 282 of file LocalContext.cc.

References InternalCheckTerminated(), lock, nodelivedead, nodemap, nodenames, and PthreadCondition::Wait().

                                                                   {
         PthreadMutexProtected pl(lock);
         InternalCheckTerminated();
         while (true) {
             NameMap::iterator nameentry = nodenames.find(nodename);
             if (nameentry != nodenames.end()) {
                 NodeMap::iterator entry = nodemap.find(nameentry->second);
                 if (entry != nodemap.end()) {
                     if (entry->second->started) {
                         return entry->first;
                     }
                 }
             }
             nodelivedead.Wait(lock);
             InternalCheckTerminated();
         }
     }