d2_queue_mgr.h

Go to the documentation of this file.

// Copyright (C) 2013-2015,2017,2021 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 D2_QUEUE_MGR_H
#define D2_QUEUE_MGR_H


#include <asiolink/io_service.h>
#include <exceptions/exceptions.h>
#include <dhcp_ddns/ncr_msg.h>
#include <dhcp_ddns/ncr_io.h>

#include <boost/noncopyable.hpp>
#include <deque>

namespace isc {
namespace d2 {

typedef std::deque<dhcp_ddns::NameChangeRequestPtr> RequestQueue;

class D2QueueMgrError : public isc::Exception {
public:
    D2QueueMgrError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class D2QueueMgrReceiveError : public isc::Exception {
public:
    D2QueueMgrReceiveError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};


class D2QueueMgrQueueFull : public isc::Exception {
public:
    D2QueueMgrQueueFull(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class D2QueueMgrQueueEmpty : public isc::Exception {
public:
    D2QueueMgrQueueEmpty(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

class D2QueueMgrInvalidIndex : public isc::Exception {
public:
    D2QueueMgrInvalidIndex(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};


class D2QueueMgr : public dhcp_ddns::NameChangeListener::RequestReceiveHandler,
                   boost::noncopyable {
public:
    static const size_t MAX_QUEUE_DEFAULT = 1024;

    enum State {
      NOT_INITTED,
      INITTED,
      RUNNING,
      STOPPING,
      STOPPED_QUEUE_FULL,
      STOPPED_RECV_ERROR,
      STOPPED,
    };

    D2QueueMgr(asiolink::IOServicePtr& io_service,
               const size_t max_queue_size = MAX_QUEUE_DEFAULT);

    virtual ~D2QueueMgr();

    void initUDPListener(const isc::asiolink::IOAddress& ip_address,
                         const uint32_t port,
                         const dhcp_ddns::NameChangeFormat format,
                         const bool reuse_address = false);

    void startListening();

    virtual void operator ()(const dhcp_ddns::NameChangeListener::Result result,
                             dhcp_ddns::NameChangeRequestPtr& ncr);

    void stopListening(const State target_stop_state = STOPPED);


    void removeListener();

    size_t getQueueSize() const {
        return (ncr_queue_.size());
    };

    size_t getMaxQueueSize() const {
        return (max_queue_size_);
    }

    void setMaxQueueSize(const size_t max_queue_size);

    State getMgrState() const {
        return (mgr_state_);
    }

    const dhcp_ddns::NameChangeRequestPtr& peek() const;

    const dhcp_ddns::NameChangeRequestPtr& peekAt(const size_t index) const;

    void dequeueAt(const size_t index);

    void dequeue();

    void enqueue(dhcp_ddns::NameChangeRequestPtr& ncr);

    void clearQueue();

  private:
    void updateStopState();

    asiolink::IOServicePtr io_service_;

    size_t max_queue_size_;

    RequestQueue ncr_queue_;

    boost::shared_ptr<dhcp_ddns::NameChangeListener> listener_;

    State mgr_state_;

    State target_stop_state_;
};

typedef boost::shared_ptr<D2QueueMgr> D2QueueMgrPtr;

} // namespace isc::d2
} // namespace isc

#endif