callout_manager.h

Go to the documentation of this file.

// Copyright (C) 2013-2018 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 CALLOUT_MANAGER_H
#define CALLOUT_MANAGER_H
 
#include <exceptions/exceptions.h>
#include <hooks/library_handle.h>
#include <hooks/server_hooks.h>
 
#include <boost/shared_ptr.hpp>
 
#include <climits>
#include <map>
#include <string>
 
namespace isc {
namespace hooks {
 
class NoSuchLibrary : public Exception {
public:
    NoSuchLibrary(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
 
class CalloutManager {
private:
 
    // Private typedefs
 
    typedef std::pair<int, CalloutPtr> CalloutEntry;
 
    typedef std::vector<CalloutEntry> CalloutVector;
 
public:
 
    CalloutManager(int num_libraries = 0);
 
    void registerCallout(const std::string& name, CalloutPtr callout);
 
    bool deregisterCallout(const std::string& name, CalloutPtr callout);
 
    bool deregisterAllCallouts(const std::string& name);
 
    bool calloutsPresent(int hook_index) const;
 
    bool commandHandlersPresent(const std::string& command_name) const;
 
    void callCallouts(int hook_index, CalloutHandle& callout_handle);
 
    void callCommandHandlers(const std::string& command_name,
                             CalloutHandle& callout_handle);
 
    void registerCommandHook(const std::string& command_name);
 
    int getHookIndex() const {
        return (current_hook_);
    }
 
    int getNumLibraries() const {
        return (num_libraries_);
    }
 
    int getLibraryIndex() const {
        return (current_library_);
    }
 
    void setLibraryIndex(int library_index) {
        checkLibraryIndex(library_index);
        current_library_ = library_index;
    }
 
    //    callouts to run prior to user-library callouts.
 
 
    LibraryHandle& getLibraryHandle() {
        return (library_handle_);
    }
 
    LibraryHandle& getPreLibraryHandle() {
        return (pre_library_handle_);
    }
 
    LibraryHandle& getPostLibraryHandle() {
        return (post_library_handle_);
    }
 
 
    size_t getHookLibsVectorSize() const {
        return (hook_vector_.size());
    }
 
private:
 
    void ensureHookLibsVectorSize();
 
    void checkLibraryIndex(int library_index) const;
 
    class CalloutLibraryEqual :
        public std::binary_function<CalloutEntry, CalloutEntry, bool> {
    public:
        bool operator()(const CalloutEntry& ent1,
                        const CalloutEntry& ent2) const {
            return (ent1.first == ent2.first);
        }
    };
 
    // Member variables
 
    ServerHooks& server_hooks_;
 
    int current_hook_;
 
    int current_library_;
 
    std::vector<CalloutVector> hook_vector_;
 
    LibraryHandle library_handle_;
 
    LibraryHandle pre_library_handle_;
 
    LibraryHandle post_library_handle_;
 
    int num_libraries_;
};
 
} // namespace util
} // namespace isc
 
#endif // CALLOUT_MANAGER_H