ncr_io.h File Reference

This file defines abstract classes for exchanging NameChangeRequests. More...

#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <dhcp_ddns/ncr_msg.h>
#include <exceptions/exceptions.h>
#include <boost/scoped_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <deque>
#include <mutex>

Include dependency graph for ncr_io.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	isc::dhcp_ddns::NameChangeListener
	Abstract interface for receiving NameChangeRequests. More...
class	isc::dhcp_ddns::NameChangeSender
	Abstract interface for sending NameChangeRequests. More...
class	isc::dhcp_ddns::NcrListenerError
	Exception thrown if an NcrListenerError encounters a general error. More...
class	isc::dhcp_ddns::NcrListenerOpenError
	Exception thrown if an error occurs during IO source open. More...
class	isc::dhcp_ddns::NcrListenerReceiveError
	Exception thrown if an error occurs initiating an IO receive. More...
class	isc::dhcp_ddns::NcrSenderError
	Thrown when a NameChangeSender encounters an error. More...
class	isc::dhcp_ddns::NcrSenderOpenError
	Exception thrown if an error occurs during IO source open. More...
class	isc::dhcp_ddns::NcrSenderQueueFull
	Exception thrown if an error occurs initiating an IO send. More...
class	isc::dhcp_ddns::NcrSenderSendError
	Exception thrown if an error occurs initiating an IO send. More...
class	isc::dhcp_ddns::NameChangeListener::RequestReceiveHandler
	Abstract class for defining application layer receive callbacks. More...
class	isc::dhcp_ddns::NameChangeSender::RequestSendHandler
	Abstract class for defining application layer send callbacks. More...

Namespaces
namespace	isc
	Defines the logger used by the top-level component of kea-lfc.
namespace	isc::dhcp_ddns

Typedefs
typedef boost::shared_ptr< NameChangeListener >	isc::dhcp_ddns::NameChangeListenerPtr
	Defines a smart pointer to an instance of a listener.
typedef boost::shared_ptr< NameChangeSender >	isc::dhcp_ddns::NameChangeSenderPtr
	Defines a smart pointer to an instance of a sender.

Enumerations
enum	isc::dhcp_ddns::NameChangeProtocol { isc::dhcp_ddns::NCR_UDP , isc::dhcp_ddns::NCR_TCP }
	Defines the list of socket protocols supported. More...

Functions
std::string	isc::dhcp_ddns::ncrProtocolToString (NameChangeProtocol protocol)
	Function which converts NameChangeProtocol enums to text labels.
NameChangeProtocol	isc::dhcp_ddns::stringToNcrProtocol (const std::string &protocol_str)
	Function which converts text labels to NameChangeProtocol enums.

Detailed Description

This file defines abstract classes for exchanging NameChangeRequests.

These classes are used for sending and receiving requests to update DNS information for FQDNs embodied as NameChangeRequests (aka NCRs). Ultimately, NCRs must move through the following three layers in order to implement DHCP-DDNS:

• Application layer - the business layer which needs to transport NameChangeRequests, and is unaware of the means by which they are transported.
• NameChangeRequest layer - This is the layer which acts as the intermediary between the Application layer and the IO layer. It must be able to move NameChangeRequests to the IO layer as raw data and move raw data from the IO layer in the Application layer as NameChangeRequests.
• IO layer - the low-level layer that is directly responsible for sending and receiving data asynchronously and is supplied through other libraries. This layer is largely unaware of the nature of the data being transmitted. In other words, it doesn't know beans about NCRs.

The abstract classes defined here implement the latter, middle layer, the NameChangeRequest layer. There are two types of participants in this middle ground:

• listeners - Receive NCRs from one or more sources. The DHCP-DDNS application, (aka D2), is a listener. Listeners are embodied by the class, NameChangeListener.
• senders - sends NCRs to a given target. DHCP servers are senders. Senders are embodied by the class, NameChangeSender.

These two classes present a public interface for asynchronous communications that is independent of the IO layer mechanisms. While the type and details of the IO mechanism are not relevant to either class, it is presumed to use isc::asiolink library for asynchronous event processing.

Definition in file ncr_io.h.