d2_queue_mgr.h

Go to the documentation of this file.

// Copyright (C) 2013-2024 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