hooks_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 HOOKS_MANAGER_H
#define HOOKS_MANAGER_H
 
#include <hooks/server_hooks.h>
#include <hooks/libinfo.h>
 
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
 
#include <string>
#include <vector>
 
namespace isc {
namespace hooks {
 
// Forward declarations
class CalloutHandle;
class CalloutManager;
class LibraryHandle;
class LibraryManagerCollection;
 
 
class HooksManager : boost::noncopyable {
public:
    static HooksManager& getHooksManager();
 
    static bool loadLibraries(const HookLibsCollection& libraries);
 
    static void unloadLibraries();
 
    static bool calloutsPresent(int index);
 
    static bool commandHandlersPresent(const std::string& command_name);
 
    static void callCallouts(int index, CalloutHandle& handle);
 
    static void callCommandHandlers(const std::string& command_name,
                                    CalloutHandle& handle);
 
    static LibraryHandle& preCalloutsLibraryHandle();
 
    static LibraryHandle& postCalloutsLibraryHandle();
 
    static boost::shared_ptr<CalloutHandle> createCalloutHandle();
 
    static int registerHook(const std::string& name);
 
    static std::vector<std::string> getLibraryNames();
 
    static HookLibsCollection getLibraryInfo();
 
    static std::vector<std::string> validateLibraries(
                       const std::vector<std::string>& libraries);
 
    static const int CONTEXT_CREATE = ServerHooks::CONTEXT_CREATE;
    static const int CONTEXT_DESTROY = ServerHooks::CONTEXT_DESTROY;
 
    static boost::shared_ptr<CalloutManager>& getSharedCalloutManager();
 
    template<typename T>
    static void park(const std::string& hook_name, T parked_object,
                     std::function<void()> unpark_callback) {
        getHooksManager().parkInternal(hook_name, parked_object, unpark_callback);
    }
 
    template<typename T>
    static bool unpark(const std::string& hook_name, T parked_object) {
        return (getHooksManager().unparkInternal(hook_name, parked_object));
    }
 
    template<typename T>
    static bool drop(const std::string& hook_name, T parked_object) {
        return (getHooksManager().dropInternal(hook_name, parked_object));
    }
 
    template<typename T>
    static void reference(const std::string& hook_name, T parked_object) {
        getHooksManager().referenceInternal(hook_name, parked_object);
    }
 
    static void clearParkingLots() {
        getHooksManager().clearParkingLotsInternal();
    }
 
private:
 
    HooksManager();
 
    template<typename T>
    void parkInternal(const std::string& hook_name, T parked_object,
                      std::function<void()> unpark_callback) {
        ServerHooks::getServerHooks().
            getParkingLotPtr(hook_name)->park(parked_object, unpark_callback);
    }
 
    template<typename T>
    bool unparkInternal(const std::string& hook_name, T parked_object) {
        return (ServerHooks::getServerHooks().
                getParkingLotPtr(hook_name)->unpark(parked_object, true));
    }
 
    template<typename T>
    static bool dropInternal(const std::string& hook_name, T parked_object) {
        return (ServerHooks::getServerHooks().
                getParkingLotPtr(hook_name)->drop(parked_object));
    }
 
    template<typename T>
    void referenceInternal(const std::string& hook_name, T parked_object) {
        ServerHooks::getServerHooks().
            getParkingLotPtr(hook_name)->reference(parked_object);
    }
 
    void clearParkingLotsInternal() {
        ServerHooks::getServerHooks().getParkingLotsPtr()->clear();
    }
 
 
 
    std::string validateLibrariesInternal(
                       const std::vector<std::string>& libraries) const;
 
    bool loadLibrariesInternal(const HookLibsCollection& libraries);
 
    void unloadLibrariesInternal();
 
    bool calloutsPresentInternal(int index);
 
    bool commandHandlersPresentInternal(const std::string& command_name);
 
    void callCalloutsInternal(int index, CalloutHandle& handle);
 
    void callCommandHandlersInternal(const std::string& command_name,
                                     CalloutHandle& handle);
 
    boost::shared_ptr<CalloutHandle> createCalloutHandleInternal();
 
    LibraryHandle& preCalloutsLibraryHandleInternal();
 
    LibraryHandle& postCalloutsLibraryHandleInternal();
 
    std::vector<std::string> getLibraryNamesInternal() const;
 
    HookLibsCollection getLibraryInfoInternal() const;
 
 
    void performConditionalInitialization();
 
    void conditionallyInitialize() {
        if (!lm_collection_) {
            performConditionalInitialization();
        }
    }
 
    // Members
 
    boost::shared_ptr<LibraryManagerCollection> lm_collection_;
 
    boost::shared_ptr<CalloutManager> callout_manager_;
 
    boost::shared_ptr<CalloutManager> shared_callout_manager_;
 
};
 
} // namespace util
} // namespace hooks
 
#endif // HOOKS_MANAGER_H