run_manager.cpp

Go to the documentation of this file.

// Copyright (c) 2024 anabrid GmbH
// Contact: https://www.anabrid.com/licensing/
// SPDX-License-Identifier: MIT OR GPL-2.0-or-later
 
#include <Arduino.h>
#include <cmath>
#include <cstdlib>
 
#include <daq/daq.h>
#include <mode/counters.h>
#include <run/manager.h>
#include <run/registry.h>
#include <run/handlers.h>
#include <utils/logging.h>
#include <protocol/protocol.h>
 
FLASHMEM utils::status run::RunManager::prepare_run(JsonObjectConst msg_in, Stream &io) {
  LOG_ALWAYS("run::RunManager::prepare_run");
  if (!msg_in.containsKey("id"))
    return utils::status(-1, "Need a run ID, must be a UUID");
 
  // *always* end any previous run. Ignore msg_in["end_repetitive"] or
  // msg_in["clear_queue"] because we just always overwrite any previous run.
  end_run();
 
  // Compatibility to former API
  auto json_run_config = msg_in["config"].as<JsonObjectConst>();
 
  bool calibrate = json_run_config["calibrate"] | false;
  bool compat_streaming = json_run_config["streaming"] | false;
  bool enable_state_change_handler = json_run_config["enable_state_change_handler"] | true;
  bool enable_data_handler = json_run_config["enable_data_handler"] | true;
  bool enable_alt_data_handler = json_run_config["enable_alt_data_handler"] | false;
 
  const char* default_runner_type = compat_streaming ? "flexio" : "sleep";
  
  std::string run_type = msg_in["run_type"] | default_runner_type;
  auto &registry = run::drivers::Registry::get();
  current_run = registry.create(run_type);
 
  if(!current_run) {
    if(run_type == default_runner_type) {
      LOG_ALWAYS("Default runner is not part of registry. Will default to first available driver.");
      current_run = registry.create_any();
      if(!current_run) {
        return utils::status(-2, "Run Driver Registry is empty.");
      }
    } else {
      return utils::status(-3, "Requested run_type is not available.");
    }
  }
 
  current_run->from_json(msg_in);
 
  if(enable_state_change_handler) {
    auto& envelope_out = msg::JsonLinesProtocol::get().envelope_out;
    current_run->state_change_handler = new run::RunStateChangeNotificationHandler(io, *envelope_out);
  }
 
  if(enable_data_handler) {
    current_run->data_handler = new run::RunDataNotificationHandler(io);
  }
 
  if(enable_alt_data_handler) {
    current_run->alt_data_handler = new run::StreamingRunDataNotificationHandler{io};
  }
 
  if(calibrate) {
    LOG_ALWAYS("Calibrating routes for run...")
    if(!carrier::get().calibrate_routes())
      LOG_ERROR("Error during self-calibration. Continue with reduced accuracy.");
  }
 
  return utils::status::success();
}
 
FLASHMEM void run::RunManager::start_run(const msg::Request& req, Stream &io) {
  auto status = prepare_run(req.msg_in, io);
 // the protocol wants to have a "all okay" reply before the run data/state handler outputs
  msg::StreamingJsonResponse::empty_envelope(io, req, status);
 
  invoke_run();
 
  auto json_run_config = req.msg_in["config"].as<JsonObjectConst>();
  bool repetitive = json_run_config["repetitive"] | false;
 
  if(!repetitive)
    end_run();
}
 
FLASHMEM utils::status run::RunManager::stop_run(JsonObjectConst msg_in, JsonObject &msg_out) {
  end_run();
  return utils::status::success();
}
 
FLASHMEM void run::drivers::DynamicRegistry::write_handler_names_to(JsonArray &target) {
  for (auto const &kv : entries) {
    target.add(kv.first);
  }
}