vtkSMSession.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSMSession_h
#define vtkSMSession_h

#include "vtkNetworkAccessManager.h" // needed for vtkNetworkAccessManager::ConnectionResult.
#include "vtkPVSessionBase.h"
#include "vtkRemotingServerManagerModule.h" //needed for exports

class vtkSMCollaborationManager;
class vtkSMProxyLocator;
class vtkSMSessionProxyManager;
class vtkSMStateLocator;

class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMSession : public vtkPVSessionBase
{
public:
  static vtkSMSession* New();
  static vtkSMSession* New(vtkPVSessionBase* otherSession);
  static vtkSMSession* New(vtkPVSessionCore* otherSessionCore);
  vtkTypeMacro(vtkSMSession, vtkPVSessionBase);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  //---------------------------------------------------------------------------
  // API for collaboration management
  //---------------------------------------------------------------------------

  virtual vtkSMCollaborationManager* GetCollaborationManager() { return nullptr; }

  //---------------------------------------------------------------------------
  // API for client-side components of a session.
  //---------------------------------------------------------------------------

  virtual const char* GetURI() { return "builtin:"; }


  vtkGetObjectMacro(SessionProxyManager, vtkSMSessionProxyManager);

  virtual int GetNumberOfProcesses(vtkTypeUInt32 servers);

  virtual bool IsMPIInitialized(vtkTypeUInt32 servers);

  //---------------------------------------------------------------------------
  // API for Proxy Finder/ReNew
  //---------------------------------------------------------------------------

  vtkGetObjectMacro(ProxyLocator, vtkSMProxyLocator);

  enum RenderingMode
  {
    RENDERING_NOT_AVAILABLE = 0x00,
    RENDERING_UNIFIED = 0x01,
    RENDERING_SPLIT = 0x02
  };

  virtual unsigned int GetRenderClientMode();

  //---------------------------------------------------------------------------
  // Undo/Redo related API.
  //---------------------------------------------------------------------------


  vtkGetObjectMacro(StateLocator, vtkSMStateLocator);

  //---------------------------------------------------------------------------
  // Superclass Implementations
  //---------------------------------------------------------------------------

  bool GetIsAlive() override { return true; }

  ServerFlags GetProcessRoles() override;

  void PushState(vtkSMMessage* msg) override;

  void NotifyAllClients(const vtkSMMessage* msg) override { this->ProcessNotification(msg); }

  void NotifyOtherClients(const vtkSMMessage*) override
  { /* nothing to do. */
  }

  //---------------------------------------------------------------------------
  // API for Collaboration management
  //---------------------------------------------------------------------------

  // Called before application quit or session disconnection
  virtual void PreDisconnection() {}

  //---------------------------------------------------------------------------
  // Static methods to create and register sessions easily.
  //---------------------------------------------------------------------------

  static vtkIdType ConnectToCatalyst();


  static vtkIdType ConnectToSelf();


  static vtkIdType ConnectToRemote(const char* hostname, int port, int timeout = 60)
  {
    vtkNetworkAccessManager::ConnectionResult result;
    return vtkSMSession::ConnectToRemote(hostname, port, timeout, nullptr, result);
  }
  static vtkIdType ConnectToRemote(const char* hostname, int port, int timeout, bool (*callback)(),
    vtkNetworkAccessManager::ConnectionResult& result);


  static vtkIdType ReverseConnectToRemote(int port)
  {
    return vtkSMSession::ReverseConnectToRemoteWithTimeout(port, 60);
  }
  static vtkIdType ReverseConnectToRemoteWithTimeout(int port, int timeout)
  {
    vtkNetworkAccessManager::ConnectionResult result;
    return vtkSMSession::ReverseConnectToRemote(port, timeout, nullptr, result);
  }
  static vtkIdType ReverseConnectToRemote(
    int port, int timeout, bool (*callback)(), vtkNetworkAccessManager::ConnectionResult& result);


  static vtkIdType ConnectToRemote(
    const char* dshost, int dsport, const char* rshost, int rsport, int timeout = 60)
  {
    vtkNetworkAccessManager::ConnectionResult result;
    return vtkSMSession::ConnectToRemote(dshost, dsport, rshost, rsport, timeout, nullptr, result);
  }
  static vtkIdType ConnectToRemote(const char* dshost, int dsport, const char* rshost, int rsport,
    int timeout, bool (*callback)(), vtkNetworkAccessManager::ConnectionResult& result);


  static vtkIdType ReverseConnectToRemote(int dsport, int rsport)
  {
    return vtkSMSession::ReverseConnectToRemoteWithTimeout(dsport, rsport, 60);
  }
  static vtkIdType ReverseConnectToRemoteWithTimeout(int dsport, int rsport, int timeout)
  {
    vtkNetworkAccessManager::ConnectionResult result;
    return vtkSMSession::ReverseConnectToRemote(dsport, rsport, timeout, nullptr, result);
  }
  static vtkIdType ReverseConnectToRemote(int dsport, int rsport, int timeout, bool (*callback)(),
    vtkNetworkAccessManager::ConnectionResult& result);


  static void Disconnect(vtkIdType sessionid);
  static void Disconnect(vtkSMSession* session);

protected:
  // Subclasses should set initialize_during_constructor to false so that
  // this->Initialize() is not called in constructor but only after the session
  // has been created/setup correctly.
  vtkSMSession(
    bool initialize_during_constructor = true, vtkPVSessionCore* preExistingSessionCore = nullptr);
  ~vtkSMSession() override;

  virtual void ProcessNotification(const vtkSMMessage*);

  virtual void Initialize();

  void UpdateStateHistory(vtkSMMessage* msg);

  vtkSMSessionProxyManager* SessionProxyManager;
  vtkSMStateLocator* StateLocator;
  vtkSMProxyLocator* ProxyLocator;

private:
  vtkSMSession(const vtkSMSession&) = delete;
  void operator=(const vtkSMSession&) = delete;
};

#endif