ServerImpl.h

Go to the documentation of this file.

// Copyright 2014 Sensics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef INCLUDED_ServerImpl_h_GUID_BA15589C_D1AD_4BBE_4F93_8AC87043A982
#define INCLUDED_ServerImpl_h_GUID_BA15589C_D1AD_4BBE_4F93_8AC87043A982

// Internal Includes
#include <osvr/Common/CommonComponent_fwd.h>
#include <osvr/Common/CreateDevice.h>
#include <osvr/Common/LowLatency.h>
#include <osvr/Common/PathTree.h>
#include <osvr/Common/SystemComponent_fwd.h>
#include <osvr/Connection/ConnectionPtr.h>
#include <osvr/Connection/DeviceToken.h>
#include <osvr/Connection/MessageTypePtr.h>
#include <osvr/PluginHost/RegistrationContext_fwd.h>
#include <osvr/Server/Server.h>
#include <osvr/Util/Flag.h>
#include <osvr/Util/Log.h>
#include <osvr/Util/SharedPtr.h>
#include <osvr/Util/UniquePtr.h>

// Library/third-party includes
#include <boost/noncopyable.hpp>
#include <boost/optional.hpp>
#include <boost/thread.hpp>

#include <json/value.h>
#include <util/RunLoopManagerBoost.h>
#include <vrpn_Connection.h>

// Standard includes
#include <string>

namespace osvr {
namespace server {

    class ServerImpl : boost::noncopyable {
      public:
        ServerImpl(connection::ConnectionPtr const &conn,
                   boost::optional<std::string> const &host,
                   boost::optional<int> const &port);

        ~ServerImpl();

        void start();

        void startAndAwaitShutdown();

        void awaitShutdown();

        void stop();

        void signalStop();

        void loadPlugin(std::string const &pluginName);

        void loadAutoPlugins();

        void setHardwareDetectOnConnection();

        void triggerHardwareDetect();

        void registerMainloopMethod(MainloopMethod f);

        bool addRoute(std::string const &routingDirective);

        bool addAlias(std::string const &path, std::string const &source,
                      common::AliasPriority priority);

        bool addAliases(Json::Value const &aliases,
                        common::AliasPriority priority);

        void addExternalDevice(std::string const &path,
                               std::string const &deviceName,
                               std::string const &server,
                               std::string const &descriptor);

        bool addString(std::string const &path, std::string const &value);

        void setSleepTime(int microseconds);
#if 0
        int getSleepTime() const;
#endif
        void instantiateDriver(std::string const &plugin,
                               std::string const &driver,
                               std::string const &params);

        void update();

      private:
        bool m_loop();

        void m_update();

        template <typename Callable> void m_callControlled(Callable f);

        template <typename Callable> void m_callControlled(Callable f) const;

        void m_orderedDestruction();

        void m_queueTreeSend();

        void m_sendTree();

        static int VRPN_CALLBACK m_handleUpdatedRoute(void *userdata,
                                                      vrpn_HANDLERPARAM p);

        bool m_addRoute(std::string const &routingDirective);

        bool m_addAlias(std::string const &path, std::string const &source,
                        common::AliasPriority priority);

        bool m_addAliases(Json::Value const &aliases,
                          common::AliasPriority priority);

        void m_handleDeviceDescriptors();

        bool m_inServerThread() const;

        static int VRPN_CALLBACK m_exitIdle(void *userdata, vrpn_HANDLERPARAM);
        static int VRPN_CALLBACK m_enterIdle(void *userdata, vrpn_HANDLERPARAM);

        connection::ConnectionPtr m_conn;

        shared_ptr<pluginhost::RegistrationContext> m_ctx;

        std::vector<MainloopMethod> m_mainloopMethods;

        common::BaseDevicePtr m_systemDevice;

        common::SystemComponent *m_systemComponent = nullptr;

        common::CommonComponent *m_commonComponent = nullptr;

        bool m_triggeredDetect = false;

        common::PathTree m_tree;
        util::Flag m_treeDirty;

        mutable boost::mutex m_mainThreadMutex;

        mutable boost::mutex m_runControl;
        boost::thread m_thread;
        ::util::RunLoopManagerBoost m_run;
        bool m_running = false;
        bool m_everStarted = false;

        mutable boost::thread::id m_mainThreadId;

        int m_sleepTime = 0;

        static const int IDLE_SLEEP_TIME = 1000;

        int m_currentSleepTime = IDLE_SLEEP_TIME;

        std::string m_host;

        int m_port;

        util::log::LoggerPtr m_log;

        unique_ptr<common::LowLatency> m_lowLatency;
    };

    class TemporaryThreadIDChanger : boost::noncopyable {
      public:
        TemporaryThreadIDChanger(boost::thread::id &id)
            : m_id(id), m_origID(id) {
            m_id = boost::this_thread::get_id();
        }
        ~TemporaryThreadIDChanger() { m_id = m_origID; }

      private:
        boost::thread::id &m_id;
        boost::thread::id m_origID;
    };

    inline bool ServerImpl::m_inServerThread() const {
        boost::unique_lock<boost::mutex> lock(m_runControl);
        return !m_running || (boost::this_thread::get_id() == m_mainThreadId);
    }

    template <typename Callable>
    inline void ServerImpl::m_callControlled(Callable f) {
        boost::unique_lock<boost::mutex> lock(m_runControl);
        if (m_running && boost::this_thread::get_id() != m_thread.get_id()) {
            boost::unique_lock<boost::mutex> innerLock(m_mainThreadMutex);
            TemporaryThreadIDChanger changer(m_mainThreadId);
            f();
        } else {
            f();
        }
    }

    template <typename Callable>
    inline void ServerImpl::m_callControlled(Callable f) const {
        boost::unique_lock<boost::mutex> lock(m_runControl);
        if (m_running && boost::this_thread::get_id() != m_thread.get_id()) {
            boost::unique_lock<boost::mutex> innerLock(m_mainThreadMutex);
            TemporaryThreadIDChanger changer(m_mainThreadId);
            f();
        } else {
            f();
        }
    }

} // namespace server
} // namespace osvr

#endif // INCLUDED_ServerImpl_h_GUID_BA15589C_D1AD_4BBE_4F93_8AC87043A982