Specialization of a local node. More...

#include <localNode.h>

Inheritance diagram for co::LocalNode:

Collaboration diagram for co::LocalNode:

Classes
class	CommandThread
	The command handler thread.
class	ReceiverThread
	The receiver thread.
Public Member Functions
CO_API void	ackRequest (NodePtr node, const uint32_t requestID)
State Changes
The following methods affect the state of the node by changing its connectivity to the network.
virtual CO_API bool	initLocal (const int argc, char **argv)
	Initialize the node.
virtual CO_API bool	listen ()
	Open all connections and put this node into the listening state.
virtual CO_API bool	close ()
	Close a listening node.
virtual bool	exitLocal ()
	Close a listening node.
CO_API bool	connect (NodePtr node)
	Connect a proxy node to this listening node.
CO_API NodePtr	connect (const NodeID &nodeID)
	Create and connect a node given by an identifier.
virtual CO_API bool	disconnect (NodePtr node)
	Disconnects a connected node.
Object Registry
CO_API void	disableInstanceCache ()
	Disable the instance cache of a stopped local node.
CO_API void	expireInstanceData (const int64_t age)
CO_API void	enableSendOnRegister ()
	Enable sending instance data after registration.
CO_API void	disableSendOnRegister ()
	Disable sending data of newly registered objects when idle.
CO_API bool	registerObject (Object *object)
	Register a distributed object.
virtual CO_API void	deregisterObject (Object *object)
	Deregister a distributed object.
CO_API bool	mapObject (Object *object, const base::UUID &id, const uint128_t &version=VERSION_OLDEST)
	Map a distributed object.
bool	mapObject (Object *object, const ObjectVersion &v)
	Convenience wrapper for mapObject().
CO_API uint32_t	mapObjectNB (Object *object, const base::UUID &id, const uint128_t &version=VERSION_OLDEST)
	Start mapping a distributed object.
CO_API uint32_t	mapObjectNB (Object *object, const base::UUID &id, const uint128_t &version, NodePtr master)
	Start mapping a distributed object from a known master.
CO_API bool	mapObjectSync (const uint32_t requestID)
	Finalize the mapping of a distributed object.
CO_API void	unmapObject (Object *object)
	Unmap a mapped object.
CO_API void	releaseObject (Object *object)
	Convenience method to deregister or unmap an object.
CO_API void	swapObject (Object oldObject, Object newObject)
Data Access
CO_API NodePtr	getNode (const NodeID &id) const
	Get a node by identifier.
void	getNodes (Nodes &nodes, const bool addSelf=true) const
	Assemble a vector of the currently connected nodes.
CO_API void	acquireSendToken (NodePtr toNode)
CO_API void	releaseSendToken (NodePtr toNode)
virtual CommandQueue *	getCommandThreadQueue ()
	Return the command queue to the command thread.
bool	inCommandThread () const
Operations
CO_API void	addListener (ConnectionPtr connection)
	Add a listening connection to this listening node.
CO_API uint32_t	removeListenerNB (ConnectionPtr connection)
	Remove a listening connection from this listening node.
void	flushCommands ()
	Flush all pending commands on this listening node.
Command &	cloneCommand (Command &command)
CO_API Command &	allocCommand (const uint64_t size)
CO_API bool	dispatchCommand (Command &command)
	Dispatches a packet to the registered command queue.
Protected Member Functions
CO_API bool	_connect (NodePtr node, ConnectionPtr connection)
	Connect a node proxy to this node.
Friends
class	ObjectStore

Detailed Description

Specialization of a local node.

Local nodes listen on network connections, manage connections to other nodes and provide session registration, mapping and command dispatch.

Definition at line 53 of file localNode.h.

Member Function Documentation

CO_API bool co::LocalNode::_connect	(	NodePtr	node,
		ConnectionPtr	connection
	)		`[protected]`

Connect a node proxy to this node.

This node has to be in the listening state. The node proxy will be put in the connected state upon success. The connection has to be connected.

Parameters:

node	the remote node.
connection	the connection to the remote node.

Returns:: true if the node was connected correctly, false otherwise.

CO_API void co::LocalNode::addListener ( ConnectionPtr connection )

Add a listening connection to this listening node.

virtual CO_API bool co::LocalNode::close ( ) [virtual]

Close a listening node.

Disconnects all connected node proxies, closes the listening connections and terminates all threads created in listen().

Returns:: true if the node was stopped, false if it was not stopped.

Referenced by exitLocal().

Here is the caller graph for this function:

CO_API bool co::LocalNode::connect ( NodePtr node )

Connect a proxy node to this listening node.

The connection descriptions of the node are used to connect the node. On success, the node is in the connected state, otherwise its state is unchanged.

This method is one-sided, that is, the node to be connected should not initiate a connection to this node at the same time.

Parameters:

node	the remote node.

Returns:: true if this node was connected, false otherwise.

See also:: initConnect, syncConnect

CO_API NodePtr co::LocalNode::connect ( const NodeID & nodeID )

Create and connect a node given by an identifier.

This method is two-sided and thread-safe, that is, it can be called by mulltiple threads on the same node with the same nodeID, or concurrently on two nodes with each others' nodeID.

Parameters:

nodeID the identifier of the node to connect.

Returns:: the connected node, or an invalid RefPtr if the node could not be connected.

virtual CO_API void co::LocalNode::deregisterObject ( Object * object ) [virtual]

Deregister a distributed object.

Parameters:

object the object instance.

CO_API void co::LocalNode::disableInstanceCache ( )

Disable the instance cache of a stopped local node.

CO_API void co::LocalNode::disableSendOnRegister ( )

Disable sending data of newly registered objects when idle.

virtual CO_API bool co::LocalNode::disconnect ( NodePtr node ) [virtual]

Disconnects a connected node.

Parameters:

node	the remote node.

Returns:: true if the node was disconnected correctly, false otherwise.

CO_API bool co::LocalNode::dispatchCommand ( Command & command ) [virtual]

Dispatches a packet to the registered command queue.

Parameters:

command the command.

Returns:: the result of the operation.

See also:: Command::invoke

Reimplemented from co::Dispatcher.

Reimplemented in eq::fabric::Client.

CO_API void co::LocalNode::enableSendOnRegister ( )

Enable sending instance data after registration.

Send-on-register starts transmitting instance data of registered objects directly after they have been registered. The data is cached on remote nodes and accelerates object mapping. Send-on-register should not be active when remote nodes are joining a multicast group of this node, since they will potentially read out-of-order data streams on the multicast connection.

Enable and disable are counted, that is, the last disable on a matched series of enable/disable will be effective. The disable is completely synchronous, that is, no more instance data will be sent after an effective disable.

void co::LocalNode::flushCommands ( ) [inline]

Flush all pending commands on this listening node.

This causes the receiver thread to redispatch all pending commands, which are normally only redispatched when a new command is received.

Definition at line 314 of file localNode.h.

References co::ConnectionSet::interrupt().

Here is the call graph for this function:

virtual CommandQueue* co::LocalNode::getCommandThreadQueue ( ) [inline, virtual]

Return the command queue to the command thread.

Definition at line 290 of file localNode.h.

CO_API NodePtr co::LocalNode::getNode ( const NodeID & id ) const

Get a node by identifier.

The node might not be connected.

Parameters:

id	the node identifier.

Returns:: the node.

void co::LocalNode::getNodes	(	Nodes &	nodes,
		const bool	addSelf = `true`
	)		const

Assemble a vector of the currently connected nodes.

bool co::LocalNode::inCommandThread ( ) const [inline]

Returns:: true if executed from the command handler thread, false if not.

Definition at line 297 of file localNode.h.

virtual CO_API bool co::LocalNode::initLocal	(	const int	argc,
		char **	argv
	)		`[virtual]`

Initialize the node.

Before calling listen(), the '--eq-listen <connection description>' command line options is recognized by this method to add listening connections to this node. This parameter might be used multiple times. ConnectionDescription::fromString() is used to parse the provided description.

Please note that further command line parameters are recognized by eq::init().

Parameters:

argc	the command line argument count.
argv	the command line argument values.

Returns:: true if the client was successfully initialized, false otherwise.

Reimplemented in eq::Client.

virtual CO_API bool co::LocalNode::listen ( ) [virtual]

Open all connections and put this node into the listening state.

The node will spawn a receiver and command thread, and listen on all connections for incoming commands. The node will be in the listening state if the method completed successfully. A listening node can connect other nodes.

Returns:: true if the node could be initialized, false if not.

See also:: connect

bool co::LocalNode::mapObject	(	Object *	object,
		const ObjectVersion &	v
	)		`[inline]`

Convenience wrapper for mapObject().

Definition at line 239 of file localNode.h.

References mapObject().

Referenced by mapObject().

Here is the call graph for this function:

Here is the caller graph for this function:

CO_API bool co::LocalNode::mapObject	(	Object *	object,
		const base::UUID &	id,
		const uint128_t &	version = `VERSION_OLDEST`
	)

Map a distributed object.

The mapped object becomes a slave instance of the master version which was registered with the provided identifier. The given version can be used to map a specific version.

If VERSION_NONE is provided, the slave instance is not initialized with any data from the master. This is useful if the object has been pre-initialized by other means, for example from a shared file system.

If VERSION_OLDEST is provided, the oldest available version is mapped.

If a concrete requested version no longer exists, mapObject() will map the oldest available version.

If the requested version is newer than the head version, mapObject() will block until the requested version is available.

Mapping an object is a potentially time-consuming operation. Using mapObjectNB() and mapObjectSync() to asynchronously map multiple objects in parallel improves performance of this operation.

Parameters:

object	the object.
id	the master object identifier.
version	the initial version.

Returns:: true if the object was mapped, false if the master of the object is not found or the requested version is no longer available.

See also:: registerObject

CO_API uint32_t co::LocalNode::mapObjectNB	(	Object *	object,
		const base::UUID &	id,
		const uint128_t &	version = `VERSION_OLDEST`
	)

Start mapping a distributed object.

See also:: mapObject()

CO_API uint32_t co::LocalNode::mapObjectNB	(	Object *	object,
		const base::UUID &	id,
		const uint128_t &	version,
		NodePtr	master
	)

Start mapping a distributed object from a known master.

See also:: mapObject()

CO_API bool co::LocalNode::mapObjectSync ( const uint32_t requestID )

Finalize the mapping of a distributed object.

CO_API bool co::LocalNode::registerObject ( Object * object )

Register a distributed object.

Registering a distributed object makes this object the master version. The object's identifier is used to map slave instances of the object. Master versions of objects are typically writable and can commit new versions of the distributed object.

Parameters:

object the object instance.

Returns:: true if the object was registered, false otherwise.

CO_API void co::LocalNode::releaseObject ( Object * object )

Convenience method to deregister or unmap an object.

CO_API uint32_t co::LocalNode::removeListenerNB ( ConnectionPtr connection )

Remove a listening connection from this listening node.

CO_API void co::LocalNode::unmapObject ( Object * object )

Unmap a mapped object.

Parameters:

object the mapped object.

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

localNode.h

co::LocalNode Class Reference

Classes

Public Member Functions

Protected Member Functions

Friends

Detailed Description

Member Function Documentation