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