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