Revert "Allow components to depend on other components (#4295)"

This reverts commit 7b612d3, reversing
changes made to 49f0c60.

libtenzir/builtins/components/metrics_collector.cpp

@@ -63,9 +63,7 @@ struct metrics_collector_state {
  return ok.error();
  }
  }
- if (instances.empty()) {
- return {};
- }
+ TENZIR_ASSERT(not instances.empty());
  detail::weak_run_delayed_loop(
  self, std::chrono::seconds{30},
  [this] {
@@ -141,6 +139,9 @@ class plugin final : public virtual component_plugin {
 
  auto make_component(node_actor::stateful_pointer<node_state> node) const
  -> component_plugin_actor override {
+ if (collect(plugins::get<metrics_plugin>()).empty()) {
+ return {};
+ }
  auto [importer] = node->state.registry.find<importer_actor>();
  return node->spawn<caf::linked>(metrics_collector, std::move(importer));
  }

libtenzir/include/tenzir/node.hpp

@@ -74,9 +74,6 @@ struct node_state {
  /// The component registry.
  component_registry registry = {};
 
- /// The list of component plugin actors in the order that they were spawned.
- std::vector<std::string> ordered_components = {};
-
  /// Components that are still alive for lifetime-tracking.
  std::set<std::pair<caf::actor_addr, std::string>> alive_components = {};
 

libtenzir/include/tenzir/plugin.hpp

@@ -147,11 +147,6 @@ class component_plugin : public virtual plugin {
  /// Defaults to the plugin name.
  virtual std::string component_name() const;
 
- /// Components that should be created before the current one so initialization
- /// can succeed.
- /// Defaults to empty list.
- virtual auto wanted_components() const -> std::vector<std::string>;
-
  /// Creates an actor as a component in the NODE.
  /// @param node A stateful pointer to the NODE actor.
  /// @returns The actor handle to the NODE component.

libtenzir/src/node.cpp

@@ -284,56 +284,6 @@ auto node_state::get_endpoint_handler(const http_request_description& desc)
  return result->second;
 }
 
-auto spawn_components(node_actor::stateful_pointer<node_state> self) -> void {
- using component_plugin_map = std::unordered_map<std::string, const component_plugin*>;
- // 1. Collect all component_plugins into a name -> plugin* map:
- component_plugin_map todo = {};
- for (const auto* component : plugins::get<component_plugin>()) {
- todo.emplace(component->component_name(), component);
- }
- // 2. Calculate an ordered loading sequnce based on the wanted_components of
- // each plugin.
- std::vector<const component_plugin*> sequenced_components = {};
- std::unordered_set<std::string> done = {};
- auto derive_sequence = [&](auto derive_sequence, const std::string& name) {
- auto entry = todo.find(name);
- if (entry == todo.end()) {
- return;
- }
- const auto* plugin = entry->second;
- todo.erase(entry);
- if (done.contains(name)) {
- return;
- }
- for (auto& wanted : plugin->wanted_components()) {
- derive_sequence(derive_sequence, wanted);
- }
- done.insert(name);
- sequenced_components.push_back(plugin);
- };
- while (not todo.empty()) {
- derive_sequence(derive_sequence, todo.begin()->second->component_name());
- }
- // 3. Load all components in order.
- for (const auto* plugin : sequenced_components) {
- auto name = plugin->component_name();
- auto handle = plugin->make_component(self);
- if (!handle) {
- diagnostic::error("{} failed to create the {} component", *self, name)
- .throw_();
- }
- self->system().registry().put(fmt::format("tenzir.{}", name), handle);
- if (auto err = register_component(self, caf::actor_cast<caf::actor>(handle),
- name)) {
- diagnostic::error(err)
- .note("{} failed to register component {} in component registry", *self,
- name)
- .throw_();
- }
- self->state.ordered_components.push_back(name);
- }
-}
-
 node_actor::behavior_type
 node(node_actor::stateful_pointer<node_state> self, std::string /*name*/,
  std::filesystem::path dir) {
@@ -380,19 +330,6 @@ node(node_actor::stateful_pointer<node_state> self, std::string /*name*/,
  }
  }
  });
- self->set_exception_handler([=](std::exception_ptr& ptr) -> caf::error {
- try {
- std::rethrow_exception(ptr);
- } catch (const diagnostic& diag) {
- return diag.to_error();
- } catch (const std::exception& err) {
- return diagnostic::error("{}", err.what())
- .note("unhandled exception in {}", *self)
- .to_error();
- } catch (...) {
- return diagnostic::error("unhandled exception in {}", *self).to_error();
- }
- });
  // Terminate deterministically on shutdown.
  self->set_exit_handler([=](const caf::exit_msg& msg) {
  TENZIR_DEBUG("{} got EXIT from {}", *self, msg.source);
@@ -417,12 +354,6 @@ node(node_actor::stateful_pointer<node_state> self, std::string /*name*/,
  // Core components are terminated in a second stage, we remove them from the
  // registry upfront and deal with them later.
  std::vector<caf::actor> core_shutdown_handles;
- for (const auto& name :
- self->state.ordered_components | std::ranges::views::reverse) {
- if (auto comp = registry.remove(name)) {
- core_shutdown_handles.push_back(comp->actor);
- }
- }
  caf::actor filesystem_handle;
  // The components listed here need to be terminated in sequential order.
  // The importer needs to shut down first because it might still have
@@ -526,7 +457,27 @@ node(node_actor::stateful_pointer<node_state> self, std::string /*name*/,
  return rp;
  },
  [self](atom::internal, atom::spawn, atom::plugin) -> caf::result<void> {
- spawn_components(self);
+ // Add all plugins to the component registry.
+ for (const auto& component : plugins::get<component_plugin>()) {
+ auto handle = component->make_component(self);
+ if (!handle) {
+ // The spawn function can provide a better log message so we don't
+ // print one here.
+ continue;
+ }
+ self->system().registry().put(
+ fmt::format("tenzir.{}", component->component_name()), handle);
+ if (auto err
+ = register_component(self, caf::actor_cast<caf::actor>(handle),
+ component->component_name())) {
+ return caf::make_error( //
+ ec::unspecified, fmt::format("{} failed to register component {} "
+ "from plugin {} in component "
+ "registry: {}",
+ *self, component->component_name(),
+ component->name(), err));
+ }
+ }
  return {};
  },
  [self](atom::spawn, const invocation& inv) {

libtenzir/src/plugin.cpp

@@ -405,10 +405,6 @@ std::string component_plugin::component_name() const {
  return this->name();
 }
 
-auto component_plugin::wanted_components() const -> std::vector<std::string> {
- return {};
-}
-
 // -- loader plugin -----------------------------------------------------------
 
 auto loader_parser_plugin::supported_uri_schemes() const

nix/tenzir/plugins/source.json

@@ -2,7 +2,8 @@
  "name": "tenzir-plugins",
  "url": "[email protected]:tenzir/tenzir-plugins",
  "ref": "main",
- "rev": "0fa9bf5efa10534e21ca7d2b399871f06dbd0022",
+ "rev": "891b31784dccb6868afb5c19d8c88c10f3bb1a09",
  "submodules": true,
- "shallow": true
+ "shallow": true,
+ "allRefs": true
 }