ncr_io.h

Go to the documentation of this file.

// Copyright (C) 2013-2020 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef NCR_IO_H
#define NCR_IO_H
 
 
#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 <deque>
#include <mutex>
 
namespace isc {
namespace dhcp_ddns {
 
enum NameChangeProtocol {
  NCR_UDP,
  NCR_TCP
};
 
extern NameChangeProtocol stringToNcrProtocol(const std::string& protocol_str);
 
extern std::string ncrProtocolToString(NameChangeProtocol protocol);
 
class NcrListenerError : public isc::Exception {
public:
    NcrListenerError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class NcrListenerOpenError : public isc::Exception {
public:
    NcrListenerOpenError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class NcrListenerReceiveError : public isc::Exception {
public:
    NcrListenerReceiveError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
 
class NameChangeListener {
public:
 
    enum Result {
        SUCCESS,
        TIME_OUT,
        STOPPED,
        ERROR
    };
 
    class RequestReceiveHandler {
    public:
 
        virtual void operator ()(const Result result,
                                 NameChangeRequestPtr& ncr) = 0;
 
        virtual ~RequestReceiveHandler() {
        }
    };
 
    NameChangeListener(RequestReceiveHandler& recv_handler);
 
    virtual ~NameChangeListener() {
    };
 
    void startListening(isc::asiolink::IOService& io_service);
 
    void stopListening();
 
protected:
    void receiveNext();
 
    void invokeRecvHandler(const Result result, NameChangeRequestPtr& ncr);
 
    virtual void open(isc::asiolink::IOService& io_service) = 0;
 
    virtual void close() = 0;
 
    virtual void doReceive() = 0;
 
public:
 
    bool amListening() const {
        return (listening_);
    }
 
    bool isIoPending() const {
        return (io_pending_);
    }
 
private:
    void setListening(bool value) {
        listening_ = value;
    }
 
    bool listening_;
 
    bool io_pending_;
 
    RequestReceiveHandler& recv_handler_;
};
 
typedef boost::shared_ptr<NameChangeListener> NameChangeListenerPtr;
 
 
class NcrSenderError : public isc::Exception {
public:
    NcrSenderError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class NcrSenderOpenError : public isc::Exception {
public:
    NcrSenderOpenError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class NcrSenderQueueFull : public isc::Exception {
public:
    NcrSenderQueueFull(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
class NcrSenderSendError : public isc::Exception {
public:
    NcrSenderSendError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
 
 
 
class NameChangeSender {
public:
 
    typedef std::deque<NameChangeRequestPtr> SendQueue;
 
    static const size_t MAX_QUEUE_DEFAULT = 1024;
 
    enum Result {
        SUCCESS,
        TIME_OUT,
        STOPPED,
        ERROR
    };
 
    class RequestSendHandler {
    public:
 
        virtual void operator ()(const Result result,
                                 NameChangeRequestPtr& ncr) = 0;
 
        virtual ~RequestSendHandler() {
        }
    };
 
    NameChangeSender(RequestSendHandler& send_handler,
                     size_t send_queue_max = MAX_QUEUE_DEFAULT);
 
    virtual ~NameChangeSender() {
    }
 
    void startSending(isc::asiolink::IOService & io_service);
 
    void stopSending();
 
    void sendRequest(NameChangeRequestPtr& ncr);
 
    void assumeQueue(NameChangeSender& source_sender);
 
    virtual int getSelectFd() = 0;
 
    virtual bool ioReady() = 0;
 
private:
 
    void startSendingInternal(isc::asiolink::IOService & io_service);
 
    void sendRequestInternal(NameChangeRequestPtr& ncr);
 
    void assumeQueueInternal(NameChangeSender& source_sender);
 
    void invokeSendHandlerInternal(const NameChangeSender::Result result);
 
    void skipNextInternal();
 
    size_t getQueueSizeInternal() const;
 
    const NameChangeRequestPtr& peekAtInternal(const size_t index) const;
 
protected:
 
    void sendNext();
 
    void invokeSendHandler(const NameChangeSender::Result result);
 
    virtual void open(isc::asiolink::IOService& io_service) = 0;
 
    virtual void close() = 0;
 
    virtual void doSend(NameChangeRequestPtr& ncr) = 0;
 
public:
 
    void skipNext();
 
    void clearSendQueue();
 
    bool amSending() const {
        return (sending_);
    }
 
    bool isSendInProgress() const;
 
    size_t getQueueMaxSize() const  {
        return (send_queue_max_);
    }
 
    void setQueueMaxSize(const size_t new_max);
 
    size_t getQueueSize() const;
 
    const NameChangeRequestPtr& peekAt(const size_t index) const;
 
    virtual void runReadyIO();
 
protected:
 
    SendQueue& getSendQueue() {
        return (send_queue_);
    }
 
private:
 
    void setSending(bool value) {
        sending_ = value;
    }
 
    bool sending_;
 
    RequestSendHandler& send_handler_;
 
    size_t send_queue_max_;
 
    SendQueue send_queue_;
 
    NameChangeRequestPtr ncr_to_send_;
 
    asiolink::IOService* io_service_;
 
    const boost::scoped_ptr<std::mutex> mutex_;
};
 
typedef boost::shared_ptr<NameChangeSender> NameChangeSenderPtr;
 
}  // namespace dhcp_ddns
}  // namespace isc
 
#endif