hooks_manager.h

Go to the documentation of this file.

// Copyright (C) 2013-2023 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 {
 
class LibrariesStillOpened : public Exception {
public:
    LibrariesStillOpened(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
// Forward declarations
class CalloutHandle;
class CalloutManager;
class LibraryHandle;
class LibraryManagerCollection;
 
 
class HooksManager : boost::noncopyable {
public:
 
    static bool loadLibraries(const HookLibsCollection& libraries,
                              bool multi_threading_enabled = false);
 
    static bool unloadLibraries();
 
    static void prepareUnloadLibraries();
 
    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,
                                                      bool multi_threading_enabled = false);
 
    static const int CONTEXT_CREATE = ServerHooks::CONTEXT_CREATE;
    static const int CONTEXT_DESTROY = ServerHooks::CONTEXT_DESTROY;
 
    template<typename T>
    static void park(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>
    static bool unpark(const std::string& hook_name, T parked_object) {
        return (ServerHooks::getServerHooks().
                getParkingLotPtr(hook_name)->unpark(parked_object, true));
    }
 
    template<typename T>
    static bool drop(const std::string& hook_name, T parked_object) {
        return (ServerHooks::getServerHooks().
                getParkingLotPtr(hook_name)->drop(parked_object));
    }
 
    template<typename T>
    static void reference(const std::string& hook_name, T parked_object) {
        ServerHooks::getServerHooks().
            getParkingLotPtr(hook_name)->reference(parked_object);
    }
 
    static void clearParkingLots() {
        ServerHooks::getServerHooks().getParkingLotsPtr()->clear();
    }
 
    static void setTestMode(bool mode);
 
    static bool getTestMode();
 
private:
 
    HooksManager();
 
    static HooksManager& getHooksManager();
 
 
 
    bool loadLibrariesInternal(const HookLibsCollection& libraries,
                               bool multi_threading_enabled);
 
    bool unloadLibrariesInternal();
 
    void prepareUnloadLibrariesInternal();
 
    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;
 
 
    // Members
 
    boost::shared_ptr<LibraryManagerCollection> lm_collection_;
 
    boost::shared_ptr<CalloutManager> callout_manager_;
 
    bool test_mode_;
};
 
} // namespace util
} // namespace hooks
 
#endif // HOOKS_MANAGER_H