13#include <boost/algorithm/string/predicate.hpp>
24 if (boost::iequals(protocol_str,
"UDP")) {
28 if (boost::iequals(protocol_str,
"TCP")) {
33 "Invalid NameChangeRequest protocol: " << protocol_str);
46 std::ostringstream stream;
47 stream <<
"UNKNOWN(" << protocol <<
")";
48 return (stream.str());
54 : listening_(false), io_pending_(false), recv_handler_(recv_handler) {
116 (*recv_handler_)(result, ncr);
117 }
catch (
const std::exception& ex) {
145 (*recv_handler_)(
ERROR, empty);
146 }
catch (
const std::exception& ex) {
158 size_t send_queue_max)
159 : sending_(false), send_handler_(send_handler),
160 send_queue_max_(send_queue_max), mutex_(new mutex()) {
176 lock_guard<mutex> lock(*mutex_);
177 startSendingInternal(io_service);
179 startSendingInternal(io_service);
190 ncr_to_send_.reset();
214 }
catch (
const std::exception& ex) {
237 }
catch (
const std::exception& ex) {
259 lock_guard<mutex> lock(*mutex_);
260 sendRequestInternal(ncr);
262 sendRequestInternal(ncr);
268 if (send_queue_.size() >= send_queue_max_) {
270 "send queue has reached maximum capacity: "
275 send_queue_.push_back(ncr);
292 if (!send_queue_.empty()) {
293 ncr_to_send_ = send_queue_.front();
307 lock_guard<mutex> lock(*mutex_);
308 invokeSendHandlerInternal(result);
310 invokeSendHandlerInternal(result);
319 send_queue_.pop_front();
328 (*send_handler_)(result, ncr_to_send_);
329 }
catch (
const std::exception& ex) {
335 ncr_to_send_.reset();
357 (*send_handler_)(
ERROR, ncr_to_send_);
358 }
catch (
const std::exception& ex) {
368 lock_guard<mutex> lock(*mutex_);
376NameChangeSender::skipNextInternal() {
377 if (!send_queue_.empty()) {
379 send_queue_.pop_front();
390 lock_guard<mutex> lock(*mutex_);
401 " queue size must be greater than zero");
404 send_queue_max_ = new_max;
410 lock_guard<mutex> lock(*mutex_);
411 return (getQueueSizeInternal());
413 return (getQueueSizeInternal());
418NameChangeSender::getQueueSizeInternal()
const {
419 return (send_queue_.size());
425 lock_guard<mutex> lock(*mutex_);
426 return (peekAtInternal(index));
428 return (peekAtInternal(index));
433NameChangeSender::peekAtInternal(
const size_t index)
const {
434 auto size = getQueueSizeInternal();
437 "NameChangeSender::peekAt peek beyond end of queue attempted"
438 <<
" index: " << index <<
" queue size: " << size);
441 return (send_queue_.at(index));
447 lock_guard<mutex> lock(*mutex_);
448 return ((ncr_to_send_) ?
true :
false);
450 return ((ncr_to_send_) ?
true :
false);
458 " source sender is actively sending");
463 " target sender is actively sending");
468 " source queue count exceeds target queue max");
472 lock_guard<mutex> lock(*mutex_);
473 assumeQueueInternal(source_sender);
475 assumeQueueInternal(source_sender);
481 if (!send_queue_.empty()) {
483 " target queue is not empty");
498 " sender io service is null");
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
This is a base class for exceptions thrown from the DNS library module.
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
A generic exception that is thrown when a function is not implemented.
virtual void open(const isc::asiolink::IOServicePtr &io_service)=0
Abstract method which opens the IO source for reception.
boost::shared_ptr< RequestReceiveHandler > RequestReceiveHandlerPtr
Defines a smart pointer to an instance of a request receive handler.
void stopListening()
Closes the IO source and stops listen logic.
virtual void close()=0
Abstract method which closes the IO source.
NameChangeListener(RequestReceiveHandlerPtr recv_handler)
Constructor.
virtual void doReceive()=0
Initiates an IO layer asynchronous read.
void invokeRecvHandler(const Result result, NameChangeRequestPtr &ncr)
Calls the NCR receive handler registered with the listener.
bool amListening() const
Returns true if the listener is listening, false otherwise.
Result
Defines the outcome of an asynchronous NCR receive.
void receiveNext()
Initiates an asynchronous receive.
void startListening(const isc::asiolink::IOServicePtr &io_service)
Prepares the IO for reception and initiates the first receive.
Abstract interface for sending NameChangeRequests.
asiolink::IOServicePtr io_service_
Pointer to the IOService currently being used by the sender.
void stopSending()
Closes the IO sink and stops send logic.
virtual int getSelectFd()=0
Returns a file descriptor suitable for use with select.
void startSending(const isc::asiolink::IOServicePtr &io_service)
Prepares the IO for transmission.
NameChangeSender(RequestSendHandlerPtr send_handler, size_t send_queue_max=MAX_QUEUE_DEFAULT)
Constructor.
void assumeQueue(NameChangeSender &source_sender)
Move all queued requests from a given sender into the send queue.
size_t getQueueMaxSize() const
Returns the maximum number of entries allowed in the send queue.
size_t getQueueSize() const
Returns the number of entries currently in the send queue.
const NameChangeRequestPtr & peekAt(const size_t index) const
Returns the entry at a given position in the queue.
virtual bool ioReady()=0
Returns whether or not the sender has IO ready to process.
void skipNext()
Removes the request at the front of the send queue.
boost::shared_ptr< RequestSendHandler > RequestSendHandlerPtr
Defines a smart pointer to an instance of a request send handler.
void clearSendQueue()
Flushes all entries in the send queue.
bool amSending() const
Returns true if the sender is in send mode, false otherwise.
virtual void doSend(NameChangeRequestPtr &ncr)=0
Initiates an IO layer asynchronous send.
void setQueueMaxSize(const size_t new_max)
Sets the maximum queue size to the given value.
void invokeSendHandler(const NameChangeSender::Result result)
Calls the NCR send completion handler registered with the sender.
virtual void open(const isc::asiolink::IOServicePtr &io_service)=0
Abstract method which opens the IO sink for transmission.
virtual void close()=0
Abstract method which closes the IO sink.
void sendRequest(NameChangeRequestPtr &ncr)
Queues the given request to be sent.
virtual void runReadyIO()
Processes sender IO events.
SendQueue & getSendQueue()
Returns a reference to the send queue.
bool isSendInProgress() const
Returns true when a send is in progress.
Result
Defines the outcome of an asynchronous NCR send.
void sendNext()
Dequeues and sends the next request on the send queue in a thread safe context.
Exception thrown if an NcrListenerError encounters a general error.
Exception thrown if an error occurs during IO source open.
Exception thrown if an error occurs initiating an IO receive.
Thrown when a NameChangeSender encounters an error.
Exception thrown if an error occurs during IO source open.
Exception thrown if an error occurs initiating an IO send.
static MultiThreadingMgr & instance()
Returns a single instance of Multi Threading Manager.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
#define LOG_ERROR(LOGGER, MESSAGE)
Macro to conveniently test error output and log it.
boost::shared_ptr< IOService > IOServicePtr
Defines a smart pointer to an IOService instance.
isc::log::Logger dhcp_ddns_logger("libdhcp-ddns")
Defines the logger used within lib dhcp_ddns.
NameChangeProtocol stringToNcrProtocol(const std::string &protocol_str)
Function which converts text labels to NameChangeProtocol enums.
const isc::log::MessageID DHCP_DDNS_NCR_SEND_CLOSE_ERROR
const isc::log::MessageID DHCP_DDNS_NCR_SEND_NEXT_ERROR
const isc::log::MessageID DHCP_DDNS_NCR_FLUSH_IO_ERROR
NameChangeProtocol
Defines the list of socket protocols supported.
std::string ncrProtocolToString(NameChangeProtocol protocol)
Function which converts NameChangeProtocol enums to text labels.
const isc::log::MessageID DHCP_DDNS_UNCAUGHT_NCR_SEND_HANDLER_ERROR
const isc::log::MessageID DHCP_DDNS_UNCAUGHT_NCR_RECV_HANDLER_ERROR
boost::shared_ptr< NameChangeRequest > NameChangeRequestPtr
Defines a pointer to a NameChangeRequest.
const isc::log::MessageID DHCP_DDNS_NCR_LISTEN_CLOSE_ERROR
const isc::log::MessageID DHCP_DDNS_NCR_RECV_NEXT_ERROR
Defines the logger used by the top-level component of kea-lfc.
This file defines abstract classes for exchanging NameChangeRequests.