Service.h

Go to the documentation of this file.

 
#pragma once
 
#include "RobotRaconteur/RobotRaconteurNode.h"
#include "RobotRaconteur/DataTypes.h"
#include "RobotRaconteur/ServiceFactory.h"
#include "RobotRaconteur/ServiceDefinition.h"
#include "RobotRaconteur/ServiceStructure.h"
#include <istream>
#include <boost/atomic.hpp>
 
#pragma warning(push)
#pragma warning(disable : 4996)
#include <boost/signals2.hpp>
 
namespace RobotRaconteur
{
 
class ROBOTRACONTEUR_CORE_API ServerEndpoint;
class ROBOTRACONTEUR_CORE_API AuthenticatedUser;
class ROBOTRACONTEUR_CORE_API ServerContext;
class ROBOTRACONTEUR_CORE_API ServerContext_ObjectLock;
class ROBOTRACONTEUR_CORE_API ServerContext_MonitorObjectSkel;
 
class ROBOTRACONTEUR_CORE_API GeneratorServerBase;
 
class ROBOTRACONTEUR_CORE_API IRobotRaconteurMonitorObject;
 
class ROBOTRACONTEUR_CORE_API IRRServiceObject
{
  public:
    virtual void RRServiceObjectInit(RR_WEAK_PTR<ServerContext> context, const std::string& service_path) = 0;
    virtual ~IRRServiceObject() {}
};
 
class ROBOTRACONTEUR_CORE_API ServiceSkel : public RR_ENABLE_SHARED_FROM_THIS<ServiceSkel>, private boost::noncopyable
{
 
  public:
    ServiceSkel();
    virtual ~ServiceSkel() {}
 
    virtual void Init(boost::string_ref s, const RR_SHARED_PTR<RRObject>& o, const RR_SHARED_PTR<ServerContext>& c);
 
    virtual void InitCallbackServers(const RR_SHARED_PTR<RRObject>& o);
 
    std::string GetServicePath() const;
 
  protected:
    std::string m_ServicePath;
 
  public:
    RR_SHARED_PTR<ServerContext> GetContext();
 
  protected:
    RR_WEAK_PTR<ServerContext> m_context;
 
    RR_SHARED_PTR<RRObject> uncastobj;
 
    std::vector<boost::tuple<RobotRaconteurVersion, std::string> > object_type_ver;
 
    boost::unordered_map<int32_t, RR_SHARED_PTR<GeneratorServerBase> > generators;
    boost::mutex generators_lock;
 
    int32_t get_new_generator_index();
 
  public:
    RR_SHARED_PTR<RRObject> GetUncastObject() const;
 
    virtual RR_INTRUSIVE_PTR<MessageEntry> CallGetProperty(const RR_INTRUSIVE_PTR<MessageEntry>& m) = 0;
 
    virtual RR_INTRUSIVE_PTR<MessageEntry> CallSetProperty(const RR_INTRUSIVE_PTR<MessageEntry>& m) = 0;
 
    virtual RR_INTRUSIVE_PTR<MessageEntry> CallFunction(const RR_INTRUSIVE_PTR<MessageEntry>& m) = 0;
 
  protected:
    static void EndAsyncCallGetProperty(RR_WEAK_PTR<ServiceSkel> skel, const RR_INTRUSIVE_PTR<MessageElement>& value,
                                        const RR_SHARED_PTR<RobotRaconteurException>& err,
                                        const RR_INTRUSIVE_PTR<MessageEntry>& m,
                                        const RR_SHARED_PTR<ServerEndpoint>& ep);
 
    static void EndAsyncCallSetProperty(RR_WEAK_PTR<ServiceSkel> skel,
                                        const RR_SHARED_PTR<RobotRaconteurException>& err,
                                        const RR_INTRUSIVE_PTR<MessageEntry>& m,
                                        const RR_SHARED_PTR<ServerEndpoint>& ep);
 
    static void EndAsyncCallFunction(RR_WEAK_PTR<ServiceSkel> skel, const RR_INTRUSIVE_PTR<MessageElement>& ret,
                                     const RR_SHARED_PTR<RobotRaconteurException>& err,
                                     const RR_INTRUSIVE_PTR<MessageEntry>& m, const RR_SHARED_PTR<ServerEndpoint>& ep);
 
  public:
    virtual RR_SHARED_PTR<RRObject> GetSubObj(boost::string_ref name, boost::string_ref ind) = 0;
 
    RR_SHARED_PTR<RRObject> GetSubObj(boost::string_ref name);
 
    virtual void RegisterEvents(const RR_SHARED_PTR<RRObject>& obj1);
 
    virtual void UnregisterEvents(const RR_SHARED_PTR<RRObject>& obj1);
 
    virtual void InitPipeServers(const RR_SHARED_PTR<RRObject>& obj1);
 
    virtual void InitWireServers(const RR_SHARED_PTR<RRObject>& obj1);
 
    void ObjRefChanged(boost::string_ref name);
 
    void SendEvent(const RR_INTRUSIVE_PTR<MessageEntry>& m);
 
    void ReleaseObject();
 
    virtual void ReleaseCastObject() = 0;
 
    void AsyncSendPipeMessage(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e, bool unreliable,
                              RR_MOVE_ARG(boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)>)
                                  handler);
 
    void SendWireMessage(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e);
 
    virtual void DispatchPipeMessage(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e);
 
    virtual void DispatchWireMessage(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e);
 
    virtual RR_INTRUSIVE_PTR<MessageEntry> CallPipeFunction(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e);
 
    virtual RR_INTRUSIVE_PTR<MessageEntry> CallWireFunction(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e);
 
    virtual RR_SHARED_PTR<void> GetCallbackFunction(uint32_t endpoint, boost::string_ref membername);
 
    virtual RR_INTRUSIVE_PTR<MessageEntry> CallMemoryFunction(const RR_INTRUSIVE_PTR<MessageEntry>& m,
                                                              const RR_SHARED_PTR<Endpoint>& e);
 
    RR_WEAK_PTR<ServerContext_ObjectLock> objectlock;
    boost::mutex objectlock_lock;
 
    RR_SHARED_PTR<ServerContext_MonitorObjectSkel> monitorlock;
 
    RR_UNORDERED_MAP<uint32_t, RR_SHARED_PTR<ServerContext_MonitorObjectSkel> > monitorlocks;
    boost::mutex monitorlocks_lock;
 
    bool IsLocked();
 
    virtual bool IsRequestNoLock(const RR_INTRUSIVE_PTR<MessageEntry>& m);
 
    bool IsMonitorLocked();
 
    virtual std::string GetObjectType() = 0;
 
    virtual std::string GetObjectType(const RobotRaconteurVersion& client_version);
 
    RR_SHARED_PTR<RobotRaconteurNode> RRGetNode();
    RR_WEAK_PTR<RobotRaconteurNode> RRGetNodeWeak();
 
    virtual void CallGeneratorNext(const RR_INTRUSIVE_PTR<MessageEntry>& m, const RR_SHARED_PTR<Endpoint>& e);
 
    void SendGeneratorResponse(int32_t index, const RR_INTRUSIVE_PTR<MessageEntry>& m,
                               const RR_SHARED_PTR<ServerEndpoint>& ep);
 
    void CleanupGenerators();
 
  protected:
    RR_WEAK_PTR<RobotRaconteurNode> node;
};
 
class ROBOTRACONTEUR_CORE_API UserAuthenticator;
 
class ROBOTRACONTEUR_CORE_API ServerContext : public RR_ENABLE_SHARED_FROM_THIS<ServerContext>, boost::noncopyable
{
  public:
    std::map<std::string, RR_INTRUSIVE_PTR<RRValue> > GetAttributes();
 
    void SetAttributes(const std::map<std::string, RR_INTRUSIVE_PTR<RRValue> >& attr);
 
  private:
    std::map<std::string, RR_INTRUSIVE_PTR<RRValue> > m_Attributes;
    boost::mutex m_Attributes_lock;
 
  public:
    RR_SHARED_PTR<ServiceFactory> GetServiceDef() const;
 
    RR_SHARED_PTR<ServiceFactory> GetRootObjectServiceDef(const RobotRaconteurVersion& client_version);
 
    virtual ~ServerContext() {}
 
  protected:
    RR_SHARED_PTR<ServiceFactory> m_ServiceDef;
 
  public:
    std::vector<std::string> GetExtraImports();
 
    void AddExtraImport(boost::string_ref import_);
 
    bool RemoveExtraImport(boost::string_ref import_);
 
  protected:
    std::vector<std::string> extra_imports;
    boost::mutex extra_imports_lock;
 
  public:
    std::string GetServiceName() const;
 
  protected:
    std::string m_ServiceName;
 
    RR_UNORDERED_MAP<MessageStringPtr, RR_SHARED_PTR<ServiceSkel> > skels;
    boost::mutex skels_lock;
 
    RR_UNORDERED_MAP<uint32_t, RR_SHARED_PTR<ServerEndpoint> > client_endpoints;
    boost::mutex client_endpoints_lock;
 
  public:
    std::string GetRootObjectType(const RobotRaconteurVersion& client_version);
 
  protected:
    std::string m_RootObjectType;
 
    RR_WEAK_PTR<RobotRaconteurNode> node;
 
    /*public Message SendRequest(Message m)
    {
        return null;
    }*/
 
  public:
    ServerContext(const RR_SHARED_PTR<ServiceFactory>& f, const RR_SHARED_PTR<RobotRaconteurNode>& node);
 
    RR_SHARED_PTR<RobotRaconteurNode> GetNode();
 
    virtual void SendEvent(const RR_INTRUSIVE_PTR<MessageEntry>& m);
#undef SendMessage
    virtual void SendMessage(const RR_INTRUSIVE_PTR<MessageEntry>& m, const RR_SHARED_PTR<Endpoint>& e);
 
    virtual void SendMessage(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e);
 
    virtual void AsyncSendMessage(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e,
                                  const boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)>& callback);
 
    virtual void AsyncSendMessage(const RR_INTRUSIVE_PTR<MessageEntry>& m, const RR_SHARED_PTR<Endpoint>& e,
                                  const boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)>& callback);
 
    virtual void AsyncSendUnreliableMessage(
        const RR_INTRUSIVE_PTR<MessageEntry>& m, const RR_SHARED_PTR<ServerEndpoint>& e,
        const boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)>& callback);
 
    virtual void AsyncSendPipeMessage(
        const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e, bool unreliable,
        const boost::function<void(const RR_SHARED_PTR<RobotRaconteurException>&)>& callback);
 
    virtual void SendWireMessage(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t e);
 
  private:
    // boost::mutex rec_sync;
 
    bool base_object_set;
 
  protected:
    void SetSecurityPolicy(const RR_SHARED_PTR<ServiceSecurityPolicy>& policy);
 
  public:
    virtual void SetBaseObject(
        boost::string_ref name, const RR_SHARED_PTR<RRObject>& o,
        const RR_SHARED_PTR<ServiceSecurityPolicy>& policy = RR_SHARED_PTR<ServiceSecurityPolicy>());
 
    virtual RR_SHARED_PTR<ServiceSkel> GetObjectSkel(MessageStringRef servicepath);
 
    virtual void ReplaceObject(boost::string_ref path);
 
    virtual std::string GetObjectType(MessageStringRef servicepath, const RobotRaconteurVersion& client_version);
 
    static RR_SHARED_PTR<ServerContext> GetCurrentServerContext();
 
  private:
    static boost::thread_specific_ptr<RR_SHARED_PTR<ServerContext> > m_CurrentServerContext;
 
  public:
    static std::string GetCurrentServicePath();
 
  private:
    static boost::thread_specific_ptr<std::string> m_CurrentServicePath;
 
  public:
    virtual RR_INTRUSIVE_PTR<MessageEntry> ProcessMessageEntry(const RR_INTRUSIVE_PTR<MessageEntry>& m,
                                                               const RR_SHARED_PTR<ServerEndpoint>& c);
 
    virtual void Close();
 
    virtual void MessageReceived(const RR_INTRUSIVE_PTR<Message>& m, const RR_SHARED_PTR<ServerEndpoint>& e);
 
    virtual void AddClient(const RR_SHARED_PTR<ServerEndpoint>& cendpoint);
 
    virtual void RemoveClient(const RR_SHARED_PTR<ServerEndpoint>& cendpoint);
 
    virtual void KickUser(boost::string_ref username);
 
  private:
    RR_SHARED_PTR<UserAuthenticator> user_authenticator;
    std::map<std::string, std::string> security_policies;
 
    bool m_RequireValidUser;
    bool AllowObjectLock;
 
    virtual RR_INTRUSIVE_PTR<MessageEntry> ClientSessionOp(const RR_INTRUSIVE_PTR<MessageEntry>& m,
                                                           const RR_SHARED_PTR<ServerEndpoint>& e);
 
  public:
    virtual bool RequireValidUser();
 
    virtual RR_SHARED_PTR<AuthenticatedUser> AuthenticateUser(
        boost::string_ref username, std::map<std::string, RR_INTRUSIVE_PTR<RRValue> >& credentials,
        const RR_SHARED_PTR<ServerEndpoint>& ep);
 
  private:
    boost::mutex ClientLockOp_lockobj;
 
    virtual void ClientLockOp(const RR_INTRUSIVE_PTR<MessageEntry>& m, const RR_INTRUSIVE_PTR<MessageEntry>& ret);
 
  public:
    void RequestObjectLock(boost::string_ref servicepath, boost::string_ref username);
 
    void RequestClientObjectLock(boost::string_ref servicepath, boost::string_ref username, uint32_t endpoint);
 
    void ReleaseObjectLock(boost::string_ref servicepath, boost::string_ref username, bool override_);
 
    std::string GetObjectLockUsername(boost::string_ref servicepath);
 
  protected:
    void check_lock(const RR_SHARED_PTR<ServiceSkel>& skel, const RR_INTRUSIVE_PTR<MessageEntry>& m);
 
    void check_monitor_lock(const RR_SHARED_PTR<ServiceSkel>& skel);
 
    RR_UNORDERED_MAP<std::string, RR_SHARED_PTR<ServerContext_ObjectLock> > active_object_locks;
 
  public:
    virtual void PeriodicCleanupTask();
 
  protected:
    RR_INTRUSIVE_PTR<MessageEntry> CheckServiceCapability(const RR_INTRUSIVE_PTR<MessageEntry>& m,
                                                          const RR_SHARED_PTR<ServerEndpoint>& c);
 
  public:
    boost::signals2::signal<void(const RR_SHARED_PTR<ServerContext>&, ServerServiceListenerEventType,
                                 const RR_SHARED_PTR<void>&)>
        ServerServiceListener;
 
  protected:
    void ReleaseServicePath1(const std::string& path);
 
  public:
    void ReleaseServicePath(boost::string_ref path);
 
    void ReleaseServicePath(boost::string_ref path, const std::vector<uint32_t>& endpoints);
 
    void AsyncProcessCallbackRequest(
        const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t endpoint,
        RR_MOVE_ARG(
            boost::function<void(const RR_INTRUSIVE_PTR<MessageEntry>&, const RR_SHARED_PTR<RobotRaconteurException>&)>)
            handler,
        int32_t timeout = RR_TIMEOUT_INFINITE);
 
  private:
    void AsyncProcessCallbackRequest_err(const RR_SHARED_PTR<RobotRaconteurException>& error, uint32_t endpoint,
                                         uint32_t requestid);
 
    void AsyncProcessCallbackRequest_timeout(const TimerEvent&, uint32_t endpoint, uint32_t requestid);
 
    uint32_t request_number;
 
    struct outstanding_request
    {
        RR_INTRUSIVE_PTR<MessageEntry> ret;
        RR_SHARED_PTR<AutoResetEvent> evt;
        boost::function<void(const RR_INTRUSIVE_PTR<MessageEntry>& ret,
                             const RR_SHARED_PTR<RobotRaconteurException>& error)>
            handler;
        RR_SHARED_PTR<Timer> timer;
    };
 
    boost::mutex outstanding_requests_lock;
    RR_UNORDERED_MAP<uint32_t, RR_SHARED_PTR<outstanding_request> > outstanding_requests;
 
  public:
    RR_INTRUSIVE_PTR<MessageEntry> ProcessCallbackRequest(const RR_INTRUSIVE_PTR<MessageEntry>& m, uint32_t endpointid);
 
    int32_t GetMonitorThreadPoolCount();
 
    void SetMonitorThreadPoolCount(int32_t count);
 
    RR_SHARED_PTR<ThreadPool> GetMonitorThreadPool();
 
  protected:
    RR_SHARED_PTR<ThreadPool> monitor_thread_pool;
    boost::mutex monitor_thread_pool_lock;
 
  public:
    std::vector<std::string> GetCandidateConnectionURLs();
 
    void PrintCandidateConnectionURLs(std::ostream& out = std::cout);
 
    void LogCandidateConnectionURLs(RobotRaconteur_LogLevel level = RobotRaconteur_LogLevel_Info);
};
 
class ROBOTRACONTEUR_CORE_API ServerEndpoint : public Endpoint, public RR_ENABLE_SHARED_FROM_THIS<ServerEndpoint>
{
  public:
    RR_SHARED_PTR<ServerContext> service;
 
  private:
    static boost::thread_specific_ptr<RR_SHARED_PTR<ServerEndpoint> > m_CurrentEndpoint;
 
  public:
    static RR_SHARED_PTR<ServerEndpoint> GetCurrentEndpoint();
 
  private:
    static boost::thread_specific_ptr<RR_SHARED_PTR<AuthenticatedUser> > m_CurrentAuthenticatedUser;
 
  public:
    static RR_SHARED_PTR<AuthenticatedUser> GetCurrentAuthenticatedUser();
 
  private:
    RR_SHARED_PTR<AuthenticatedUser> endpoint_authenticated_user;
 
  public:
    const std::string GetAuthenticatedUsername() const;
 
    RR_OVIRTUAL void MessageReceived(const RR_INTRUSIVE_PTR<Message>& m) RR_OVERRIDE;
 
    void AuthenticateUser(boost::string_ref username, std::map<std::string, RR_INTRUSIVE_PTR<RRValue> >& credentials);
 
    void LogoutUser();
 
    RR_OVIRTUAL void PeriodicCleanupTask() RR_OVERRIDE;
 
    RR_OVIRTUAL void SetTransportConnection(const RR_SHARED_PTR<ITransportConnection>& c) RR_OVERRIDE;
 
  private:
    RobotRaconteurVersion client_version;
    boost::mutex this_lock;
 
  public:
    RobotRaconteurVersion GetClientVersion();
    void SetClientVersion(const RobotRaconteurVersion& version);
 
    ServerEndpoint(const RR_SHARED_PTR<RobotRaconteurNode>& node) : Endpoint(node) {}
};
 
class ROBOTRACONTEUR_CORE_API IRobotRaconteurMonitorObject
{
  public:
    virtual void RobotRaconteurMonitorEnter() = 0;
 
    virtual void RobotRaconteurMonitorEnter(int32_t timeout) = 0;
 
    virtual void RobotRaconteurMonitorExit() = 0;
 
    virtual ~IRobotRaconteurMonitorObject() {}
};
 
class ROBOTRACONTEUR_CORE_API RRObject_default_impl : public virtual RRObject
{
  protected:
    boost::mutex this_lock;
};
 
#ifndef ROBOTRACONTEUR_NO_CXX11_TEMPLATE_ALIASES
using ServiceSkelPtr = RR_SHARED_PTR<ServiceSkel>;
using ServerContextPtr = RR_SHARED_PTR<ServerContext>;
using ServerEndpointPtr = RR_SHARED_PTR<ServerEndpoint>;
#endif
 
} // namespace RobotRaconteur
 
#pragma warning(pop)