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