d2_queue_mgr.h

Go to the documentation of this file.

// Copyright (C) 2013-2026 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 <dhcp_ddns/ncr_io.h>
#include <dhcp_ddns/ncr_msg.h>
#include <exceptions/exceptions.h>
 
#include <cstdint>
#include <deque>
 
#include <boost/noncopyable.hpp>
 
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 : uint16_t {
      NOT_INITTED = 0,
      INITTED = 1,
      RUNNING = 2,
      STOPPING = 3,
      STOPPED_QUEUE_FULL = 4,
      STOPPED_RECV_ERROR = 5,
      STOPPED = 6,
    };

    static std::string const& stateToText(State const& state) {
        static std::vector<std::string> const text_vector {
            "NOT_INITTED",
            "INITTED",
            "RUNNING",
            "STOPPING",
            "STOPPED_QUEUE_FULL",
            "STOPPED_RECV_ERROR",
            "STOPPED",
        };
        static std::string const unknown("UNKNOWN");
        return (state < text_vector.size() ? text_vector[state] : unknown);
    }

    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