Line oriented Telnet connection for use in a Reactor environment. More...

#include <tsReactiveTelnetConnection.h>

Inheritance diagram for ts::ReactiveTelnetConnection:

[legend]

Collaboration diagram for ts::ReactiveTelnetConnection:

[legend]

Public Member Functions
	ReactiveTelnetConnection (ReactiveTCPConnection &socket, Object *owner=nullptr)
	Constructor.

virtual	~ReactiveTelnetConnection () override
	Destructor.

bool	isOwned ()
	Check if the object is owned.

template<class OBJECT > requires std::derived_from<OBJECT, ts::Object>
bool	isOwned ()
	Check if the object is owned by an object of a given type.

bool	muteReport (bool mute)
	Temporarily mute the associated report.

Object *	owner ()
	Get the address of the optional "owner" object which was specified in the constructor.

template<class OBJECT > requires std::derived_from<OBJECT, ts::Object>
OBJECT *	owner ()
	Get the address of the "owner" object which was specified in the constructor.

Reactor &	reactor ()
	Get a reference to the associated reactor.

Report &	report () const
	Access the Report which is associated with this object.

Report *	setReport (Report *report)
	Associate this object with another Report to log errors.

ReporterBase *	setReport (ReporterBase *delegate)
	Associate this object with another ReporterBase to log errors.

bool	signalQueuedOperations ()
	Trigger the execution of processQueuedOperations() in the context of a Reactor handler.

ReactiveTCPConnection &	socket ()
	Get a reference to the associated socket.

bool	startReceive (ReactiveTelnetConnectionHandlerInterface *handler, size_t buffer_size=ReactiveTCPConnection::DEFAULT_RECEIVE_BUFFER_SIZE)
	Start the operation of receiving messages from the socket.

bool	startSendLine (const std::string &line, bool flush=true)
	Start the operation of sending a line of text over the TCP connection.

bool	startSendLine (const UString &line, bool flush=true)
	Start the operation of sending a line of text over the TCP connection.

bool	startSendText (const std::string &text, bool flush=true)
	Start the operation of sending text over the TCP connection.

bool	startSendText (const UString &text, bool flush=true)
	Start the operation of sending text over the TCP connection.

Static Public Member Functions
static int	SilentLevel (bool silent)
	Compute a log severity level from a "silent" parameter.

Protected Types
using	IOQueue = std::list< std::shared_ptr< IOSB > >
	Queues of I/O requests are queues of shared_ptr to IOSB.

using	IOSB = NonBlockingDevice::IOSB
	IOSB shortcut fpr subclasses.

using	IOSet = std::set< std::shared_ptr< IOSB > >
	Unordered set of I/O requests, set of shared_ptr to IOSB.

Protected Member Functions
bool	activateAsynchronousIO ()
	Activate notification for asynchronous I/O.

bool	activateReadReady ()
	Activate read-ready notification for non-blocking I/O.

bool	activateWriteReady ()
	Activate write-ready notification for non-blocking I/O.

bool	cancelAndWaitAsynchronousIO (NonBlockingDevice::IOSB &iosb, bool silent)
	Cancel one specific pending asynchronous I/O and wait for its completion.

void	cancelAsynchronousIO (bool silent)
	Cancel all asynchronous I/O in progress.

template<class REQUEST > requires std::derived_from<REQUEST, ts::Object>
void	cancelQueue (IOQueue &inqueue, IOQueue &outqueue)
	Transfer all requests from one queue to another and mark all I/O as canceled.

void	deactivateAll (bool silent)
	Deactivate all registrations for non-blocking and asynchronous I/O.

void	deactivateAsynchronousIO (bool silent)
	Deactivate notification for asynchronous I/O.

void	deactivateQueuedOperations (bool silent)
	Deactivate the execution of processQueuedOperations() in the context of a Reactor handler.

void	deactivateReadReady (bool silent)
	Deactivate read-ready notification for non-blocking I/O.

void	deactivateWriteReady (bool silent)
	Deactivate write-ready notification for non-blocking I/O.

virtual void	handleAsynchronousIO (Reactor &reactor, EventId id, NonBlockingDevice::IOSB &iosb, size_t io_size)
	Handle an asynchronous I/O completion event in a Reactor.

virtual void	handleReadReady (Reactor &reactor, EventId id, int error_code)
	Handle a read-ready event in a Reactor.

virtual void	handleTimer (Reactor &reactor, EventId id)
	Handle a timer in a Reactor.

virtual void	handleUserEvent (Reactor &, EventId) override
	Handle a user-defined event in a Reactor.

virtual void	handleWriteReady (Reactor &reactor, EventId id, int error_code)
	Handle a write-ready event in a Reactor.

virtual void	processQueuedOperations ()
	This virtual method processes operations in the context of a Reactor handler.

std::shared_ptr< IOSB >	removeFromQueue (IOQueue &queue, IOSB *iosb)
	Search and remove a shared_ptr to IOSB, based on an IOSB address.

Detailed Description

Line oriented Telnet connection for use in a Reactor environment.

The class ReactiveTelnetConnection is a wrapper around ReactiveTCPConnection to handle reactive I/O.

Member Typedef Documentation

◆ IOQueue

using ts::ReactiveSocketBase::IOQueue = std::list<std::shared_ptr<IOSB> >

protectedinherited

Queues of I/O requests are queues of shared_ptr to IOSB.

This is typically used with non-blocking I/O where we must process requests in order. Send and receive requests are structures which are stored in the react_data of the IOSB.

◆ IOSet

using ts::ReactiveSocketBase::IOSet = std::set<std::shared_ptr<IOSB> >

protectedinherited

Unordered set of I/O requests, set of shared_ptr to IOSB.

This is typically used with asynchronous I/O. The ordering is enforced because I/O are started in order of calls from applications. The completion processing is likely the same, but driven by the system I/O Completion Ports and we must not assume any order. Send and receive requests are structures which are stored in the react_data of the IOSB.

Constructor & Destructor Documentation

◆ ReactiveTelnetConnection()

ts::ReactiveTelnetConnection::ReactiveTelnetConnection	(	ReactiveTCPConnection &	socket,
		Object *	owner = `nullptr`
	)

Constructor.

Parameters

[in,out]	socket	Associated reactive TCP socket. The socket object must remain valid as long as this object is valid.
[in]	owner	Optional address of an "owner" object, typically an instance of class containing this object.

Member Function Documentation

◆ socket()

ReactiveTCPConnection & ts::ReactiveTelnetConnection::socket ( )

inline

Get a reference to the associated socket.

Returns: A reference to the associated socket.

◆ startSendLine() [1/2]

bool ts::ReactiveTelnetConnection::startSendLine	(	const std::string &	line,
		bool	flush = `true`
	)

Start the operation of sending a line of text over the TCP connection.

There is no completion handler because the sent data is kept in a dedicated buffer.

Parameters

[in]	line	Text line to send. The corresponding memory area is no longer used upon return. An end-of-line marker is automatically added.
[in]	flush	If false, data are buffered into the ReactiveTelnetConnection and no completion handler will be called. When true, all previously buffered data are sent with data from this call.

Returns: True on success, false on error. Success means that the I/O was successfully started.

◆ startSendLine() [2/2]

bool ts::ReactiveTelnetConnection::startSendLine	(	const UString &	line,
		bool	flush = `true`
	)

Start the operation of sending a line of text over the TCP connection.

There is no completion handler because the sent data is kept in a dedicated buffer.

Parameters

[in]	line	Text line to send. The corresponding memory area is no longer used upon return. An end-of-line marker is automatically added.
[in]	flush	If false, data are buffered into the ReactiveTelnetConnection and no completion handler will be called. When true, all previously buffered data are sent with data from this call.

Returns: True on success, false on error. Success means that the I/O was successfully started.

◆ startSendText() [1/2]

bool ts::ReactiveTelnetConnection::startSendText	(	const std::string &	text,
		bool	flush = `true`
	)

Start the operation of sending text over the TCP connection.

There is no completion handler because the sent data is kept in a dedicated buffer.

Parameters

[in]	text	Text to send. The corresponding memory area is no longer used upon return. No end-of-line marker is added.
[in]	flush	If false, data are buffered into the ReactiveTelnetConnection and no completion handler will be called. When true, all previously buffered data are sent with data from this call.

Returns: True on success, false on error. Success means that the I/O was successfully started.

◆ startSendText() [2/2]

bool ts::ReactiveTelnetConnection::startSendText	(	const UString &	text,
		bool	flush = `true`
	)

Start the operation of sending text over the TCP connection.

There is no completion handler because the sent data is kept in a dedicated buffer.

Parameters

[in]	text	Text to send. The corresponding memory area is no longer used upon return. No end-of-line marker is added.
[in]	flush	If false, data are buffered into the ReactiveTelnetConnection and no completion handler will be called. When true, all previously buffered data are sent with data from this call.

Returns: True on success, false on error. Success means that the I/O was successfully started.

◆ startReceive()

bool ts::ReactiveTelnetConnection::startReceive	(	ReactiveTelnetConnectionHandlerInterface *	handler,
		size_t	buffer_size = `ReactiveTCPConnection::DEFAULT_RECEIVE_BUFFER_SIZE`
	)

Start the operation of receiving messages from the socket.

Parameters

[in]	handler	Handler class to call each time a text line is received. The method handleTelnetLine() will be called on each received line. Cannot be null. If a previous receive handler was registered, it is replaced.
[in]	buffer_size	Size of input buffers to receive data.

Returns: True on success, false on error. Success means that the I/O was successfully started. The final status of the I/O will be transmitted in the handler.

◆ removeFromQueue()

std::shared_ptr< IOSB > ts::ReactiveSocketBase::removeFromQueue	(	IOQueue &	queue,
		IOSB *	iosb
	)

protectedinherited

Search and remove a shared_ptr to IOSB, based on an IOSB address.

Search from the front (end) of the queue since a completed I/O is likely on the front.

Parameters

[in,out]	queue	The queue from which to remove iosb.
[in]	iosb	Standard pointer to an IOSB to search and remove.

Returns: The removed shared_ptr to IOSB, or a null pointer if iosb is not found.

◆ cancelQueue()

template<class REQUEST >
requires std::derived_from<REQUEST, ts::Object>

void ts::ReactiveSocketBase::cancelQueue	(	IOQueue &	inqueue,
		IOQueue &	outqueue
	)

protectedinherited

Transfer all requests from one queue to another and mark all I/O as canceled.

Template Parameters

REQUEST The subclass of Object which is set in react_data of all requests in inqueue.

Parameters

[in,out]	inqueue	The queue from which all requests are removed.
[in,out]	outqueue	The queue which receives all canceled requests.

◆ activateReadReady()

bool ts::ReactiveSocketBase::activateReadReady ( )

protectedinherited

Activate read-ready notification for non-blocking I/O.

Returns: True on success, false on error.

◆ deactivateReadReady()

void ts::ReactiveSocketBase::deactivateReadReady ( bool silent )

protectedinherited

Deactivate read-ready notification for non-blocking I/O.

Parameters

[in] silent If true, do not report errors through the logger.

◆ activateWriteReady()

bool ts::ReactiveSocketBase::activateWriteReady ( )

protectedinherited

Activate write-ready notification for non-blocking I/O.

Returns: True on success, false on error.

◆ deactivateWriteReady()

void ts::ReactiveSocketBase::deactivateWriteReady ( bool silent )

protectedinherited

Deactivate write-ready notification for non-blocking I/O.

Parameters

[in] silent If true, do not report errors through the logger.

◆ activateAsynchronousIO()

bool ts::ReactiveSocketBase::activateAsynchronousIO ( )

protectedinherited

Activate notification for asynchronous I/O.

Returns: True on success, false on error.

◆ deactivateAsynchronousIO()

void ts::ReactiveSocketBase::deactivateAsynchronousIO ( bool silent )

protectedinherited

Deactivate notification for asynchronous I/O.

Parameters

[in] silent If true, do not report errors through the logger.

◆ cancelAsynchronousIO()

void ts::ReactiveSocketBase::cancelAsynchronousIO ( bool silent )

protectedinherited

Cancel all asynchronous I/O in progress.

The cancelation occurs in the background and end of canceled asynchronous I/O will be notified.

Parameters

[in] silent If true, do not report errors through the logger.

◆ cancelAndWaitAsynchronousIO()

bool ts::ReactiveSocketBase::cancelAndWaitAsynchronousIO	(	NonBlockingDevice::IOSB &	iosb,
		bool	silent
	)

protectedinherited

Cancel one specific pending asynchronous I/O and wait for its completion.

Warning: This is a blocking call. It shall be used in case of trouble only.

Parameters

[in,out]	iosb	The asynchronous I/O status block.
[in]	silent	If true, do not report errors through the logger.

Returns: True on success, false on error.

◆ deactivateAll()

void ts::ReactiveSocketBase::deactivateAll ( bool silent )

protectedinherited

Deactivate all registrations for non-blocking and asynchronous I/O.

Parameters

[in] silent If true, do not report errors through the logger.

◆ reactor()

Reactor & ts::ReactiveBase::reactor ( )

inlineinherited

Get a reference to the associated reactor.

Returns: A reference to the associated reactor.

◆ signalQueuedOperations()

bool ts::ReactiveBase::signalQueuedOperations ( )

inherited

Trigger the execution of processQueuedOperations() in the context of a Reactor handler.

Create if necessary and then signal a dedicated user event.

Returns: True on success, false on error.

◆ deactivateQueuedOperations()

void ts::ReactiveBase::deactivateQueuedOperations ( bool silent )

protectedinherited

Deactivate the execution of processQueuedOperations() in the context of a Reactor handler.

Deactivate and delete the dedicated user event.

Parameters

[in] silent If true, do not report errors through the logger.

◆ processQueuedOperations()

virtual void ts::ReactiveBase::processQueuedOperations ( )

protectedvirtualinherited

This virtual method processes operations in the context of a Reactor handler.

This is dedicated to operations which must be serialized from an application perspective. These operations are typically queued when triggered from a method which is called by the application. When the reactor processes events, we are sure that the application is not executing a handler. The default implementation does nothing. A subclass should override it if it calls signalQueuedOperations().

Reimplemented in ts::ReactiveTCPConnection, and ts::ReactiveTLSConnection.

◆ handleUserEvent()

virtual void ts::ReactiveBase::handleUserEvent	(	Reactor &	reactor,
		EventId	id
	)

overrideprotectedvirtualinherited

Handle a user-defined event in a Reactor.

Parameters

[in,out]	reactor	Reactor into which the handler is invoked.
[in]	id	Id of the event which was signaled.

Reimplemented from ts::ReactorHandlerInterface.

◆ report()

Report & ts::ReporterBase::report ( ) const

inherited

Access the Report which is associated with this object.

Can be called from another thread only if the Report object is thread-safe.

Returns: A reference to the associated report.

◆ setReport() [1/2]

Report * ts::ReporterBase::setReport ( Report * report )

inherited

Associate this object with another Report to log errors.

Parameters

[in] report Where to report errors. The report object must remain valid as long as this object exists or setReport() is used with another Report object. If report is null, log messages are discarded.

Returns: The address of the previous Report object or a null pointer if there was none.

◆ setReport() [2/2]

ReporterBase * ts::ReporterBase::setReport ( ReporterBase * delegate )

inherited

Associate this object with another ReporterBase to log errors.

Parameters

[in] delegate Use the report of another ReporterBase. If delegate is null, the previous explicit Report is used..

Returns: The address of the previous ReporterBase object or a null pointer if there was none.

◆ muteReport()

bool ts::ReporterBase::muteReport ( bool mute )

inherited

Temporarily mute the associated report.

Parameters

[in] mute It true, report() will return a null report (log messages are discarded), until muteReport() is invoked again with mute set to false.

Returns: Previous state of the mute field.

◆ SilentLevel()

static int ts::ReporterBase::SilentLevel ( bool silent )

inlinestaticinherited

Compute a log severity level from a "silent" parameter.

Some subclass methods have a "silent" parameter to avoid reporting errors which may be insignificant, typically when closing a device after an error, in which case the close operation may produce other errors if the previous error left the device in an inconsistent state. While those errors should not be displayed as errors, we still display them at debug level.

Parameters

[in] silent If true, do not report errors, report debug messages instead.

Returns: Error when silent is false, Debug otherwise.

◆ owner() [1/2]

Object * ts::OwnedObject::owner ( )

inlineinherited

Get the address of the optional "owner" object which was specified in the constructor.

Returns: Address of the "owner" object or a null pointer if there was none.

◆ owner() [2/2]

template<class OBJECT >
requires std::derived_from<OBJECT, ts::Object>

OBJECT * ts::OwnedObject::owner ( )

inherited

Get the address of the "owner" object which was specified in the constructor.

This template version requires that the owner objet is set and of type OBJECT, or some subclass of it. If there is no owner object or if it is not compatible with the template class OBJECT, this is a fatal error and the application is terminated.

Template Parameters

OBJECT A subclass of Object

Returns: Address of the "owner" object or a null pointer if there was none.

◆ isOwned() [1/2]

bool ts::OwnedObject::isOwned ( )

inlineinherited

Check if the object is owned.

Returns: True if this object has an owner, false otherwise.

◆ isOwned() [2/2]

template<class OBJECT >
requires std::derived_from<OBJECT, ts::Object>

bool ts::OwnedObject::isOwned ( )

inlineinherited

Check if the object is owned by an object of a given type.

Template Parameters

OBJECT A subclass of Object

Returns: True if this object has an owner by an object of type OBJECT, false otherwise.

◆ handleTimer()

virtual void ts::ReactorHandlerInterface::handleTimer	(	Reactor &	reactor,
		EventId	id
	)

virtualinherited

Handle a timer in a Reactor.

Parameters

[in,out]	reactor	Reactor into which the handler is invoked.
[in]	id	Id of the timer which expires.

◆ handleReadReady()

virtual void ts::ReactorHandlerInterface::handleReadReady	(	Reactor &	reactor,
		EventId	id,
		int	error_code
	)

virtualinherited

Handle a read-ready event in a Reactor.

This handler is only invoked in the non-blocking I/O model.

Parameters

[in,out]	reactor	Reactor into which the handler is invoked.
[in]	id	Id of the event which was signaled.
[in]	error_code	System-specific error code, zero on success, SYS_ERROR in case of unknown error.

Reimplemented in ts::ReactiveTCPConnection.

◆ handleWriteReady()

virtual void ts::ReactorHandlerInterface::handleWriteReady	(	Reactor &	reactor,
		EventId	id,
		int	error_code
	)

virtualinherited

Handle a write-ready event in a Reactor.

This handler is only invoked in the non-blocking I/O model.

Parameters

[in,out]	reactor	Reactor into which the handler is invoked.
[in]	id	Id of the event which was signaled.
[in]	error_code	System-specific error code, zero on success, SYS_ERROR in case of unknown error.

Reimplemented in ts::ReactiveTCPConnection.

◆ handleAsynchronousIO()

virtual void ts::ReactorHandlerInterface::handleAsynchronousIO	(	Reactor &	reactor,
		EventId	id,
		NonBlockingDevice::IOSB &	iosb,
		size_t	io_size
	)

virtualinherited

Handle an asynchronous I/O completion event in a Reactor.

This handler is only invoked in the asynchronous I/O model.

Parameters

[in,out]	reactor	Reactor into which the handler is invoked.
[in]	id	Id of the event which was signaled.
[in,out]	iosb	IOSB structure which was used when the asynchronous I/O was started. A system-specific error code is in iosb, SYS_CANCELED if the I/O was canceled before completion.
[in]	io_size	Size of the I/O in bytes.

Reimplemented in ts::ReactiveTCPConnection.

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

tsReactiveTelnetConnection.h

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ IOQueue

◆ IOSet

Constructor & Destructor Documentation

◆ ReactiveTelnetConnection()

Member Function Documentation

◆ socket()

◆ startSendLine() [1/2]

◆ startSendLine() [2/2]

◆ startSendText() [1/2]

◆ startSendText() [2/2]

◆ startReceive()

◆ removeFromQueue()

◆ cancelQueue()

◆ activateReadReady()

◆ deactivateReadReady()

◆ activateWriteReady()

◆ deactivateWriteReady()

◆ activateAsynchronousIO()

◆ deactivateAsynchronousIO()

◆ cancelAsynchronousIO()

◆ cancelAndWaitAsynchronousIO()

◆ deactivateAll()

◆ reactor()

◆ signalQueuedOperations()

◆ deactivateQueuedOperations()

◆ processQueuedOperations()

◆ handleUserEvent()

◆ report()

◆ setReport() [1/2]

◆ setReport() [2/2]

◆ muteReport()

◆ SilentLevel()

◆ owner() [1/2]

◆ owner() [2/2]

◆ isOwned() [1/2]

◆ isOwned() [2/2]

◆ handleTimer()

◆ handleReadReady()

◆ handleWriteReady()

◆ handleAsynchronousIO()