hooks_manager.h

Go to the documentation of this file.

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

    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);

    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();


    std::string validateLibrariesInternal(
                       const std::vector<std::string>& libraries) const;

    bool loadLibrariesInternal(const HookLibsCollection& libraries);

    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