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