ServiceSpec.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef O2_FRAMEWORK_SERVICESPEC_H_
#define O2_FRAMEWORK_SERVICESPEC_H_
 
#include "Framework/ServiceHandle.h"
#include "Framework/RoutingIndices.h"
#include <fairmq/FwdDecls.h>
#include <string>
#include <functional>
#include <vector>
 
namespace fair::mq
{
struct ProgOptions;
}
 
namespace o2::framework
{
 
struct InitContext;
struct DeviceSpec;
struct ServiceRegistry;
struct ServiceRegistryRef;
struct DeviceState;
struct ProcessingContext;
class EndOfStreamContext;
struct ConfigContext;
struct WorkflowSpecNode;
 
struct ServiceMetricsInfo;
struct DeviceConfig;
struct DriverServerContext;
 
class DanglingContext;
 
using ServiceId = std::function<unsigned int()>;
using ServiceInit = ServiceHandle (*)(ServiceRegistryRef, DeviceState&, fair::mq::ProgOptions&);
using ServiceStartCallback = void (*)(ServiceRegistryRef, void*);
using ServiceStopCallback = void (*)(ServiceRegistryRef, void*);
using ServiceExitCallback = void (*)(ServiceRegistryRef, void*);
 
using ServiceConfigureCallback = void* (*)(InitContext&, void*);
 
using ServiceProcessingCallback = void (*)(ProcessingContext&, void*);
 
using ServiceDanglingCallback = void (*)(DanglingContext&, void*);
 
using ServiceEOSCallback = void (*)(EndOfStreamContext&, void*);
 
using ServicePreFork = std::function<void(ServiceRegistryRef, DeviceConfig const&)>;
 
using ServicePostForkChild = std::function<void(ServiceRegistryRef)>;
 
using ServicePostForkParent = std::function<void(ServiceRegistryRef)>;
 
using ServicePreSchedule = void (*)(ServiceRegistryRef, DeviceConfig const&);
 
using ServicePostSchedule = void (*)(ServiceRegistryRef, DeviceConfig const&);
 
using ServiceMetricHandling = void (*)(ServiceRegistryRef,
                                       ServiceMetricsInfo const&,
                                       size_t timestamp);
 
using ServiceSummaryHandling = void (*)(ServiceMetricsInfo const& metrics);
 
using ServicePostDispatching = void (*)(ProcessingContext&, void*);
 
using ServicePostForwarding = void (*)(ProcessingContext&, void*);
 
using ServiceDriverInit = void (*)(ServiceRegistryRef, DeviceConfig const&);
 
using ServiceDriverStartup = void (*)(ServiceRegistryRef, DeviceConfig const&);
 
using ServicePreLoop = void (*)(ServiceRegistryRef, void*);
 
using ServiceTopologyInject = void (*)(WorkflowSpecNode&, ConfigContext&);
 
using ServiceTopologyAdjust = void (*)(WorkflowSpecNode&, ConfigContext const&);
 
using ServiceDomainInfoUpdated = void (*)(ServiceRegistryRef, size_t tileslice, ChannelIndex channel);
 
using ServicePreSendingMessages = void (*)(ServiceRegistryRef, fair::mq::Parts&, ChannelIndex channel);
 
using ServicePostRenderGUI = void (*)(ServiceRegistryRef);
 
struct ServiceSpec {
  std::string name = "please specify name";
  ServiceId uniqueId = nullptr;
  ServiceInit init = nullptr;
  ServiceConfigureCallback configure = nullptr;
  ServiceProcessingCallback preProcessing = nullptr;
  ServiceProcessingCallback finaliseOutputs = nullptr;
  ServiceProcessingCallback postProcessing = nullptr;
  ServiceDanglingCallback preDangling = nullptr;
  ServiceDanglingCallback postDangling = nullptr;
  ServiceEOSCallback preEOS = nullptr;
  ServiceEOSCallback postEOS = nullptr;
  ServicePreFork preFork = nullptr;
  ServicePostForkChild postForkChild = nullptr;
  ServicePostForkParent postForkParent = nullptr;
 
  ServicePreSchedule preSchedule = nullptr;
  ServicePostSchedule postSchedule = nullptr;
 
  ServiceMetricHandling metricHandling = nullptr;
 
  ServicePostDispatching postDispatching = nullptr;
 
  ServicePostForwarding postForwarding = nullptr;
 
  ServiceStartCallback start = nullptr;
  ServiceStopCallback stop = nullptr;
  ServiceExitCallback exit = nullptr;
  ServiceDriverInit driverInit = nullptr;
  ServiceDriverStartup driverStartup = nullptr;
 
  ServicePreLoop preLoop = nullptr;
 
  ServiceTopologyInject injectTopology = nullptr;
 
  ServiceTopologyAdjust adjustTopology = nullptr;
 
  ServiceDomainInfoUpdated domainInfoUpdated = nullptr;
 
  ServicePreSendingMessages preSendingMessages = nullptr;
 
  ServicePostRenderGUI postRenderGUI = nullptr;
 
  ServiceSummaryHandling summaryHandling = nullptr;
 
  bool active = true;
 
  ServiceKind kind = ServiceKind::Serial;
};
 
struct OverrideServiceSpec {
  std::string name;
  bool active;
};
 
using OverrideServiceSpecs = std::vector<OverrideServiceSpec>;
using ServiceSpecs = std::vector<ServiceSpec>;
 
struct ServiceSpecHelpers {
  static OverrideServiceSpecs parseOverrides(char const* overrideString);
  static ServiceSpecs filterDisabled(ServiceSpecs originals, OverrideServiceSpecs const& overrides);
};
 
struct ServiceConfigureHandle {
  ServiceSpec const& spec;
  ServiceConfigureCallback callback;
  void* service;
};
 
struct ServiceProcessingHandle {
  ServiceSpec const& spec;
  ServiceProcessingCallback callback;
  void* service;
};
 
struct ServiceDanglingHandle {
  ServiceSpec const& spec;
  ServiceDanglingCallback callback;
  void* service;
};
 
struct ServiceEOSHandle {
  ServiceSpec const& spec;
  ServiceEOSCallback callback;
  void* service;
};
 
struct ServiceDispatchingHandle {
  ServiceSpec const& spec;
  ServicePostDispatching callback;
  void* service;
};
 
struct ServiceForwardingHandle {
  ServiceSpec const& spec;
  ServicePostForwarding callback;
  void* service;
};
 
struct ServiceStartHandle {
  ServiceSpec const& spec;
  ServiceStartCallback callback;
  void* service;
};
 
struct ServiceStartStreamHandle {
  ServiceSpec const& spec;
  ServiceStartCallback callback;
  void* service;
};
 
struct ServiceStopHandle {
  ServiceSpec const& spec;
  ServiceStopCallback callback;
  void* service;
};
 
struct ServiceExitHandle {
  ServiceSpec const& spec;
  ServiceExitCallback callback;
  void* service;
};
 
struct ServiceDomainInfoHandle {
  ServiceSpec const& spec;
  ServiceDomainInfoUpdated callback;
  void* service;
};
 
struct ServicePreSendingMessagesHandle {
  ServiceSpec const& spec;
  ServicePreSendingMessages callback;
  void* service;
};
 
struct ServicePostRenderGUIHandle {
  ServiceSpec const& spec;
  ServicePostRenderGUI callback;
  void* service;
};
 
struct ServicePreLoopHandle {
  ServiceSpec const& spec;
  ServicePreLoop callback;
  void* service;
};
 
struct ServicePlugin {
  virtual ServiceSpec* create() = 0;
};
 
} // namespace o2::framework
 
#endif // O2_FRAMEWORK_SERVICESPEC_H_