MIRA
Classes | Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | List of all members
RemoteConnection Class Referenceabstract

Base class of connections between frameworks. More...

#include <fw/RemoteConnection.h>

Inheritance diagram for RemoteConnection:
Inheritance graph
[legend]

Classes

class  RPCRemoteFinishHandler
 RPCHandler for getting notified when an rpc call on server side is finished and the response is ready. More...
 
class  RPCRemoteRequestHandler
 RPCHandler for sending a rpc call to the server side. More...
 
struct  SendData
 

Public Types

typedef std::map< std::string, TypenameChannelTypeMap
 
typedef std::set< std::string > StringSet
 
typedef std::map< std::string, SendDataChannelSendMap
 
typedef std::set< std::string > MetaSet
 
typedef std::list< AuthorityDescriptionAuthorityDescriptions
 

Public Member Functions

virtual ~RemoteConnection ()
 Destructor. More...
 
template<typename Reflector >
void reflect (Reflector &r)
 
boost::asio::ip::tcp::socket & getSocket ()
 Returns the network socket of this connection. More...
 
virtual void start ()
 Starts the connection. Can be implemented in derived classes. More...
 
void stop ()
 Close the socket. More...
 
void onConnect (bool enablePTPTimeSync, bool enablePingTimeout)
 Called by RemoteModule::onIncomingConnected/onOutgoingConnected. More...
 
bool isPTPSyncEnabled ()
 Is synchronization of clocks via PTP enabled? More...
 
bool isPingTimeoutEnabled ()
 Is ping timeout enabled? More...
 
void startTimeSync ()
 Create a timer to frequently call syncTime. More...
 
bool isSynchronized () const
 synchronizeFrameworks() was executed. More...
 
virtual void publishChannels (const ChannelTypeMap &channels)=0
 Notifies the connected framework that we have at least one publisher for each of the channels in the channels map. More...
 
void unpublishChannel (const std::string &channel)
 Notifies the connected framework that we no longer have a publisher for the given channel. More...
 
virtual void subscribeChannel (const std::string &channelID, const ServiceLevel &serviceLevel)=0
 Notify the connected remote frameworks that we have a subscriber for the given channel (assuming it has a publisher for it). More...
 
virtual void publishAuthorities (const AuthorityDescriptions &authorities)=0
 Notifies the connected framework that the authorities in the authorities map exist in our framework. More...
 
virtual void unpublishAuthorities (const AuthorityDescriptions &authorities)=0
 Notifies the connected framework that the authorities in the authorities map do not longer exist in our framework. More...
 
void migrateUnit (const std::string &id)
 Send a request to the connected framework to transfer ownership of a unit to this framework. More...
 
bool hasAuthority (const std::string &id) const
 Check if a authority with given full id exists in the connected framework. More...
 
virtual void publishServices (const StringSet &services)=0
 Notifies the connected framework that the services in the services set exist in our framework. More...
 
virtual void unpublishServices (const StringSet &services)=0
 Notifies the connected framework that the services in the services set do not longer exist in our framework. More...
 
template<typename BufferSequence >
void write (const BufferSequence &buffers)
 Send data in the buffers to the connected framework. More...
 
UUID getRemoteID () const
 
std::string getGlobalID () const
 
void setAuthority (std::unique_ptr< Authority > auth)
 
const std::string & getFrameworkID () const
 
const KnownFrameworkgetAddress () const
 
void setAddress (const KnownFramework &addr)
 
void setAutoReconnect (bool autoReconnect)
 
Class const & getClass () const
 call the virtual internalGetClass(). More...
 

Static Public Member Functions

static PseudoClass const & CLASS ()
 

Protected Types

enum  AuthState {
  AUTHSTATE_NONE, AUTHSTATE_CONNECTING, AUTHSTATE_AUTHENTICATING, AUTHSTATE_ACCEPTED,
  AUTHSTATE_DENIED
}
 
typedef std::pair< FrameworkMessageType, Buffer< uint8 > > RPCMessage
 

Protected Member Functions

 RemoteConnection ()
 Constructs a remote connection that uses its own io service. More...
 
 RemoteConnection (boost::asio::io_service &service)
 Constructs a remote connection that uses a given io service. More...
 
virtual void onDisconnect ()
 Called in stop() when connection is about to be stopped. More...
 
virtual void onWriteError (boost::system::system_error &e)
 Called when writing to the socket failed. Can be implemented in derived classes. More...
 
void syncTime ()
 Time synchronization between frameworks. More...
 
void sendPTP ()
 Sends a PTP command used for time synchronization between frameworks. More...
 
void ping ()
 Sends a ping command. More...
 
bool hasPingTimeout () const
 Check if the connection incoming ping's are still alive. More...
 
void writeMessage (FrameworkMessageType msg)
 Writes a message to the other framework. More...
 
template<typename Arg , typename... Args>
void writeMessage (FrameworkMessageType msg, Arg &&arg, Args &&... args)
 Writes a message to the other framework. More...
 
template<typename BufferType >
void writeMessageFromBuffer (FrameworkMessageType msg, const BufferType &buffer)
 Writes a message to the other framework. More...
 
template<typename DataType >
void writeMessageFromData (FrameworkMessageType msg, const DataType &data)
 Writes a message to the other framework. More...
 
void queueRPCMessage (FrameworkMessageType msg, Buffer< uint8 > &&answer)
 Queue an outgoing RPC request or RPC response to be transmitted in a separate thread. More...
 
void valueChanged (ChannelRead< void > value, ServiceLevel &serviceLevel)
 Channel callback method that gets registered on each channel the connected framework subscribes. More...
 
void parseMessage ()
 Parses an incoming message (stored in mMessage) and calls the respective receivedXXX method. More...
 
void receivedPTPFollowUp (uint64 timestamp)
 
void receivedPTPDelayResponse (uint64 timestamp)
 
void receivedPTPDelayRequest (uint64 timestamp)
 
void receivedPTPFinish ()
 
void receivedSubscribeChannelRequest ()
 
void receivedUnsubscribeChannelRequest (const std::string &channelID)
 
void receivedPublishChannelMsg ()
 
void receivedUnpublishChannelMsg ()
 
void receivedPublishAuthorityMsg ()
 
void receivedUnpublishAuthorityMsg ()
 
virtual void receivedPublishServiceMsg ()=0
 
void receivedUnpublishServiceMsg ()
 
void receivedWriteChannelMsg ()
 
virtual void receivedRPCRequestMsg ()=0
 
virtual void receivedRPCResponseMsg ()=0
 
void receivedRequestMigrationMsg ()
 
void receivedMigrationMsg ()
 
void receivedMigrationSinkSuccessMsg ()
 
void receivedMigrationSinkFailureMsg ()
 
void receivedMigrationFinishedMsg ()
 
void receivedTypeMetaMsg ()
 
void receivedChannelMetaMsg ()
 
void receivedPingMsg ()
 
virtual void sendData (ChannelRead< void > value, ServiceLevel &serviceLevel)
 
virtual int addBinaryFormatVersion (Buffer< uint8 > &data)=0
 
void synchronizeFrameworks ()
 
void updateOutgoingStats (std::size_t size)
 
bool checkMessageHeader () const
 Returns true, if the message (header) is valid, i.e. More...
 
void sendConnectDenied (const std::string &msg)
 
void sendRPCMessagesThread ()
 
void processPingThread ()
 
void checkPingTimeoutThread ()
 
void sendChannelUpdatesThread ()
 
virtual Class const & internalGetClass () const =0
 

Protected Attributes

KnownFramework address
 The address of the connected framework. More...
 
UUID remoteID
 The UUID of the connected framework. More...
 
std::string frameworkID
 The ID/Name of the connected framework. More...
 
uint32 remoteVersion
 The protocol version of the connected framework. More...
 
std::unique_ptr< Authorityauthority
 Our authority used for subscribing to data. More...
 
ChannelSendMap subscriptions
 List of channels the connected framework is subscribed to + what was sent to them. More...
 
MetaSet sentMetaInformation
 Set of type meta information already sent. More...
 
StringSet publishedServices
 List of services of the connected framework. More...
 
Time synchronizedTime
 Time when the connection was fully established (e.g. PTP synchronized) More...
 
bool mEnablePTPSync
 PTP Sync enabled for this connection? More...
 
bool mEnablePingTimeout
 Ping timeout enabled for this connection? More...
 
TimeOffsetCompensation clockOffset
 The clock offset between us and the connected framework. More...
 
IOService mService
 
boost::asio::ip::tcp::socket mSocket
 
boost::condition_variable mRPCMessagesCondition
 
boost::mutex mWriteMutex
 
boost::mutex mStopMutex
 
TimerPtr mSyncTimeTimer
 
boost::thread mSendRPCMessagesThread
 
boost::thread mProcessPingThread
 
boost::thread mCheckPingTimeoutThread
 
boost::thread mSendChannelUpdatesThread
 
Time mHeaderReceived
 
FrameworkMessageHeader mHeader
 
Buffer< uint8 > mMessage
 
AuthState mAuthState
 
std::string mAuthSignMsg
 
bool mPTPOutgoing
 
Time mPTPSyncLocal
 
Time mPTPSyncRemote
 
Time mPTPDelayLocal
 
Time mPTPDelayRemote
 
Time mLastPTP
 
Time mPingLastSend
 
Time mPingLastReceived
 
boost::shared_ptr< MicroUnitmMigrationUnit
 
std::string mMigrationNS
 
std::string mMigrationID
 
bool mStopped
 
boost::shared_ptr< RPCRemoteFinishHandlermRPCFinishHandler
 
boost::shared_ptr< RPCRemoteRequestHandlermRPCRequestHandler
 
std::map< std::string, boost::shared_ptr< RemoteAuthority > > mRemoteAuthorities
 
std::list< RPCMessagemOutgoingRPCMessages
 
boost::mutex mRPCMessagesMutex
 
std::unordered_map< std::string, ServiceLevelmPendingChannelUpdates
 
boost::mutex mChannelUpdatesMutex
 

Detailed Description

Base class of connections between frameworks.

If PTP synchronization is enabled for a connection, the protocol for establishing a time sync (determining a time offset) between two connected frameworks is as follows:

Framework A Framework B
| |
|--------------------------------------------------->| take timestamp
take timestamp | | as PTPSyncLocal (T1')
| PTP_FOLLOW_UP_MSG: timestamp |
|--------------------------------------------------->| store received timestamp
| | as PTPSyncRemote (T1)
| PTP_DELAY_REQUEST_MSG |
|<---------------------------------------------------|
take timestamp | | take timestamp
| | as PTPDelayLocal (T2)
| PTP_DELAY_RESPONSE_MSG: timestamp |
|--------------------------------------------------->| store received timestamp
| | as PTPDelayRemote (T2'),
| | calculate offset
| | = (T1'-T1-T2'+T2)/2
|<---------------------------------------------------|
| |
| PUBLISH_CHANNEL_MSG: channels |
|--------------------------------------------------->|
| PUBLISH_SERVICE_MSG: services |
|--------------------------------------------------->|
| PUBLISH_AUTHORITY_MSG: authorities |
|--------------------------------------------------->|

If PTP synchronization is not enabled, the PUBLISH_CHANNEL/SERVICE/AUTHORITY_MSG messages are sent immediately.

Member Typedef Documentation

◆ ChannelTypeMap

typedef std::map<std::string, Typename> ChannelTypeMap

◆ StringSet

typedef std::set<std::string> StringSet

◆ ChannelSendMap

typedef std::map<std::string, SendData> ChannelSendMap

◆ MetaSet

typedef std::set<std::string> MetaSet

◆ AuthorityDescriptions

◆ RPCMessage

typedef std::pair<FrameworkMessageType, Buffer<uint8> > RPCMessage
protected

Member Enumeration Documentation

◆ AuthState

enum AuthState
protected
Enumerator
AUTHSTATE_NONE 
AUTHSTATE_CONNECTING 
AUTHSTATE_AUTHENTICATING 
AUTHSTATE_ACCEPTED 
AUTHSTATE_DENIED 

Constructor & Destructor Documentation

◆ RemoteConnection() [1/2]

RemoteConnection ( )
protected

Constructs a remote connection that uses its own io service.

run()/runThreads() must be called on the service by the subclass!

◆ RemoteConnection() [2/2]

RemoteConnection ( boost::asio::io_service &  service)
protected

Constructs a remote connection that uses a given io service.

run()/runThreads() must be called on the service by the owner!

◆ ~RemoteConnection()

virtual ~RemoteConnection ( )
virtual

Destructor.

Member Function Documentation

◆ reflect()

void reflect ( Reflector &  r)
inline

◆ getSocket()

boost::asio::ip::tcp::socket& getSocket ( )
inline

Returns the network socket of this connection.

◆ start()

virtual void start ( )
virtual

Starts the connection. Can be implemented in derived classes.

Reimplemented in RemoteOutgoingConnectionBase, and RemoteIncomingConnection.

◆ stop()

void stop ( )

Close the socket.

◆ onConnect()

void onConnect ( bool  enablePTPTimeSync,
bool  enablePingTimeout 
)

Called by RemoteModule::onIncomingConnected/onOutgoingConnected.

Provides the RemoteModule settings for enabling PTP sync and ping timeout, which should be kept by the RemoteConnection through its lifetime.

◆ isPTPSyncEnabled()

bool isPTPSyncEnabled ( )
inline

Is synchronization of clocks via PTP enabled?

◆ isPingTimeoutEnabled()

bool isPingTimeoutEnabled ( )
inline

Is ping timeout enabled?

◆ startTimeSync()

void startTimeSync ( )

Create a timer to frequently call syncTime.

Time sync must be completed at least once before data is transmitted (if ping timeout is enabled in the RemoteModule, time sync is automatically done in the ping thread and the timer should not be created).

◆ isSynchronized()

bool isSynchronized ( ) const
inline

synchronizeFrameworks() was executed.

The connection is fully established, time was synchronized at least once (if enabled and required) and authorities/channels/services have been published to the remote framework (unless monitor-only).

◆ publishChannels()

virtual void publishChannels ( const ChannelTypeMap channels)
pure virtual

Notifies the connected framework that we have at least one publisher for each of the channels in the channels map.

Implemented in ConcreteRemoteConnection< BinaryFormatVersion >, and ConcreteRemoteConnection< 2 >.

◆ unpublishChannel()

void unpublishChannel ( const std::string &  channel)

Notifies the connected framework that we no longer have a publisher for the given channel.

◆ subscribeChannel()

virtual void subscribeChannel ( const std::string &  channelID,
const ServiceLevel serviceLevel 
)
pure virtual

Notify the connected remote frameworks that we have a subscriber for the given channel (assuming it has a publisher for it).

Implemented in ConcreteRemoteConnection< BinaryFormatVersion >, and ConcreteRemoteConnection< 2 >.

◆ publishAuthorities()

virtual void publishAuthorities ( const AuthorityDescriptions authorities)
pure virtual

Notifies the connected framework that the authorities in the authorities map exist in our framework.

Implemented in ConcreteRemoteConnection< BinaryFormatVersion >, and ConcreteRemoteConnection< 2 >.

◆ unpublishAuthorities()

virtual void unpublishAuthorities ( const AuthorityDescriptions authorities)
pure virtual

Notifies the connected framework that the authorities in the authorities map do not longer exist in our framework.

Implemented in ConcreteRemoteConnection< BinaryFormatVersion >, and ConcreteRemoteConnection< 2 >.

◆ migrateUnit()

void migrateUnit ( const std::string &  id)

Send a request to the connected framework to transfer ownership of a unit to this framework.

◆ hasAuthority()

bool hasAuthority ( const std::string &  id) const

Check if a authority with given full id exists in the connected framework.

◆ publishServices()

virtual void publishServices ( const StringSet services)
pure virtual

Notifies the connected framework that the services in the services set exist in our framework.

Implemented in ConcreteRemoteConnection< BinaryFormatVersion >, and ConcreteRemoteConnection< 2 >.

◆ unpublishServices()

virtual void unpublishServices ( const StringSet services)
pure virtual

Notifies the connected framework that the services in the services set do not longer exist in our framework.

Implemented in ConcreteRemoteConnection< BinaryFormatVersion >, and ConcreteRemoteConnection< 2 >.

◆ write()

void write ( const BufferSequence &  buffers)
inline

Send data in the buffers to the connected framework.

Parameters
[in]buffersThe data to send

◆ getRemoteID()

UUID getRemoteID ( ) const
inline

◆ getGlobalID()

std::string getGlobalID ( ) const
inline

◆ setAuthority()

void setAuthority ( std::unique_ptr< Authority auth)
inline

◆ getFrameworkID()

const std::string& getFrameworkID ( ) const
inline

◆ getAddress()

const KnownFramework& getAddress ( ) const
inline

◆ setAddress()

void setAddress ( const KnownFramework addr)
inline

◆ setAutoReconnect()

void setAutoReconnect ( bool  autoReconnect)
inline

◆ onDisconnect()

virtual void onDisconnect ( )
inlineprotectedvirtual

Called in stop() when connection is about to be stopped.

Can be implemented in derived classes.

Reimplemented in RemoteOutgoingConnectionBase, and RemoteIncomingConnection.

◆ onWriteError()

virtual void onWriteError ( boost::system::system_error &  e)
inlineprotectedvirtual

Called when writing to the socket failed. Can be implemented in derived classes.

Reimplemented in RemoteOutgoingConnectionBase.

◆ syncTime()

void syncTime ( )
protected

Time synchronization between frameworks.

For local connected frameworks the method synchronizeFrameworks will be called. For frameworks on remote hosts sendPTP will be called.

◆ sendPTP()

void sendPTP ( )
protected

Sends a PTP command used for time synchronization between frameworks.

◆ ping()

void ping ( )
protected

Sends a ping command.

This method ensures, that the ping is not send more than the configured interval in the RemoteModule.

◆ hasPingTimeout()

bool hasPingTimeout ( ) const
protected

Check if the connection incoming ping's are still alive.

◆ writeMessage() [1/2]

void writeMessage ( FrameworkMessageType  msg)
inlineprotected

Writes a message to the other framework.

This method takes just the message type.

◆ writeMessage() [2/2]

void writeMessage ( FrameworkMessageType  msg,
Arg &&  arg,
Args &&...  args 
)
inlineprotected

Writes a message to the other framework.

This method takes the message type and a variable number of parameters that are sent within the message.

◆ writeMessageFromBuffer()

void writeMessageFromBuffer ( FrameworkMessageType  msg,
const BufferType &  buffer 
)
inlineprotected

Writes a message to the other framework.

Instead of writing parameters into a buffer for generating the message, this method expects a buffer as parameter directly, e.g. created by serializing data.

◆ writeMessageFromData()

void writeMessageFromData ( FrameworkMessageType  msg,
const DataType &  data 
)
inlineprotected

Writes a message to the other framework.

Instead of writing the parameter into a buffer for generating the message, (as writeMessage does), this method uses the parameter memory location directly.

◆ queueRPCMessage()

void queueRPCMessage ( FrameworkMessageType  msg,
Buffer< uint8 > &&  answer 
)
protected

Queue an outgoing RPC request or RPC response to be transmitted in a separate thread.

msg must be either RPC_RESPONSE_MSG or RPC_REQUEST_MSG

◆ valueChanged()

void valueChanged ( ChannelRead< void >  value,
ServiceLevel serviceLevel 
)
protected

Channel callback method that gets registered on each channel the connected framework subscribes.

When data in the channel changes it is sent to the connected framework.

◆ parseMessage()

void parseMessage ( )
protected

Parses an incoming message (stored in mMessage) and calls the respective receivedXXX method.

◆ receivedPTPFollowUp()

void receivedPTPFollowUp ( uint64  timestamp)
protected

◆ receivedPTPDelayResponse()

void receivedPTPDelayResponse ( uint64  timestamp)
protected

◆ receivedPTPDelayRequest()

void receivedPTPDelayRequest ( uint64  timestamp)
protected

◆ receivedPTPFinish()

void receivedPTPFinish ( )
protected

◆ receivedSubscribeChannelRequest()

void receivedSubscribeChannelRequest ( )
protected

◆ receivedUnsubscribeChannelRequest()

void receivedUnsubscribeChannelRequest ( const std::string &  channelID)
protected

◆ receivedPublishChannelMsg()

void receivedPublishChannelMsg ( )
protected

◆ receivedUnpublishChannelMsg()

void receivedUnpublishChannelMsg ( )
protected

◆ receivedPublishAuthorityMsg()

void receivedPublishAuthorityMsg ( )
protected

◆ receivedUnpublishAuthorityMsg()

void receivedUnpublishAuthorityMsg ( )
protected

◆ receivedPublishServiceMsg()

virtual void receivedPublishServiceMsg ( )
protectedpure virtual

◆ receivedUnpublishServiceMsg()

void receivedUnpublishServiceMsg ( )
protected

◆ receivedWriteChannelMsg()

void receivedWriteChannelMsg ( )
protected

◆ receivedRPCRequestMsg()

virtual void receivedRPCRequestMsg ( )
protectedpure virtual

◆ receivedRPCResponseMsg()

virtual void receivedRPCResponseMsg ( )
protectedpure virtual

◆ receivedRequestMigrationMsg()

void receivedRequestMigrationMsg ( )
protected

◆ receivedMigrationMsg()

void receivedMigrationMsg ( )
protected

◆ receivedMigrationSinkSuccessMsg()

void receivedMigrationSinkSuccessMsg ( )
protected

◆ receivedMigrationSinkFailureMsg()

void receivedMigrationSinkFailureMsg ( )
protected

◆ receivedMigrationFinishedMsg()

void receivedMigrationFinishedMsg ( )
protected

◆ receivedTypeMetaMsg()

void receivedTypeMetaMsg ( )
protected

◆ receivedChannelMetaMsg()

void receivedChannelMetaMsg ( )
protected

◆ receivedPingMsg()

void receivedPingMsg ( )
protected

◆ sendData()

virtual void sendData ( ChannelRead< void >  value,
ServiceLevel serviceLevel 
)
inlineprotectedvirtual

◆ addBinaryFormatVersion()

virtual int addBinaryFormatVersion ( Buffer< uint8 > &  data)
protectedpure virtual

◆ synchronizeFrameworks()

void synchronizeFrameworks ( )
protected

◆ updateOutgoingStats()

void updateOutgoingStats ( std::size_t  size)
protected

◆ checkMessageHeader()

bool checkMessageHeader ( ) const
protected

Returns true, if the message (header) is valid, i.e.

if the specified message length does not exceed a max size and the message type is known. This is used to prevent Denial of Service attacks.

◆ sendConnectDenied()

void sendConnectDenied ( const std::string &  msg)
protected

◆ sendRPCMessagesThread()

void sendRPCMessagesThread ( )
protected

◆ processPingThread()

void processPingThread ( )
protected

◆ checkPingTimeoutThread()

void checkPingTimeoutThread ( )
protected

◆ sendChannelUpdatesThread()

void sendChannelUpdatesThread ( )
protected

◆ getClass()

Class const& getClass ( ) const
inlineinherited

call the virtual internalGetClass().

◆ CLASS()

static PseudoClass const& CLASS ( )
inlinestaticinherited

◆ internalGetClass()

virtual Class const& internalGetClass ( ) const
protectedpure virtualinherited

Member Data Documentation

◆ address

KnownFramework address
protected

The address of the connected framework.

◆ remoteID

UUID remoteID
protected

The UUID of the connected framework.

◆ frameworkID

std::string frameworkID
protected

The ID/Name of the connected framework.

◆ remoteVersion

uint32 remoteVersion
protected

The protocol version of the connected framework.

◆ authority

std::unique_ptr<Authority> authority
protected

Our authority used for subscribing to data.

◆ subscriptions

ChannelSendMap subscriptions
protected

List of channels the connected framework is subscribed to + what was sent to them.

◆ sentMetaInformation

MetaSet sentMetaInformation
protected

Set of type meta information already sent.

◆ publishedServices

StringSet publishedServices
protected

List of services of the connected framework.

◆ synchronizedTime

Time synchronizedTime
protected

Time when the connection was fully established (e.g. PTP synchronized)

◆ mEnablePTPSync

bool mEnablePTPSync
protected

PTP Sync enabled for this connection?

◆ mEnablePingTimeout

bool mEnablePingTimeout
protected

Ping timeout enabled for this connection?

◆ clockOffset

TimeOffsetCompensation clockOffset
protected

The clock offset between us and the connected framework.

◆ mService

IOService mService
protected

◆ mSocket

boost::asio::ip::tcp::socket mSocket
protected

◆ mRPCMessagesCondition

boost::condition_variable mRPCMessagesCondition
protected

◆ mWriteMutex

boost::mutex mWriteMutex
protected

◆ mStopMutex

boost::mutex mStopMutex
protected

◆ mSyncTimeTimer

TimerPtr mSyncTimeTimer
protected

◆ mSendRPCMessagesThread

boost::thread mSendRPCMessagesThread
protected

◆ mProcessPingThread

boost::thread mProcessPingThread
protected

◆ mCheckPingTimeoutThread

boost::thread mCheckPingTimeoutThread
protected

◆ mSendChannelUpdatesThread

boost::thread mSendChannelUpdatesThread
protected

◆ mHeaderReceived

Time mHeaderReceived
protected

◆ mHeader

FrameworkMessageHeader mHeader
protected

◆ mMessage

Buffer<uint8> mMessage
protected

◆ mAuthState

AuthState mAuthState
protected

◆ mAuthSignMsg

std::string mAuthSignMsg
protected

◆ mPTPOutgoing

bool mPTPOutgoing
protected

◆ mPTPSyncLocal

Time mPTPSyncLocal
protected

◆ mPTPSyncRemote

Time mPTPSyncRemote
protected

◆ mPTPDelayLocal

Time mPTPDelayLocal
protected

◆ mPTPDelayRemote

Time mPTPDelayRemote
protected

◆ mLastPTP

Time mLastPTP
protected

◆ mPingLastSend

Time mPingLastSend
protected

◆ mPingLastReceived

Time mPingLastReceived
protected

◆ mMigrationUnit

boost::shared_ptr<MicroUnit> mMigrationUnit
protected

◆ mMigrationNS

std::string mMigrationNS
protected

◆ mMigrationID

std::string mMigrationID
protected

◆ mStopped

bool mStopped
protected

◆ mRPCFinishHandler

boost::shared_ptr<RPCRemoteFinishHandler> mRPCFinishHandler
protected

◆ mRPCRequestHandler

boost::shared_ptr<RPCRemoteRequestHandler> mRPCRequestHandler
protected

◆ mRemoteAuthorities

std::map<std::string, boost::shared_ptr<RemoteAuthority> > mRemoteAuthorities
protected

◆ mOutgoingRPCMessages

std::list<RPCMessage> mOutgoingRPCMessages
protected

◆ mRPCMessagesMutex

boost::mutex mRPCMessagesMutex
protected

◆ mPendingChannelUpdates

std::unordered_map<std::string, ServiceLevel> mPendingChannelUpdates
protected

◆ mChannelUpdatesMutex

boost::mutex mChannelUpdatesMutex
protected

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