vtkPVSessionBase.h

Go to the documentation of this file.

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

#include "vtkPVSession.h"
#include "vtkRemotingServerManagerModule.h" //needed for exports
#include "vtkSMMessageMinimal.h"            // needed for vtkSMMessage

class vtkClientServerStream;
class vtkCollection;
class vtkSIObject;
class vtkPVInformation;
class vtkPVServerInformation;
class vtkSIProxyDefinitionManager;
class vtkPVSessionCore;

class VTKREMOTINGSERVERMANAGER_EXPORT vtkPVSessionBase : public vtkPVSession
{
public:
  vtkTypeMacro(vtkPVSessionBase, vtkPVSession);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum EventIds
  {
    RegisterRemoteObjectEvent = 1234,
    UnRegisterRemoteObjectEvent = 4321,
    ProcessingRemoteEnd = 2143,
    ConnectionLost = 6789
  };

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

  ServerFlags GetProcessRoles() override;

  vtkPVServerInformation* GetServerInformation() override;

  vtkMPIMToNSocketConnection* GetMPIMToNSocketConnection() override;

  //---------------------------------------------------------------------------
  // Remote communication API. This API is used for communication in the
  // CLIENT -> SERVER(s) direction.
  //---------------------------------------------------------------------------

  virtual void PushState(vtkSMMessage* msg);

  virtual void PullState(vtkSMMessage* msg);

  virtual void ExecuteStream(vtkTypeUInt32 location, const vtkClientServerStream& stream,
    bool ignoreErrors = false, bool sendReply = false);

  virtual const vtkClientServerStream& GetLastResult(vtkTypeUInt32 location);

  virtual bool GatherInformation(
    vtkTypeUInt32 location, vtkPVInformation* information, vtkTypeUInt32 globalid);

  //---------------------------------------------------------------------------
  // Remote communication API. This API is used for communication in the
  // SERVER -> CLIENT direction. Since satellite nodes cannot communicate with
  // the client, these methods have no effect on the satellite nodes and must
  // only the called on the root-nodes for the server processes.
  // If these methods are called on a process acting as a client, then it is
  // processed on that process immediately, as appropriate.
  //---------------------------------------------------------------------------

  virtual void NotifyAllClients(const vtkSMMessage*) = 0;

  virtual void NotifyOtherClients(const vtkSMMessage*) = 0;

  //---------------------------------------------------------------------------
  // API dealing with/forwarded to vtkPVSessionCore dealing with SIObjects and
  // SMObjects.
  //---------------------------------------------------------------------------


  vtkGetObjectMacro(SessionCore, vtkPVSessionCore);

  vtkSIProxyDefinitionManager* GetProxyDefinitionManager();

  vtkSIObject* GetSIObject(vtkTypeUInt32 globalid);

  virtual void UnRegisterSIObject(vtkSMMessage* msg);

  virtual void RegisterSIObject(vtkSMMessage* msg);

  vtkObject* GetRemoteObject(vtkTypeUInt32 globalid);

  virtual void GetAllRemoteObjects(vtkCollection* collection);

  //---------------------------------------------------------------------------
  // API for GlobalId management
  //---------------------------------------------------------------------------

  virtual vtkTypeUInt32 GetNextGlobalUniqueIdentifier();

  virtual vtkTypeUInt32 GetNextChunkGlobalUniqueIdentifier(vtkTypeUInt32 chunkSize);

  virtual bool IsProcessingRemoteNotification();

  virtual void UseSessionCoreOf(vtkPVSessionBase* other);

protected:
  vtkPVSessionBase();
  vtkPVSessionBase(vtkPVSessionCore* coreToUse);
  ~vtkPVSessionBase() override;


  vtkPVSessionCore* GetSessionCore() const;
  void SetSessionCore(vtkPVSessionCore*);


  void PrepareProgressInternal() override;
  void CleanupPendingProgressInternal() override;

  friend class vtkSMRemoteObject;
  friend class vtkSMSessionProxyManager;
  friend class vtkSMLiveInsituLinkProxy; // Needed to get access to vtkPVCatalystSessionCore


  virtual bool StartProcessingRemoteNotification();
  virtual void StopProcessingRemoteNotification(bool previousValue);
  bool ProcessingRemoteNotification;

  void RegisterRemoteObject(vtkTypeUInt32 globalid, vtkTypeUInt32 location, vtkObject* obj);

  void UnRegisterRemoteObject(vtkTypeUInt32 globalid, vtkTypeUInt32 location);

  vtkPVSessionCore* SessionCore;

private:
  vtkPVSessionBase(const vtkPVSessionBase&) = delete;
  void operator=(const vtkPVSessionBase&) = delete;

  // Shared constructor method
  void InitSessionBase(vtkPVSessionCore* coreToUse);

  vtkPVServerInformation* LocalServerInformation;
  unsigned long ActivateObserverTag;
  unsigned long DesactivateObserverTag;
};

#endif