From 7db6cc3a59f030c196a6ecbede972c00bcd5bf8c Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 01:54:18 +0400
Subject: [PATCH 01/79] Step1

---
 .idea/codeStyles/Project.xml                  |   7 +-
 modules/di/build.gradle                       |  34 +++
 .../di/IgniteComponentLifecycleManager.java   | 166 ++++++++++++++
 .../internal/di/IgniteStartupPhase.java       |  41 ++++
 .../ignite/internal/di/StartupPhase.java      |  35 +++
 .../IgniteComponentLifecycleManagerTest.java  | 211 ++++++++++++++++++
 .../internal/di/TestComponentFactory.java     |  71 ++++++
 settings.gradle                               |   2 +
 8 files changed, 562 insertions(+), 5 deletions(-)
 create mode 100644 modules/di/build.gradle
 create mode 100644 modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
 create mode 100644 modules/di/src/main/java/org/apache/ignite/internal/di/IgniteStartupPhase.java
 create mode 100644 modules/di/src/main/java/org/apache/ignite/internal/di/StartupPhase.java
 create mode 100644 modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
 create mode 100644 modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index bf6498d4532f..a20afe5b881d 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -42,7 +42,7 @@
         </value>
       </option>
     </AndroidXmlCodeStyleSettings>
-    <JSCodeStyleSettings>
+    <JSCodeStyleSettings version="0">
       <option name="INDENT_CHAINED_CALLS" value="false" />
     </JSCodeStyleSettings>
     <JavaCodeStyleSettings>
@@ -112,7 +112,7 @@
     <Python>
       <option name="USE_CONTINUATION_INDENT_FOR_ARGUMENTS" value="true" />
     </Python>
-    <TypeScriptCodeStyleSettings>
+    <TypeScriptCodeStyleSettings version="0">
       <option name="INDENT_CHAINED_CALLS" value="false" />
     </TypeScriptCodeStyleSettings>
     <XML>
@@ -200,7 +200,6 @@
       <option name="DOWHILE_BRACE_FORCE" value="3" />
       <option name="WHILE_BRACE_FORCE" value="3" />
       <option name="FOR_BRACE_FORCE" value="3" />
-      <option name="PARENT_SETTINGS_INSTALLED" value="true" />
       <indentOptions>
         <option name="INDENT_SIZE" value="2" />
         <option name="TAB_SIZE" value="2" />
@@ -232,10 +231,8 @@
       </indentOptions>
     </codeStyleSettings>
     <codeStyleSettings language="Python">
-      <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
       <option name="RIGHT_MARGIN" value="80" />
       <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
-      <option name="PARENT_SETTINGS_INSTALLED" value="true" />
       <indentOptions>
         <option name="INDENT_SIZE" value="2" />
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
diff --git a/modules/di/build.gradle b/modules/di/build.gradle
new file mode 100644
index 000000000000..9e74b98d2b4c
--- /dev/null
+++ b/modules/di/build.gradle
@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+apply from: "$rootDir/buildscripts/java-core.gradle"
+apply from: "$rootDir/buildscripts/publishing.gradle"
+apply from: "$rootDir/buildscripts/java-junit5.gradle"
+
+dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
+    implementation project(':ignite-core')
+    implementation libs.micronaut.inject
+    implementation libs.jetbrains.annotations
+
+    testAnnotationProcessor libs.micronaut.inject.annotation.processor
+    testImplementation libs.micronaut.inject
+    testImplementation testFixtures(project(':ignite-core'))
+}
+
+description = 'ignite-di'
\ No newline at end of file
diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
new file mode 100644
index 000000000000..3f41aeed81ed
--- /dev/null
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
@@ -0,0 +1,166 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import static java.util.Collections.reverse;
+import static java.util.concurrent.CompletableFuture.allOf;
+import static java.util.concurrent.CompletableFuture.failedFuture;
+import static org.apache.ignite.internal.util.IgniteUtils.closeAll;
+
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.inject.BeanDefinition;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.manager.ComponentContext;
+import org.apache.ignite.internal.manager.IgniteComponent;
+
+/**
+ * Manages the lifecycle of {@link IgniteComponent} beans obtained from a Micronaut {@link ApplicationContext}.
+ *
+ * <p>Components are grouped by {@link StartupPhase} and can be started per-phase.
+ * Stopping is done in reverse order of startup across all phases.
+ */
+public class IgniteComponentLifecycleManager {
+    private final Map<StartupPhase, List<IgniteComponent>> componentsByPhase;
+
+    private final List<IgniteComponent> startedComponents = new ArrayList<>();
+
+    /**
+     * Creates the lifecycle manager by collecting all {@link IgniteComponent} beans from the given context
+     * and grouping them by their {@link IgniteStartupPhase} annotation.
+     *
+     * @param context Micronaut application context containing the component beans.
+     */
+    public IgniteComponentLifecycleManager(ApplicationContext context) {
+        componentsByPhase = new EnumMap<>(StartupPhase.class);
+
+        for (StartupPhase phase : StartupPhase.values()) {
+            componentsByPhase.put(phase, new ArrayList<>());
+        }
+
+        Collection<IgniteComponent> allComponents = context.getBeansOfType(IgniteComponent.class);
+
+        for (IgniteComponent component : allComponents) {
+            StartupPhase phase = resolvePhase(context, component);
+            componentsByPhase.get(phase).add(component);
+        }
+    }
+
+    /**
+     * Starts all components belonging to the given phase.
+     *
+     * @param phase The startup phase.
+     * @param componentContext The component lifecycle context.
+     * @return Future that completes when all components in the phase have started.
+     */
+    public CompletableFuture<Void> startPhase(StartupPhase phase, ComponentContext componentContext) {
+        List<IgniteComponent> components = componentsByPhase.get(phase);
+
+        CompletableFuture<?>[] futures = new CompletableFuture[components.size()];
+
+        for (int i = 0; i < components.size(); i++) {
+            IgniteComponent component = components.get(i);
+            startedComponents.add(component);
+            futures[i] = component.startAsync(componentContext);
+        }
+
+        return allOf(futures);
+    }
+
+    /**
+     * Stops all started components in reverse order of startup.
+     * Calls {@link IgniteComponent#beforeNodeStop()} on each component first,
+     * then {@link IgniteComponent#stopAsync(ComponentContext)}.
+     *
+     * @param componentContext The component lifecycle context.
+     * @return Future that completes when all components have stopped.
+     */
+    public CompletableFuture<Void> stopAll(ComponentContext componentContext) {
+        List<IgniteComponent> components = new ArrayList<>(startedComponents);
+        reverse(components);
+
+        try {
+            closeAll(components.stream().filter(Objects::nonNull).map(c -> c::beforeNodeStop));
+        } catch (Exception e) {
+            return failedFuture(e);
+        }
+
+        CompletableFuture<?>[] stopFutures = components.stream()
+                .filter(Objects::nonNull)
+                .map(component -> {
+                    try {
+                        return component.stopAsync(componentContext);
+                    } catch (Throwable e) {
+                        return failedFuture(e);
+                    }
+                })
+                .toArray(CompletableFuture[]::new);
+
+        return allOf(stopFutures);
+    }
+
+    /**
+     * Returns the components assigned to the given phase (unmodifiable view for testing).
+     *
+     * @param phase The startup phase.
+     * @return List of components in that phase.
+     */
+    public List<IgniteComponent> componentsForPhase(StartupPhase phase) {
+        return List.copyOf(componentsByPhase.get(phase));
+    }
+
+    /**
+     * Returns all started components in startup order.
+     *
+     * @return List of started components.
+     */
+    public List<IgniteComponent> startedComponents() {
+        return List.copyOf(startedComponents);
+    }
+
+    @SuppressWarnings("unchecked")
+    private static StartupPhase resolvePhase(ApplicationContext context, IgniteComponent component) {
+        // First, try to get the phase from the BeanDefinition (works for compile-time and factory beans).
+        Optional<BeanDefinition<IgniteComponent>> definition =
+                (Optional<BeanDefinition<IgniteComponent>>) (Optional<?>)
+                        context.findBeanDefinition(component.getClass());
+
+        if (definition.isPresent()) {
+            Optional<StartupPhase> phase = definition.get()
+                    .findAnnotation(IgniteStartupPhase.class)
+                    .flatMap(av -> av.enumValue(StartupPhase.class));
+            if (phase.isPresent()) {
+                return phase.get();
+            }
+        }
+
+        // Fall back to class-level annotation.
+        IgniteStartupPhase classAnnotation = component.getClass().getAnnotation(IgniteStartupPhase.class);
+        if (classAnnotation != null) {
+            return classAnnotation.value();
+        }
+
+        return StartupPhase.PHASE_1;
+    }
+}
diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteStartupPhase.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteStartupPhase.java
new file mode 100644
index 000000000000..559cf4f6b163
--- /dev/null
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteStartupPhase.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks an {@link org.apache.ignite.internal.manager.IgniteComponent} bean with the startup phase
+ * in which it should be started.
+ *
+ * <p>This annotation is used by {@link IgniteComponentLifecycleManager} to group components
+ * and start them in the correct phase during node startup.
+ *
+ * <p>Components without this annotation default to {@link StartupPhase#PHASE_1}.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface IgniteStartupPhase {
+    /** The startup phase for this component. */
+    StartupPhase value();
+}
diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/StartupPhase.java b/modules/di/src/main/java/org/apache/ignite/internal/di/StartupPhase.java
new file mode 100644
index 000000000000..e7c529dc40e2
--- /dev/null
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/StartupPhase.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+/**
+ * Defines the startup phase in which an {@link org.apache.ignite.internal.manager.IgniteComponent} should be started.
+ *
+ * <p>Ignite node startup happens in two phases:
+ * <ul>
+ *     <li>{@link #PHASE_1} — before the node joins the cluster (pre-join).</li>
+ *     <li>{@link #PHASE_2} — after the node joins the cluster (post-join).</li>
+ * </ul>
+ */
+public enum StartupPhase {
+    /** Components started before the node joins the cluster. */
+    PHASE_1,
+
+    /** Components started after the node joins the cluster. */
+    PHASE_2
+}
diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
new file mode 100644
index 000000000000..76139e259fa4
--- /dev/null
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
@@ -0,0 +1,211 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import static org.apache.ignite.internal.testframework.matchers.CompletableFutureMatcher.willCompleteSuccessfully;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.empty;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.micronaut.context.ApplicationContext;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import org.apache.ignite.internal.manager.ComponentContext;
+import org.apache.ignite.internal.manager.IgniteComponent;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests for {@link IgniteComponentLifecycleManager}.
+ */
+public class IgniteComponentLifecycleManagerTest {
+    private static final List<String> EVENTS = Collections.synchronizedList(new ArrayList<>());
+
+    private ApplicationContext appContext;
+
+    @AfterEach
+    void tearDown() {
+        EVENTS.clear();
+
+        if (appContext != null && appContext.isRunning()) {
+            appContext.close();
+        }
+    }
+
+    @Test
+    void componentsGroupedByPhase() {
+        appContext = ApplicationContext.builder().start();
+
+        IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
+
+        // TestComponentFactory produces one PHASE_1 and one PHASE_2 bean.
+        assertThat(manager.componentsForPhase(StartupPhase.PHASE_1), hasSize(1));
+        assertThat(manager.componentsForPhase(StartupPhase.PHASE_2), hasSize(1));
+    }
+
+    @Test
+    void startPhaseStartsComponentsAndTracksOrder() {
+        appContext = ApplicationContext.builder().start();
+
+        IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
+
+        assertThat(manager.startedComponents(), is(empty()));
+
+        assertThat(
+                manager.startPhase(StartupPhase.PHASE_1, new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+
+        List<IgniteComponent> started = manager.startedComponents();
+        assertThat(started, hasSize(manager.componentsForPhase(StartupPhase.PHASE_1).size()));
+    }
+
+    @Test
+    void stopAllStopsInReverseStartOrder() {
+        TrackingComponentA compA = new TrackingComponentA();
+        TrackingComponentB compB = new TrackingComponentB();
+
+        appContext = ApplicationContext.builder()
+                .singletons(compA, compB)
+                .start();
+
+        IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
+
+        // Start all phases so all components (factory + tracking) are started.
+        assertThat(
+                manager.startPhase(StartupPhase.PHASE_1, new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+
+        // Record start order of tracking components.
+        List<String> startOrder = EVENTS.stream()
+                .filter(e -> e.startsWith("start:"))
+                .map(e -> e.substring("start:".length()))
+                .collect(Collectors.toList());
+        assertEquals(2, startOrder.size(), "Expected exactly 2 tracking component start events");
+
+        EVENTS.clear();
+
+        assertThat(
+                manager.stopAll(new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+
+        // Verify beforeNodeStop is called in reverse of start order.
+        List<String> beforeStopOrder = EVENTS.stream()
+                .filter(e -> e.startsWith("beforeNodeStop:"))
+                .map(e -> e.substring("beforeNodeStop:".length()))
+                .collect(Collectors.toList());
+
+        List<String> stopOrder = EVENTS.stream()
+                .filter(e -> e.startsWith("stop:"))
+                .map(e -> e.substring("stop:".length()))
+                .collect(Collectors.toList());
+
+        List<String> expectedReverse = new ArrayList<>(startOrder);
+        Collections.reverse(expectedReverse);
+
+        assertEquals(expectedReverse, beforeStopOrder, "beforeNodeStop should be in reverse start order");
+        assertEquals(expectedReverse, stopOrder, "stopAsync should be in reverse start order");
+
+        // Verify all beforeNodeStop calls happen before any stopAsync calls.
+        int lastBeforeStop = -1;
+        int firstStop = Integer.MAX_VALUE;
+        for (int i = 0; i < EVENTS.size(); i++) {
+            if (EVENTS.get(i).startsWith("beforeNodeStop:")) {
+                lastBeforeStop = i;
+            }
+            if (EVENTS.get(i).startsWith("stop:") && i < firstStop) {
+                firstStop = i;
+            }
+        }
+        assertTrue(lastBeforeStop < firstStop, "All beforeNodeStop calls should precede stopAsync calls");
+    }
+
+    @Test
+    void multiPhaseStartAndStop() {
+        appContext = ApplicationContext.builder().start();
+
+        IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
+
+        assertThat(
+                manager.startPhase(StartupPhase.PHASE_1, new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+        int phase1Count = manager.startedComponents().size();
+        assertTrue(phase1Count > 0, "Phase 1 should have components");
+
+        assertThat(
+                manager.startPhase(StartupPhase.PHASE_2, new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+        int totalCount = manager.startedComponents().size();
+        assertTrue(totalCount > phase1Count, "Phase 2 should add more started components");
+
+        assertThat(
+                manager.stopAll(new ComponentContext()),
+                willCompleteSuccessfully()
+        );
+    }
+
+    /** Base test component that records lifecycle events. */
+    private abstract static class TrackingComponent implements IgniteComponent {
+        private final String name;
+
+        TrackingComponent(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
+            EVENTS.add("start:" + name);
+            return CompletableFuture.completedFuture(null);
+        }
+
+        @Override
+        public void beforeNodeStop() {
+            EVENTS.add("beforeNodeStop:" + name);
+        }
+
+        @Override
+        public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
+            EVENTS.add("stop:" + name);
+            return CompletableFuture.completedFuture(null);
+        }
+    }
+
+    /** Distinct type so Micronaut registers it as a separate bean. */
+    private static class TrackingComponentA extends TrackingComponent {
+        TrackingComponentA() {
+            super("A");
+        }
+    }
+
+    /** Distinct type so Micronaut registers it as a separate bean. */
+    private static class TrackingComponentB extends TrackingComponent {
+        TrackingComponentB() {
+            super("B");
+        }
+    }
+}
diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java b/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java
new file mode 100644
index 000000000000..93f90436b75a
--- /dev/null
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import io.micronaut.context.annotation.Bean;
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Singleton;
+import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.manager.ComponentContext;
+import org.apache.ignite.internal.manager.IgniteComponent;
+
+/**
+ * Test factory that produces {@link IgniteComponent} beans annotated with different {@link IgniteStartupPhase}s.
+ */
+@Factory
+class TestComponentFactory {
+    @Bean
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    TestPhase1Component phase1Component() {
+        return new TestPhase1Component();
+    }
+
+    @Bean
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    TestPhase2Component phase2Component() {
+        return new TestPhase2Component();
+    }
+
+    /** Test component for Phase 1. */
+    static class TestPhase1Component implements IgniteComponent {
+        @Override
+        public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
+            return CompletableFuture.completedFuture(null);
+        }
+
+        @Override
+        public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
+            return CompletableFuture.completedFuture(null);
+        }
+    }
+
+    /** Test component for Phase 2. */
+    static class TestPhase2Component implements IgniteComponent {
+        @Override
+        public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
+            return CompletableFuture.completedFuture(null);
+        }
+
+        @Override
+        public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
+            return CompletableFuture.completedFuture(null);
+        }
+    }
+}
diff --git a/settings.gradle b/settings.gradle
index e8212ab9d87d..d534d6f59ee9 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -108,6 +108,7 @@ include(':ignite-system-disaster-recovery')
 include(':ignite-system-disaster-recovery-api')
 include(':ignite-compatibility-tests')
 include(':ignite-configuration-storage')
+include(':ignite-di')
 include(':ignite-checkstyle-custom')
 
 project(":ignite-examples").projectDir = file('examples/java')
@@ -194,6 +195,7 @@ project(":ignite-system-disaster-recovery").projectDir = file('modules/system-di
 project(":ignite-system-disaster-recovery-api").projectDir = file('modules/system-disaster-recovery-api')
 project(':ignite-compatibility-tests').projectDir = file('modules/compatibility-tests')
 project(':ignite-configuration-storage').projectDir = file('modules/configuration-storage')
+project(':ignite-di').projectDir = file('modules/di')
 project(':ignite-checkstyle-custom').projectDir = file('modules/checkstyle-custom')
 
 include(":migration-tools-ignite2-repack")

From dccbcb8f921af0ad255df3953a1ae5055c21a6da Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 02:05:04 +0400
Subject: [PATCH 02/79] Step2

---
 .../ignite/internal/di/IgniteDiContext.java   | 100 ++++++++++++
 .../internal/di/IgniteDiContextTest.java      | 146 ++++++++++++++++++
 2 files changed, 246 insertions(+)
 create mode 100644 modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
 create mode 100644 modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java

diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
new file mode 100644
index 000000000000..3ccc8cb1a1b0
--- /dev/null
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
@@ -0,0 +1,100 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.ApplicationContextBuilder;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Builds and manages a non-HTTP Micronaut {@link ApplicationContext} for core Ignite component wiring.
+ *
+ * <p>This context is separate from the REST module's HTTP-enabled Micronaut context.
+ * It handles construction and dependency injection of {@link org.apache.ignite.internal.manager.IgniteComponent}
+ * beans, while lifecycle management (start/stop) remains with {@link IgniteComponentLifecycleManager}.
+ *
+ * <p>Usage:
+ * <pre>{@code
+ * ApplicationContext ctx = IgniteDiContext.builder()
+ *         .withSingleton(seedParams)
+ *         .withPackages("org.apache.ignite.internal.app")
+ *         .build();
+ * }</pre>
+ */
+public final class IgniteDiContext {
+    /**
+     * Creates a new builder for the core DI context.
+     *
+     * @return A new builder instance.
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /** Builder for constructing the core DI {@link ApplicationContext}. */
+    public static class Builder {
+        private final List<Object> singletons = new ArrayList<>();
+
+        private final List<String> packages = new ArrayList<>();
+
+        /**
+         * Registers a seed singleton that will be available for injection in the context.
+         *
+         * @param singleton The object to register as a singleton bean.
+         * @return This builder for chaining.
+         */
+        public Builder withSingleton(Object singleton) {
+            singletons.add(singleton);
+            return this;
+        }
+
+        /**
+         * Adds packages to scan for bean definitions.
+         *
+         * @param packageNames Package names to scan.
+         * @return This builder for chaining.
+         */
+        public Builder withPackages(String... packageNames) {
+            Collections.addAll(packages, packageNames);
+            return this;
+        }
+
+        /**
+         * Builds and starts the Micronaut {@link ApplicationContext}.
+         *
+         * @return The started application context.
+         */
+        public ApplicationContext build() {
+            ApplicationContextBuilder contextBuilder = ApplicationContext.builder()
+                    .deduceEnvironment(false)
+                    .banner(false);
+
+            if (!packages.isEmpty()) {
+                contextBuilder.packages(packages.toArray(String[]::new));
+            }
+
+            if (!singletons.isEmpty()) {
+                contextBuilder.singletons(singletons.toArray());
+            }
+
+            return contextBuilder.start();
+        }
+    }
+}
diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java
new file mode 100644
index 000000000000..4054a4f0b22e
--- /dev/null
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java
@@ -0,0 +1,146 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.di;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.micronaut.context.ApplicationContext;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests for {@link IgniteDiContext}.
+ */
+public class IgniteDiContextTest {
+    @Test
+    void buildsRunningContext() {
+        ApplicationContext ctx = IgniteDiContext.builder().build();
+
+        try {
+            assertTrue(ctx.isRunning());
+        } finally {
+            ctx.close();
+        }
+    }
+
+    @Test
+    void seedSingletonsAreInjectable() {
+        String seedValue = "test-node";
+
+        ApplicationContext ctx = IgniteDiContext.builder()
+                .withSingleton(seedValue)
+                .build();
+
+        try {
+            String retrieved = ctx.getBean(String.class);
+            assertThat(retrieved, is(sameInstance(seedValue)));
+        } finally {
+            ctx.close();
+        }
+    }
+
+    @Test
+    void seedSingletonsOfDifferentTypesCoexist() {
+        SeedA seedA = new SeedA("a");
+        SeedB seedB = new SeedB(42);
+
+        ApplicationContext ctx = IgniteDiContext.builder()
+                .withSingleton(seedA)
+                .withSingleton(seedB)
+                .build();
+
+        try {
+            assertThat(ctx.getBean(SeedA.class), is(sameInstance(seedA)));
+            assertThat(ctx.getBean(SeedB.class), is(sameInstance(seedB)));
+        } finally {
+            ctx.close();
+        }
+    }
+
+    @Test
+    void twoContextsCoexistIndependently() {
+        SeedA seedForCtx1 = new SeedA("ctx1");
+        SeedA seedForCtx2 = new SeedA("ctx2");
+
+        ApplicationContext ctx1 = IgniteDiContext.builder()
+                .withSingleton(seedForCtx1)
+                .build();
+
+        ApplicationContext ctx2 = IgniteDiContext.builder()
+                .withSingleton(seedForCtx2)
+                .build();
+
+        try {
+            assertThat(ctx1.getBean(SeedA.class).value, is("ctx1"));
+            assertThat(ctx2.getBean(SeedA.class).value, is("ctx2"));
+
+            assertTrue(ctx1.isRunning());
+            assertTrue(ctx2.isRunning());
+        } finally {
+            ctx1.close();
+            ctx2.close();
+        }
+    }
+
+    @Test
+    void contextDiscoversBeanDefinitions() {
+        ApplicationContext ctx = IgniteDiContext.builder().build();
+
+        try {
+            // TestComponentFactory (from test classpath) should be discovered.
+            assertThat(
+                    ctx.getBean(TestComponentFactory.TestPhase1Component.class),
+                    is(notNullValue())
+            );
+        } finally {
+            ctx.close();
+        }
+    }
+
+    @Test
+    void closedContextStopsCleanly() {
+        ApplicationContext ctx = IgniteDiContext.builder().build();
+
+        assertTrue(ctx.isRunning());
+        assertDoesNotThrow(ctx::close);
+        assertFalse(ctx.isRunning());
+    }
+
+    /** Simple seed type for testing. */
+    private static class SeedA {
+        final String value;
+
+        SeedA(String value) {
+            this.value = value;
+        }
+    }
+
+    /** Another seed type for testing. */
+    private static class SeedB {
+        final int value;
+
+        SeedB(int value) {
+            this.value = value;
+        }
+    }
+}

From f067d930f1ca06228e8901b4a9948732d5cc2f4f Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 02:19:17 +0400
Subject: [PATCH 03/79] Step3

---
 modules/runner/build.gradle                   |  1 +
 .../app/di/IgniteConfigurationFactory.java    | 91 +++++++++++++++++
 .../app/di/IgniteNodeSeedFactory.java         | 50 ++++++++++
 .../internal/app/di/NodeSeedParams.java       | 97 +++++++++++++++++++
 4 files changed, 239 insertions(+)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java

diff --git a/modules/runner/build.gradle b/modules/runner/build.gradle
index fb38f6c2eace..cc361e23ef03 100644
--- a/modules/runner/build.gradle
+++ b/modules/runner/build.gradle
@@ -97,6 +97,7 @@ dependencies {
     implementation project(':ignite-system-disaster-recovery')
     implementation project(':ignite-system-disaster-recovery-api')
     implementation project(':ignite-configuration-storage')
+    implementation project(':ignite-di')
     implementation libs.jetbrains.annotations
     implementation libs.micronaut.inject
     implementation libs.micronaut.validation
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
new file mode 100644
index 000000000000..14cd233199eb
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
+import org.apache.ignite.internal.configuration.storage.LocalFileConfigurationStorage;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
+
+/**
+ * Micronaut factory that produces local (node) configuration beans.
+ *
+ * <p>These form the configuration chain:
+ * {@link ConfigurationModules} → {@link ConfigurationTreeGenerator} → {@link LocalFileConfigurationStorage}
+ * → {@link ConfigurationValidator} → {@link ConfigurationRegistry}.
+ */
+@Factory
+public class IgniteConfigurationFactory {
+    private final NodeSeedParams seedParams;
+
+    private final ConfigurationModules modules;
+
+    public IgniteConfigurationFactory(NodeSeedParams seedParams, ConfigurationModules modules) {
+        this.seedParams = seedParams;
+        this.modules = modules;
+    }
+
+    /** Creates the tree generator for local configuration schemas. */
+    @Singleton
+    @Named("local")
+    public ConfigurationTreeGenerator localConfigurationTreeGenerator() {
+        return new ConfigurationTreeGenerator(
+                modules.local().rootKeys(),
+                modules.local().schemaExtensions(),
+                modules.local().polymorphicSchemaExtensions()
+        );
+    }
+
+    /** Creates the file-based storage for local configuration. */
+    @Singleton
+    public LocalFileConfigurationStorage localFileConfigurationStorage(
+            @Named("local") ConfigurationTreeGenerator generator
+    ) {
+        return new LocalFileConfigurationStorage(
+                seedParams.nodeName(),
+                seedParams.configPath(),
+                generator,
+                modules.local()
+        );
+    }
+
+    /** Creates the validator for local configuration. */
+    @Singleton
+    @Named("local")
+    public ConfigurationValidator localConfigurationValidator(
+            @Named("local") ConfigurationTreeGenerator generator
+    ) {
+        return ConfigurationValidatorImpl.withDefaultValidators(generator, modules.local().validators());
+    }
+
+    /** Creates the local (node) configuration registry. */
+    @Singleton
+    @Named("nodeConfig")
+    public ConfigurationRegistry nodeConfigRegistry(
+            LocalFileConfigurationStorage storage,
+            @Named("local") ConfigurationTreeGenerator generator,
+            @Named("local") ConfigurationValidator validator
+    ) {
+        return ConfigurationRegistry.create(modules.local(), storage, generator, validator);
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
new file mode 100644
index 000000000000..40086571b918
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import static org.apache.ignite.internal.configuration.IgnitePaths.vaultPath;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.vault.VaultService;
+import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
+
+/**
+ * Micronaut factory that produces infrastructure beans derived from {@link NodeSeedParams}.
+ */
+@Factory
+public class IgniteNodeSeedFactory {
+    private final NodeSeedParams seedParams;
+
+    public IgniteNodeSeedFactory(NodeSeedParams seedParams) {
+        this.seedParams = seedParams;
+    }
+
+    /** Creates the persistent vault service backed by the node's work directory. */
+    @Singleton
+    public VaultService vaultService() {
+        return new PersistentVaultService(vaultPath(seedParams.workDir()));
+    }
+
+    /** Discovers configuration modules from the service provider class loader. */
+    @Singleton
+    public ConfigurationModules configurationModules() {
+        return ConfigurationModules.create(seedParams.serviceProviderClassLoader());
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java
new file mode 100644
index 000000000000..c14c0e6c69d5
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import java.nio.file.Path;
+import java.util.concurrent.Executor;
+import org.apache.ignite.IgniteServer;
+import org.apache.ignite.internal.disaster.system.ServerRestarter;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Holds the seed parameters provided to an Ignite node at construction time.
+ * Registered as a singleton bean in the core DI context so that factories and components
+ * can inject it to access node identity, paths, and bootstrap objects.
+ */
+public class NodeSeedParams {
+    private final IgniteServer node;
+
+    private final ServerRestarter restarter;
+
+    private final Path configPath;
+
+    private final Path workDir;
+
+    @Nullable
+    private final ClassLoader serviceProviderClassLoader;
+
+    private final Executor asyncContinuationExecutor;
+
+    /** Constructor. */
+    public NodeSeedParams(
+            IgniteServer node,
+            ServerRestarter restarter,
+            Path configPath,
+            Path workDir,
+            @Nullable ClassLoader serviceProviderClassLoader,
+            Executor asyncContinuationExecutor
+    ) {
+        this.node = node;
+        this.restarter = restarter;
+        this.configPath = configPath;
+        this.workDir = workDir;
+        this.serviceProviderClassLoader = serviceProviderClassLoader;
+        this.asyncContinuationExecutor = asyncContinuationExecutor;
+    }
+
+    /** Node name. */
+    public String nodeName() {
+        return node.name();
+    }
+
+    /** The Ignite server instance. */
+    public IgniteServer node() {
+        return node;
+    }
+
+    /** Server restarter for handling node restarts. */
+    public ServerRestarter restarter() {
+        return restarter;
+    }
+
+    /** Path to the node configuration file. */
+    public Path configPath() {
+        return configPath;
+    }
+
+    /** Node working directory. */
+    public Path workDir() {
+        return workDir;
+    }
+
+    /** Class loader used to discover service providers, or {@code null} for the system class loader. */
+    @Nullable
+    public ClassLoader serviceProviderClassLoader() {
+        return serviceProviderClassLoader;
+    }
+
+    /** Executor in which user-facing futures will be completed. */
+    public Executor asyncContinuationExecutor() {
+        return asyncContinuationExecutor;
+    }
+}

From 748b8f58f851d2ad705b694468714ae16d0f096e Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 02:25:50 +0400
Subject: [PATCH 04/79] Step4

---
 .../app/di/CoreComponentsFactory.java         | 83 +++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
new file mode 100644
index 000000000000..2231f59ec872
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import java.util.UUID;
+import java.util.function.Supplier;
+import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.components.LongJvmPauseDetector;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.failure.FailureProcessor;
+import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.hlc.HybridClockImpl;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.metrics.MetricManagerImpl;
+import org.apache.ignite.internal.vault.VaultManager;
+import org.apache.ignite.internal.vault.VaultService;
+
+/**
+ * Micronaut factory for leaf Ignite components that have few or no dependencies on other components.
+ */
+@Factory
+public class CoreComponentsFactory {
+    /** Creates the JVM pause detector. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public LongJvmPauseDetector longJvmPauseDetector(NodeSeedParams seedParams) {
+        return new LongJvmPauseDetector(seedParams.nodeName());
+    }
+
+    /** Creates the vault manager backed by persistent storage. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public VaultManager vaultManager(VaultService vaultService) {
+        return new VaultManager(vaultService);
+    }
+
+    /**
+     * Creates the metric manager.
+     *
+     * @param seedParams Node seed parameters.
+     * @param clusterIdSupplier Supplier of the cluster ID; resolved lazily after cluster initialization.
+     */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public MetricManager metricManager(
+            NodeSeedParams seedParams,
+            @Named("clusterIdSupplier") Supplier<UUID> clusterIdSupplier
+    ) {
+        return new MetricManagerImpl(seedParams.nodeName(), clusterIdSupplier);
+    }
+
+    /** Creates the thread pools manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public ThreadPoolsManager threadPoolsManager(NodeSeedParams seedParams, MetricManager metricManager) {
+        return new ThreadPoolsManager(seedParams.nodeName(), metricManager);
+    }
+
+    /** Creates the hybrid logical clock. */
+    @Singleton
+    public HybridClock hybridClock(FailureProcessor failureProcessor) {
+        return new HybridClockImpl(failureProcessor);
+    }
+}

From a3ecffc43bd063a991557695ebf37c383897f349 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 09:05:43 +0400
Subject: [PATCH 05/79] Step5

---
 .../app/di/NetworkComponentsFactory.java      | 132 ++++++++++++++++++
 1 file changed, 132 insertions(+)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
new file mode 100644
index 000000000000..3d86a2ffbce4
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -0,0 +1,132 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
+import org.apache.ignite.internal.configuration.SystemLocalExtensionConfiguration;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.disaster.system.ClusterIdService;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
+import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
+import org.apache.ignite.internal.hlc.ClockWaiter;
+import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.network.NettyBootstrapFactory;
+import org.apache.ignite.internal.network.NettyWorkersRegistrar;
+import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
+import org.apache.ignite.internal.network.configuration.NetworkExtensionConfiguration;
+import org.apache.ignite.internal.vault.VaultManager;
+import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
+import org.apache.ignite.internal.worker.CriticalWorkerWatchdog;
+
+/**
+ * Micronaut factory for network and infrastructure components.
+ */
+@Factory
+public class NetworkComponentsFactory {
+    /** Creates the network configuration from the node config registry. */
+    @Singleton
+    public NetworkConfiguration networkConfiguration(@Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry) {
+        return nodeConfigRegistry.getConfiguration(NetworkExtensionConfiguration.KEY).network();
+    }
+
+    /** Creates the failure processor configuration from the node config registry. */
+    @Singleton
+    public FailureProcessorConfiguration failureProcessorConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(FailureProcessorExtensionConfiguration.KEY).failureHandler();
+    }
+
+    /** Creates the system local configuration from the node config registry. */
+    @Singleton
+    public SystemLocalConfiguration systemLocalConfiguration(@Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry) {
+        return nodeConfigRegistry.getConfiguration(SystemLocalExtensionConfiguration.KEY).system();
+    }
+
+    /** Creates the failure manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public FailureManager failureManager(
+            NodeSeedParams seedParams,
+            FailureProcessorConfiguration failureProcessorConfiguration
+    ) {
+        return new FailureManager(seedParams.nodeName(), seedParams.node()::shutdown, failureProcessorConfiguration);
+    }
+
+    /** Creates the critical worker watchdog. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public CriticalWorkerWatchdog criticalWorkerWatchdog(
+            SystemLocalConfiguration systemConfiguration,
+            ThreadPoolsManager threadPoolsManager,
+            FailureManager failureManager
+    ) {
+        return new CriticalWorkerWatchdog(
+                systemConfiguration.criticalWorkers(),
+                threadPoolsManager.commonScheduler(),
+                failureManager
+        );
+    }
+
+    /** Creates the netty bootstrap factory. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public NettyBootstrapFactory nettyBootstrapFactory(NodeSeedParams seedParams, NetworkConfiguration networkConfiguration) {
+        return new NettyBootstrapFactory(networkConfiguration, seedParams.nodeName());
+    }
+
+    /** Creates the netty workers registrar. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public NettyWorkersRegistrar nettyWorkersRegistrar(
+            CriticalWorkerRegistry criticalWorkerRegistry,
+            ThreadPoolsManager threadPoolsManager,
+            NettyBootstrapFactory nettyBootstrapFactory,
+            SystemLocalConfiguration systemConfiguration,
+            FailureManager failureManager
+    ) {
+        return new NettyWorkersRegistrar(
+                criticalWorkerRegistry,
+                threadPoolsManager.commonScheduler(),
+                nettyBootstrapFactory,
+                systemConfiguration.criticalWorkers(),
+                failureManager
+        );
+    }
+
+    /** Creates the clock waiter. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public ClockWaiter clockWaiter(NodeSeedParams seedParams, HybridClock clock, ThreadPoolsManager threadPoolsManager) {
+        return new ClockWaiter(seedParams.nodeName(), clock, threadPoolsManager.commonScheduler());
+    }
+
+    /** Creates the cluster ID service. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public ClusterIdService clusterIdService(VaultManager vaultManager) {
+        return new ClusterIdService(vaultManager);
+    }
+}

From abe4454575f89224cc14939084f98b3b70dfbb6e Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 09:21:02 +0400
Subject: [PATCH 06/79] Step6

---
 .../app/di/ClusterManagementFactory.java      | 246 ++++++++++++++++++
 .../ignite/internal/app/di/RaftFactory.java   | 236 +++++++++++++++++
 2 files changed, 482 insertions(+)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
new file mode 100644
index 000000000000..4e5d538f8d99
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -0,0 +1,246 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
+import org.apache.ignite.internal.cluster.management.ClusterInitializer;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.cluster.management.NodeAttributesCollector;
+import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesConfiguration;
+import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesExtensionConfiguration;
+import org.apache.ignite.internal.cluster.management.raft.ClusterStateStorageManager;
+import org.apache.ignite.internal.cluster.management.raft.RocksDbClusterStateStorage;
+import org.apache.ignite.internal.cluster.management.raft.ValidationManager;
+import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
+import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyServiceImpl;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
+import org.apache.ignite.internal.configuration.ConfigurationDynamicDefaultsPatcherImpl;
+import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.disaster.system.ClusterIdService;
+import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.ChannelTypeRegistryProvider;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.MessageSerializationRegistryImpl;
+import org.apache.ignite.internal.network.NettyBootstrapFactory;
+import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
+import org.apache.ignite.internal.network.recovery.InMemoryStaleIds;
+import org.apache.ignite.internal.network.scalecube.ScaleCubeClusterService;
+import org.apache.ignite.internal.network.serialization.MessageSerializationRegistry;
+import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
+import org.apache.ignite.internal.raft.RaftManager;
+import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
+import org.apache.ignite.internal.storage.configurations.StorageExtensionConfiguration;
+import org.apache.ignite.internal.vault.VaultManager;
+import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
+import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
+
+/**
+ * Micronaut factory for cluster management components.
+ */
+@Factory
+public class ClusterManagementFactory {
+    /** Creates the message serialization registry. */
+    @Singleton
+    public MessageSerializationRegistry messageSerializationRegistry() {
+        return new MessageSerializationRegistryImpl();
+    }
+
+    /** Creates the cluster service. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public ClusterService clusterService(
+            NodeSeedParams seedParams,
+            NetworkConfiguration networkConfiguration,
+            NettyBootstrapFactory nettyBootstrapFactory,
+            MessageSerializationRegistry serializationRegistry,
+            ClusterIdService clusterIdService,
+            CriticalWorkerRegistry criticalWorkerRegistry,
+            FailureManager failureManager,
+            MetricManager metricManager
+    ) {
+        return new ScaleCubeClusterService(
+                seedParams.nodeName(),
+                networkConfiguration,
+                nettyBootstrapFactory,
+                serializationRegistry,
+                new InMemoryStaleIds(),
+                clusterIdService,
+                criticalWorkerRegistry,
+                failureManager,
+                ChannelTypeRegistryProvider.loadByServiceLoader(seedParams.serviceProviderClassLoader()),
+                new DefaultIgniteProductVersionSource(),
+                metricManager
+        );
+    }
+
+    /** Creates the node attributes configuration from the node config registry. */
+    @Singleton
+    public NodeAttributesConfiguration nodeAttributesConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(NodeAttributesExtensionConfiguration.KEY).nodeAttributes();
+    }
+
+    /** Creates the storage profiles configuration from the node config registry. */
+    @Singleton
+    public StorageConfiguration storageConfiguration(@Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry) {
+        return nodeConfigRegistry.getConfiguration(StorageExtensionConfiguration.KEY).storage();
+    }
+
+    /** Creates the cluster state storage backed by RocksDB. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public RocksDbClusterStateStorage clusterStateStorage(@Named("cmg") ComponentWorkingDir cmgWorkDir, NodeSeedParams seedParams) {
+        return new RocksDbClusterStateStorage(cmgWorkDir.dbPath(), seedParams.nodeName());
+    }
+
+    /** Creates the cluster state storage manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public ClusterStateStorageManager clusterStateStorageManager(RocksDbClusterStateStorage clusterStateStorage) {
+        return new ClusterStateStorageManager(clusterStateStorage);
+    }
+
+    /** Creates the logical topology implementation. */
+    @Singleton
+    public LogicalTopologyImpl logicalTopology(RocksDbClusterStateStorage clusterStateStorage, FailureManager failureManager) {
+        return new LogicalTopologyImpl(clusterStateStorage, failureManager);
+    }
+
+    /** Creates the validation manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public ValidationManager validationManager(
+            ClusterStateStorageManager clusterStateStorageManager,
+            LogicalTopologyImpl logicalTopology
+    ) {
+        return new ValidationManager(clusterStateStorageManager, logicalTopology);
+    }
+
+    /** Creates the distributed configuration tree generator. */
+    @Singleton
+    @Named("distributed")
+    public ConfigurationTreeGenerator distributedConfigurationTreeGenerator(ConfigurationModules modules) {
+        return new ConfigurationTreeGenerator(
+                modules.distributed().rootKeys(),
+                modules.distributed().schemaExtensions(),
+                modules.distributed().polymorphicSchemaExtensions()
+        );
+    }
+
+    /** Creates the distributed configuration validator. */
+    @Singleton
+    @Named("distributed")
+    public ConfigurationValidator distributedConfigurationValidator(
+            @Named("distributed") ConfigurationTreeGenerator generator,
+            ConfigurationModules modules
+    ) {
+        return ConfigurationValidatorImpl.withDefaultValidators(generator, modules.distributed().validators());
+    }
+
+    /** Creates the configuration dynamic defaults patcher. */
+    @Singleton
+    public ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher(
+            ConfigurationModules modules,
+            @Named("distributed") ConfigurationTreeGenerator generator
+    ) {
+        return new ConfigurationDynamicDefaultsPatcherImpl(modules.distributed(), generator);
+    }
+
+    /** Creates the cluster initializer. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public ClusterInitializer clusterInitializer(
+            ClusterService clusterService,
+            ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher,
+            @Named("distributed") ConfigurationValidator distributedCfgValidator
+    ) {
+        return new ClusterInitializer(clusterService, configurationDynamicDefaultsPatcher, distributedCfgValidator);
+    }
+
+    /** Creates the node attributes collector. */
+    @Singleton
+    public NodeAttributesCollector nodeAttributesCollector(
+            NodeAttributesConfiguration nodeAttributesConfiguration,
+            StorageConfiguration storageConfiguration
+    ) {
+        return new NodeAttributesCollector(nodeAttributesConfiguration, storageConfiguration);
+    }
+
+    /** Creates the system disaster recovery storage. */
+    @Singleton
+    public SystemDisasterRecoveryStorage systemDisasterRecoveryStorage(VaultManager vaultManager) {
+        return new SystemDisasterRecoveryStorage(vaultManager);
+    }
+
+    /** Creates the cluster management group manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public ClusterManagementGroupManager clusterManagementGroupManager(
+            VaultManager vaultManager,
+            SystemDisasterRecoveryStorage systemDisasterRecoveryStorage,
+            ClusterService clusterService,
+            ClusterInitializer clusterInitializer,
+            RaftManager raftManager,
+            ClusterStateStorageManager clusterStateStorageManager,
+            LogicalTopologyImpl logicalTopology,
+            ValidationManager validationManager,
+            NodeAttributesCollector nodeAttributesCollector,
+            FailureManager failureManager,
+            ClusterIdService clusterIdService,
+            @Named("cmg") RaftGroupOptionsConfigurer cmgRaftConfigurer,
+            MetricManager metricManager
+    ) {
+        return new ClusterManagementGroupManager(
+                vaultManager,
+                systemDisasterRecoveryStorage,
+                clusterService,
+                clusterInitializer,
+                raftManager,
+                clusterStateStorageManager,
+                logicalTopology,
+                validationManager,
+                nodeAttributesCollector,
+                failureManager,
+                clusterIdService,
+                cmgRaftConfigurer,
+                metricManager
+        );
+    }
+
+    /** Creates the logical topology service. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public LogicalTopologyServiceImpl logicalTopologyService(
+            LogicalTopologyImpl logicalTopology,
+            ClusterManagementGroupManager cmgManager
+    ) {
+        return new LogicalTopologyServiceImpl(logicalTopology, cmgManager);
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
new file mode 100644
index 000000000000..a10ac6b8a364
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
@@ -0,0 +1,236 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import static org.apache.ignite.internal.configuration.IgnitePaths.cmgPath;
+import static org.apache.ignite.internal.configuration.IgnitePaths.metastoragePath;
+import static org.apache.ignite.internal.configuration.IgnitePaths.partitionsPath;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import java.nio.file.Path;
+import java.util.Map;
+import org.apache.ignite.internal.cluster.management.CmgGroupId;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
+import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.raft.Loza;
+import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
+import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
+import org.apache.ignite.internal.raft.configuration.RaftExtensionConfiguration;
+import org.apache.ignite.internal.raft.server.impl.GroupStoragesContextResolver;
+import org.apache.ignite.internal.raft.storage.GroupStoragesDestructionIntents;
+import org.apache.ignite.internal.raft.storage.LogStorageManager;
+import org.apache.ignite.internal.raft.storage.impl.VaultGroupStoragesDestructionIntents;
+import org.apache.ignite.internal.raft.util.SharedLogStorageManagerUtils;
+import org.apache.ignite.internal.replicator.PartitionGroupId;
+import org.apache.ignite.internal.vault.VaultManager;
+import org.apache.ignite.raft.jraft.rpc.impl.RaftGroupEventsClientListener;
+
+/**
+ * Micronaut factory for Raft infrastructure components.
+ */
+@Factory
+public class RaftFactory {
+    /** Used for durable destruction purposes. */
+    private static final String PARTITION_GROUP_NAME = "partition";
+
+    /** Creates the Raft configuration from the node config registry. */
+    @Singleton
+    public RaftConfiguration raftConfiguration(@Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry) {
+        return nodeConfigRegistry.getConfiguration(RaftExtensionConfiguration.KEY).raft();
+    }
+
+    /** Creates the Raft group events client listener. */
+    @Singleton
+    public RaftGroupEventsClientListener raftGroupEventsClientListener() {
+        return new RaftGroupEventsClientListener();
+    }
+
+    /** Creates the partitions working directory. */
+    @Singleton
+    @Named("partitions")
+    public ComponentWorkingDir partitionsWorkDir(SystemLocalConfiguration systemConfiguration, NodeSeedParams seedParams) {
+        return partitionsPath(systemConfiguration, seedParams.workDir());
+    }
+
+    /** Creates the metastorage working directory. */
+    @Singleton
+    @Named("metastorage")
+    public ComponentWorkingDir metastorageWorkDir(SystemLocalConfiguration systemConfiguration, NodeSeedParams seedParams) {
+        return metastoragePath(systemConfiguration, seedParams.workDir());
+    }
+
+    /** Creates the CMG working directory. */
+    @Singleton
+    @Named("cmg")
+    public ComponentWorkingDir cmgWorkDir(SystemLocalConfiguration systemConfiguration, NodeSeedParams seedParams) {
+        return cmgPath(systemConfiguration, seedParams.workDir());
+    }
+
+    /** Creates the partitions log storage manager. */
+    @Singleton
+    @Named("partitions")
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public LogStorageManager partitionsLogStorageManager(
+            NodeSeedParams seedParams,
+            RaftConfiguration raftConfiguration,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir
+    ) {
+        return SharedLogStorageManagerUtils.create(
+                "table data log",
+                seedParams.nodeName(),
+                partitionsWorkDir.raftLogPath(),
+                raftConfiguration.fsync().value()
+        );
+    }
+
+    /** Creates the metastorage log storage manager. */
+    @Singleton
+    @Named("metastorage")
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public LogStorageManager msLogStorageManager(
+            NodeSeedParams seedParams,
+            @Named("metastorage") ComponentWorkingDir metastorageWorkDir
+    ) {
+        return SharedLogStorageManagerUtils.create(
+                "meta-storage log",
+                seedParams.nodeName(),
+                metastorageWorkDir.raftLogPath(),
+                true
+        );
+    }
+
+    /** Creates the CMG log storage manager. */
+    @Singleton
+    @Named("cmg")
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public LogStorageManager cmgLogStorageManager(
+            NodeSeedParams seedParams,
+            @Named("cmg") ComponentWorkingDir cmgWorkDir
+    ) {
+        return SharedLogStorageManagerUtils.create(
+                "cluster-management-group log",
+                seedParams.nodeName(),
+                cmgWorkDir.raftLogPath(),
+                true
+        );
+    }
+
+    /** Creates the partitions Raft group options configurer. */
+    @Singleton
+    @Named("partitions")
+    public RaftGroupOptionsConfigurer partitionRaftConfigurer(
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir
+    ) {
+        return RaftGroupOptionsConfigHelper.configureProperties(partitionsLogStorageManager, partitionsWorkDir.metaPath());
+    }
+
+    /** Creates the metastorage Raft group options configurer. */
+    @Singleton
+    @Named("metastorage")
+    public RaftGroupOptionsConfigurer msRaftConfigurer(
+            @Named("metastorage") LogStorageManager msLogStorageManager,
+            @Named("metastorage") ComponentWorkingDir metastorageWorkDir
+    ) {
+        return RaftGroupOptionsConfigHelper.configureProperties(msLogStorageManager, metastorageWorkDir.metaPath());
+    }
+
+    /** Creates the CMG Raft group options configurer. */
+    @Singleton
+    @Named("cmg")
+    public RaftGroupOptionsConfigurer cmgRaftConfigurer(
+            @Named("cmg") LogStorageManager cmgLogStorageManager,
+            @Named("cmg") ComponentWorkingDir cmgWorkDir
+    ) {
+        return RaftGroupOptionsConfigHelper.configureProperties(cmgLogStorageManager, cmgWorkDir.metaPath());
+    }
+
+    /** Creates the group storages context resolver. */
+    @Singleton
+    public GroupStoragesContextResolver groupStoragesContextResolver(
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            @Named("metastorage") LogStorageManager msLogStorageManager,
+            @Named("cmg") LogStorageManager cmgLogStorageManager,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir,
+            @Named("metastorage") ComponentWorkingDir metastorageWorkDir,
+            @Named("cmg") ComponentWorkingDir cmgWorkDir
+    ) {
+        Map<String, LogStorageManager> logStorageManagerByGroupName = Map.of(
+                PARTITION_GROUP_NAME, partitionsLogStorageManager,
+                MetastorageGroupId.INSTANCE.toString(), msLogStorageManager,
+                CmgGroupId.INSTANCE.toString(), cmgLogStorageManager
+        );
+
+        Map<String, Path> serverDataPathByGroupName = Map.of(
+                PARTITION_GROUP_NAME, partitionsWorkDir.metaPath(),
+                MetastorageGroupId.INSTANCE.toString(), metastorageWorkDir.metaPath(),
+                CmgGroupId.INSTANCE.toString(), cmgWorkDir.metaPath()
+        );
+
+        return new GroupStoragesContextResolver(
+                replicationGroupId -> replicationGroupId instanceof PartitionGroupId
+                        ? PARTITION_GROUP_NAME : replicationGroupId.toString(),
+                serverDataPathByGroupName,
+                logStorageManagerByGroupName
+        );
+    }
+
+    /** Creates the group storages destruction intents backed by vault. */
+    @Singleton
+    public GroupStoragesDestructionIntents groupStoragesDestructionIntents(VaultManager vaultManager) {
+        return new VaultGroupStoragesDestructionIntents(vaultManager);
+    }
+
+    /** Creates the Raft manager (Loza). */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public Loza loza(
+            ClusterService clusterService,
+            MetricManager metricManager,
+            RaftConfiguration raftConfiguration,
+            SystemLocalConfiguration systemConfiguration,
+            HybridClock clock,
+            RaftGroupEventsClientListener raftGroupEventsClientListener,
+            FailureManager failureManager,
+            GroupStoragesDestructionIntents groupStoragesDestructionIntents,
+            GroupStoragesContextResolver groupStoragesContextResolver
+    ) {
+        return new Loza(
+                clusterService,
+                metricManager,
+                raftConfiguration,
+                systemConfiguration,
+                clock,
+                raftGroupEventsClientListener,
+                failureManager,
+                groupStoragesDestructionIntents,
+                groupStoragesContextResolver
+        );
+    }
+}

From 23e5a282f3a26d19cde2d7259cff3adb3a57aa91 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 09:32:26 +0400
Subject: [PATCH 07/79] Step7

---
 .../internal/app/di/CatalogFactory.java       | 170 ++++++++++++++++
 .../internal/app/di/MetaStorageFactory.java   | 188 ++++++++++++++++++
 2 files changed, 358 insertions(+)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
new file mode 100644
index 000000000000..fe97b91cfeba
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -0,0 +1,170 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
+import java.util.concurrent.TimeUnit;
+import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.catalog.PartitionCountCalculatorWrapper;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
+import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.ClockWaiter;
+import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.metastorage.cache.IdempotentCacheVacuumizer;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.metrics.sources.ClockServiceMetricSource;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.raft.RaftManager;
+import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
+import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
+
+/**
+ * Micronaut factory for catalog, clock service, and placement driver components.
+ */
+@Factory
+public class CatalogFactory {
+    /** Creates the clock service metric source. */
+    @Singleton
+    public ClockServiceMetricSource clockServiceMetricSource() {
+        return new ClockServiceMetricSource();
+    }
+
+    /** Creates the clock service. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public ClockServiceImpl clockService(
+            HybridClock clock,
+            ClockWaiter clockWaiter,
+            SchemaSynchronizationConfiguration schemaSyncConfig,
+            ClockServiceMetricSource clockServiceMetricSource
+    ) {
+        return new ClockServiceImpl(
+                clock,
+                clockWaiter,
+                () -> schemaSyncConfig.maxClockSkewMillis().value(),
+                clockServiceMetricSource::onMaxClockSkewExceeded
+        );
+    }
+
+    /** Creates the idempotent cache vacuumizer. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
+            NodeSeedParams seedParams,
+            ThreadPoolsManager threadPoolsManager,
+            MetaStorageManagerImpl metaStorageManager,
+            RaftConfiguration raftConfiguration,
+            ClockServiceImpl clockService,
+            FailureManager failureManager
+    ) {
+        return new IdempotentCacheVacuumizer(
+                seedParams.nodeName(),
+                threadPoolsManager.commonScheduler(),
+                metaStorageManager::evictIdempotentCommandsCache,
+                raftConfiguration.retryTimeoutMillis(),
+                clockService,
+                failureManager,
+                1,
+                1,
+                TimeUnit.MINUTES
+        );
+    }
+
+    /** Creates the partition count calculator wrapper. */
+    @Singleton
+    public PartitionCountCalculatorWrapper partitionCountCalculatorWrapper() {
+        return new PartitionCountCalculatorWrapper();
+    }
+
+    /** Creates the catalog update log. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public UpdateLogImpl updateLog(MetaStorageManagerImpl metaStorageManager, FailureManager failureManager) {
+        return new UpdateLogImpl(metaStorageManager, failureManager);
+    }
+
+    /** Creates the catalog manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public CatalogManagerImpl catalogManager(
+            UpdateLogImpl updateLog,
+            ClockServiceImpl clockService,
+            FailureManager failureManager,
+            SchemaSynchronizationConfiguration schemaSyncConfig,
+            PartitionCountCalculatorWrapper partitionCountCalculatorWrapper
+    ) {
+        return new CatalogManagerImpl(
+                updateLog,
+                clockService,
+                failureManager,
+                () -> schemaSyncConfig.delayDurationMillis().value(),
+                partitionCountCalculatorWrapper
+        );
+    }
+
+    /** Creates the placement driver manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public PlacementDriverManager placementDriverManager(
+            NodeSeedParams seedParams,
+            MetaStorageManagerImpl metaStorageManager,
+            ClusterService clusterService,
+            ClusterManagementGroupManager cmgManager,
+            LogicalTopologyService logicalTopologyService,
+            RaftManager raftManager,
+            TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
+            ClockServiceImpl clockService,
+            FailureManager failureManager,
+            ReplicationConfiguration replicationConfiguration,
+            ThreadPoolsManager threadPoolsManager,
+            MetricManager metricManager,
+            Provider<DistributionZoneManager> distributionZoneManagerProvider
+    ) {
+        return new PlacementDriverManager(
+                seedParams.nodeName(),
+                metaStorageManager,
+                MetastorageGroupId.INSTANCE,
+                clusterService,
+                cmgManager::metaStorageNodes,
+                logicalTopologyService,
+                raftManager,
+                topologyAwareRaftGroupServiceFactory,
+                clockService,
+                failureManager,
+                replicationConfiguration,
+                threadPoolsManager.commonScheduler(),
+                metricManager,
+                zoneId -> distributionZoneManagerProvider.get().currentDataNodes(zoneId)
+        );
+    }
+}
+
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
new file mode 100644
index 000000000000..6d3b25306aa4
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -0,0 +1,188 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
+import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
+import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
+import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.disaster.system.MetastorageRepairImpl;
+import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.metastorage.server.ReadOperationForCompactionTracker;
+import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.raft.Loza;
+import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
+import org.apache.ignite.internal.raft.RaftManager;
+import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
+import org.apache.ignite.internal.replicator.configuration.ReplicationExtensionConfiguration;
+import org.apache.ignite.raft.jraft.rpc.impl.RaftGroupEventsClientListener;
+
+/**
+ * Micronaut factory for MetaStorage and cluster configuration components.
+ */
+@Factory
+public class MetaStorageFactory {
+    /** Creates the topology-aware Raft group service factory. */
+    @Singleton
+    public TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory(
+            ClusterService clusterService,
+            LogicalTopologyService logicalTopologyService,
+            RaftGroupEventsClientListener raftGroupEventsClientListener
+    ) {
+        return new TopologyAwareRaftGroupServiceFactory(
+                clusterService,
+                logicalTopologyService,
+                Loza.FACTORY,
+                raftGroupEventsClientListener
+        );
+    }
+
+    /** Creates the read operation for compaction tracker. */
+    @Singleton
+    public ReadOperationForCompactionTracker readOperationForCompactionTracker() {
+        return new ReadOperationForCompactionTracker();
+    }
+
+    /** Creates the RocksDB key-value storage for metastorage. */
+    @Singleton
+    public RocksDbKeyValueStorage metastorageKeyValueStorage(
+            NodeSeedParams seedParams,
+            @Named("metastorage") ComponentWorkingDir metastorageWorkDir,
+            FailureManager failureManager,
+            ReadOperationForCompactionTracker readOperationForCompactionTracker,
+            ThreadPoolsManager threadPoolsManager
+    ) {
+        return new RocksDbKeyValueStorage(
+                seedParams.nodeName(),
+                metastorageWorkDir.dbPath(),
+                failureManager,
+                readOperationForCompactionTracker,
+                threadPoolsManager.commonScheduler()
+        );
+    }
+
+    /** Creates the metastorage repair implementation. */
+    @Singleton
+    public MetastorageRepairImpl metastorageRepair(
+            ClusterService clusterService,
+            LogicalTopologyImpl logicalTopology,
+            ClusterManagementGroupManager cmgManager
+    ) {
+        return new MetastorageRepairImpl(
+                clusterService.messagingService(),
+                logicalTopology,
+                cmgManager
+        );
+    }
+
+    /** Creates the MetaStorage manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public MetaStorageManagerImpl metaStorageManager(
+            ClusterService clusterService,
+            ClusterManagementGroupManager cmgManager,
+            LogicalTopologyService logicalTopologyService,
+            RaftManager raftManager,
+            RocksDbKeyValueStorage storage,
+            HybridClock clock,
+            TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
+            MetricManager metricManager,
+            SystemDisasterRecoveryStorage systemDisasterRecoveryStorage,
+            MetastorageRepairImpl metastorageRepair,
+            @Named("metastorage") RaftGroupOptionsConfigurer msRaftConfigurer,
+            ReadOperationForCompactionTracker readOperationForCompactionTracker,
+            ThreadPoolsManager threadPoolsManager,
+            FailureManager failureManager
+    ) {
+        return new MetaStorageManagerImpl(
+                clusterService,
+                cmgManager,
+                logicalTopologyService,
+                raftManager,
+                storage,
+                clock,
+                topologyAwareRaftGroupServiceFactory,
+                metricManager,
+                systemDisasterRecoveryStorage,
+                metastorageRepair,
+                msRaftConfigurer,
+                readOperationForCompactionTracker,
+                threadPoolsManager.tableIoExecutor(),
+                failureManager
+        );
+    }
+
+    /** Creates the distributed configuration storage backed by MetaStorage. */
+    @Singleton
+    public DistributedConfigurationStorage distributedConfigurationStorage(
+            NodeSeedParams seedParams,
+            MetaStorageManagerImpl metaStorageManager
+    ) {
+        return new DistributedConfigurationStorage(seedParams.nodeName(), metaStorageManager);
+    }
+
+    /** Creates the cluster (distributed) configuration registry. */
+    @Singleton
+    @Named("clusterConfig")
+    public ConfigurationRegistry clusterConfigRegistry(
+            ConfigurationModules modules,
+            DistributedConfigurationStorage cfgStorage,
+            @Named("distributed") ConfigurationTreeGenerator generator,
+            @Named("distributed") ConfigurationValidator validator
+    ) {
+        return ConfigurationRegistry.create(modules.distributed(), cfgStorage, generator, validator);
+    }
+
+    /** Creates the schema synchronization configuration from the cluster config registry. */
+    @Singleton
+    public SchemaSynchronizationConfiguration schemaSynchronizationConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry
+                .getConfiguration(SchemaSynchronizationExtensionConfiguration.KEY).schemaSync();
+    }
+
+    /** Creates the replication configuration from the cluster config registry. */
+    @Singleton
+    public ReplicationConfiguration replicationConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry
+                .getConfiguration(ReplicationExtensionConfiguration.KEY).replication();
+    }
+}
+

From 8f4f75815f8159e14ec4d6e637aa98434282625c Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 09:53:22 +0400
Subject: [PATCH 08/79] Step8

---
 .../internal/app/di/DataPathFactory.java      | 510 ++++++++++++++++++
 .../internal/app/di/TransactionFactory.java   | 226 ++++++++
 2 files changed, 736 insertions(+)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
new file mode 100644
index 000000000000..24daf2a81348
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -0,0 +1,510 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import static org.apache.ignite.internal.distributionzones.rebalance.RebalanceUtil.pendingPartAssignmentsQueueKey;
+import static org.apache.ignite.internal.distributionzones.rebalance.ZoneRebalanceUtil.zonePartitionStableAssignments;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.ServiceLoader;
+import java.util.Set;
+import java.util.function.LongSupplier;
+import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.LongJvmPauseDetector;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.hlc.HybridTimestampTracker;
+import org.apache.ignite.internal.index.IndexBuildingManager;
+import org.apache.ignite.internal.index.IndexManager;
+import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
+import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageRevisionListenerRegistry;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.MessagingService;
+import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
+import org.apache.ignite.internal.partition.replicator.network.PartitionReplicationMessageGroup;
+import org.apache.ignite.internal.partition.replicator.raft.snapshot.outgoing.OutgoingSnapshotsManager;
+import org.apache.ignite.internal.partition.replicator.schema.CatalogValidationSchemasSource;
+import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
+import org.apache.ignite.internal.raft.RaftManager;
+import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
+import org.apache.ignite.internal.raft.storage.LogStorageManager;
+import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
+import org.apache.ignite.internal.replicator.ReplicaManager;
+import org.apache.ignite.internal.replicator.ReplicaService;
+import org.apache.ignite.internal.replicator.TablePartitionId;
+import org.apache.ignite.internal.replicator.VersionedAssignments;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
+import org.apache.ignite.internal.schema.SchemaManager;
+import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
+import org.apache.ignite.internal.schema.configuration.GcConfiguration;
+import org.apache.ignite.internal.storage.DataStorageManager;
+import org.apache.ignite.internal.storage.DataStorageModule;
+import org.apache.ignite.internal.storage.DataStorageModules;
+import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
+import org.apache.ignite.internal.storage.engine.StorageEngine;
+import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
+import org.apache.ignite.internal.table.distributed.TableManager;
+import org.apache.ignite.internal.table.distributed.index.IndexMetaStorage;
+import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorServiceImpl;
+import org.apache.ignite.internal.table.distributed.raft.PartitionSafeTimeValidator;
+import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
+import org.apache.ignite.internal.table.distributed.schema.ThreadLocalPartitionCommandsMarshaller;
+import org.apache.ignite.internal.tx.LockManager;
+import org.apache.ignite.internal.tx.TxManager;
+import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
+import org.apache.ignite.internal.tx.impl.TransactionInflights;
+import org.apache.ignite.internal.tx.message.TxMessageGroup;
+import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
+import org.apache.ignite.internal.vault.VaultManager;
+import org.apache.ignite.sql.IgniteSql;
+
+/**
+ * Micronaut factory for data path components.
+ */
+@Factory
+public class DataPathFactory {
+    /** Creates the volatile log storage manager creator. */
+    @Singleton
+    public VolatileLogStorageManagerCreator volatileLogStorageManagerCreator(NodeSeedParams seedParams) {
+        return new VolatileLogStorageManagerCreator(
+                seedParams.nodeName(),
+                seedParams.workDir().resolve("volatile-log-spillout")
+        );
+    }
+
+    /** Creates the MetaStorage revision listener registry. */
+    @Singleton
+    public MetaStorageRevisionListenerRegistry revisionListenerRegistry(MetaStorageManagerImpl metaStorageManager) {
+        return new MetaStorageRevisionListenerRegistry(metaStorageManager);
+    }
+
+    /** Creates the schema safe time tracker. */
+    @Singleton
+    public SchemaSafeTimeTrackerImpl schemaSafeTimeTracker(MetaStorageManagerImpl metaStorageManager) {
+        return new SchemaSafeTimeTrackerImpl(metaStorageManager.clusterTime());
+    }
+
+    /** Creates the schema sync service. */
+    @Singleton
+    public SchemaSyncServiceImpl schemaSyncService(
+            SchemaSafeTimeTrackerImpl schemaSafeTimeTracker,
+            SchemaSynchronizationConfiguration schemaSyncConfig
+    ) {
+        LongSupplier delayDurationMsSupplier = () -> schemaSyncConfig.delayDurationMillis().value();
+        return new SchemaSyncServiceImpl(schemaSafeTimeTracker, delayDurationMsSupplier);
+    }
+
+    /** Creates the schema manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public SchemaManager schemaManager(
+            MetaStorageRevisionListenerRegistry revisionListenerRegistry,
+            CatalogManagerImpl catalogManager
+    ) {
+        return new SchemaManager(revisionListenerRegistry, catalogManager);
+    }
+
+    /** Creates the catalog validation schemas source. */
+    @Singleton
+    public CatalogValidationSchemasSource catalogValidationSchemasSource(
+            CatalogManagerImpl catalogManager,
+            SchemaManager schemaManager
+    ) {
+        return new CatalogValidationSchemasSource(catalogManager, schemaManager);
+    }
+
+    /** Creates the index node finished rw transactions checker. */
+    @Singleton
+    public IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker(
+            CatalogManagerImpl catalogManager,
+            ClusterService clusterService,
+            HybridClock clock
+    ) {
+        return new IndexNodeFinishedRwTransactionsChecker(catalogManager, clusterService.messagingService(), clock);
+    }
+
+    /** Creates the observable hybrid timestamp tracker. */
+    @Singleton
+    public HybridTimestampTracker hybridTimestampTracker() {
+        return HybridTimestampTracker.atomicTracker(null);
+    }
+
+    /** Creates the replica manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public ReplicaManager replicaManager(
+            NodeSeedParams seedParams,
+            ClusterService clusterService,
+            ClusterManagementGroupManager cmgManager,
+            MetaStorageManagerImpl metaStorageManager,
+            ClockServiceImpl clockService,
+            PlacementDriverManager placementDriverManager,
+            ThreadPoolsManager threadPoolsManager,
+            ReplicationConfiguration replicationConfiguration,
+            FailureManager failureManager,
+            CatalogValidationSchemasSource validationSchemasSource,
+            CatalogManagerImpl catalogManager,
+            SchemaSyncServiceImpl schemaSyncService,
+            TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
+            RaftManager raftManager,
+            @Named("partitions") RaftGroupOptionsConfigurer partitionRaftConfigurer,
+            VolatileLogStorageManagerCreator volatileLogStorageManagerCreator
+    ) {
+        return new ReplicaManager(
+                seedParams.nodeName(),
+                clusterService,
+                cmgManager,
+                groupId -> zonePartitionStableAssignments(metaStorageManager, groupId),
+                clockService,
+                Set.of(
+                        PartitionReplicationMessageGroup.class,
+                        TxMessageGroup.class
+                ),
+                placementDriverManager.placementDriver(),
+                threadPoolsManager.partitionOperationsExecutor(),
+                () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
+                failureManager,
+                new ThreadLocalPartitionCommandsMarshaller(
+                        clusterService.serializationRegistry()
+                ),
+                new PartitionSafeTimeValidator(validationSchemasSource, catalogManager, schemaSyncService),
+                topologyAwareRaftGroupServiceFactory,
+                raftManager,
+                partitionRaftConfigurer,
+                volatileLogStorageManagerCreator,
+                threadPoolsManager.tableIoExecutor(),
+                replicaGrpId -> metaStorageManager.get(
+                        pendingPartAssignmentsQueueKey((TablePartitionId) replicaGrpId)
+                ).thenApply(entry -> new VersionedAssignments(
+                        entry.value(), entry.revision()
+                )),
+                threadPoolsManager.commonScheduler()
+        );
+    }
+
+    /** Creates the data storage manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public DataStorageManager dataStorageManager(
+            NodeSeedParams seedParams,
+            MetricManager metricManager,
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir,
+            @Named("longJvmPauseDetector") Provider<LongJvmPauseDetector> longJvmPauseDetector,
+            FailureManager failureManager,
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            HybridClock clock,
+            ThreadPoolsManager threadPoolsManager,
+            StorageConfiguration storageConfiguration
+    ) {
+        DataStorageModules dataStorageModules = new DataStorageModules(
+                ServiceLoader.load(DataStorageModule.class, seedParams.serviceProviderClassLoader())
+        );
+
+        Path storagePath = partitionsWorkDir.dbPath();
+
+        Map<String, StorageEngine> storageEngines = dataStorageModules.createStorageEngines(
+                seedParams.nodeName(),
+                metricManager,
+                nodeConfigRegistry,
+                storagePath,
+                longJvmPauseDetector.get(),
+                failureManager,
+                partitionsLogStorageManager.logSyncer(),
+                clock,
+                threadPoolsManager.commonScheduler()
+        );
+
+        return new DataStorageManager(storageEngines, storageConfiguration);
+    }
+
+    /** Creates the outgoing snapshots manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public OutgoingSnapshotsManager outgoingSnapshotsManager(
+            NodeSeedParams seedParams,
+            ClusterService clusterService,
+            FailureManager failureManager
+    ) {
+        return new OutgoingSnapshotsManager(seedParams.nodeName(), clusterService.messagingService(), failureManager);
+    }
+
+    /** Creates the low watermark. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public LowWatermarkImpl lowWatermark(
+            NodeSeedParams seedParams,
+            GcConfiguration gcConfiguration,
+            ClockServiceImpl clockService,
+            VaultManager vaultManager,
+            FailureManager failureManager,
+            ClusterService clusterService
+    ) {
+        return new LowWatermarkImpl(
+                seedParams.nodeName(),
+                gcConfiguration.lowWatermark(),
+                clockService,
+                vaultManager,
+                failureManager,
+                clusterService.messagingService()
+        );
+    }
+
+    /** Creates the index meta storage. */
+    @Singleton
+    public IndexMetaStorage indexMetaStorage(
+            CatalogManagerImpl catalogManager,
+            LowWatermarkImpl lowWatermark,
+            MetaStorageManagerImpl metaStorageManager
+    ) {
+        return new IndexMetaStorage(catalogManager, lowWatermark, metaStorageManager);
+    }
+
+    /** Creates the distribution zone manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public DistributionZoneManager distributionZoneManager(
+            NodeSeedParams seedParams,
+            ClusterService clusterService,
+            MetaStorageManagerImpl metaStorageManager,
+            LogicalTopologyService logicalTopologyService,
+            FailureManager failureManager,
+            CatalogManagerImpl catalogManager,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            ClockServiceImpl clockService,
+            MetricManager metricManager,
+            LowWatermarkImpl lowWatermark
+    ) {
+        return new DistributionZoneManager(
+                seedParams.nodeName(),
+                () -> clusterService.topologyService().localMember().id(),
+                metaStorageManager,
+                logicalTopologyService,
+                failureManager,
+                catalogManager,
+                systemDistributedConfiguration,
+                clockService,
+                metricManager,
+                lowWatermark
+        );
+    }
+
+    /** Creates the partition replica lifecycle manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
+            CatalogManagerImpl catalogManager,
+            ReplicaManager replicaManager,
+            DistributionZoneManager distributionZoneManager,
+            MetaStorageManagerImpl metaStorageManager,
+            ClusterService clusterService,
+            LowWatermarkImpl lowWatermark,
+            FailureManager failureManager,
+            ThreadPoolsManager threadPoolsManager,
+            ClockServiceImpl clockService,
+            PlacementDriverManager placementDriverManager,
+            SchemaSyncServiceImpl schemaSyncService,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            TxStateRocksDbSharedStorage sharedTxStateStorage,
+            TxManager txManager,
+            SchemaManager schemaManager,
+            DataStorageManager dataStorageManager,
+            OutgoingSnapshotsManager outgoingSnapshotsManager,
+            MetricManager metricManager,
+            @Named("storageOperations") MessagingService messagingService,
+            ReplicaService replicaService
+    ) {
+        return new PartitionReplicaLifecycleManager(
+                catalogManager,
+                replicaManager,
+                distributionZoneManager,
+                metaStorageManager,
+                clusterService.topologyService(),
+                lowWatermark,
+                failureManager,
+                threadPoolsManager.tableIoExecutor(),
+                threadPoolsManager.rebalanceScheduler(),
+                threadPoolsManager.partitionOperationsExecutor(),
+                clockService,
+                placementDriverManager.placementDriver(),
+                schemaSyncService,
+                systemDistributedConfiguration,
+                sharedTxStateStorage,
+                txManager,
+                schemaManager,
+                dataStorageManager,
+                outgoingSnapshotsManager,
+                metricManager,
+                messagingService,
+                replicaService
+        );
+    }
+
+    /** Creates the table manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public TableManager tableManager(
+            NodeSeedParams seedParams,
+            MetaStorageRevisionListenerRegistry revisionListenerRegistry,
+            GcConfiguration gcConfiguration,
+            ReplicationConfiguration replicationConfiguration,
+            @Named("storageOperations") MessagingService messagingService,
+            ClusterService clusterService,
+            LockManager lockManager,
+            ReplicaService replicaService,
+            TxManager txManager,
+            DataStorageManager dataStorageManager,
+            MetaStorageManagerImpl metaStorageManager,
+            SchemaManager schemaManager,
+            CatalogValidationSchemasSource validationSchemasSource,
+            ThreadPoolsManager threadPoolsManager,
+            ClockServiceImpl clockService,
+            OutgoingSnapshotsManager outgoingSnapshotsManager,
+            SchemaSyncServiceImpl schemaSyncService,
+            CatalogManagerImpl catalogManager,
+            FailureManager failureManager,
+            HybridTimestampTracker observableTimestampTracker,
+            PlacementDriverManager placementDriverManager,
+            Provider<IgniteSql> sqlProvider,
+            RemotelyTriggeredResourceRegistry resourcesRegistry,
+            LowWatermarkImpl lowWatermark,
+            TransactionInflights transactionInflights,
+            IndexMetaStorage indexMetaStorage,
+            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            MetricManager metricManager
+    ) {
+        return new TableManager(
+                seedParams.nodeName(),
+                revisionListenerRegistry,
+                gcConfiguration,
+                replicationConfiguration,
+                messagingService,
+                clusterService.topologyService(),
+                lockManager,
+                replicaService,
+                txManager,
+                dataStorageManager,
+                metaStorageManager,
+                schemaManager,
+                validationSchemasSource,
+                threadPoolsManager.tableIoExecutor(),
+                threadPoolsManager.partitionOperationsExecutor(),
+                clockService,
+                outgoingSnapshotsManager,
+                schemaSyncService,
+                catalogManager,
+                failureManager,
+                observableTimestampTracker,
+                placementDriverManager.placementDriver(),
+                sqlProvider::get,
+                resourcesRegistry,
+                lowWatermark,
+                transactionInflights,
+                indexMetaStorage,
+                partitionReplicaLifecycleManager,
+                new MinimumRequiredTimeCollectorServiceImpl(),
+                systemDistributedConfiguration,
+                metricManager,
+                new PartitionModificationCounterFactory(
+                        clockService::current, clusterService.messagingService()
+                )
+        );
+    }
+
+    /** Creates the index manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public IndexManager indexManager(
+            SchemaManager schemaManager,
+            TableManager tableManager,
+            CatalogManagerImpl catalogManager,
+            ThreadPoolsManager threadPoolsManager,
+            MetaStorageRevisionListenerRegistry revisionListenerRegistry,
+            LowWatermarkImpl lowWatermark
+    ) {
+        return new IndexManager(
+                schemaManager,
+                tableManager,
+                catalogManager,
+                threadPoolsManager.tableIoExecutor(),
+                revisionListenerRegistry,
+                lowWatermark
+        );
+    }
+
+    /** Creates the index building manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public IndexBuildingManager indexBuildingManager(
+            NodeSeedParams seedParams,
+            ReplicaService replicaService,
+            CatalogManagerImpl catalogManager,
+            MetaStorageManagerImpl metaStorageManager,
+            IndexManager indexManager,
+            IndexMetaStorage indexMetaStorage,
+            PlacementDriverManager placementDriverManager,
+            ClusterService clusterService,
+            LogicalTopologyService logicalTopologyService,
+            ClockServiceImpl clockService,
+            FailureManager failureManager,
+            LowWatermarkImpl lowWatermark,
+            TxManager txManager,
+            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            MetricManager metricManager
+    ) {
+        return new IndexBuildingManager(
+                seedParams.nodeName(),
+                replicaService,
+                catalogManager,
+                metaStorageManager,
+                indexManager,
+                indexMetaStorage,
+                placementDriverManager.placementDriver(),
+                clusterService,
+                logicalTopologyService,
+                clockService,
+                failureManager,
+                lowWatermark,
+                txManager,
+                partitionReplicaLifecycleManager,
+                metricManager
+        );
+    }
+}
+
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
new file mode 100644
index 000000000000..3800262c8053
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -0,0 +1,226 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
+import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
+import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
+import org.apache.ignite.internal.lowwatermark.LowWatermark;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.MessagingService;
+import org.apache.ignite.internal.network.wrapper.JumpToExecutorByConsistentIdAfterSend;
+import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.raft.storage.LogStorageManager;
+import org.apache.ignite.internal.replicator.ReplicaService;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
+import org.apache.ignite.internal.schema.configuration.GcConfiguration;
+import org.apache.ignite.internal.schema.configuration.GcExtensionConfiguration;
+import org.apache.ignite.internal.tx.LockManager;
+import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
+import org.apache.ignite.internal.tx.configuration.TransactionExtensionConfiguration;
+import org.apache.ignite.internal.tx.impl.HeapLockManager;
+import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
+import org.apache.ignite.internal.tx.impl.TransactionIdGenerator;
+import org.apache.ignite.internal.tx.impl.TransactionInflights;
+import org.apache.ignite.internal.tx.impl.TxManagerImpl;
+import org.apache.ignite.internal.tx.impl.VolatileTxStateMetaStorage;
+import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
+
+/**
+ * Micronaut factory for transaction-related components.
+ */
+@Factory
+public class TransactionFactory {
+    /** Creates the transaction configuration from the cluster config registry. */
+    @Singleton
+    public TransactionConfiguration transactionConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(TransactionExtensionConfiguration.KEY).transaction();
+    }
+
+    /** Creates the system distributed configuration from the cluster config registry. */
+    @Singleton
+    public SystemDistributedConfiguration systemDistributedConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(SystemDistributedExtensionConfiguration.KEY).system();
+    }
+
+    /** Creates the GC configuration from the cluster config registry. */
+    @Singleton
+    public GcConfiguration gcConfiguration(@Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry) {
+        return clusterConfigRegistry.getConfiguration(GcExtensionConfiguration.KEY).gc();
+    }
+
+    /** Creates the messaging service wrapper that jumps to the storage operations thread pool. */
+    @Singleton
+    @Named("storageOperations")
+    public MessagingService storageOperationsMessagingService(
+            ClusterService clusterService,
+            NodeSeedParams seedParams,
+            ThreadPoolsManager threadPoolsManager
+    ) {
+        return new JumpToExecutorByConsistentIdAfterSend(
+                clusterService.messagingService(),
+                seedParams.nodeName(),
+                message -> threadPoolsManager.partitionOperationsExecutor()
+        );
+    }
+
+    /** Creates the replica service. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public ReplicaService replicaService(
+            @Named("storageOperations") MessagingService messagingService,
+            ClockServiceImpl clockService,
+            ThreadPoolsManager threadPoolsManager,
+            ReplicationConfiguration replicationConfiguration
+    ) {
+        return new ReplicaService(
+                messagingService,
+                clockService,
+                threadPoolsManager.partitionOperationsExecutor(),
+                replicationConfiguration,
+                threadPoolsManager.commonScheduler()
+        );
+    }
+
+    /** Creates the volatile transaction state meta storage. */
+    @Singleton
+    public VolatileTxStateMetaStorage volatileTxStateMetaStorage() {
+        return new VolatileTxStateMetaStorage();
+    }
+
+    /** Creates the transaction inflights tracker. */
+    @Singleton
+    public TransactionInflights transactionInflights(
+            PlacementDriverManager placementDriverManager,
+            ClockServiceImpl clockService,
+            VolatileTxStateMetaStorage txStateVolatileStorage
+    ) {
+        return new TransactionInflights(
+                placementDriverManager.placementDriver(),
+                clockService,
+                txStateVolatileStorage
+        );
+    }
+
+    /** Creates the lock manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public LockManager lockManager(
+            SystemLocalConfiguration systemConfiguration,
+            VolatileTxStateMetaStorage txStateVolatileStorage
+    ) {
+        return new HeapLockManager(systemConfiguration, txStateVolatileStorage);
+    }
+
+    /** Creates the transaction ID generator. */
+    @Singleton
+    public TransactionIdGenerator transactionIdGenerator(ClusterService clusterService) {
+        return new TransactionIdGenerator(() -> clusterService.nodeName().hashCode());
+    }
+
+    /** Creates the remotely triggered resource registry. */
+    @Singleton
+    public RemotelyTriggeredResourceRegistry remotelyTriggeredResourceRegistry() {
+        return new RemotelyTriggeredResourceRegistry();
+    }
+
+    /** Creates the transaction manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public TxManagerImpl txManager(
+            NodeSeedParams seedParams,
+            TransactionConfiguration txConfig,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            @Named("storageOperations") MessagingService messagingService,
+            ClusterService clusterService,
+            ReplicaService replicaService,
+            LockManager lockManager,
+            VolatileTxStateMetaStorage txStateVolatileStorage,
+            ClockServiceImpl clockService,
+            TransactionIdGenerator transactionIdGenerator,
+            PlacementDriverManager placementDriverManager,
+            ReplicationConfiguration replicationConfiguration,
+            IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker,
+            ThreadPoolsManager threadPoolsManager,
+            RemotelyTriggeredResourceRegistry resourcesRegistry,
+            TransactionInflights transactionInflights,
+            LowWatermark lowWatermark,
+            FailureManager failureManager,
+            MetricManager metricManager
+    ) {
+        return new TxManagerImpl(
+                seedParams.nodeName(),
+                txConfig,
+                systemDistributedConfiguration,
+                messagingService,
+                clusterService.topologyService(),
+                replicaService,
+                lockManager,
+                txStateVolatileStorage,
+                clockService,
+                transactionIdGenerator,
+                placementDriverManager.placementDriver(),
+                () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
+                indexNodeFinishedRwTransactionsChecker,
+                threadPoolsManager.partitionOperationsExecutor(),
+                resourcesRegistry,
+                transactionInflights,
+                lowWatermark,
+                threadPoolsManager.commonScheduler(),
+                failureManager,
+                metricManager
+        );
+    }
+
+    /** Creates the shared RocksDB transaction state storage. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public TxStateRocksDbSharedStorage txStateRocksDbSharedStorage(
+            NodeSeedParams seedParams,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir,
+            ThreadPoolsManager threadPoolsManager,
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            FailureManager failureManager
+    ) {
+        return new TxStateRocksDbSharedStorage(
+                seedParams.nodeName(),
+                partitionsWorkDir.dbPath().resolve("tx-state"),
+                threadPoolsManager.commonScheduler(),
+                threadPoolsManager.tableIoExecutor(),
+                partitionsLogStorageManager.logSyncer(),
+                failureManager
+        );
+    }
+}
+

From 4b9a6466001c51180a5e2d2cf57e32ed3f89c341 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 10:04:47 +0400
Subject: [PATCH 09/79] Step9

---
 .../internal/app/di/ClientHandlerFactory.java | 143 +++++++++
 .../internal/app/di/ComputeFactory.java       | 179 +++++++++++
 .../ignite/internal/app/di/SqlFactory.java    | 142 +++++++++
 .../app/di/SystemServicesFactory.java         | 297 ++++++++++++++++++
 4 files changed, 761 insertions(+)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
new file mode 100644
index 000000000000..c362f251cc95
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -0,0 +1,143 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
+import org.apache.ignite.client.handler.ClientHandlerMetricSource;
+import org.apache.ignite.client.handler.ClientHandlerModule;
+import org.apache.ignite.client.handler.ClusterInfo;
+import org.apache.ignite.client.handler.configuration.ClientConnectorConfiguration;
+import org.apache.ignite.client.handler.configuration.ClientConnectorExtensionConfiguration;
+import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.cluster.management.ClusterState;
+import org.apache.ignite.internal.compute.IgniteComputeInternal;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SuggestionsClusterExtensionConfiguration;
+import org.apache.ignite.internal.configuration.SuggestionsConfiguration;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
+import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.NettyBootstrapFactory;
+import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.security.authentication.AuthenticationManager;
+import org.apache.ignite.internal.security.authentication.AuthenticationManagerImpl;
+import org.apache.ignite.internal.security.configuration.SecurityConfiguration;
+import org.apache.ignite.internal.security.configuration.SecurityExtensionConfiguration;
+import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
+import org.apache.ignite.internal.table.distributed.TableManager;
+import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
+import org.apache.ignite.internal.tx.TxManager;
+
+/**
+ * Micronaut factory for client handler and authentication components.
+ */
+@Factory
+public class ClientHandlerFactory {
+    /** Creates the security configuration from the cluster config registry. */
+    @Singleton
+    public SecurityConfiguration securityConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(SecurityExtensionConfiguration.KEY).security();
+    }
+
+    /** Creates the authentication manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public AuthenticationManager authenticationManager(
+            SecurityConfiguration securityConfiguration,
+            EventLogImpl eventLog
+    ) {
+        return new AuthenticationManagerImpl(securityConfiguration, eventLog);
+    }
+
+    /** Creates the client connector configuration from the node config registry. */
+    @Singleton
+    public ClientConnectorConfiguration clientConnectorConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(ClientConnectorExtensionConfiguration.KEY).clientConnector();
+    }
+
+    /** Creates the suggestions configuration from the cluster config registry. */
+    @Singleton
+    public SuggestionsConfiguration suggestionsConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(SuggestionsClusterExtensionConfiguration.KEY).suggestions();
+    }
+
+    /** Creates the client handler module. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public ClientHandlerModule clientHandlerModule(
+            SqlQueryProcessor sqlQueryProcessor,
+            TableManager tableManager,
+            TxManager txManager,
+            IgniteComputeInternal compute,
+            ClusterService clusterService,
+            NettyBootstrapFactory nettyBootstrapFactory,
+            Provider<ClusterManagementGroupManager> cmgManagerProvider,
+            MetricManager metricManager,
+            AuthenticationManager authenticationManager,
+            ClockServiceImpl clockService,
+            SchemaSyncServiceImpl schemaSyncService,
+            CatalogManagerImpl catalogManager,
+            PlacementDriverManager placementDriverManager,
+            ClientConnectorConfiguration clientConnectorConfiguration,
+            EventLogImpl eventLog,
+            LowWatermarkImpl lowWatermark,
+            ThreadPoolsManager threadPoolsManager,
+            SuggestionsConfiguration suggestionsConfiguration
+    ) {
+        return new ClientHandlerModule(
+                sqlQueryProcessor,
+                tableManager,
+                txManager,
+                compute,
+                clusterService,
+                nettyBootstrapFactory,
+                () -> {
+                    ClusterState clusterState = cmgManagerProvider.get().clusterState().join();
+
+                    return new ClusterInfo(clusterState.clusterTag(), clusterState.clusterIdHistory());
+                },
+                metricManager,
+                new ClientHandlerMetricSource(),
+                authenticationManager,
+                clockService,
+                schemaSyncService,
+                catalogManager,
+                placementDriverManager.placementDriver(),
+                clientConnectorConfiguration,
+                eventLog,
+                lowWatermark,
+                threadPoolsManager.partitionOperationsExecutor(),
+                () -> suggestionsConfiguration.sequentialDdlExecution().enabled().value()
+        );
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
new file mode 100644
index 000000000000..0dfd774ec3b6
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -0,0 +1,179 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
+import org.apache.ignite.Ignite;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.compute.ComputeComponentImpl;
+import org.apache.ignite.internal.compute.IgniteComputeImpl;
+import org.apache.ignite.internal.compute.IgniteComputeInternal;
+import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
+import org.apache.ignite.internal.compute.configuration.ComputeExtensionConfiguration;
+import org.apache.ignite.internal.compute.executor.ComputeExecutorImpl;
+import org.apache.ignite.internal.compute.state.InMemoryComputeStateMachine;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.deployunit.DeploymentManagerImpl;
+import org.apache.ignite.internal.deployunit.configuration.DeploymentConfiguration;
+import org.apache.ignite.internal.deployunit.configuration.DeploymentExtensionConfiguration;
+import org.apache.ignite.internal.deployunit.loader.UnitsClassLoaderFactory;
+import org.apache.ignite.internal.deployunit.loader.UnitsContextManager;
+import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
+import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.hlc.HybridTimestampTracker;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.table.distributed.TableManager;
+
+/**
+ * Micronaut factory for compute and deployment components.
+ */
+@Factory
+public class ComputeFactory {
+    /** Creates the compute configuration from the node config registry. */
+    @Singleton
+    public ComputeConfiguration computeConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(ComputeExtensionConfiguration.KEY).compute();
+    }
+
+    /** Creates the deployment configuration from the node config registry. */
+    @Singleton
+    public DeploymentConfiguration deploymentConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(DeploymentExtensionConfiguration.KEY).deployment();
+    }
+
+    /** Creates the in-memory compute state machine. */
+    @Singleton
+    public InMemoryComputeStateMachine inMemoryComputeStateMachine(
+            ComputeConfiguration computeConfiguration,
+            NodeSeedParams seedParams
+    ) {
+        return new InMemoryComputeStateMachine(computeConfiguration, seedParams.nodeName());
+    }
+
+    /** Creates the compute executor. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public ComputeExecutorImpl computeExecutor(
+            Provider<Ignite> igniteProvider,
+            InMemoryComputeStateMachine stateMachine,
+            ComputeConfiguration computeConfiguration,
+            ClusterService clusterService,
+            ClockServiceImpl clockService,
+            EventLogImpl eventLog
+    ) {
+        return new ComputeExecutorImpl(
+                igniteProvider.get(),
+                stateMachine,
+                computeConfiguration,
+                clusterService.topologyService(),
+                clockService,
+                eventLog
+        );
+    }
+
+    /** Creates the deployment manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public DeploymentManagerImpl deploymentManager(
+            ClusterService clusterService,
+            MetaStorageManagerImpl metaStorageManager,
+            LogicalTopologyService logicalTopologyService,
+            NodeSeedParams seedParams,
+            DeploymentConfiguration deploymentConfiguration,
+            ClusterManagementGroupManager cmgManager,
+            ComputeExecutorImpl computeExecutor
+    ) {
+        return new DeploymentManagerImpl(
+                clusterService,
+                new DeploymentUnitStoreImpl(metaStorageManager),
+                logicalTopologyService,
+                seedParams.workDir(),
+                deploymentConfiguration,
+                cmgManager,
+                seedParams.nodeName(),
+                computeExecutor::onUnitRemoving
+        );
+    }
+
+    /** Creates the compute component. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public ComputeComponentImpl computeComponent(
+            NodeSeedParams seedParams,
+            ClusterService clusterService,
+            LogicalTopologyService logicalTopologyService,
+            DeploymentManagerImpl deploymentManager,
+            ComputeExecutorImpl computeExecutor,
+            ComputeConfiguration computeConfiguration,
+            EventLogImpl eventLog,
+            HybridTimestampTracker observableTimestampTracker
+    ) {
+        return new ComputeComponentImpl(
+                seedParams.nodeName(),
+                clusterService.messagingService(),
+                clusterService.topologyService(),
+                logicalTopologyService,
+                new UnitsContextManager(
+                        deploymentManager,
+                        deploymentManager.deploymentUnitAccessor(),
+                        new UnitsClassLoaderFactory()
+                ),
+                computeExecutor,
+                computeConfiguration,
+                eventLog,
+                observableTimestampTracker
+        );
+    }
+
+    /** Creates the internal compute implementation. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public IgniteComputeInternal igniteCompute(
+            NodeSeedParams seedParams,
+            PlacementDriverManager placementDriverManager,
+            ClusterService clusterService,
+            TableManager tableManager,
+            ComputeComponentImpl computeComponent,
+            HybridClock clock,
+            HybridTimestampTracker observableTimestampTracker
+    ) {
+        return new IgniteComputeImpl(
+                seedParams.nodeName(),
+                placementDriverManager.placementDriver(),
+                clusterService.topologyService(),
+                tableManager,
+                computeComponent,
+                clock,
+                observableTimestampTracker
+        );
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
new file mode 100644
index 000000000000..7b31063ce278
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -0,0 +1,142 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.HybridTimestampTracker;
+import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.replicator.ReplicaService;
+import org.apache.ignite.internal.schema.SchemaManager;
+import org.apache.ignite.internal.sql.api.IgniteSqlImpl;
+import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
+import org.apache.ignite.internal.sql.configuration.distributed.SqlDistributedConfiguration;
+import org.apache.ignite.internal.sql.configuration.local.SqlLocalConfiguration;
+import org.apache.ignite.internal.sql.configuration.local.SqlNodeExtensionConfiguration;
+import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
+import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
+import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
+import org.apache.ignite.internal.table.distributed.TableManager;
+import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
+import org.apache.ignite.internal.tx.TxManager;
+import org.apache.ignite.internal.tx.impl.TransactionInflights;
+
+/**
+ * Micronaut factory for SQL engine components.
+ */
+@Factory
+public class SqlFactory {
+    /** Creates the SQL distributed configuration from the cluster config registry. */
+    @Singleton
+    public SqlDistributedConfiguration sqlDistributedConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(SqlClusterExtensionConfiguration.KEY).sql();
+    }
+
+    /** Creates the SQL local configuration from the node config registry. */
+    @Singleton
+    public SqlLocalConfiguration sqlLocalConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(SqlNodeExtensionConfiguration.KEY).sql();
+    }
+
+    /** Creates the kill command handler. */
+    @Singleton
+    public KillCommandHandler killCommandHandler(
+            NodeSeedParams seedParams,
+            LogicalTopologyService logicalTopologyService,
+            ClusterService clusterService
+    ) {
+        return new KillCommandHandler(seedParams.nodeName(), logicalTopologyService, clusterService.messagingService());
+    }
+
+    /** Creates the SQL query processor. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public SqlQueryProcessor sqlQueryProcessor(
+            ClusterService clusterService,
+            LogicalTopologyService logicalTopologyService,
+            TableManager tableManager,
+            SchemaManager schemaManager,
+            ReplicaService replicaService,
+            ClockServiceImpl clockService,
+            SchemaSyncServiceImpl schemaSyncService,
+            CatalogManagerImpl catalogManager,
+            MetricManager metricManager,
+            SystemViewManagerImpl systemViewManager,
+            FailureManager failureManager,
+            PlacementDriverManager placementDriverManager,
+            SqlDistributedConfiguration sqlDistributedConfiguration,
+            SqlLocalConfiguration sqlLocalConfiguration,
+            TransactionInflights transactionInflights,
+            TxManager txManager,
+            LowWatermarkImpl lowWatermark,
+            ThreadPoolsManager threadPoolsManager,
+            KillCommandHandler killCommandHandler,
+            EventLogImpl eventLog
+    ) {
+        return new SqlQueryProcessor(
+                clusterService,
+                logicalTopologyService,
+                tableManager,
+                schemaManager,
+                replicaService,
+                clockService,
+                schemaSyncService,
+                catalogManager,
+                metricManager,
+                systemViewManager,
+                failureManager,
+                placementDriverManager.placementDriver(),
+                sqlDistributedConfiguration,
+                sqlLocalConfiguration,
+                transactionInflights,
+                txManager,
+                lowWatermark,
+                threadPoolsManager.commonScheduler(),
+                killCommandHandler,
+                eventLog
+        );
+    }
+
+    /** Creates the IgniteSql implementation. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public IgniteSqlImpl igniteSql(
+            SqlQueryProcessor sqlQueryProcessor,
+            HybridTimestampTracker observableTimestampTracker,
+            ThreadPoolsManager threadPoolsManager
+    ) {
+        return new IgniteSqlImpl(sqlQueryProcessor, observableTimestampTracker, threadPoolsManager.commonScheduler());
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
new file mode 100644
index 000000000000..f3acd47380a7
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -0,0 +1,297 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.catalog.DataNodesAwarePartitionCountCalculator;
+import org.apache.ignite.internal.catalog.PartitionCountCalculatorWrapper;
+import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.disaster.system.ClusterIdService;
+import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManagerImpl;
+import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
+import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
+import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
+import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
+import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
+import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageCompactionTrigger;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.metastorage.server.ReadOperationForCompactionTracker;
+import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
+import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.metrics.logstorage.LogStorageMetrics;
+import org.apache.ignite.internal.metrics.messaging.MetricMessaging;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.MessagingService;
+import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
+import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.raft.Loza;
+import org.apache.ignite.internal.raft.storage.LogStorageManager;
+import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
+import org.apache.ignite.internal.replicator.ReplicaService;
+import org.apache.ignite.internal.system.CpuInformationProvider;
+import org.apache.ignite.internal.system.JvmCpuInformationProvider;
+import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
+import org.apache.ignite.internal.table.distributed.TableManager;
+import org.apache.ignite.internal.table.distributed.disaster.DisasterRecoveryManager;
+import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorServiceImpl;
+import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
+import org.apache.ignite.internal.tx.TxManager;
+import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
+import org.apache.ignite.internal.tx.impl.ResourceVacuumManager;
+import org.apache.ignite.internal.tx.impl.TransactionInflights;
+import org.apache.ignite.internal.vault.VaultManager;
+
+/**
+ * Micronaut factory for system services and miscellaneous components.
+ */
+@Factory
+public class SystemServicesFactory {
+    /** Creates the event log. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public EventLogImpl eventLog(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry,
+            Provider<ClusterManagementGroupManager> cmgManagerProvider,
+            NodeSeedParams seedParams
+    ) {
+        return new EventLogImpl(
+                clusterConfigRegistry.getConfiguration(EventLogExtensionConfiguration.KEY).eventlog(),
+                () -> cmgManagerProvider.get().clusterState().join().clusterTag().clusterId(),
+                seedParams.nodeName()
+        );
+    }
+
+    /** Creates the system view manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public SystemViewManagerImpl systemViewManager(
+            NodeSeedParams seedParams,
+            CatalogManagerImpl catalogManager,
+            FailureManager failureManager
+    ) {
+        return new SystemViewManagerImpl(seedParams.nodeName(), catalogManager, failureManager);
+    }
+
+    /** Creates the CPU information provider. */
+    @Singleton
+    public CpuInformationProvider cpuInformationProvider() {
+        return new JvmCpuInformationProvider();
+    }
+
+    /** Creates the data-nodes-aware partition count calculator and wires it into the wrapper. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public DataNodesAwarePartitionCountCalculator dataNodesAwarePartitionCountCalculator(
+            DistributionZoneManager distributionZoneManager,
+            CpuInformationProvider cpuInformationProvider,
+            PartitionCountCalculatorWrapper partitionCountCalculatorWrapper
+    ) {
+        DataNodesAwarePartitionCountCalculator calculator = new DataNodesAwarePartitionCountCalculator(
+                distributionZoneManager::estimatedDataNodesCount,
+                cpuInformationProvider
+        );
+        partitionCountCalculatorWrapper.setPartitionCountCalculator(calculator);
+        return calculator;
+    }
+
+    /** Creates the system disaster recovery manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
+            NodeSeedParams seedParams,
+            ClusterService clusterService,
+            VaultManager vaultManager,
+            MetaStorageManagerImpl metaStorageManager,
+            ClusterManagementGroupManager cmgManager,
+            ClusterIdService clusterIdService
+    ) {
+        return new SystemDisasterRecoveryManagerImpl(
+                seedParams.nodeName(),
+                clusterService.topologyService(),
+                clusterService.messagingService(),
+                vaultManager,
+                seedParams.restarter(),
+                metaStorageManager,
+                cmgManager,
+                clusterIdService
+        );
+    }
+
+    /** Creates the MetaStorage compaction trigger. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public MetaStorageCompactionTrigger metaStorageCompactionTrigger(
+            NodeSeedParams seedParams,
+            RocksDbKeyValueStorage storage,
+            MetaStorageManagerImpl metaStorageManager,
+            FailureManager failureManager,
+            ReadOperationForCompactionTracker readOperationForCompactionTracker,
+            SystemDistributedConfiguration systemDistributedConfiguration
+    ) {
+        return new MetaStorageCompactionTrigger(
+                seedParams.nodeName(),
+                storage,
+                metaStorageManager,
+                failureManager,
+                readOperationForCompactionTracker,
+                systemDistributedConfiguration
+        );
+    }
+
+    /** Creates the catalog compaction runner. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public CatalogCompactionRunner catalogCompactionRunner(
+            NodeSeedParams seedParams,
+            CatalogManagerImpl catalogManager,
+            ClusterService clusterService,
+            LogicalTopologyService logicalTopologyService,
+            PlacementDriverManager placementDriverManager,
+            ReplicaService replicaService,
+            ClockServiceImpl clockService,
+            SchemaSyncServiceImpl schemaSyncService,
+            LowWatermarkImpl lowWatermark,
+            IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker,
+            MetaStorageManagerImpl metaStorageManager
+    ) {
+        MinimumRequiredTimeCollectorServiceImpl minTimeCollectorService = new MinimumRequiredTimeCollectorServiceImpl();
+
+        return new CatalogCompactionRunner(
+                seedParams.nodeName(),
+                catalogManager,
+                clusterService.messagingService(),
+                logicalTopologyService,
+                placementDriverManager.placementDriver(),
+                replicaService,
+                clockService,
+                schemaSyncService,
+                clusterService.topologyService(),
+                lowWatermark,
+                indexNodeFinishedRwTransactionsChecker,
+                minTimeCollectorService,
+                new RebalanceMinimumRequiredTimeProviderImpl(metaStorageManager, catalogManager)
+        );
+    }
+
+    /** Creates the log storage metrics. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public LogStorageMetrics logStorageMetrics(
+            NodeSeedParams seedParams,
+            MetricManager metricManager,
+            @Named("cmg") LogStorageManager cmgLogStorageManager,
+            @Named("metastorage") LogStorageManager msLogStorageManager,
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            VolatileLogStorageManagerCreator volatileLogStorageManagerCreator
+    ) {
+        return new LogStorageMetrics(
+                seedParams.nodeName(),
+                metricManager,
+                cmgLogStorageManager,
+                msLogStorageManager,
+                partitionsLogStorageManager,
+                volatileLogStorageManagerCreator
+        );
+    }
+
+    /** Creates the metric messaging. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public MetricMessaging metricMessaging(
+            MetricManager metricManager,
+            ClusterService clusterService
+    ) {
+        return new MetricMessaging(metricManager, clusterService.messagingService(), clusterService.topologyService());
+    }
+
+    /** Creates the resource vacuum manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public ResourceVacuumManager resourceVacuumManager(
+            NodeSeedParams seedParams,
+            RemotelyTriggeredResourceRegistry resourcesRegistry,
+            ClusterService clusterService,
+            @Named("storageOperations") MessagingService messagingService,
+            TransactionInflights transactionInflights,
+            TxManager txManager,
+            LowWatermarkImpl lowWatermark,
+            FailureManager failureManager,
+            MetricManager metricManager
+    ) {
+        return new ResourceVacuumManager(
+                seedParams.nodeName(),
+                resourcesRegistry,
+                clusterService.topologyService(),
+                messagingService,
+                transactionInflights,
+                txManager,
+                lowWatermark,
+                failureManager,
+                metricManager
+        );
+    }
+
+    /** Creates the disaster recovery manager. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public DisasterRecoveryManager disasterRecoveryManager(
+            ThreadPoolsManager threadPoolsManager,
+            @Named("storageOperations") MessagingService messagingService,
+            MetaStorageManagerImpl metaStorageManager,
+            CatalogManagerImpl catalogManager,
+            DistributionZoneManager distributionZoneManager,
+            Loza raftManager,
+            ClusterService clusterService,
+            LogicalTopologyService logicalTopologyService,
+            TableManager tableManager,
+            MetricManager metricManager,
+            FailureManager failureManager,
+            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            SystemViewManagerImpl systemViewManager
+    ) {
+        return new DisasterRecoveryManager(
+                threadPoolsManager.tableIoExecutor(),
+                messagingService,
+                metaStorageManager,
+                catalogManager,
+                distributionZoneManager,
+                raftManager,
+                clusterService.topologyService(),
+                logicalTopologyService,
+                tableManager,
+                metricManager,
+                failureManager,
+                partitionReplicaLifecycleManager,
+                systemViewManager
+        );
+    }
+}

From c9444ed1335e685e1b6ef2bf1791c2a3427c50ab Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 10:29:16 +0400
Subject: [PATCH 10/79] Step10a

---
 .../internal/app/LowWatermarkRectifier.java   |   4 +-
 .../app/SystemPropertiesComponent.java        |   5 +-
 .../app/di/CoreComponentsFactory.java         |  10 +-
 .../app/di/PostConstructionWiring.java        | 252 ++++++++++++++++++
 .../app/di/SystemServicesFactory.java         |  21 ++
 5 files changed, 287 insertions(+), 5 deletions(-)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
index 205580ee98e9..2ec177ac0576 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
@@ -31,11 +31,11 @@
 /**
  * Component that rectifies the low watermark on node startup if it is lower than the earliest catalog timestamp.
  */
-class LowWatermarkRectifier implements IgniteComponent {
+public class LowWatermarkRectifier implements IgniteComponent {
     private final LowWatermark lowWatermark;
     private final CatalogService catalogService;
 
-    LowWatermarkRectifier(LowWatermark lowWatermark, CatalogService catalogService) {
+    public LowWatermarkRectifier(LowWatermark lowWatermark, CatalogService catalogService) {
         this.lowWatermark = lowWatermark;
         this.catalogService = catalogService;
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
index 5f85e3c74ac6..0d5633299596 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
@@ -28,7 +28,7 @@
 /**
  * System properties initialization.
  */
-class SystemPropertiesComponent implements IgniteComponent {
+public class SystemPropertiesComponent implements IgniteComponent {
 
     /**
      * Sensitive data logging option. See {@link IgniteToStringBuilder#setSensitiveDataPolicy(SensitiveDataLoggingPolicy)}}. 
@@ -37,7 +37,8 @@ class SystemPropertiesComponent implements IgniteComponent {
 
     private final SystemDistributedConfigurationPropertyHolder<SensitiveDataLoggingPolicy> sensitiveDataLogging;
 
-    SystemPropertiesComponent(SystemDistributedConfiguration configuration) {
+    /** Constructor. */
+    public SystemPropertiesComponent(SystemDistributedConfiguration configuration) {
         this.sensitiveDataLogging = new SystemDistributedConfigurationPropertyHolder<>(
                 configuration,
                 (value, revision) -> IgniteToStringBuilder.setSensitiveDataPolicy(value),
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
index 2231f59ec872..e9f18a679c17 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
@@ -22,6 +22,7 @@
 import jakarta.inject.Singleton;
 import java.util.UUID;
 import java.util.function.Supplier;
+import org.apache.ignite.internal.app.NodePropertiesImpl;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.components.LongJvmPauseDetector;
 import org.apache.ignite.internal.di.IgniteStartupPhase;
@@ -61,7 +62,7 @@ public VaultManager vaultManager(VaultService vaultService) {
      */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
-    public MetricManager metricManager(
+    public MetricManagerImpl metricManager(
             NodeSeedParams seedParams,
             @Named("clusterIdSupplier") Supplier<UUID> clusterIdSupplier
     ) {
@@ -80,4 +81,11 @@ public ThreadPoolsManager threadPoolsManager(NodeSeedParams seedParams, MetricMa
     public HybridClock hybridClock(FailureProcessor failureProcessor) {
         return new HybridClockImpl(failureProcessor);
     }
+
+    /** Creates the node properties component. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    public NodePropertiesImpl nodeProperties(VaultManager vaultManager) {
+        return new NodePropertiesImpl(vaultManager);
+    }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java
new file mode 100644
index 000000000000..6af1212ee1ef
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java
@@ -0,0 +1,252 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.client.handler.ClientHandlerModule;
+import org.apache.ignite.internal.app.NodePropertiesImpl;
+import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
+import org.apache.ignite.internal.cluster.management.NodeAttributesCollector;
+import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
+import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.compute.ComputeComponentImpl;
+import org.apache.ignite.internal.compute.IgniteComputeInternal;
+import org.apache.ignite.internal.compute.executor.ComputeExecutorImpl;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
+import org.apache.ignite.internal.metastorage.cache.IdempotentCacheVacuumizer;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.metrics.MetricManagerImpl;
+import org.apache.ignite.internal.metrics.configuration.MetricExtensionConfiguration;
+import org.apache.ignite.internal.metrics.sources.ClockServiceMetricSource;
+import org.apache.ignite.internal.metrics.sources.JvmMetricSource;
+import org.apache.ignite.internal.metrics.sources.OsMetricSource;
+import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.LogicalTopologyEventsListener;
+import org.apache.ignite.internal.raft.Loza;
+import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
+import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
+import org.apache.ignite.internal.sql.engine.api.kill.CancellableOperationType;
+import org.apache.ignite.internal.sql.engine.api.kill.OperationKillHandler;
+import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
+import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
+import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
+import org.apache.ignite.internal.table.distributed.schema.CheckCatalogVersionOnActionRequest;
+import org.apache.ignite.internal.table.distributed.schema.CheckCatalogVersionOnAppendEntries;
+import org.apache.ignite.internal.tx.TxManager;
+import org.apache.ignite.internal.tx.impl.TxManagerImpl;
+
+/**
+ * Performs post-construction wiring that cannot be expressed as constructor injection.
+ * This includes listener registrations, interceptor setups, and cross-component hookups.
+ */
+@Singleton
+public class PostConstructionWiring {
+    private final MetricManagerImpl metricManager;
+    private final ClockServiceMetricSource clockServiceMetricSource;
+    private final MetaStorageManagerImpl metaStorageManager;
+    private final CatalogManagerImpl catalogManager;
+    private final IdempotentCacheVacuumizer idempotentCacheVacuumizer;
+    private final CatalogCompactionRunner catalogCompactionRunner;
+    private final SchemaSafeTimeTrackerImpl schemaSafeTimeTracker;
+    private final Loza raftManager;
+    private final LogicalTopologyImpl logicalTopology;
+    private final ClusterService clusterService;
+    private final NodeAttributesCollector nodeAttributesCollector;
+    private final NodePropertiesImpl nodeProperties;
+    private final SystemViewManagerImpl systemViewManager;
+    private final TxManagerImpl txManager;
+    private final SqlQueryProcessor sqlQueryProcessor;
+    private final ComputeComponentImpl computeComponent;
+    private final IgniteComputeInternal compute;
+    private final KillCommandHandler killCommandHandler;
+    private final ComputeExecutorImpl computeExecutor;
+    private final ClientHandlerModule clientHandlerModule;
+    private final PartitionModificationCounterFactory partitionModificationCounterFactory;
+    private final SystemDistributedConfiguration systemDistributedConfiguration;
+    private final ConfigurationRegistry clusterConfigRegistry;
+
+    /** Constructor. */
+    public PostConstructionWiring(
+            MetricManagerImpl metricManager,
+            ClockServiceMetricSource clockServiceMetricSource,
+            MetaStorageManagerImpl metaStorageManager,
+            CatalogManagerImpl catalogManager,
+            IdempotentCacheVacuumizer idempotentCacheVacuumizer,
+            CatalogCompactionRunner catalogCompactionRunner,
+            SchemaSafeTimeTrackerImpl schemaSafeTimeTracker,
+            Loza raftManager,
+            LogicalTopologyImpl logicalTopology,
+            ClusterService clusterService,
+            NodeAttributesCollector nodeAttributesCollector,
+            NodePropertiesImpl nodeProperties,
+            SystemViewManagerImpl systemViewManager,
+            TxManagerImpl txManager,
+            SqlQueryProcessor sqlQueryProcessor,
+            ComputeComponentImpl computeComponent,
+            IgniteComputeInternal compute,
+            KillCommandHandler killCommandHandler,
+            ComputeExecutorImpl computeExecutor,
+            ClientHandlerModule clientHandlerModule,
+            PartitionModificationCounterFactory partitionModificationCounterFactory,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        this.metricManager = metricManager;
+        this.clockServiceMetricSource = clockServiceMetricSource;
+        this.metaStorageManager = metaStorageManager;
+        this.catalogManager = catalogManager;
+        this.idempotentCacheVacuumizer = idempotentCacheVacuumizer;
+        this.catalogCompactionRunner = catalogCompactionRunner;
+        this.schemaSafeTimeTracker = schemaSafeTimeTracker;
+        this.raftManager = raftManager;
+        this.logicalTopology = logicalTopology;
+        this.clusterService = clusterService;
+        this.nodeAttributesCollector = nodeAttributesCollector;
+        this.nodeProperties = nodeProperties;
+        this.systemViewManager = systemViewManager;
+        this.txManager = txManager;
+        this.sqlQueryProcessor = sqlQueryProcessor;
+        this.computeComponent = computeComponent;
+        this.compute = compute;
+        this.killCommandHandler = killCommandHandler;
+        this.computeExecutor = computeExecutor;
+        this.clientHandlerModule = clientHandlerModule;
+        this.partitionModificationCounterFactory = partitionModificationCounterFactory;
+        this.systemDistributedConfiguration = systemDistributedConfiguration;
+        this.clusterConfigRegistry = clusterConfigRegistry;
+    }
+
+    /**
+     * Performs wiring needed before Phase 1 start.
+     * This includes metric source registration and metric configuration.
+     */
+    public void wirePhase1() {
+        JvmMetricSource jvmMetrics = new JvmMetricSource();
+        metricManager.registerSource(jvmMetrics);
+        metricManager.enable(jvmMetrics);
+
+        OsMetricSource osMetrics = new OsMetricSource();
+        metricManager.registerSource(osMetrics);
+        metricManager.enable(osMetrics);
+
+        metricManager.registerSource(clockServiceMetricSource);
+        metricManager.enable(clockServiceMetricSource);
+
+        partitionModificationCounterFactory.start();
+    }
+
+    /**
+     * Performs wiring needed before Phase 2 start.
+     * This includes MetaStorage listeners, Raft interceptors, system view registrations, and kill handlers.
+     */
+    public void wirePhase2() {
+        // MetaStorage configuration and listeners.
+        metaStorageManager.configure(systemDistributedConfiguration);
+        metricManager.configure(clusterConfigRegistry.getConfiguration(MetricExtensionConfiguration.KEY).metrics());
+        metaStorageManager.addElectionListener(idempotentCacheVacuumizer);
+        metaStorageManager.addElectionListener(catalogCompactionRunner::updateCoordinator);
+        metaStorageManager.registerNotificationEnqueuedListener(schemaSafeTimeTracker);
+
+        // Raft interceptors.
+        raftManager.appendEntriesRequestInterceptor(new CheckCatalogVersionOnAppendEntries(catalogManager));
+        raftManager.actionRequestInterceptor(new CheckCatalogVersionOnActionRequest(catalogManager));
+
+        // Node attributes.
+        nodeAttributesCollector.register(nodeProperties);
+        nodeAttributesCollector.register(systemViewManager);
+
+        // Logical topology listener for joined nodes.
+        logicalTopology.addEventListener(logicalTopologyJoinedNodesListener(clusterService.topologyService()));
+        logicalTopology.addEventListener(systemViewManager);
+
+        // System view registrations.
+        systemViewManager.register(catalogManager);
+        systemViewManager.register(txManager);
+        systemViewManager.register(sqlQueryProcessor);
+        systemViewManager.register(computeComponent);
+
+        // Kill command handlers.
+        killCommandHandler.register(transactionKillHandler(txManager));
+        killCommandHandler.register(computeKillHandler(compute));
+
+        // Compute <-> client handler bridge.
+        computeExecutor.setPlatformComputeTransport(clientHandlerModule);
+    }
+
+    private static LogicalTopologyEventListener logicalTopologyJoinedNodesListener(LogicalTopologyEventsListener listener) {
+        return new LogicalTopologyEventListener() {
+            @Override
+            public void onNodeJoined(LogicalNode joinedNode, LogicalTopologySnapshot newTopology) {
+                listener.onJoined(joinedNode, newTopology.version());
+            }
+
+            @Override
+            public void onNodeLeft(LogicalNode leftNode, LogicalTopologySnapshot newTopology) {
+                listener.onLeft(leftNode, newTopology.version());
+            }
+        };
+    }
+
+    private static OperationKillHandler computeKillHandler(IgniteComputeInternal compute) {
+        return new OperationKillHandler() {
+            @Override
+            public CompletableFuture<Boolean> cancelAsync(String operationId) {
+                UUID jobId = UUID.fromString(operationId);
+                return compute.cancelAsync(jobId)
+                        .thenApply(res -> res != null ? res : Boolean.FALSE);
+            }
+
+            @Override
+            public boolean local() {
+                return false;
+            }
+
+            @Override
+            public CancellableOperationType type() {
+                return CancellableOperationType.COMPUTE;
+            }
+        };
+    }
+
+    private static OperationKillHandler transactionKillHandler(TxManager txManager) {
+        return new OperationKillHandler() {
+            @Override
+            public CompletableFuture<Boolean> cancelAsync(String operationId) {
+                UUID transactionId = UUID.fromString(operationId);
+                return txManager.kill(transactionId);
+            }
+
+            @Override
+            public boolean local() {
+                return true;
+            }
+
+            @Override
+            public CancellableOperationType type() {
+                return CancellableOperationType.TRANSACTION;
+            }
+        };
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index f3acd47380a7..65a36d5a8869 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -21,6 +21,8 @@
 import jakarta.inject.Named;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
+import org.apache.ignite.internal.app.LowWatermarkRectifier;
+import org.apache.ignite.internal.app.SystemPropertiesComponent;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.catalog.DataNodesAwarePartitionCountCalculator;
@@ -260,6 +262,25 @@ public ResourceVacuumManager resourceVacuumManager(
         );
     }
 
+    /** Creates the system properties component. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public SystemPropertiesComponent systemPropertiesComponent(
+            SystemDistributedConfiguration systemDistributedConfiguration
+    ) {
+        return new SystemPropertiesComponent(systemDistributedConfiguration);
+    }
+
+    /** Creates the low watermark rectifier. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    public LowWatermarkRectifier lowWatermarkRectifier(
+            LowWatermarkImpl lowWatermark,
+            CatalogManagerImpl catalogManager
+    ) {
+        return new LowWatermarkRectifier(lowWatermark, catalogManager);
+    }
+
     /** Creates the disaster recovery manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)

From dfa32c523d7cdbc6574aab1ae56148af32d9e347 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 11:18:14 +0400
Subject: [PATCH 11/79] Step10b

---
 .../ignite/internal/di/IgniteDiContext.java   |   45 +-
 .../ignite/internal/app/IgniteImpl.java       | 1146 ++---------------
 .../app/di/CoreComponentsFactory.java         |    2 +-
 .../internal/app/di/DataPathFactory.java      |   18 +-
 4 files changed, 163 insertions(+), 1048 deletions(-)

diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
index 3ccc8cb1a1b0..aed969e6b319 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
@@ -19,6 +19,7 @@
 
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.ApplicationContextBuilder;
+import io.micronaut.inject.qualifiers.Qualifiers;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -52,6 +53,8 @@ public static Builder builder() {
     public static class Builder {
         private final List<Object> singletons = new ArrayList<>();
 
+        private final List<NamedSingletonEntry> namedSingletons = new ArrayList<>();
+
         private final List<String> packages = new ArrayList<>();
 
         /**
@@ -65,6 +68,19 @@ public Builder withSingleton(Object singleton) {
             return this;
         }
 
+        /**
+         * Registers a named singleton that will be available for injection via {@code @Named} qualifier.
+         *
+         * @param name The qualifier name.
+         * @param type The bean type to register under.
+         * @param singleton The object to register.
+         * @return This builder for chaining.
+         */
+        public Builder withNamedSingleton(String name, Class<?> type, Object singleton) {
+            namedSingletons.add(new NamedSingletonEntry(name, type, singleton));
+            return this;
+        }
+
         /**
          * Adds packages to scan for bean definitions.
          *
@@ -94,7 +110,34 @@ public ApplicationContext build() {
                 contextBuilder.singletons(singletons.toArray());
             }
 
-            return contextBuilder.start();
+            ApplicationContext context = contextBuilder.start();
+
+            for (NamedSingletonEntry entry : namedSingletons) {
+                registerNamedSingleton(context, entry);
+            }
+
+            return context;
+        }
+
+        @SuppressWarnings({"rawtypes", "unchecked"})
+        private static void registerNamedSingleton(ApplicationContext context, NamedSingletonEntry entry) {
+            context.registerSingleton(
+                    (Class) entry.type,
+                    entry.singleton,
+                    Qualifiers.byName(entry.name)
+            );
+        }
+    }
+
+    private static final class NamedSingletonEntry {
+        final String name;
+        final Class<?> type;
+        final Object singleton;
+
+        NamedSingletonEntry(String name, Class<?> type, Object singleton) {
+            this.name = name;
+            this.type = type;
+            this.singleton = singleton;
         }
     }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index ec77e546c2db..07681193de34 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -17,13 +17,7 @@
 
 package org.apache.ignite.internal.app;
 
-import static java.util.concurrent.TimeUnit.MINUTES;
-import static org.apache.ignite.internal.configuration.IgnitePaths.cmgPath;
-import static org.apache.ignite.internal.configuration.IgnitePaths.metastoragePath;
-import static org.apache.ignite.internal.configuration.IgnitePaths.partitionsPath;
-import static org.apache.ignite.internal.configuration.IgnitePaths.vaultPath;
-import static org.apache.ignite.internal.distributionzones.rebalance.RebalanceUtil.pendingPartAssignmentsQueueKey;
-import static org.apache.ignite.internal.distributionzones.rebalance.ZoneRebalanceUtil.zonePartitionStableAssignments;
+import static java.util.stream.Collectors.toSet;
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_READ;
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_WRITE;
 import static org.apache.ignite.internal.util.CompletableFutures.copyStateTo;
@@ -34,14 +28,11 @@
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 import com.typesafe.config.ConfigRenderOptions;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.inject.qualifiers.Qualifiers;
 import java.nio.file.Path;
 import java.util.Collection;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.ServiceLoader;
-import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
@@ -51,101 +42,56 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiPredicate;
-import java.util.function.LongSupplier;
 import java.util.function.Supplier;
 import org.apache.ignite.Ignite;
 import org.apache.ignite.IgniteServer;
 import org.apache.ignite.catalog.IgniteCatalog;
-import org.apache.ignite.client.handler.ClientHandlerMetricSource;
 import org.apache.ignite.client.handler.ClientHandlerModule;
 import org.apache.ignite.client.handler.ClientInboundMessageHandler;
-import org.apache.ignite.client.handler.ClusterInfo;
-import org.apache.ignite.client.handler.configuration.ClientConnectorConfiguration;
-import org.apache.ignite.client.handler.configuration.ClientConnectorExtensionConfiguration;
 import org.apache.ignite.compute.IgniteCompute;
-import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
+import org.apache.ignite.internal.app.di.NodeSeedParams;
+import org.apache.ignite.internal.app.di.PostConstructionWiring;
 import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
-import org.apache.ignite.internal.catalog.DataNodesAwarePartitionCountCalculator;
 import org.apache.ignite.internal.catalog.PartitionCountCalculator;
 import org.apache.ignite.internal.catalog.PartitionCountCalculatorWrapper;
 import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
-import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
-import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
 import org.apache.ignite.internal.catalog.sql.IgniteCatalogSqlImpl;
-import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
 import org.apache.ignite.internal.cluster.management.ClusterInitializer;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.ClusterState;
-import org.apache.ignite.internal.cluster.management.CmgGroupId;
 import org.apache.ignite.internal.cluster.management.InvalidNodeConfigurationException;
-import org.apache.ignite.internal.cluster.management.NodeAttributesCollector;
-import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesExtensionConfiguration;
 import org.apache.ignite.internal.cluster.management.raft.ClusterStateStorage;
-import org.apache.ignite.internal.cluster.management.raft.ClusterStateStorageManager;
-import org.apache.ignite.internal.cluster.management.raft.RocksDbClusterStateStorage;
-import org.apache.ignite.internal.cluster.management.raft.ValidationManager;
-import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
-import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyServiceImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
-import org.apache.ignite.internal.components.LogSyncer;
 import org.apache.ignite.internal.components.LongJvmPauseDetector;
 import org.apache.ignite.internal.components.NodeProperties;
 import org.apache.ignite.internal.compute.AntiHijackIgniteCompute;
 import org.apache.ignite.internal.compute.ComputeComponentImpl;
-import org.apache.ignite.internal.compute.IgniteComputeImpl;
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
-import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
-import org.apache.ignite.internal.compute.configuration.ComputeExtensionConfiguration;
-import org.apache.ignite.internal.compute.executor.ComputeExecutorImpl;
-import org.apache.ignite.internal.compute.state.InMemoryComputeStateMachine;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
-import org.apache.ignite.internal.configuration.ConfigurationDynamicDefaultsPatcherImpl;
-import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.JdbcPortProviderImpl;
-import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
-import org.apache.ignite.internal.configuration.SuggestionsClusterExtensionConfiguration;
-import org.apache.ignite.internal.configuration.SuggestionsConfiguration;
-import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
-import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
-import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
-import org.apache.ignite.internal.configuration.SystemLocalExtensionConfiguration;
 import org.apache.ignite.internal.configuration.hocon.HoconConverter;
 import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
-import org.apache.ignite.internal.configuration.storage.LocalFileConfigurationStorage;
 import org.apache.ignite.internal.configuration.tree.ConfigurationSource;
-import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
-import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
 import org.apache.ignite.internal.deployunit.DeploymentManagerImpl;
 import org.apache.ignite.internal.deployunit.IgniteDeployment;
-import org.apache.ignite.internal.deployunit.configuration.DeploymentExtensionConfiguration;
-import org.apache.ignite.internal.deployunit.loader.UnitsClassLoaderFactory;
-import org.apache.ignite.internal.deployunit.loader.UnitsContextManager;
-import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
+import org.apache.ignite.internal.di.IgniteDiContext;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
-import org.apache.ignite.internal.disaster.system.MetastorageRepairImpl;
 import org.apache.ignite.internal.disaster.system.ServerRestarter;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManager;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManagerImpl;
-import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
-import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
-import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
-import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.hlc.ClockWaiter;
 import org.apache.ignite.internal.hlc.HybridClock;
-import org.apache.ignite.internal.hlc.HybridClockImpl;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.index.IndexBuildingManager;
 import org.apache.ignite.internal.index.IndexManager;
@@ -161,64 +107,30 @@
 import org.apache.ignite.internal.metastorage.cache.IdempotentCacheVacuumizer;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageCompactionTrigger;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageRevisionListenerRegistry;
-import org.apache.ignite.internal.metastorage.server.ReadOperationForCompactionTracker;
-import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
-import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.metrics.MetricManagerImpl;
-import org.apache.ignite.internal.metrics.configuration.MetricExtensionConfiguration;
 import org.apache.ignite.internal.metrics.logstorage.LogStorageMetrics;
 import org.apache.ignite.internal.metrics.messaging.MetricMessaging;
 import org.apache.ignite.internal.metrics.sources.ClockServiceMetricSource;
 import org.apache.ignite.internal.metrics.sources.JvmMetricSource;
 import org.apache.ignite.internal.metrics.sources.OsMetricSource;
 import org.apache.ignite.internal.network.ChannelType;
-import org.apache.ignite.internal.network.ChannelTypeRegistryProvider;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.DefaultMessagingService;
 import org.apache.ignite.internal.network.IgniteClusterImpl;
 import org.apache.ignite.internal.network.InternalClusterNode;
-import org.apache.ignite.internal.network.LogicalTopologyEventsListener;
-import org.apache.ignite.internal.network.MessageSerializationRegistryImpl;
-import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.NettyBootstrapFactory;
 import org.apache.ignite.internal.network.NettyWorkersRegistrar;
 import org.apache.ignite.internal.network.NetworkMessage;
 import org.apache.ignite.internal.network.PublicApiThreadingIgniteCluster;
-import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
-import org.apache.ignite.internal.network.configuration.NetworkExtensionConfiguration;
-import org.apache.ignite.internal.network.recovery.InMemoryStaleIds;
-import org.apache.ignite.internal.network.scalecube.ScaleCubeClusterService;
-import org.apache.ignite.internal.network.serialization.MessageSerializationRegistry;
-import org.apache.ignite.internal.network.serialization.SerializationRegistryServiceLoader;
-import org.apache.ignite.internal.network.wrapper.JumpToExecutorByConsistentIdAfterSend;
 import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
-import org.apache.ignite.internal.partition.replicator.network.PartitionReplicationMessageGroup;
 import org.apache.ignite.internal.partition.replicator.raft.snapshot.outgoing.OutgoingSnapshotsManager;
-import org.apache.ignite.internal.partition.replicator.schema.CatalogValidationSchemasSource;
-import org.apache.ignite.internal.partition.replicator.schema.ValidationSchemasSource;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
 import org.apache.ignite.internal.raft.Loza;
-import org.apache.ignite.internal.raft.Marshaller;
-import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
-import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
-import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
-import org.apache.ignite.internal.raft.configuration.RaftExtensionConfiguration;
-import org.apache.ignite.internal.raft.server.impl.GroupStoragesContextResolver;
-import org.apache.ignite.internal.raft.storage.GroupStoragesDestructionIntents;
 import org.apache.ignite.internal.raft.storage.LogStorageManager;
-import org.apache.ignite.internal.raft.storage.impl.VaultGroupStoragesDestructionIntents;
 import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
-import org.apache.ignite.internal.raft.util.SharedLogStorageManagerUtils;
-import org.apache.ignite.internal.replicator.PartitionGroupId;
 import org.apache.ignite.internal.replicator.ReplicaManager;
-import org.apache.ignite.internal.replicator.ReplicaService;
-import org.apache.ignite.internal.replicator.TablePartitionId;
-import org.apache.ignite.internal.replicator.VersionedAssignments;
-import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
-import org.apache.ignite.internal.replicator.configuration.ReplicationExtensionConfiguration;
 import org.apache.ignite.internal.rest.RestComponent;
 import org.apache.ignite.internal.rest.RestFactory;
 import org.apache.ignite.internal.rest.RestManager;
@@ -240,30 +152,13 @@
 import org.apache.ignite.internal.rest.sql.SqlQueryRestFactory;
 import org.apache.ignite.internal.schema.SchemaManager;
 import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
-import org.apache.ignite.internal.schema.SchemaSyncService;
-import org.apache.ignite.internal.schema.configuration.GcConfiguration;
-import org.apache.ignite.internal.schema.configuration.GcExtensionConfiguration;
 import org.apache.ignite.internal.security.authentication.AuthenticationManager;
-import org.apache.ignite.internal.security.authentication.AuthenticationManagerImpl;
-import org.apache.ignite.internal.security.configuration.SecurityConfiguration;
-import org.apache.ignite.internal.security.configuration.SecurityExtensionConfiguration;
 import org.apache.ignite.internal.sql.api.IgniteSqlImpl;
 import org.apache.ignite.internal.sql.api.PublicApiThreadingIgniteSql;
-import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
-import org.apache.ignite.internal.sql.configuration.local.SqlNodeExtensionConfiguration;
 import org.apache.ignite.internal.sql.engine.QueryProcessor;
 import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
-import org.apache.ignite.internal.sql.engine.api.kill.CancellableOperationType;
-import org.apache.ignite.internal.sql.engine.api.kill.OperationKillHandler;
 import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
 import org.apache.ignite.internal.storage.DataStorageManager;
-import org.apache.ignite.internal.storage.DataStorageModule;
-import org.apache.ignite.internal.storage.DataStorageModules;
-import org.apache.ignite.internal.storage.configurations.StorageExtensionConfiguration;
-import org.apache.ignite.internal.storage.engine.StorageEngine;
-import org.apache.ignite.internal.storage.engine.ThreadAssertingStorageEngine;
-import org.apache.ignite.internal.system.CpuInformationProvider;
-import org.apache.ignite.internal.system.JvmCpuInformationProvider;
 import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
 import org.apache.ignite.internal.systemview.api.SystemViewManager;
 import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
@@ -271,39 +166,21 @@
 import org.apache.ignite.internal.table.distributed.TableManager;
 import org.apache.ignite.internal.table.distributed.disaster.DisasterRecoveryManager;
 import org.apache.ignite.internal.table.distributed.index.IndexMetaStorage;
-import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorServiceImpl;
-import org.apache.ignite.internal.table.distributed.raft.PartitionSafeTimeValidator;
-import org.apache.ignite.internal.table.distributed.schema.CheckCatalogVersionOnActionRequest;
-import org.apache.ignite.internal.table.distributed.schema.CheckCatalogVersionOnAppendEntries;
-import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
-import org.apache.ignite.internal.table.distributed.schema.ThreadLocalPartitionCommandsMarshaller;
 import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.threading.PublicApiThreadingIgniteCatalog;
-import org.apache.ignite.internal.tx.LockManager;
 import org.apache.ignite.internal.tx.TxManager;
-import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
-import org.apache.ignite.internal.tx.configuration.TransactionExtensionConfiguration;
-import org.apache.ignite.internal.tx.impl.HeapLockManager;
 import org.apache.ignite.internal.tx.impl.IgniteTransactionsImpl;
 import org.apache.ignite.internal.tx.impl.PublicApiThreadingIgniteTransactions;
 import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
 import org.apache.ignite.internal.tx.impl.ResourceVacuumManager;
-import org.apache.ignite.internal.tx.impl.TransactionIdGenerator;
-import org.apache.ignite.internal.tx.impl.TransactionInflights;
 import org.apache.ignite.internal.tx.impl.TxManagerImpl;
-import org.apache.ignite.internal.tx.impl.VolatileTxStateMetaStorage;
-import org.apache.ignite.internal.tx.message.TxMessageGroup;
 import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
 import org.apache.ignite.internal.vault.VaultManager;
-import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
-import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
 import org.apache.ignite.internal.worker.CriticalWorkerWatchdog;
-import org.apache.ignite.internal.worker.ThreadAssertions;
 import org.apache.ignite.lang.IgniteException;
 import org.apache.ignite.network.IgniteCluster;
 import org.apache.ignite.network.NetworkAddress;
 import org.apache.ignite.network.NodeMetadata;
-import org.apache.ignite.raft.jraft.rpc.impl.RaftGroupEventsClientListener;
 import org.apache.ignite.sql.IgniteSql;
 import org.apache.ignite.table.IgniteTables;
 import org.apache.ignite.tx.IgniteTransactions;
@@ -317,12 +194,6 @@ public class IgniteImpl implements Ignite {
     /** The logger. */
     private static final IgniteLogger LOG = Loggers.forClass(IgniteImpl.class);
 
-    /** Used for durable destruction purposes. */
-    private static final String PARTITION_GROUP_NAME = "partition";
-
-    /** Name of a transaction state directory. */
-    private static final String TX_STATE_DIR = "tx-state";
-
     /** Ignite node name. */
     private final String name;
 
@@ -331,6 +202,9 @@ public class IgniteImpl implements Ignite {
     /** Lifecycle manager. */
     private final LifecycleManager lifecycleManager;
 
+    /** Micronaut DI context for component construction and dependency injection. */
+    private final ApplicationContext diContext;
+
     private final ThreadPoolsManager threadPoolsManager;
 
     /** Vault manager. */
@@ -414,8 +288,6 @@ public class IgniteImpl implements Ignite {
 
     private final ComponentWorkingDir metastorageWorkDir;
 
-    private final ComponentWorkingDir cmgWorkDir;
-
     /** Client handler module. */
     private final ClientHandlerModule clientHandlerModule;
 
@@ -473,7 +345,7 @@ public class IgniteImpl implements Ignite {
     private final AuthenticationManager authenticationManager;
 
     /** Timestamp tracker for embedded transactions. */
-    private final HybridTimestampTracker observableTimestampTracker = HybridTimestampTracker.atomicTracker(null);
+    private final HybridTimestampTracker observableTimestampTracker;
 
     /** System views manager. */
     private final SystemViewManagerImpl systemViewManager;
@@ -506,8 +378,6 @@ public class IgniteImpl implements Ignite {
 
     private final LogStorageManager cmgLogStorageManager;
 
-    private final RaftGroupOptionsConfigurer partitionRaftConfigurer;
-
     private final IndexMetaStorage indexMetaStorage;
 
     private final EventLogImpl eventLog;
@@ -551,46 +421,26 @@ public class IgniteImpl implements Ignite {
         this.name = node.name();
         this.workDir = workDir;
 
-        longJvmPauseDetector = new LongJvmPauseDetector(name);
-
         lifecycleManager = new LifecycleManager(name);
 
-        metricManager = new MetricManagerImpl(name, () -> clusterState().clusterTag().clusterId());
-
-        threadPoolsManager = new ThreadPoolsManager(name, metricManager);
-
-        vaultMgr = new VaultManager(new PersistentVaultService(vaultPath(workDir)));
-
-        nodeProperties = new NodePropertiesImpl(vaultMgr);
-
-        CpuInformationProvider cpuInformationProvider = new JvmCpuInformationProvider();
-
-        ConfigurationModules modules = ConfigurationModules.create(serviceProviderClassLoader);
-
-        ConfigurationTreeGenerator localConfigurationGenerator = new ConfigurationTreeGenerator(
-                modules.local().rootKeys(),
-                modules.local().schemaExtensions(),
-                modules.local().polymorphicSchemaExtensions()
+        // Build the Micronaut DI context with seed singletons.
+        NodeSeedParams seedParams = new NodeSeedParams(
+                node, restarter, configPath, workDir, serviceProviderClassLoader, asyncContinuationExecutor
         );
 
-        LocalFileConfigurationStorage localFileConfigurationStorage = new LocalFileConfigurationStorage(
-                name,
-                configPath,
-                localConfigurationGenerator,
-                modules.local()
-        );
+        @SuppressWarnings("unchecked")
+        Supplier<UUID> clusterIdSupplier = () -> clusterState().clusterTag().clusterId();
 
-        ConfigurationValidator localConfigurationValidator =
-                ConfigurationValidatorImpl.withDefaultValidators(localConfigurationGenerator, modules.local().validators());
+        diContext = IgniteDiContext.builder()
+                .withSingleton(seedParams)
+                .withSingleton(this)
+                .withNamedSingleton("clusterIdSupplier", Supplier.class, clusterIdSupplier)
+                .withPackages("org.apache.ignite.internal.app.di")
+                .build();
 
-        nodeConfigRegistry = ConfigurationRegistry.create(
-                modules.local(),
-                localFileConfigurationStorage,
-                localConfigurationGenerator,
-                localConfigurationValidator
-        );
+        // Start local configuration early — factory methods read config values during bean construction.
+        nodeConfigRegistry = diContext.getBean(ConfigurationRegistry.class, Qualifiers.byName("nodeConfig"));
 
-        // Start local configuration to be able to read all local properties.
         try {
             lifecycleManager.startComponentsAsync(new ComponentContext(), nodeConfigRegistry);
         } catch (NodeStoppingException e) {
@@ -598,752 +448,92 @@ public class IgniteImpl implements Ignite {
         }
 
         LOG.info("Starting node: [name={}, workDir={}, configPath={}]", name, workDir, configPath);
-
         LOG.info("Local node configuration: {}", convertToHoconString(nodeConfigRegistry));
 
-        NetworkConfiguration networkConfiguration = nodeConfigRegistry.getConfiguration(NetworkExtensionConfiguration.KEY).network();
-
-        MessageSerializationRegistry serializationRegistry = createSerializationRegistry(serviceProviderClassLoader);
-
-        FailureProcessorConfiguration failureProcessorConfiguration = nodeConfigRegistry.getConfiguration(
-                FailureProcessorExtensionConfiguration.KEY).failureHandler();
-        failureManager = new FailureManager(name, node::shutdown, failureProcessorConfiguration);
-
-        SystemLocalConfiguration systemConfiguration = nodeConfigRegistry.getConfiguration(SystemLocalExtensionConfiguration.KEY).system();
-
-        cmgWorkDir = cmgPath(systemConfiguration, workDir);
-
-        // TODO: IGNITE-16841 - use common RocksDB instance to store cluster state as well.
-        clusterStateStorage = new RocksDbClusterStateStorage(cmgWorkDir.dbPath(), name);
-
-        clusterIdService = new ClusterIdService(vaultMgr);
-
-        criticalWorkerRegistry = new CriticalWorkerWatchdog(
-                systemConfiguration.criticalWorkers(),
-                threadPoolsManager.commonScheduler(),
-                failureManager
-        );
-
-        nettyBootstrapFactory = new NettyBootstrapFactory(networkConfiguration, name);
-        nettyWorkersRegistrar = new NettyWorkersRegistrar(
-                criticalWorkerRegistry,
-                threadPoolsManager.commonScheduler(),
-                nettyBootstrapFactory,
-                systemConfiguration.criticalWorkers(),
-                failureManager
-        );
-
-        clusterSvc = new ScaleCubeClusterService(
-                name,
-                networkConfiguration,
-                nettyBootstrapFactory,
-                serializationRegistry,
-                new InMemoryStaleIds(),
-                clusterIdService,
-                criticalWorkerRegistry,
-                failureManager,
-                ChannelTypeRegistryProvider.loadByServiceLoader(serviceProviderClassLoader),
-                new DefaultIgniteProductVersionSource(),
-                metricManager
-        );
-
-        clock = new HybridClockImpl(failureManager);
-
-        clockWaiter = new ClockWaiter(name, clock, threadPoolsManager.commonScheduler());
-
-        RaftConfiguration raftConfiguration = nodeConfigRegistry.getConfiguration(RaftExtensionConfiguration.KEY).raft();
-
-        // TODO https://issues.apache.org/jira/browse/IGNITE-19051
-        RaftGroupEventsClientListener raftGroupEventsClientListener = new RaftGroupEventsClientListener();
-
-        partitionsWorkDir = partitionsPath(systemConfiguration, workDir);
-
-        partitionsLogStorageManager = SharedLogStorageManagerUtils.create(
-                "table data log",
-                clusterSvc.nodeName(),
-                partitionsWorkDir.raftLogPath(),
-                raftConfiguration.fsync().value()
-        );
-
-        LogSyncer partitionsLogSyncer = partitionsLogStorageManager.logSyncer();
-
-        metastorageWorkDir = metastoragePath(systemConfiguration, workDir);
-
-        msLogStorageManager = SharedLogStorageManagerUtils.create(
-                "meta-storage log",
-                clusterSvc.nodeName(),
-                metastorageWorkDir.raftLogPath(),
-                // If it changes, then it will be necessary to set LogSyncer to RocksDbKeyValueStorage.
-                true
-        );
-
-        cmgLogStorageManager = SharedLogStorageManagerUtils.create(
-                "cluster-management-group log",
-                clusterSvc.nodeName(),
-                cmgWorkDir.raftLogPath(),
-                true
-        );
-
-        RaftGroupOptionsConfigurer cmgRaftConfigurer =
-                RaftGroupOptionsConfigHelper.configureProperties(cmgLogStorageManager, cmgWorkDir.metaPath());
-
-        RaftGroupOptionsConfigurer msRaftConfigurer =
-                RaftGroupOptionsConfigHelper.configureProperties(msLogStorageManager, metastorageWorkDir.metaPath());
-
-        partitionRaftConfigurer =
-                RaftGroupOptionsConfigHelper.configureProperties(partitionsLogStorageManager, partitionsWorkDir.metaPath());
-
-        GroupStoragesContextResolver groupStoragesContextResolver = createGroupStoragesContextResolver();
-
-        GroupStoragesDestructionIntents groupStoragesDestructionIntents = new VaultGroupStoragesDestructionIntents(vaultMgr);
-
-        raftMgr = new Loza(
-                clusterSvc,
-                metricManager,
-                raftConfiguration,
-                systemConfiguration,
-                clock,
-                raftGroupEventsClientListener,
-                failureManager,
-                groupStoragesDestructionIntents,
-                groupStoragesContextResolver
-        );
-
-        MessagingService messagingServiceReturningToStorageOperationsPool = new JumpToExecutorByConsistentIdAfterSend(
-                clusterSvc.messagingService(),
-                name,
-                message -> threadPoolsManager.partitionOperationsExecutor()
-        );
-
-        var logicalTopology = new LogicalTopologyImpl(clusterStateStorage, failureManager);
-        logicalTopology.addEventListener(logicalTopologyJoinedNodesListener(clusterSvc.topologyService()));
-
-        ConfigurationTreeGenerator distributedConfigurationGenerator = new ConfigurationTreeGenerator(
-                modules.distributed().rootKeys(),
-                modules.distributed().schemaExtensions(),
-                modules.distributed().polymorphicSchemaExtensions()
-        );
-
-        ConfigurationValidator distributedCfgValidator = ConfigurationValidatorImpl.withDefaultValidators(
-                distributedConfigurationGenerator,
-                modules.distributed().validators()
-        );
-
-        ConfigurationDynamicDefaultsPatcher clusterCfgDynamicDefaultsPatcher = new ConfigurationDynamicDefaultsPatcherImpl(
-                modules.distributed(),
-                distributedConfigurationGenerator
-        );
-
-        clusterInitializer = new ClusterInitializer(
-                clusterSvc,
-                clusterCfgDynamicDefaultsPatcher,
-                distributedCfgValidator
-        );
-
-        NodeAttributesCollector nodeAttributesCollector =
-                new NodeAttributesCollector(
-                        nodeConfigRegistry.getConfiguration(NodeAttributesExtensionConfiguration.KEY).nodeAttributes(),
-                        nodeConfigRegistry.getConfiguration(StorageExtensionConfiguration.KEY).storage()
-                );
-
-        nodeAttributesCollector.register(nodeProperties);
-
-        var clusterStateStorageMgr =  new ClusterStateStorageManager(clusterStateStorage);
-        var validationManager = new ValidationManager(clusterStateStorageMgr, logicalTopology);
-
-        SystemDisasterRecoveryStorage systemDisasterRecoveryStorage = new SystemDisasterRecoveryStorage(vaultMgr);
-        cmgMgr = new ClusterManagementGroupManager(
-                vaultMgr,
-                systemDisasterRecoveryStorage,
-                clusterSvc,
-                clusterInitializer,
-                raftMgr,
-                clusterStateStorageMgr,
-                logicalTopology,
-                validationManager,
-                nodeAttributesCollector,
-                failureManager,
-                clusterIdService,
-                cmgRaftConfigurer,
-                metricManager
-        );
-
-        logicalTopologyService = new LogicalTopologyServiceImpl(logicalTopology, cmgMgr);
-
-        var topologyAwareRaftGroupServiceFactory = new TopologyAwareRaftGroupServiceFactory(
-                clusterSvc,
-                logicalTopologyService,
-                Loza.FACTORY,
-                raftGroupEventsClientListener
-        );
-
-        var readOperationForCompactionTracker = new ReadOperationForCompactionTracker();
-
-        var storage = new RocksDbKeyValueStorage(
-                name,
-                metastorageWorkDir.dbPath(),
-                failureManager,
-                readOperationForCompactionTracker,
-                threadPoolsManager.commonScheduler()
-        );
-
-        metaStorageMgr = new MetaStorageManagerImpl(
-                clusterSvc,
-                cmgMgr,
-                logicalTopologyService,
-                raftMgr,
-                storage,
-                clock,
-                topologyAwareRaftGroupServiceFactory,
-                metricManager,
-                systemDisasterRecoveryStorage,
-                new MetastorageRepairImpl(clusterSvc.messagingService(), logicalTopology, cmgMgr),
-                msRaftConfigurer,
-                readOperationForCompactionTracker,
-                threadPoolsManager.tableIoExecutor(),
-                failureManager
-        );
-
-        cfgStorage = new DistributedConfigurationStorage(name, metaStorageMgr);
-
-        clusterConfigRegistry = ConfigurationRegistry.create(
-                modules.distributed(),
-                cfgStorage,
-                distributedConfigurationGenerator,
-                distributedCfgValidator
-        );
-
-        metricManager.configure(clusterConfigRegistry.getConfiguration(MetricExtensionConfiguration.KEY).metrics());
-
-        eventLog = new EventLogImpl(
-                clusterConfigRegistry.getConfiguration(EventLogExtensionConfiguration.KEY).eventlog(),
-                () -> clusterState().clusterTag().clusterId(),
-                name
-        );
-
-        SystemDistributedConfiguration systemDistributedConfiguration =
-                clusterConfigRegistry.getConfiguration(SystemDistributedExtensionConfiguration.KEY).system();
-
-        metaStorageMgr.configure(systemDistributedConfiguration);
-
-        systemDisasterRecoveryManager = new SystemDisasterRecoveryManagerImpl(
-                name,
-                clusterSvc.topologyService(),
-                clusterSvc.messagingService(),
-                vaultMgr,
-                restarter,
-                metaStorageMgr,
-                cmgMgr,
-                clusterIdService
-        );
-
-        metaStorageCompactionTrigger = new MetaStorageCompactionTrigger(
-                name,
-                storage,
-                metaStorageMgr,
-                failureManager,
-                readOperationForCompactionTracker,
-                systemDistributedConfiguration
-        );
-
-        SchemaSynchronizationConfiguration schemaSyncConfig = clusterConfigRegistry
-                .getConfiguration(SchemaSynchronizationExtensionConfiguration.KEY).schemaSync();
-
-        clockServiceMetricSource = new ClockServiceMetricSource();
-
-        clockService = new ClockServiceImpl(
-                clock,
-                clockWaiter,
-                () -> schemaSyncConfig.maxClockSkewMillis().value(),
-                clockServiceMetricSource::onMaxClockSkewExceeded
-        );
-
-        idempotentCacheVacuumizer = new IdempotentCacheVacuumizer(
-                name,
-                threadPoolsManager.commonScheduler(),
-                metaStorageMgr::evictIdempotentCommandsCache,
-                raftConfiguration.retryTimeoutMillis(),
-                clockService,
-                failureManager,
-                1,
-                1,
-                MINUTES
-        );
-
-        metaStorageMgr.addElectionListener(idempotentCacheVacuumizer);
-
-        var registry = new MetaStorageRevisionListenerRegistry(metaStorageMgr);
-
-        LongSupplier delayDurationMsSupplier = delayDurationMsSupplier(schemaSyncConfig);
-
-        partitionCountCalculatorWrapper = new PartitionCountCalculatorWrapper();
-
-        CatalogManagerImpl catalogManager = new CatalogManagerImpl(
-                new UpdateLogImpl(metaStorageMgr, failureManager),
-                clockService,
-                failureManager,
-                delayDurationMsSupplier,
-                partitionCountCalculatorWrapper
-        );
-
-        ReplicationConfiguration replicationConfig = clusterConfigRegistry
-                .getConfiguration(ReplicationExtensionConfiguration.KEY).replication();
-
-        placementDriverMgr = new PlacementDriverManager(
-                name,
-                metaStorageMgr,
-                MetastorageGroupId.INSTANCE,
-                clusterSvc,
-                cmgMgr::metaStorageNodes,
-                logicalTopologyService,
-                raftMgr,
-                topologyAwareRaftGroupServiceFactory,
-                clockService,
-                failureManager,
-                replicationConfig,
-                threadPoolsManager.commonScheduler(),
-                metricManager,
-                zoneId -> distributionZoneManager().currentDataNodes(zoneId)
-        );
-
-        TransactionConfiguration txConfig = clusterConfigRegistry.getConfiguration(TransactionExtensionConfiguration.KEY).transaction();
-
-        ReplicaService replicaSvc = new ReplicaService(
-                messagingServiceReturningToStorageOperationsPool,
-                clockService,
-                threadPoolsManager.partitionOperationsExecutor(),
-                replicationConfig,
-                threadPoolsManager.commonScheduler()
-        );
-
-        LongSupplier partitionIdleSafeTimePropagationPeriodMsSupplier = partitionIdleSafeTimePropagationPeriodMsSupplier(replicationConfig);
-
-        // TODO: IGNITE-22222 this instantiation should be moved inside ReplicaManager's constructor
-        Marshaller raftMarshaller = new ThreadLocalPartitionCommandsMarshaller(clusterSvc.serializationRegistry());
-
-        volatileLogStorageManagerCreator = new VolatileLogStorageManagerCreator(name, workDir.resolve("volatile-log-spillout"));
-
-        logStorageMetrics = new LogStorageMetrics(
-                name,
-                metricManager,
-                cmgLogStorageManager,
-                msLogStorageManager,
-                partitionsLogStorageManager,
-                volatileLogStorageManagerCreator
-        );
-
-        schemaSafeTimeTracker = new SchemaSafeTimeTrackerImpl(metaStorageMgr.clusterTime());
-        metaStorageMgr.registerNotificationEnqueuedListener(schemaSafeTimeTracker);
-
-        SchemaSyncService schemaSyncService = new SchemaSyncServiceImpl(schemaSafeTimeTracker, delayDurationMsSupplier);
-
-        schemaManager = new SchemaManager(registry, catalogManager);
-
-        ValidationSchemasSource validationSchemasSource = new CatalogValidationSchemasSource(catalogManager, schemaManager);
-
-        replicaMgr = new ReplicaManager(
-                name,
-                clusterSvc,
-                cmgMgr,
-                groupId -> zonePartitionStableAssignments(metaStorageMgr, groupId),
-                clockService,
-                Set.of(PartitionReplicationMessageGroup.class, TxMessageGroup.class),
-                placementDriverMgr.placementDriver(),
-                threadPoolsManager.partitionOperationsExecutor(),
-                partitionIdleSafeTimePropagationPeriodMsSupplier,
-                failureManager,
-                raftMarshaller,
-                new PartitionSafeTimeValidator(validationSchemasSource, catalogManager, schemaSyncService),
-                topologyAwareRaftGroupServiceFactory,
-                raftMgr,
-                partitionRaftConfigurer,
-                volatileLogStorageManagerCreator,
-                threadPoolsManager.tableIoExecutor(),
-                replicaGrpId -> metaStorageMgr.get(pendingPartAssignmentsQueueKey((TablePartitionId) replicaGrpId))
-                        .thenApply(entry -> new VersionedAssignments(entry.value(), entry.revision())),
-                threadPoolsManager.commonScheduler()
-        );
-
-        DataStorageModules dataStorageModules = new DataStorageModules(
-                ServiceLoader.load(DataStorageModule.class, serviceProviderClassLoader)
-        );
-
-        Path storagePath = partitionsWorkDir.dbPath();
-
-        GcConfiguration gcConfig = clusterConfigRegistry.getConfiguration(GcExtensionConfiguration.KEY).gc();
-
-        Map<String, StorageEngine> storageEngines = dataStorageModules.createStorageEngines(
-                name,
-                metricManager,
-                nodeConfigRegistry,
-                storagePath,
-                longJvmPauseDetector,
-                failureManager,
-                partitionsLogSyncer,
-                clock,
-                threadPoolsManager.commonScheduler()
-        );
-
-        dataStorageMgr = new DataStorageManager(
-                applyThreadAssertionsIfNeeded(storageEngines),
-                nodeConfigRegistry.getConfiguration(StorageExtensionConfiguration.KEY).storage()
-        );
-
-        outgoingSnapshotsManager = new OutgoingSnapshotsManager(name, clusterSvc.messagingService(), failureManager);
-
-        systemViewManager = new SystemViewManagerImpl(name, catalogManager, failureManager);
-        nodeAttributesCollector.register(systemViewManager);
-        logicalTopology.addEventListener(systemViewManager);
-        systemViewManager.register(catalogManager);
-
-        this.catalogManager = catalogManager;
-
-        lowWatermark = new LowWatermarkImpl(
-                name,
-                gcConfig.lowWatermark(),
-                clockService,
-                vaultMgr,
-                failureManager,
-                clusterSvc.messagingService()
-        );
-
-        this.indexMetaStorage = new IndexMetaStorage(catalogManager, lowWatermark, metaStorageMgr);
-
-        raftMgr.appendEntriesRequestInterceptor(new CheckCatalogVersionOnAppendEntries(catalogManager));
-        raftMgr.actionRequestInterceptor(new CheckCatalogVersionOnActionRequest(catalogManager));
-
-        distributionZoneManager = new DistributionZoneManager(
-                name,
-                () -> clusterSvc.topologyService().localMember().id(),
-                metaStorageMgr,
-                logicalTopologyService,
-                failureManager,
-                catalogManager,
-                systemDistributedConfiguration,
-                clockService,
-                metricManager,
-                lowWatermark
-        );
-
-        var dataNodesAwarePartitionCountCalculator = new DataNodesAwarePartitionCountCalculator(
-                distributionZoneManager::estimatedDataNodesCount,
-                cpuInformationProvider
-        );
-
-        partitionCountCalculatorWrapper.setPartitionCountCalculator(dataNodesAwarePartitionCountCalculator);
-
-        indexNodeFinishedRwTransactionsChecker = new IndexNodeFinishedRwTransactionsChecker(
-                catalogManager,
-                clusterSvc.messagingService(),
-                clock
-        );
-
-        MinimumRequiredTimeCollectorServiceImpl minTimeCollectorService = new MinimumRequiredTimeCollectorServiceImpl();
-
-        CatalogCompactionRunner catalogCompactionRunner = new CatalogCompactionRunner(
-                name,
-                catalogManager,
-                clusterSvc.messagingService(),
-                logicalTopologyService,
-                placementDriverMgr.placementDriver(),
-                replicaSvc,
-                clockService,
-                schemaSyncService,
-                clusterSvc.topologyService(),
-                lowWatermark,
-                indexNodeFinishedRwTransactionsChecker,
-                minTimeCollectorService,
-                new RebalanceMinimumRequiredTimeProviderImpl(metaStorageMgr, catalogManager)
-        );
-
-        metaStorageMgr.addElectionListener(catalogCompactionRunner::updateCoordinator);
-        this.catalogCompactionRunner = catalogCompactionRunner;
-
-        killCommandHandler = new KillCommandHandler(name, logicalTopologyService, clusterSvc.messagingService());
-
-        resourcesRegistry = new RemotelyTriggeredResourceRegistry();
-
-        VolatileTxStateMetaStorage txStateVolatileStorage = new VolatileTxStateMetaStorage();
-
-        TransactionInflights transactionInflights =
-                new TransactionInflights(placementDriverMgr.placementDriver(), clockService, txStateVolatileStorage);
-
-        LockManager lockMgr = new HeapLockManager(systemConfiguration, txStateVolatileStorage);
-
-        // TODO: IGNITE-19344 - use nodeId that is validated on join (and probably generated differently).
-        txManager = new TxManagerImpl(
-                name,
-                txConfig,
-                systemDistributedConfiguration,
-                messagingServiceReturningToStorageOperationsPool,
-                clusterSvc.topologyService(),
-                replicaSvc,
-                lockMgr,
-                txStateVolatileStorage,
-                clockService,
-                new TransactionIdGenerator(() -> clusterSvc.nodeName().hashCode()),
-                placementDriverMgr.placementDriver(),
-                partitionIdleSafeTimePropagationPeriodMsSupplier,
-                indexNodeFinishedRwTransactionsChecker,
-                threadPoolsManager.partitionOperationsExecutor(),
-                resourcesRegistry,
-                transactionInflights,
-                lowWatermark,
-                threadPoolsManager.commonScheduler(),
-                failureManager,
-                metricManager
-        );
-
-        sharedTxStateStorage = new TxStateRocksDbSharedStorage(
-                name,
-                storagePath.resolve(TX_STATE_DIR),
-                threadPoolsManager.commonScheduler(),
-                threadPoolsManager.tableIoExecutor(),
-                partitionsLogSyncer,
-                failureManager
-        );
-
-        partitionReplicaLifecycleManager = new PartitionReplicaLifecycleManager(
-                catalogManager,
-                replicaMgr,
-                distributionZoneManager,
-                metaStorageMgr,
-                clusterSvc.topologyService(),
-                lowWatermark,
-                failureManager,
-                threadPoolsManager.tableIoExecutor(),
-                threadPoolsManager.rebalanceScheduler(),
-                threadPoolsManager.partitionOperationsExecutor(),
-                clockService,
-                placementDriverMgr.placementDriver(),
-                schemaSyncService,
-                systemDistributedConfiguration,
-                sharedTxStateStorage,
-                txManager,
-                schemaManager,
-                dataStorageMgr,
-                outgoingSnapshotsManager,
-                metricManager,
-                messagingServiceReturningToStorageOperationsPool,
-                replicaSvc
-        );
-
-        systemViewManager.register(txManager);
-        killCommandHandler.register(transactionKillHandler(txManager));
-
-        resourceVacuumManager = new ResourceVacuumManager(
-                name,
-                resourcesRegistry,
-                clusterSvc.topologyService(),
-                messagingServiceReturningToStorageOperationsPool,
-                transactionInflights,
-                txManager,
-                lowWatermark,
-                failureManager,
-                metricManager
-        );
-
-        partitionModificationCounterFactory = new PartitionModificationCounterFactory(clockService::current, clusterSvc.messagingService());
-
-        distributedTblMgr = new TableManager(
-                name,
-                registry,
-                gcConfig,
-                replicationConfig,
-                messagingServiceReturningToStorageOperationsPool,
-                clusterSvc.topologyService(),
-                lockMgr,
-                replicaSvc,
-                txManager,
-                dataStorageMgr,
-                metaStorageMgr,
-                schemaManager,
-                validationSchemasSource,
-                threadPoolsManager.tableIoExecutor(),
-                threadPoolsManager.partitionOperationsExecutor(),
-                clockService,
-                outgoingSnapshotsManager,
-                schemaSyncService,
-                catalogManager,
-                failureManager,
-                observableTimestampTracker,
-                placementDriverMgr.placementDriver(),
-                this::bareSql,
-                resourcesRegistry,
-                lowWatermark,
-                transactionInflights,
-                indexMetaStorage,
-                partitionReplicaLifecycleManager,
-                minTimeCollectorService,
-                systemDistributedConfiguration,
-                metricManager,
-                partitionModificationCounterFactory
-        );
-
-        disasterRecoveryManager = new DisasterRecoveryManager(
-                threadPoolsManager.tableIoExecutor(),
-                messagingServiceReturningToStorageOperationsPool,
-                metaStorageMgr,
-                catalogManager,
-                distributionZoneManager,
-                raftMgr,
-                clusterSvc.topologyService(),
-                logicalTopologyService,
-                distributedTblMgr,
-                metricManager,
-                failureManager,
-                partitionReplicaLifecycleManager,
-                systemViewManager
-        );
-
-        indexManager = new IndexManager(
-                schemaManager,
-                distributedTblMgr,
-                catalogManager,
-                threadPoolsManager.tableIoExecutor(),
-                registry,
-                lowWatermark
-        );
-
-        indexBuildingManager = new IndexBuildingManager(
-                name,
-                replicaSvc,
-                catalogManager,
-                metaStorageMgr,
-                indexManager,
-                indexMetaStorage,
-                placementDriverMgr.placementDriver(),
-                clusterSvc,
-                logicalTopologyService,
-                clockService,
-                failureManager,
-                lowWatermark,
-                txManager,
-                partitionReplicaLifecycleManager,
-                metricManager
-        );
-
-        qryEngine = new SqlQueryProcessor(
-                clusterSvc,
-                logicalTopologyService,
-                distributedTblMgr,
-                schemaManager,
-                replicaSvc,
-                clockService,
-                schemaSyncService,
-                catalogManager,
-                metricManager,
-                systemViewManager,
-                failureManager,
-                placementDriverMgr.placementDriver(),
-                clusterConfigRegistry.getConfiguration(SqlClusterExtensionConfiguration.KEY).sql(),
-                nodeConfigRegistry.getConfiguration(SqlNodeExtensionConfiguration.KEY).sql(),
-                transactionInflights,
-                txManager,
-                lowWatermark,
-                threadPoolsManager.commonScheduler(),
-                killCommandHandler,
-                eventLog
-        );
-
-        systemViewManager.register(qryEngine);
-
-        sql = new IgniteSqlImpl(qryEngine, observableTimestampTracker, threadPoolsManager.commonScheduler());
-
-        ComputeConfiguration computeCfg = nodeConfigRegistry.getConfiguration(ComputeExtensionConfiguration.KEY).compute();
-        InMemoryComputeStateMachine stateMachine = new InMemoryComputeStateMachine(computeCfg, name);
-        ComputeExecutorImpl computeExecutor = new ComputeExecutorImpl(
-                this,
-                stateMachine,
-                computeCfg,
-                clusterSvc.topologyService(),
-                clockService,
-                eventLog
-        );
-
-        var deploymentManagerImpl = new DeploymentManagerImpl(
-                clusterSvc,
-                new DeploymentUnitStoreImpl(metaStorageMgr),
-                logicalTopologyService,
-                workDir,
-                nodeConfigRegistry.getConfiguration(DeploymentExtensionConfiguration.KEY).deployment(),
-                cmgMgr,
-                name,
-                computeExecutor::onUnitRemoving // TODO IGNITE-25759 cleaner platform unit removal.
-        );
-        deploymentManager = deploymentManagerImpl;
-
-        computeComponent = new ComputeComponentImpl(
-                name,
-                clusterSvc.messagingService(),
-                clusterSvc.topologyService(),
-                logicalTopologyService,
-                new UnitsContextManager(
-                        deploymentManagerImpl,
-                        deploymentManagerImpl.deploymentUnitAccessor(),
-                        new UnitsClassLoaderFactory()
-                ),
-                computeExecutor,
-                computeCfg,
-                eventLog,
-                observableTimestampTracker
-        );
-
-        systemViewManager.register(computeComponent);
-
-        compute = new IgniteComputeImpl(
-                name,
-                placementDriverMgr.placementDriver(),
-                clusterSvc.topologyService(),
-                distributedTblMgr,
-                computeComponent,
-                clock,
-                observableTimestampTracker
-        );
-
-        killCommandHandler.register(computeKillHandler(compute));
-
-        authenticationManager = createAuthenticationManager();
-
-        ClientConnectorConfiguration clientConnectorConfiguration = nodeConfigRegistry
-                .getConfiguration(ClientConnectorExtensionConfiguration.KEY).clientConnector();
-
-        SuggestionsConfiguration suggestionsConfiguration = clusterConfigRegistry
-                .getConfiguration(SuggestionsClusterExtensionConfiguration.KEY).suggestions();
-
-        clientHandlerModule = new ClientHandlerModule(
-                qryEngine,
-                distributedTblMgr,
-                txManager,
-                compute,
-                clusterSvc,
-                nettyBootstrapFactory,
-                () -> {
-                    ClusterState localClusterState = clusterState();
-
-                    return new ClusterInfo(localClusterState.clusterTag(), localClusterState.clusterIdHistory());
-                },
-                metricManager,
-                new ClientHandlerMetricSource(),
-                authenticationManager,
-                clockService,
-                schemaSyncService,
-                catalogManager,
-                placementDriverMgr.placementDriver(),
-                clientConnectorConfiguration,
-                eventLog,
-                lowWatermark,
-                threadPoolsManager.partitionOperationsExecutor(),
-                () -> suggestionsConfiguration.sequentialDdlExecution().enabled().value()
-        );
-
-        computeExecutor.setPlatformComputeTransport(clientHandlerModule);
-
-        metricMessaging = new MetricMessaging(metricManager, clusterSvc.messagingService(), clusterSvc.topologyService());
-        systemPropertiesComponent = new SystemPropertiesComponent(systemDistributedConfiguration);
-
+        // Resolve all DI-managed components. Bean creation is lazy — requesting the first bean triggers
+        // its construction plus all transitive dependencies. By the time we're done, all beans are created.
+
+        // Phase 1 components (pre-join).
+        longJvmPauseDetector = diContext.getBean(LongJvmPauseDetector.class);
+        metricManager = diContext.getBean(MetricManagerImpl.class);
+        threadPoolsManager = diContext.getBean(ThreadPoolsManager.class);
+        vaultMgr = diContext.getBean(VaultManager.class);
+        nodeProperties = diContext.getBean(NodePropertiesImpl.class);
+        failureManager = diContext.getBean(FailureManager.class);
+        clusterIdService = diContext.getBean(ClusterIdService.class);
+        criticalWorkerRegistry = diContext.getBean(CriticalWorkerWatchdog.class);
+        nettyBootstrapFactory = diContext.getBean(NettyBootstrapFactory.class);
+        nettyWorkersRegistrar = diContext.getBean(NettyWorkersRegistrar.class);
+        clusterSvc = diContext.getBean(ClusterService.class);
+        clock = diContext.getBean(HybridClock.class);
+        clockWaiter = diContext.getBean(ClockWaiter.class);
+        clusterStateStorage = diContext.getBean(ClusterStateStorage.class);
+        systemDisasterRecoveryManager = diContext.getBean(SystemDisasterRecoveryManagerImpl.class);
+        partitionsLogStorageManager = diContext.getBean(LogStorageManager.class, Qualifiers.byName("partitions"));
+        msLogStorageManager = diContext.getBean(LogStorageManager.class, Qualifiers.byName("metastorage"));
+        cmgLogStorageManager = diContext.getBean(LogStorageManager.class, Qualifiers.byName("cmg"));
+        partitionsWorkDir = diContext.getBean(ComponentWorkingDir.class, Qualifiers.byName("partitions"));
+        metastorageWorkDir = diContext.getBean(ComponentWorkingDir.class, Qualifiers.byName("metastorage"));
+        raftMgr = diContext.getBean(Loza.class);
+        cmgMgr = diContext.getBean(ClusterManagementGroupManager.class);
+        logicalTopologyService = diContext.getBean(LogicalTopologyService.class);
+        clusterInitializer = diContext.getBean(ClusterInitializer.class);
+        lowWatermark = diContext.getBean(LowWatermarkImpl.class);
+
+        // Phase 2 components (post-join).
+        metaStorageMgr = diContext.getBean(MetaStorageManagerImpl.class);
+        clusterConfigRegistry = diContext.getBean(ConfigurationRegistry.class, Qualifiers.byName("clusterConfig"));
+        cfgStorage = diContext.getBean(DistributedConfigurationStorage.class);
+        eventLog = diContext.getBean(EventLogImpl.class);
+        metaStorageCompactionTrigger = diContext.getBean(MetaStorageCompactionTrigger.class);
+        clockServiceMetricSource = diContext.getBean(ClockServiceMetricSource.class);
+        clockService = diContext.getBean(ClockServiceImpl.class);
+        idempotentCacheVacuumizer = diContext.getBean(IdempotentCacheVacuumizer.class);
+        catalogManager = diContext.getBean(CatalogManagerImpl.class);
+        catalogCompactionRunner = diContext.getBean(CatalogCompactionRunner.class);
+        placementDriverMgr = diContext.getBean(PlacementDriverManager.class);
+        schemaSafeTimeTracker = diContext.getBean(SchemaSafeTimeTrackerImpl.class);
+        schemaManager = diContext.getBean(SchemaManager.class);
+        replicaMgr = diContext.getBean(ReplicaManager.class);
+        txManager = diContext.getBean(TxManagerImpl.class);
+        dataStorageMgr = diContext.getBean(DataStorageManager.class);
+        distributionZoneManager = diContext.getBean(DistributionZoneManager.class);
+        indexNodeFinishedRwTransactionsChecker = diContext.getBean(IndexNodeFinishedRwTransactionsChecker.class);
+        outgoingSnapshotsManager = diContext.getBean(OutgoingSnapshotsManager.class);
+        sharedTxStateStorage = diContext.getBean(TxStateRocksDbSharedStorage.class);
+        partitionReplicaLifecycleManager = diContext.getBean(PartitionReplicaLifecycleManager.class);
+        distributedTblMgr = diContext.getBean(TableManager.class);
+        disasterRecoveryManager = diContext.getBean(DisasterRecoveryManager.class);
+        indexManager = diContext.getBean(IndexManager.class);
+        indexBuildingManager = diContext.getBean(IndexBuildingManager.class);
+        qryEngine = diContext.getBean(SqlQueryProcessor.class);
+        sql = diContext.getBean(IgniteSqlImpl.class);
+        killCommandHandler = diContext.getBean(KillCommandHandler.class);
+        computeComponent = diContext.getBean(ComputeComponentImpl.class);
+        compute = diContext.getBean(IgniteComputeInternal.class);
+        deploymentManager = diContext.getBean(DeploymentManagerImpl.class);
+        authenticationManager = diContext.getBean(AuthenticationManager.class);
+        clientHandlerModule = diContext.getBean(ClientHandlerModule.class);
+        resourcesRegistry = diContext.getBean(RemotelyTriggeredResourceRegistry.class);
+        resourceVacuumManager = diContext.getBean(ResourceVacuumManager.class);
+        volatileLogStorageManagerCreator = diContext.getBean(VolatileLogStorageManagerCreator.class);
+        logStorageMetrics = diContext.getBean(LogStorageMetrics.class);
+        metricMessaging = diContext.getBean(MetricMessaging.class);
+        systemPropertiesComponent = diContext.getBean(SystemPropertiesComponent.class);
+        partitionModificationCounterFactory = diContext.getBean(PartitionModificationCounterFactory.class);
+        partitionCountCalculatorWrapper = diContext.getBean(PartitionCountCalculatorWrapper.class);
+        systemViewManager = diContext.getBean(SystemViewManagerImpl.class);
+        observableTimestampTracker = diContext.getBean(HybridTimestampTracker.class);
+        indexMetaStorage = diContext.getBean(IndexMetaStorage.class);
+
+        // Post-construction wiring: cross-component hookups that cannot be expressed as constructor injection.
+        PostConstructionWiring wiring = diContext.getBean(PostConstructionWiring.class);
+        wiring.wirePhase2();
+
+        // REST component (depends on joinFuture and lifecycle state, created manually).
         restComponent = createRestComponent(name);
 
+        // Public API wrappers.
         publicTables = new PublicApiThreadingIgniteTables(distributedTblMgr, asyncContinuationExecutor);
         publicTransactions = new PublicApiThreadingIgniteTransactions(
                 new IgniteTransactionsImpl(txManager, observableTimestampTracker), asyncContinuationExecutor
@@ -1354,40 +544,6 @@ public class IgniteImpl implements Ignite {
         publicCluster = new PublicApiThreadingIgniteCluster(new IgniteClusterImpl(clusterSvc.topologyService(), clusterIdService));
     }
 
-    private GroupStoragesContextResolver createGroupStoragesContextResolver() {
-        Map<String, LogStorageManager> logStorageManagerByGroupName = Map.of(
-                PARTITION_GROUP_NAME, partitionsLogStorageManager,
-                MetastorageGroupId.INSTANCE.toString(), msLogStorageManager,
-                CmgGroupId.INSTANCE.toString(), cmgLogStorageManager
-        );
-
-        Map<String, Path> serverDataPathByGroupName = Map.of(
-                PARTITION_GROUP_NAME, partitionsWorkDir.metaPath(),
-                MetastorageGroupId.INSTANCE.toString(), metastorageWorkDir.metaPath(),
-                CmgGroupId.INSTANCE.toString(), cmgWorkDir.metaPath()
-        );
-
-        return new GroupStoragesContextResolver(
-                replicationGroupId -> replicationGroupId instanceof PartitionGroupId ? PARTITION_GROUP_NAME : replicationGroupId.toString(),
-                serverDataPathByGroupName,
-                logStorageManagerByGroupName
-        );
-    }
-
-    private static LogicalTopologyEventListener logicalTopologyJoinedNodesListener(LogicalTopologyEventsListener listener) {
-        return new LogicalTopologyEventListener() {
-            @Override
-            public void onNodeJoined(LogicalNode joinedNode, LogicalTopologySnapshot newTopology) {
-                listener.onJoined(joinedNode, newTopology.version());
-            }
-
-            @Override
-            public void onNodeLeft(LogicalNode leftNode, LogicalTopologySnapshot newTopology) {
-                listener.onLeft(leftNode, newTopology.version());
-            }
-        };
-    }
-
     private ClusterState clusterState() {
         ClusterState localClusterState = clusterState;
 
@@ -1396,39 +552,6 @@ private ClusterState clusterState() {
         return localClusterState;
     }
 
-    private static Map<String, StorageEngine> applyThreadAssertionsIfNeeded(Map<String, StorageEngine> storageEngines) {
-        boolean enabled = ThreadAssertions.enabled();
-
-        LOG.info("Thread assertions enablement status: {}", enabled);
-
-        if (!enabled) {
-            return storageEngines;
-        }
-
-        Map<String, StorageEngine> decoratedEngines = new HashMap<>();
-
-        for (Entry<String, StorageEngine> entry : storageEngines.entrySet()) {
-            decoratedEngines.put(entry.getKey(), new ThreadAssertingStorageEngine(entry.getValue()));
-        }
-
-        return Map.copyOf(decoratedEngines);
-    }
-
-    private static LongSupplier delayDurationMsSupplier(SchemaSynchronizationConfiguration schemaSyncConfig) {
-        return () -> schemaSyncConfig.delayDurationMillis().value();
-    }
-
-    private static LongSupplier partitionIdleSafeTimePropagationPeriodMsSupplier(ReplicationConfiguration replicationConfig) {
-        return () -> replicationConfig.idleSafeTimePropagationDurationMillis().value();
-    }
-
-    private AuthenticationManager createAuthenticationManager() {
-        SecurityConfiguration securityConfiguration = clusterConfigRegistry
-                .getConfiguration(SecurityExtensionConfiguration.KEY).security();
-
-        return new AuthenticationManagerImpl(securityConfiguration, eventLog);
-    }
-
     private RestComponent createRestComponent(String name) {
         RestManager restManager = new RestManager();
         Supplier<RestFactory> presentationsFactory = () -> new PresentationsFactory(nodeConfigRegistry, clusterConfigRegistry);
@@ -1476,16 +599,6 @@ private RestComponent createRestComponent(String name) {
         );
     }
 
-    private static MessageSerializationRegistry createSerializationRegistry(@Nullable ClassLoader classLoader) {
-        var serviceLoader = new SerializationRegistryServiceLoader(classLoader);
-
-        var serializationRegistry = new MessageSerializationRegistryImpl();
-
-        serviceLoader.registerSerializationFactories(serializationRegistry);
-
-        return serializationRegistry;
-    }
-
     /**
      * Starts ignite node.
      *
@@ -1865,10 +978,6 @@ public IgniteTransactions transactions() {
         return publicTransactions;
     }
 
-    private IgniteSql bareSql() {
-        return sql;
-    }
-
     /** {@inheritDoc} */
     @Override
     public IgniteSql sql() {
@@ -2027,51 +1136,6 @@ private CompletableFuture<?> recoverComponentsStateOnStart(ExecutorService start
                 }, startupExecutor);
     }
 
-    /** Returns a {@link OperationKillHandler kill handler} for the compute job. */
-    private static OperationKillHandler computeKillHandler(IgniteComputeInternal compute) {
-        return new OperationKillHandler() {
-            @Override
-            public CompletableFuture<Boolean> cancelAsync(String operationId) {
-                UUID jobId = UUID.fromString(operationId);
-
-                return compute.cancelAsync(jobId)
-                        .thenApply(res -> res != null ? res : Boolean.FALSE);
-            }
-
-            @Override
-            public boolean local() {
-                return false;
-            }
-
-            @Override
-            public CancellableOperationType type() {
-                return CancellableOperationType.COMPUTE;
-            }
-        };
-    }
-
-    /** Returns a {@link OperationKillHandler kill handler} for the transaction. */
-    private static OperationKillHandler transactionKillHandler(TxManager txManager) {
-        return new OperationKillHandler() {
-            @Override
-            public CompletableFuture<Boolean> cancelAsync(String operationId) {
-                UUID transactionId = UUID.fromString(operationId);
-
-                return txManager.kill(transactionId);
-            }
-
-            @Override
-            public boolean local() {
-                return true;
-            }
-
-            @Override
-            public CancellableOperationType type() {
-                return CancellableOperationType.TRANSACTION;
-            }
-        };
-    }
-
     @TestOnly
     public Loza raftManager() {
         return raftMgr;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
index e9f18a679c17..b33f85a8a0c8 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
@@ -61,7 +61,7 @@ public VaultManager vaultManager(VaultService vaultService) {
      * @param clusterIdSupplier Supplier of the cluster ID; resolved lazily after cluster initialization.
      */
     @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
     public MetricManagerImpl metricManager(
             NodeSeedParams seedParams,
             @Named("clusterIdSupplier") Supplier<UUID> clusterIdSupplier
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 24daf2a81348..1d0bee164e98 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -266,7 +266,7 @@ public OutgoingSnapshotsManager outgoingSnapshotsManager(
 
     /** Creates the low watermark. */
     @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @IgniteStartupPhase(StartupPhase.PHASE_1)
     public LowWatermarkImpl lowWatermark(
             NodeSeedParams seedParams,
             GcConfiguration gcConfiguration,
@@ -407,7 +407,8 @@ public TableManager tableManager(
             IndexMetaStorage indexMetaStorage,
             PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
             SystemDistributedConfiguration systemDistributedConfiguration,
-            MetricManager metricManager
+            MetricManager metricManager,
+            PartitionModificationCounterFactory partitionModificationCounterFactory
     ) {
         return new TableManager(
                 seedParams.nodeName(),
@@ -441,12 +442,19 @@ public TableManager tableManager(
                 new MinimumRequiredTimeCollectorServiceImpl(),
                 systemDistributedConfiguration,
                 metricManager,
-                new PartitionModificationCounterFactory(
-                        clockService::current, clusterService.messagingService()
-                )
+                partitionModificationCounterFactory
         );
     }
 
+    /** Creates the partition modification counter factory. */
+    @Singleton
+    public PartitionModificationCounterFactory partitionModificationCounterFactory(
+            ClockServiceImpl clockService,
+            ClusterService clusterService
+    ) {
+        return new PartitionModificationCounterFactory(clockService::current, clusterService.messagingService());
+    }
+
     /** Creates the index manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)

From 47de0d6aa4f67db3607f262960abea9ace626b4d Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 12:13:55 +0400
Subject: [PATCH 12/79] =?UTF-8?q?Step10=D1=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../di/IgniteComponentLifecycleManager.java   |  37 +++
 .../ignite/internal/app/IgniteImpl.java       | 236 ++++--------------
 2 files changed, 83 insertions(+), 190 deletions(-)

diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
index 3f41aeed81ed..69e9679f5236 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
@@ -26,11 +26,14 @@
 import io.micronaut.inject.BeanDefinition;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.EnumMap;
+import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
@@ -67,6 +70,40 @@ public IgniteComponentLifecycleManager(ApplicationContext context) {
         }
     }
 
+    /**
+     * Excludes specific component instances from being started by {@link #startPhase}.
+     * Excluded components are also removed from the stop list unless explicitly added via {@link #markAsStarted}.
+     *
+     * <p>Use this for components that are started manually due to special ordering requirements
+     * (e.g., nodeConfigRegistry must start before other beans are created).
+     *
+     * @param components Components to exclude (identity-based comparison).
+     */
+    public void exclude(IgniteComponent... components) {
+        Set<IgniteComponent> excludeSet = newIdentitySet(components);
+
+        for (List<IgniteComponent> phaseList : componentsByPhase.values()) {
+            phaseList.removeIf(excludeSet::contains);
+        }
+    }
+
+    /**
+     * Marks components as started externally, so they will be stopped during {@link #stopAll}.
+     *
+     * <p>Use this for components that are excluded from {@link #startPhase} but still need lifecycle management.
+     *
+     * @param components Components that were started externally.
+     */
+    public void markAsStarted(IgniteComponent... components) {
+        Collections.addAll(startedComponents, components);
+    }
+
+    private static Set<IgniteComponent> newIdentitySet(IgniteComponent... components) {
+        Set<IgniteComponent> set = Collections.newSetFromMap(new IdentityHashMap<>());
+        Collections.addAll(set, components);
+        return set;
+    }
+
     /**
      * Starts all components belonging to the given phase.
      *
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 07681193de34..679258fe330f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -66,7 +66,6 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
-import org.apache.ignite.internal.components.LongJvmPauseDetector;
 import org.apache.ignite.internal.components.NodeProperties;
 import org.apache.ignite.internal.compute.AntiHijackIgniteCompute;
 import org.apache.ignite.internal.compute.ComputeComponentImpl;
@@ -80,7 +79,9 @@
 import org.apache.ignite.internal.configuration.tree.ConfigurationSource;
 import org.apache.ignite.internal.deployunit.DeploymentManagerImpl;
 import org.apache.ignite.internal.deployunit.IgniteDeployment;
+import org.apache.ignite.internal.di.IgniteComponentLifecycleManager;
 import org.apache.ignite.internal.di.IgniteDiContext;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
 import org.apache.ignite.internal.disaster.system.ServerRestarter;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManager;
@@ -90,12 +91,8 @@
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
-import org.apache.ignite.internal.hlc.ClockWaiter;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
-import org.apache.ignite.internal.index.IndexBuildingManager;
-import org.apache.ignite.internal.index.IndexManager;
-import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.lang.IgniteStringBuilder;
 import org.apache.ignite.internal.lang.NodeStoppingException;
@@ -104,32 +101,23 @@
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
-import org.apache.ignite.internal.metastorage.cache.IdempotentCacheVacuumizer;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageCompactionTrigger;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.metrics.MetricManagerImpl;
-import org.apache.ignite.internal.metrics.logstorage.LogStorageMetrics;
 import org.apache.ignite.internal.metrics.messaging.MetricMessaging;
-import org.apache.ignite.internal.metrics.sources.ClockServiceMetricSource;
-import org.apache.ignite.internal.metrics.sources.JvmMetricSource;
-import org.apache.ignite.internal.metrics.sources.OsMetricSource;
 import org.apache.ignite.internal.network.ChannelType;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.DefaultMessagingService;
 import org.apache.ignite.internal.network.IgniteClusterImpl;
 import org.apache.ignite.internal.network.InternalClusterNode;
 import org.apache.ignite.internal.network.NettyBootstrapFactory;
-import org.apache.ignite.internal.network.NettyWorkersRegistrar;
 import org.apache.ignite.internal.network.NetworkMessage;
 import org.apache.ignite.internal.network.PublicApiThreadingIgniteCluster;
 import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
-import org.apache.ignite.internal.partition.replicator.raft.snapshot.outgoing.OutgoingSnapshotsManager;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
 import org.apache.ignite.internal.raft.Loza;
 import org.apache.ignite.internal.raft.storage.LogStorageManager;
-import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
 import org.apache.ignite.internal.replicator.ReplicaManager;
 import org.apache.ignite.internal.rest.RestComponent;
 import org.apache.ignite.internal.rest.RestFactory;
@@ -150,7 +138,6 @@
 import org.apache.ignite.internal.rest.recovery.DisasterRecoveryFactory;
 import org.apache.ignite.internal.rest.recovery.system.SystemDisasterRecoveryFactory;
 import org.apache.ignite.internal.rest.sql.SqlQueryRestFactory;
-import org.apache.ignite.internal.schema.SchemaManager;
 import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
 import org.apache.ignite.internal.security.authentication.AuthenticationManager;
 import org.apache.ignite.internal.sql.api.IgniteSqlImpl;
@@ -158,25 +145,20 @@
 import org.apache.ignite.internal.sql.engine.QueryProcessor;
 import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
 import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
-import org.apache.ignite.internal.storage.DataStorageManager;
 import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
 import org.apache.ignite.internal.systemview.api.SystemViewManager;
-import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
 import org.apache.ignite.internal.table.distributed.PublicApiThreadingIgniteTables;
 import org.apache.ignite.internal.table.distributed.TableManager;
 import org.apache.ignite.internal.table.distributed.disaster.DisasterRecoveryManager;
-import org.apache.ignite.internal.table.distributed.index.IndexMetaStorage;
 import org.apache.ignite.internal.thread.IgniteThreadFactory;
 import org.apache.ignite.internal.threading.PublicApiThreadingIgniteCatalog;
 import org.apache.ignite.internal.tx.TxManager;
 import org.apache.ignite.internal.tx.impl.IgniteTransactionsImpl;
 import org.apache.ignite.internal.tx.impl.PublicApiThreadingIgniteTransactions;
 import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
-import org.apache.ignite.internal.tx.impl.ResourceVacuumManager;
 import org.apache.ignite.internal.tx.impl.TxManagerImpl;
 import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
 import org.apache.ignite.internal.vault.VaultManager;
-import org.apache.ignite.internal.worker.CriticalWorkerWatchdog;
 import org.apache.ignite.lang.IgniteException;
 import org.apache.ignite.network.IgniteCluster;
 import org.apache.ignite.network.NetworkAddress;
@@ -205,7 +187,8 @@ public class IgniteImpl implements Ignite {
     /** Micronaut DI context for component construction and dependency injection. */
     private final ApplicationContext diContext;
 
-    private final ThreadPoolsManager threadPoolsManager;
+    /** Lifecycle manager for DI-managed components. */
+    private final IgniteComponentLifecycleManager componentLifecycleManager;
 
     /** Vault manager. */
     private final VaultManager vaultMgr;
@@ -228,34 +211,24 @@ public class IgniteImpl implements Ignite {
 
     private final ComputeComponentImpl computeComponent;
 
-    private final CriticalWorkerWatchdog criticalWorkerRegistry;
-
     /** Failure processor. */
     private final FailureManager failureManager;
 
     /** Netty bootstrap factory. */
     private final NettyBootstrapFactory nettyBootstrapFactory;
 
-    private final NettyWorkersRegistrar nettyWorkersRegistrar;
-
     /** Raft manager. */
     private final Loza raftMgr;
 
     /** Meta storage manager. */
     private final MetaStorageManagerImpl metaStorageMgr;
 
-    /** Metastorage compaction trigger. */
-    private final MetaStorageCompactionTrigger metaStorageCompactionTrigger;
-
     /** Placement driver manager. */
     private final PlacementDriverManager placementDriverMgr;
 
     /** Configuration registry that handles cluster (distributed) configuration. */
     private final ConfigurationRegistry clusterConfigRegistry;
 
-    /** Idempotent cache vacuumizer. */
-    private final IdempotentCacheVacuumizer idempotentCacheVacuumizer;
-
     /** Cluster initializer. */
     private final ClusterInitializer clusterInitializer;
 
@@ -273,8 +246,6 @@ public class IgniteImpl implements Ignite {
     /** Disaster recovery manager. */
     private final DisasterRecoveryManager disasterRecoveryManager;
 
-    private final IndexManager indexManager;
-
     /** Rest module. */
     private final RestComponent restComponent;
 
@@ -297,17 +268,8 @@ public class IgniteImpl implements Ignite {
     /** Compute. */
     private final IgniteComputeInternal compute;
 
-    /** JVM pause detector. */
-    private final LongJvmPauseDetector longJvmPauseDetector;
-
-    /** Data storage manager. */
-    private final DataStorageManager dataStorageMgr;
-
     private final SchemaSafeTimeTrackerImpl schemaSafeTimeTracker;
 
-    /** Schema manager. */
-    private final SchemaManager schemaManager;
-
     /** Metric manager. */
     private final MetricManagerImpl metricManager;
 
@@ -320,24 +282,13 @@ public class IgniteImpl implements Ignite {
 
     private final PartitionReplicaLifecycleManager partitionReplicaLifecycleManager;
 
-    /** Creator for volatile {@link LogStorageManager} instances. */
-    private final VolatileLogStorageManagerCreator volatileLogStorageManagerCreator;
-
-    private final LogStorageMetrics logStorageMetrics;
-
-    private final SystemPropertiesComponent systemPropertiesComponent;
-
     /** A hybrid logical clock. */
     private final HybridClock clock;
 
-    private final ClockWaiter clockWaiter;
-
     private final ClockService clockService;
 
     private final LowWatermarkImpl lowWatermark;
 
-    private final OutgoingSnapshotsManager outgoingSnapshotsManager;
-
     private final CatalogManager catalogManager;
 
     private final CatalogCompactionRunner catalogCompactionRunner;
@@ -350,15 +301,6 @@ public class IgniteImpl implements Ignite {
     /** System views manager. */
     private final SystemViewManagerImpl systemViewManager;
 
-    /** Index building manager. */
-    private final IndexBuildingManager indexBuildingManager;
-
-    /** Local node RW transaction completion checker for indexes. */
-    private final IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker;
-
-    /** Cleanup manager for tx resources. */
-    private final ResourceVacuumManager resourceVacuumManager;
-
     /** Remote triggered resources registry. */
     private final RemotelyTriggeredResourceRegistry resourcesRegistry;
 
@@ -374,12 +316,6 @@ public class IgniteImpl implements Ignite {
     /** Partitions log storage manager for raft. */
     private final LogStorageManager partitionsLogStorageManager;
 
-    private final LogStorageManager msLogStorageManager;
-
-    private final LogStorageManager cmgLogStorageManager;
-
-    private final IndexMetaStorage indexMetaStorage;
-
     private final EventLogImpl eventLog;
 
     private final KillCommandHandler killCommandHandler;
@@ -391,10 +327,6 @@ public class IgniteImpl implements Ignite {
     @Nullable
     private volatile ClusterState clusterState;
 
-    private final ClockServiceMetricSource clockServiceMetricSource;
-
-    private final PartitionModificationCounterFactory partitionModificationCounterFactory;
-
     private final PartitionCountCalculatorWrapper partitionCountCalculatorWrapper;
 
     /** Future that completes when the node has joined the cluster. */
@@ -453,25 +385,18 @@ public class IgniteImpl implements Ignite {
         // Resolve all DI-managed components. Bean creation is lazy — requesting the first bean triggers
         // its construction plus all transitive dependencies. By the time we're done, all beans are created.
 
-        // Phase 1 components (pre-join).
-        longJvmPauseDetector = diContext.getBean(LongJvmPauseDetector.class);
+        // Phase 1 components (pre-join). Only fields still used outside the constructor are resolved.
         metricManager = diContext.getBean(MetricManagerImpl.class);
-        threadPoolsManager = diContext.getBean(ThreadPoolsManager.class);
         vaultMgr = diContext.getBean(VaultManager.class);
         nodeProperties = diContext.getBean(NodePropertiesImpl.class);
         failureManager = diContext.getBean(FailureManager.class);
         clusterIdService = diContext.getBean(ClusterIdService.class);
-        criticalWorkerRegistry = diContext.getBean(CriticalWorkerWatchdog.class);
         nettyBootstrapFactory = diContext.getBean(NettyBootstrapFactory.class);
-        nettyWorkersRegistrar = diContext.getBean(NettyWorkersRegistrar.class);
         clusterSvc = diContext.getBean(ClusterService.class);
         clock = diContext.getBean(HybridClock.class);
-        clockWaiter = diContext.getBean(ClockWaiter.class);
         clusterStateStorage = diContext.getBean(ClusterStateStorage.class);
         systemDisasterRecoveryManager = diContext.getBean(SystemDisasterRecoveryManagerImpl.class);
         partitionsLogStorageManager = diContext.getBean(LogStorageManager.class, Qualifiers.byName("partitions"));
-        msLogStorageManager = diContext.getBean(LogStorageManager.class, Qualifiers.byName("metastorage"));
-        cmgLogStorageManager = diContext.getBean(LogStorageManager.class, Qualifiers.byName("cmg"));
         partitionsWorkDir = diContext.getBean(ComponentWorkingDir.class, Qualifiers.byName("partitions"));
         metastorageWorkDir = diContext.getBean(ComponentWorkingDir.class, Qualifiers.byName("metastorage"));
         raftMgr = diContext.getBean(Loza.class);
@@ -485,27 +410,18 @@ public class IgniteImpl implements Ignite {
         clusterConfigRegistry = diContext.getBean(ConfigurationRegistry.class, Qualifiers.byName("clusterConfig"));
         cfgStorage = diContext.getBean(DistributedConfigurationStorage.class);
         eventLog = diContext.getBean(EventLogImpl.class);
-        metaStorageCompactionTrigger = diContext.getBean(MetaStorageCompactionTrigger.class);
-        clockServiceMetricSource = diContext.getBean(ClockServiceMetricSource.class);
         clockService = diContext.getBean(ClockServiceImpl.class);
-        idempotentCacheVacuumizer = diContext.getBean(IdempotentCacheVacuumizer.class);
         catalogManager = diContext.getBean(CatalogManagerImpl.class);
         catalogCompactionRunner = diContext.getBean(CatalogCompactionRunner.class);
         placementDriverMgr = diContext.getBean(PlacementDriverManager.class);
         schemaSafeTimeTracker = diContext.getBean(SchemaSafeTimeTrackerImpl.class);
-        schemaManager = diContext.getBean(SchemaManager.class);
         replicaMgr = diContext.getBean(ReplicaManager.class);
         txManager = diContext.getBean(TxManagerImpl.class);
-        dataStorageMgr = diContext.getBean(DataStorageManager.class);
         distributionZoneManager = diContext.getBean(DistributionZoneManager.class);
-        indexNodeFinishedRwTransactionsChecker = diContext.getBean(IndexNodeFinishedRwTransactionsChecker.class);
-        outgoingSnapshotsManager = diContext.getBean(OutgoingSnapshotsManager.class);
         sharedTxStateStorage = diContext.getBean(TxStateRocksDbSharedStorage.class);
         partitionReplicaLifecycleManager = diContext.getBean(PartitionReplicaLifecycleManager.class);
         distributedTblMgr = diContext.getBean(TableManager.class);
         disasterRecoveryManager = diContext.getBean(DisasterRecoveryManager.class);
-        indexManager = diContext.getBean(IndexManager.class);
-        indexBuildingManager = diContext.getBean(IndexBuildingManager.class);
         qryEngine = diContext.getBean(SqlQueryProcessor.class);
         sql = diContext.getBean(IgniteSqlImpl.class);
         killCommandHandler = diContext.getBean(KillCommandHandler.class);
@@ -515,16 +431,17 @@ public class IgniteImpl implements Ignite {
         authenticationManager = diContext.getBean(AuthenticationManager.class);
         clientHandlerModule = diContext.getBean(ClientHandlerModule.class);
         resourcesRegistry = diContext.getBean(RemotelyTriggeredResourceRegistry.class);
-        resourceVacuumManager = diContext.getBean(ResourceVacuumManager.class);
-        volatileLogStorageManagerCreator = diContext.getBean(VolatileLogStorageManagerCreator.class);
-        logStorageMetrics = diContext.getBean(LogStorageMetrics.class);
         metricMessaging = diContext.getBean(MetricMessaging.class);
-        systemPropertiesComponent = diContext.getBean(SystemPropertiesComponent.class);
-        partitionModificationCounterFactory = diContext.getBean(PartitionModificationCounterFactory.class);
         partitionCountCalculatorWrapper = diContext.getBean(PartitionCountCalculatorWrapper.class);
         systemViewManager = diContext.getBean(SystemViewManagerImpl.class);
         observableTimestampTracker = diContext.getBean(HybridTimestampTracker.class);
-        indexMetaStorage = diContext.getBean(IndexMetaStorage.class);
+
+        // Initialize the DI component lifecycle manager. Exclude components with special startup ordering:
+        // nodeConfigRegistry — started early in constructor, before other beans are created
+        // metaStorageMgr — started manually in joinClusterAsync() (must start before cluster config init)
+        // systemViewManager — must start last, after all system view registrations
+        componentLifecycleManager = new IgniteComponentLifecycleManager(diContext);
+        componentLifecycleManager.exclude(nodeConfigRegistry, metaStorageMgr, systemViewManager);
 
         // Post-construction wiring: cross-component hookups that cannot be expressed as constructor injection.
         PostConstructionWiring wiring = diContext.getBean(PostConstructionWiring.class);
@@ -614,46 +531,17 @@ CompletableFuture<Void> startAsync() {
         ComponentContext componentContext = new ComponentContext(startupExecutor);
 
         try {
-            JvmMetricSource jvmMetrics = new JvmMetricSource();
-            metricManager.registerSource(jvmMetrics);
-            metricManager.enable(jvmMetrics);
-
-            OsMetricSource osMetrics = new OsMetricSource();
-            metricManager.registerSource(osMetrics);
-            metricManager.enable(osMetrics);
-
-            metricManager.registerSource(clockServiceMetricSource);
-            metricManager.enable(clockServiceMetricSource);
-
-            partitionModificationCounterFactory.start();
-
-            // Start the components that are required to join the cluster.
-            // TODO https://issues.apache.org/jira/browse/IGNITE-22570
-            CompletableFuture<Void> componentsStartFuture = lifecycleManager.startComponentsAsync(
-                    componentContext,
-                    longJvmPauseDetector,
-                    vaultMgr,
-                    nodeProperties,
-                    threadPoolsManager,
-                    clockWaiter,
-                    failureManager,
-                    clusterStateStorage,
-                    clusterIdService,
-                    systemDisasterRecoveryManager,
-                    criticalWorkerRegistry,
-                    nettyBootstrapFactory,
-                    nettyWorkersRegistrar,
-                    clusterSvc,
-                    restComponent,
-                    partitionsLogStorageManager,
-                    msLogStorageManager,
-                    cmgLogStorageManager,
-                    raftMgr,
-                    cmgMgr,
-                    lowWatermark
-            );
-
-            return componentsStartFuture
+            // Pre-start wiring: register metric sources and start partition modification counters.
+            PostConstructionWiring wiring = diContext.getBean(PostConstructionWiring.class);
+            wiring.wirePhase1();
+
+            // Start REST component separately (not DI-managed, depends on joinFuture).
+            CompletableFuture<Void> restStartFuture = lifecycleManager.startComponentAsync(restComponent, componentContext);
+
+            // Start all PHASE_1 DI-managed components.
+            CompletableFuture<Void> phase1Future = componentLifecycleManager.startPhase(StartupPhase.PHASE_1, componentContext);
+
+            return CompletableFuture.allOf(restStartFuture, phase1Future)
                     .thenRunAsync(() -> {
                         vaultMgr.putName(name);
 
@@ -712,63 +600,30 @@ CompletableFuture<Ignite> joinClusterAsync() {
                     return metaStorageMgr.recoveryFinishedFuture();
                 }, joinExecutor)
                 .thenComposeAsync(unused -> initializeClusterConfiguration(joinExecutor), joinExecutor)
-                .thenRunAsync(() -> {
+                .thenComposeAsync(unused -> {
                     LOG.info("MetaStorage started, starting the remaining components");
 
-                    // Start all other components after the join request has completed and the node has been validated.
-                    try {
-                        lifecycleManager.startComponentsAsync(
-                                componentContext,
-                                catalogManager,
-                                new LowWatermarkRectifier(lowWatermark, catalogManager),
-                                catalogCompactionRunner,
-                                indexMetaStorage,
-                                clusterConfigRegistry,
-                                idempotentCacheVacuumizer,
-                                authenticationManager,
-                                placementDriverMgr,
-                                metricManager,
-                                metricMessaging,
-                                distributionZoneManager,
-                                computeComponent,
-                                volatileLogStorageManagerCreator,
-                                logStorageMetrics,
-                                replicaMgr,
-                                indexNodeFinishedRwTransactionsChecker,
-                                txManager,
-                                dataStorageMgr,
-                                schemaSafeTimeTracker,
-                                schemaManager,
-                                outgoingSnapshotsManager,
-                                sharedTxStateStorage,
-                                partitionReplicaLifecycleManager,
-                                distributedTblMgr,
-                                disasterRecoveryManager,
-                                indexManager,
-                                indexBuildingManager,
-                                qryEngine,
-                                clientHandlerModule,
-                                deploymentManager,
-                                sql,
-                                systemPropertiesComponent,
-                                resourceVacuumManager,
-                                metaStorageCompactionTrigger,
-                                eventLog
-                        );
-
-                        // The system view manager comes last because other components
-                        // must register system views before it starts.
-                        lifecycleManager.startComponentAsync(systemViewManager, componentContext);
-                    } catch (NodeStoppingException e) {
-                        throw new CompletionException(e);
-                    }
+                    // Start all PHASE_2 DI-managed components.
+                    CompletableFuture<Void> phase2Future = componentLifecycleManager.startPhase(
+                            StartupPhase.PHASE_2, componentContext
+                    );
+
+                    // The system view manager comes last because other components
+                    // must register system views before it starts.
+                    return phase2Future.thenRunAsync(() -> {
+                        try {
+                            lifecycleManager.startComponentAsync(systemViewManager, componentContext);
+                        } catch (NodeStoppingException e) {
+                            throw new CompletionException(e);
+                        }
+                    }, joinExecutor);
                 }, joinExecutor)
                 .thenComposeAsync(v -> {
                     LOG.info("Components started, performing recovery");
 
                     LOG.info("Cluster configuration: {}", convertToHoconString(clusterConfigRegistry));
 
-                    return recoverComponentsStateOnStart(joinExecutor, lifecycleManager.allComponentsStartFuture(joinExecutor));
+                    return recoverComponentsStateOnStart(joinExecutor);
                 }, joinExecutor)
                 .thenComposeAsync(v -> clusterConfigRegistry.onDefaultsPersisted(), joinExecutor)
                 // Signal that local recovery is complete and the node is ready to join the cluster.
@@ -898,12 +753,15 @@ public CompletableFuture<Void> stopAsync() {
         }
 
         ExecutorService lifecycleExecutor = stopExecutor();
+        ComponentContext componentContext = new ComponentContext(lifecycleExecutor);
 
         cmgMgr.markAsStopping();
         metaStorageMgr.markAsStopping();
 
-        // TODO https://issues.apache.org/jira/browse/IGNITE-22570
-        lifecycleManager.stopNode(new ComponentContext(lifecycleExecutor))
+        // Stop DI-managed components first (reverse of start order: PHASE_2, then PHASE_1),
+        // then stop manually-started components (systemViewManager, metaStorageMgr, restComponent, nodeConfigRegistry).
+        componentLifecycleManager.stopAll(componentContext)
+                .thenCompose(v -> lifecycleManager.stopNode(componentContext))
                 // Moving to the common pool on purpose to close the stop pool and proceed user's code in the common pool.
                 .whenCompleteAsync((res, ex) -> lifecycleExecutor.shutdownNow())
                 .whenCompleteAsync(copyStateTo(stopFuture));
@@ -1126,10 +984,8 @@ private CompletableFuture<Void> initializeClusterConfiguration(ExecutorService s
                 .thenRunAsync(systemDisasterRecoveryManager::markInitConfigApplied, startupExecutor);
     }
 
-    private CompletableFuture<?> recoverComponentsStateOnStart(ExecutorService startupExecutor, CompletableFuture<Void> startFuture) {
-        CompletableFuture<Void> startupRevisionUpdate = metaStorageMgr.notifyRevisionUpdateListenerOnStart();
-
-        return CompletableFuture.allOf(startupRevisionUpdate, startFuture)
+    private CompletableFuture<?> recoverComponentsStateOnStart(ExecutorService startupExecutor) {
+        return metaStorageMgr.notifyRevisionUpdateListenerOnStart()
                 .thenComposeAsync(unused -> {
                     // Deploy all registered watches because all components are ready and have registered their listeners.
                     return metaStorageMgr.deployWatches();

From a73f471551df3e3394cab17a45d043282b2ffb5b Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 13:54:35 +0400
Subject: [PATCH 13/79] Step11

---
 .../di/IgniteComponentLifecycleManager.java   | 19 +++---
 .../ignite/internal/di/IgniteDiContext.java   | 59 ++++++++++++++++++-
 .../ignite/internal/app/IgniteImpl.java       | 21 +++++--
 .../internal/app/di/CatalogFactory.java       |  6 ++
 .../internal/app/di/ClientHandlerFactory.java |  3 +
 .../app/di/ClusterManagementFactory.java      |  8 +++
 .../internal/app/di/ComputeFactory.java       |  5 ++
 .../app/di/CoreComponentsFactory.java         | 17 +++---
 .../internal/app/di/DataPathFactory.java      | 19 ++++++
 .../internal/app/di/MetaStorageFactory.java   |  2 +
 .../app/di/NetworkComponentsFactory.java      |  7 +++
 .../internal/app/di/NodeSeedParams.java       | 13 +++-
 .../ignite/internal/app/di/RaftFactory.java   |  5 ++
 .../ignite/internal/app/di/SqlFactory.java    |  3 +
 .../app/di/SystemServicesFactory.java         |  8 +++
 .../internal/app/di/TransactionFactory.java   |  5 ++
 16 files changed, 175 insertions(+), 25 deletions(-)

diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
index 69e9679f5236..f3ddb2d7c378 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
@@ -23,6 +23,7 @@
 import static org.apache.ignite.internal.util.IgniteUtils.closeAll;
 
 import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.BeanRegistration;
 import io.micronaut.inject.BeanDefinition;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -176,15 +177,17 @@ public List<IgniteComponent> startedComponents() {
         return List.copyOf(startedComponents);
     }
 
-    @SuppressWarnings("unchecked")
     private static StartupPhase resolvePhase(ApplicationContext context, IgniteComponent component) {
-        // First, try to get the phase from the BeanDefinition (works for compile-time and factory beans).
-        Optional<BeanDefinition<IgniteComponent>> definition =
-                (Optional<BeanDefinition<IgniteComponent>>) (Optional<?>)
-                        context.findBeanDefinition(component.getClass());
-
-        if (definition.isPresent()) {
-            Optional<StartupPhase> phase = definition.get()
+        // First, try to get the phase from the BeanRegistration for this specific instance.
+        // Using findBeanRegistration(instance) instead of findBeanDefinition(class) avoids
+        // NonUniqueBeanException when multiple beans of the same type exist (e.g., two ConfigurationRegistry
+        // beans with different @Named qualifiers).
+        Optional<? extends BeanRegistration<? extends IgniteComponent>> registration =
+                context.findBeanRegistration(component);
+
+        if (registration.isPresent()) {
+            BeanDefinition<? extends IgniteComponent> definition = registration.get().getBeanDefinition();
+            Optional<StartupPhase> phase = definition
                     .findAnnotation(IgniteStartupPhase.class)
                     .flatMap(av -> av.enumValue(StartupPhase.class));
             if (phase.isPresent()) {
diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
index aed969e6b319..c2561436d3ce 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
@@ -19,6 +19,9 @@
 
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.ApplicationContextBuilder;
+import io.micronaut.context.ApplicationContextConfiguration;
+import io.micronaut.context.DefaultApplicationContext;
+import io.micronaut.inject.BeanDefinitionReference;
 import io.micronaut.inject.qualifiers.Qualifiers;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -57,6 +60,8 @@ public static class Builder {
 
         private final List<String> packages = new ArrayList<>();
 
+        private final List<String> excludedPackages = new ArrayList<>();
+
         /**
          * Registers a seed singleton that will be available for injection in the context.
          *
@@ -92,6 +97,21 @@ public Builder withPackages(String... packageNames) {
             return this;
         }
 
+        /**
+         * Excludes bean definitions from the specified packages. Bean definitions whose generated class name
+         * starts with any of the given package prefixes will not be loaded into the context.
+         *
+         * <p>This is needed to prevent compile-time discovered beans from other Micronaut contexts
+         * (e.g., REST module factories) from being loaded into this core DI context.
+         *
+         * @param packagePrefixes Package prefixes to exclude (e.g., {@code "org.apache.ignite.internal.rest"}).
+         * @return This builder for chaining.
+         */
+        public Builder withExcludedPackages(String... packagePrefixes) {
+            Collections.addAll(excludedPackages, packagePrefixes);
+            return this;
+        }
+
         /**
          * Builds and starts the Micronaut {@link ApplicationContext}.
          *
@@ -110,7 +130,44 @@ public ApplicationContext build() {
                 contextBuilder.singletons(singletons.toArray());
             }
 
-            ApplicationContext context = contextBuilder.start();
+            ApplicationContext context;
+
+            if (excludedPackages.isEmpty()) {
+                context = contextBuilder.start();
+            } else {
+                // Build the context manually so we can override bean discovery to exclude
+                // unwanted packages (e.g., REST module beans that conflict with core DI beans).
+                // We replicate the singleton registration that ApplicationContextBuilder.build() does,
+                // because DefaultApplicationContext(configuration) doesn't auto-register them.
+                List<String> excluded = List.copyOf(excludedPackages);
+
+                context = new DefaultApplicationContext((ApplicationContextConfiguration) contextBuilder) {
+                    @Override
+                    protected List<BeanDefinitionReference> resolveBeanDefinitionReferences() {
+                        List<BeanDefinitionReference> refs = super.resolveBeanDefinitionReferences();
+
+                        refs.removeIf(ref -> {
+                            String name = ref.getBeanDefinitionName();
+
+                            for (String pkg : excluded) {
+                                if (name.startsWith(pkg + ".")) {
+                                    return true;
+                                }
+                            }
+
+                            return false;
+                        });
+
+                        return refs;
+                    }
+                };
+
+                for (Object singleton : singletons) {
+                    context.registerSingleton(singleton);
+                }
+
+                context.start();
+            }
 
             for (NamedSingletonEntry entry : namedSingletons) {
                 registerNamedSingleton(context, entry);
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 679258fe330f..445fe4b391de 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -356,18 +356,18 @@ public class IgniteImpl implements Ignite {
         lifecycleManager = new LifecycleManager(name);
 
         // Build the Micronaut DI context with seed singletons.
+        Supplier<UUID> clusterIdSupplier = () -> clusterState().clusterTag().clusterId();
+
         NodeSeedParams seedParams = new NodeSeedParams(
-                node, restarter, configPath, workDir, serviceProviderClassLoader, asyncContinuationExecutor
+                node, restarter, configPath, workDir, serviceProviderClassLoader, asyncContinuationExecutor,
+                clusterIdSupplier
         );
 
-        @SuppressWarnings("unchecked")
-        Supplier<UUID> clusterIdSupplier = () -> clusterState().clusterTag().clusterId();
-
         diContext = IgniteDiContext.builder()
                 .withSingleton(seedParams)
                 .withSingleton(this)
-                .withNamedSingleton("clusterIdSupplier", Supplier.class, clusterIdSupplier)
                 .withPackages("org.apache.ignite.internal.app.di")
+                .withExcludedPackages("org.apache.ignite.internal.rest")
                 .build();
 
         // Start local configuration early — factory methods read config values during bean construction.
@@ -438,10 +438,11 @@ public class IgniteImpl implements Ignite {
 
         // Initialize the DI component lifecycle manager. Exclude components with special startup ordering:
         // nodeConfigRegistry — started early in constructor, before other beans are created
+        // clusterConfigRegistry — started manually in joinClusterAsync() (after MetaStorage recovery)
         // metaStorageMgr — started manually in joinClusterAsync() (must start before cluster config init)
         // systemViewManager — must start last, after all system view registrations
         componentLifecycleManager = new IgniteComponentLifecycleManager(diContext);
-        componentLifecycleManager.exclude(nodeConfigRegistry, metaStorageMgr, systemViewManager);
+        componentLifecycleManager.exclude(nodeConfigRegistry, clusterConfigRegistry, metaStorageMgr, systemViewManager);
 
         // Post-construction wiring: cross-component hookups that cannot be expressed as constructor injection.
         PostConstructionWiring wiring = diContext.getBean(PostConstructionWiring.class);
@@ -600,6 +601,14 @@ CompletableFuture<Ignite> joinClusterAsync() {
                     return metaStorageMgr.recoveryFinishedFuture();
                 }, joinExecutor)
                 .thenComposeAsync(unused -> initializeClusterConfiguration(joinExecutor), joinExecutor)
+                .thenRunAsync(() -> {
+                    // Start cluster config registry after MetaStorage recovery (it depends on DistributedConfigurationStorage).
+                    try {
+                        lifecycleManager.startComponentAsync(clusterConfigRegistry, componentContext);
+                    } catch (NodeStoppingException e) {
+                        throw new CompletionException(e);
+                    }
+                }, joinExecutor)
                 .thenComposeAsync(unused -> {
                     LOG.info("MetaStorage started, starting the remaining components");
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index fe97b91cfeba..a92a2feae053 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
 import java.util.concurrent.TimeUnit;
@@ -61,6 +62,7 @@ public ClockServiceMetricSource clockServiceMetricSource() {
     /** Creates the clock service. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(50)
     public ClockServiceImpl clockService(
             HybridClock clock,
             ClockWaiter clockWaiter,
@@ -78,6 +80,7 @@ public ClockServiceImpl clockService(
     /** Creates the idempotent cache vacuumizer. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(600)
     public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
             NodeSeedParams seedParams,
             ThreadPoolsManager threadPoolsManager,
@@ -108,6 +111,7 @@ public PartitionCountCalculatorWrapper partitionCountCalculatorWrapper() {
     /** Creates the catalog update log. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(90)
     public UpdateLogImpl updateLog(MetaStorageManagerImpl metaStorageManager, FailureManager failureManager) {
         return new UpdateLogImpl(metaStorageManager, failureManager);
     }
@@ -115,6 +119,7 @@ public UpdateLogImpl updateLog(MetaStorageManagerImpl metaStorageManager, Failur
     /** Creates the catalog manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(100)
     public CatalogManagerImpl catalogManager(
             UpdateLogImpl updateLog,
             ClockServiceImpl clockService,
@@ -134,6 +139,7 @@ public CatalogManagerImpl catalogManager(
     /** Creates the placement driver manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(800)
     public PlacementDriverManager placementDriverManager(
             NodeSeedParams seedParams,
             MetaStorageManagerImpl metaStorageManager,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
index c362f251cc95..fcaf23d6a8c3 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
@@ -68,6 +69,7 @@ public SecurityConfiguration securityConfiguration(
     /** Creates the authentication manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2850)
     public AuthenticationManager authenticationManager(
             SecurityConfiguration securityConfiguration,
             EventLogImpl eventLog
@@ -94,6 +96,7 @@ public SuggestionsConfiguration suggestionsConfiguration(
     /** Creates the client handler module. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2900)
     public ClientHandlerModule clientHandlerModule(
             SqlQueryProcessor sqlQueryProcessor,
             TableManager tableManager,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 4e5d538f8d99..70aac7a3e6fd 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
@@ -74,6 +75,7 @@ public MessageSerializationRegistry messageSerializationRegistry() {
     /** Creates the cluster service. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1300)
     public ClusterService clusterService(
             NodeSeedParams seedParams,
             NetworkConfiguration networkConfiguration,
@@ -116,6 +118,7 @@ public StorageConfiguration storageConfiguration(@Named("nodeConfig") Configurat
     /** Creates the cluster state storage backed by RocksDB. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(700)
     public RocksDbClusterStateStorage clusterStateStorage(@Named("cmg") ComponentWorkingDir cmgWorkDir, NodeSeedParams seedParams) {
         return new RocksDbClusterStateStorage(cmgWorkDir.dbPath(), seedParams.nodeName());
     }
@@ -123,6 +126,7 @@ public RocksDbClusterStateStorage clusterStateStorage(@Named("cmg") ComponentWor
     /** Creates the cluster state storage manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(710)
     public ClusterStateStorageManager clusterStateStorageManager(RocksDbClusterStateStorage clusterStateStorage) {
         return new ClusterStateStorageManager(clusterStateStorage);
     }
@@ -136,6 +140,7 @@ public LogicalTopologyImpl logicalTopology(RocksDbClusterStateStorage clusterSta
     /** Creates the validation manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(720)
     public ValidationManager validationManager(
             ClusterStateStorageManager clusterStateStorageManager,
             LogicalTopologyImpl logicalTopology
@@ -176,6 +181,7 @@ public ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher(
     /** Creates the cluster initializer. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1310)
     public ClusterInitializer clusterInitializer(
             ClusterService clusterService,
             ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher,
@@ -202,6 +208,7 @@ public SystemDisasterRecoveryStorage systemDisasterRecoveryStorage(VaultManager
     /** Creates the cluster management group manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1900)
     public ClusterManagementGroupManager clusterManagementGroupManager(
             VaultManager vaultManager,
             SystemDisasterRecoveryStorage systemDisasterRecoveryStorage,
@@ -237,6 +244,7 @@ public ClusterManagementGroupManager clusterManagementGroupManager(
     /** Creates the logical topology service. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1910)
     public LogicalTopologyServiceImpl logicalTopologyService(
             LogicalTopologyImpl logicalTopology,
             ClusterManagementGroupManager cmgManager
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index 0dfd774ec3b6..7aeced19571f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
@@ -82,6 +83,7 @@ public InMemoryComputeStateMachine inMemoryComputeStateMachine(
     /** Creates the compute executor. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1100)
     public ComputeExecutorImpl computeExecutor(
             Provider<Ignite> igniteProvider,
             InMemoryComputeStateMachine stateMachine,
@@ -103,6 +105,7 @@ public ComputeExecutorImpl computeExecutor(
     /** Creates the deployment manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(3000)
     public DeploymentManagerImpl deploymentManager(
             ClusterService clusterService,
             MetaStorageManagerImpl metaStorageManager,
@@ -127,6 +130,7 @@ public DeploymentManagerImpl deploymentManager(
     /** Creates the compute component. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1200)
     public ComputeComponentImpl computeComponent(
             NodeSeedParams seedParams,
             ClusterService clusterService,
@@ -157,6 +161,7 @@ public ComputeComponentImpl computeComponent(
     /** Creates the internal compute implementation. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1300)
     public IgniteComputeInternal igniteCompute(
             NodeSeedParams seedParams,
             PlacementDriverManager placementDriverManager,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
index b33f85a8a0c8..d6c1f59b0815 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
@@ -18,10 +18,8 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
-import jakarta.inject.Named;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Singleton;
-import java.util.UUID;
-import java.util.function.Supplier;
 import org.apache.ignite.internal.app.NodePropertiesImpl;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.components.LongJvmPauseDetector;
@@ -43,6 +41,7 @@ public class CoreComponentsFactory {
     /** Creates the JVM pause detector. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(100)
     public LongJvmPauseDetector longJvmPauseDetector(NodeSeedParams seedParams) {
         return new LongJvmPauseDetector(seedParams.nodeName());
     }
@@ -50,6 +49,7 @@ public LongJvmPauseDetector longJvmPauseDetector(NodeSeedParams seedParams) {
     /** Creates the vault manager backed by persistent storage. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(200)
     public VaultManager vaultManager(VaultService vaultService) {
         return new VaultManager(vaultService);
     }
@@ -58,20 +58,18 @@ public VaultManager vaultManager(VaultService vaultService) {
      * Creates the metric manager.
      *
      * @param seedParams Node seed parameters.
-     * @param clusterIdSupplier Supplier of the cluster ID; resolved lazily after cluster initialization.
      */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
-    public MetricManagerImpl metricManager(
-            NodeSeedParams seedParams,
-            @Named("clusterIdSupplier") Supplier<UUID> clusterIdSupplier
-    ) {
-        return new MetricManagerImpl(seedParams.nodeName(), clusterIdSupplier);
+    @Order(900)
+    public MetricManagerImpl metricManager(NodeSeedParams seedParams) {
+        return new MetricManagerImpl(seedParams.nodeName(), seedParams.clusterIdSupplier());
     }
 
     /** Creates the thread pools manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(400)
     public ThreadPoolsManager threadPoolsManager(NodeSeedParams seedParams, MetricManager metricManager) {
         return new ThreadPoolsManager(seedParams.nodeName(), metricManager);
     }
@@ -85,6 +83,7 @@ public HybridClock hybridClock(FailureProcessor failureProcessor) {
     /** Creates the node properties component. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(300)
     public NodePropertiesImpl nodeProperties(VaultManager vaultManager) {
         return new NodePropertiesImpl(vaultManager);
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 1d0bee164e98..0df9a84fe96c 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -21,6 +21,7 @@
 import static org.apache.ignite.internal.distributionzones.rebalance.ZoneRebalanceUtil.zonePartitionStableAssignments;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
@@ -100,6 +101,8 @@
 public class DataPathFactory {
     /** Creates the volatile log storage manager creator. */
     @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1300)
     public VolatileLogStorageManagerCreator volatileLogStorageManagerCreator(NodeSeedParams seedParams) {
         return new VolatileLogStorageManagerCreator(
                 seedParams.nodeName(),
@@ -115,6 +118,8 @@ public MetaStorageRevisionListenerRegistry revisionListenerRegistry(MetaStorageM
 
     /** Creates the schema safe time tracker. */
     @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1900)
     public SchemaSafeTimeTrackerImpl schemaSafeTimeTracker(MetaStorageManagerImpl metaStorageManager) {
         return new SchemaSafeTimeTrackerImpl(metaStorageManager.clusterTime());
     }
@@ -132,6 +137,7 @@ public SchemaSyncServiceImpl schemaSyncService(
     /** Creates the schema manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2000)
     public SchemaManager schemaManager(
             MetaStorageRevisionListenerRegistry revisionListenerRegistry,
             CatalogManagerImpl catalogManager
@@ -150,6 +156,8 @@ public CatalogValidationSchemasSource catalogValidationSchemasSource(
 
     /** Creates the index node finished rw transactions checker. */
     @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1600)
     public IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker(
             CatalogManagerImpl catalogManager,
             ClusterService clusterService,
@@ -167,6 +175,7 @@ public HybridTimestampTracker hybridTimestampTracker() {
     /** Creates the replica manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1500)
     public ReplicaManager replicaManager(
             NodeSeedParams seedParams,
             ClusterService clusterService,
@@ -220,6 +229,7 @@ public ReplicaManager replicaManager(
     /** Creates the data storage manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1800)
     public DataStorageManager dataStorageManager(
             NodeSeedParams seedParams,
             MetricManager metricManager,
@@ -256,6 +266,7 @@ public DataStorageManager dataStorageManager(
     /** Creates the outgoing snapshots manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2100)
     public OutgoingSnapshotsManager outgoingSnapshotsManager(
             NodeSeedParams seedParams,
             ClusterService clusterService,
@@ -267,6 +278,7 @@ public OutgoingSnapshotsManager outgoingSnapshotsManager(
     /** Creates the low watermark. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(2000)
     public LowWatermarkImpl lowWatermark(
             NodeSeedParams seedParams,
             GcConfiguration gcConfiguration,
@@ -287,6 +299,8 @@ public LowWatermarkImpl lowWatermark(
 
     /** Creates the index meta storage. */
     @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(400)
     public IndexMetaStorage indexMetaStorage(
             CatalogManagerImpl catalogManager,
             LowWatermarkImpl lowWatermark,
@@ -298,6 +312,7 @@ public IndexMetaStorage indexMetaStorage(
     /** Creates the distribution zone manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1100)
     public DistributionZoneManager distributionZoneManager(
             NodeSeedParams seedParams,
             ClusterService clusterService,
@@ -327,6 +342,7 @@ public DistributionZoneManager distributionZoneManager(
     /** Creates the partition replica lifecycle manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2300)
     public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
             CatalogManagerImpl catalogManager,
             ReplicaManager replicaManager,
@@ -378,6 +394,7 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
     /** Creates the table manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2400)
     public TableManager tableManager(
             NodeSeedParams seedParams,
             MetaStorageRevisionListenerRegistry revisionListenerRegistry,
@@ -458,6 +475,7 @@ public PartitionModificationCounterFactory partitionModificationCounterFactory(
     /** Creates the index manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2600)
     public IndexManager indexManager(
             SchemaManager schemaManager,
             TableManager tableManager,
@@ -479,6 +497,7 @@ public IndexManager indexManager(
     /** Creates the index building manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2700)
     public IndexBuildingManager indexBuildingManager(
             NodeSeedParams seedParams,
             ReplicaService replicaService,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index 6d3b25306aa4..56203d47f896 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
@@ -112,6 +113,7 @@ public MetastorageRepairImpl metastorageRepair(
     /** Creates the MetaStorage manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(200)
     public MetaStorageManagerImpl metaStorageManager(
             ClusterService clusterService,
             ClusterManagementGroupManager cmgManager,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index 3d86a2ffbce4..4a7614ae04d8 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
@@ -68,6 +69,7 @@ public SystemLocalConfiguration systemLocalConfiguration(@Named("nodeConfig") Co
     /** Creates the failure manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(600)
     public FailureManager failureManager(
             NodeSeedParams seedParams,
             FailureProcessorConfiguration failureProcessorConfiguration
@@ -78,6 +80,7 @@ public FailureManager failureManager(
     /** Creates the critical worker watchdog. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1000)
     public CriticalWorkerWatchdog criticalWorkerWatchdog(
             SystemLocalConfiguration systemConfiguration,
             ThreadPoolsManager threadPoolsManager,
@@ -93,6 +96,7 @@ public CriticalWorkerWatchdog criticalWorkerWatchdog(
     /** Creates the netty bootstrap factory. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1100)
     public NettyBootstrapFactory nettyBootstrapFactory(NodeSeedParams seedParams, NetworkConfiguration networkConfiguration) {
         return new NettyBootstrapFactory(networkConfiguration, seedParams.nodeName());
     }
@@ -100,6 +104,7 @@ public NettyBootstrapFactory nettyBootstrapFactory(NodeSeedParams seedParams, Ne
     /** Creates the netty workers registrar. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1200)
     public NettyWorkersRegistrar nettyWorkersRegistrar(
             CriticalWorkerRegistry criticalWorkerRegistry,
             ThreadPoolsManager threadPoolsManager,
@@ -119,6 +124,7 @@ public NettyWorkersRegistrar nettyWorkersRegistrar(
     /** Creates the clock waiter. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(500)
     public ClockWaiter clockWaiter(NodeSeedParams seedParams, HybridClock clock, ThreadPoolsManager threadPoolsManager) {
         return new ClockWaiter(seedParams.nodeName(), clock, threadPoolsManager.commonScheduler());
     }
@@ -126,6 +132,7 @@ public ClockWaiter clockWaiter(NodeSeedParams seedParams, HybridClock clock, Thr
     /** Creates the cluster ID service. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(800)
     public ClusterIdService clusterIdService(VaultManager vaultManager) {
         return new ClusterIdService(vaultManager);
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java
index c14c0e6c69d5..d316ced7c10b 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java
@@ -18,7 +18,9 @@
 package org.apache.ignite.internal.app.di;
 
 import java.nio.file.Path;
+import java.util.UUID;
 import java.util.concurrent.Executor;
+import java.util.function.Supplier;
 import org.apache.ignite.IgniteServer;
 import org.apache.ignite.internal.disaster.system.ServerRestarter;
 import org.jetbrains.annotations.Nullable;
@@ -42,6 +44,8 @@ public class NodeSeedParams {
 
     private final Executor asyncContinuationExecutor;
 
+    private final Supplier<UUID> clusterIdSupplier;
+
     /** Constructor. */
     public NodeSeedParams(
             IgniteServer node,
@@ -49,7 +53,8 @@ public NodeSeedParams(
             Path configPath,
             Path workDir,
             @Nullable ClassLoader serviceProviderClassLoader,
-            Executor asyncContinuationExecutor
+            Executor asyncContinuationExecutor,
+            Supplier<UUID> clusterIdSupplier
     ) {
         this.node = node;
         this.restarter = restarter;
@@ -57,6 +62,7 @@ public NodeSeedParams(
         this.workDir = workDir;
         this.serviceProviderClassLoader = serviceProviderClassLoader;
         this.asyncContinuationExecutor = asyncContinuationExecutor;
+        this.clusterIdSupplier = clusterIdSupplier;
     }
 
     /** Node name. */
@@ -94,4 +100,9 @@ public ClassLoader serviceProviderClassLoader() {
     public Executor asyncContinuationExecutor() {
         return asyncContinuationExecutor;
     }
+
+    /** Supplier of the cluster ID; resolved lazily after cluster initialization. */
+    public Supplier<UUID> clusterIdSupplier() {
+        return clusterIdSupplier;
+    }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
index a10ac6b8a364..66a0f1fd7d67 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
@@ -22,6 +22,7 @@
 import static org.apache.ignite.internal.configuration.IgnitePaths.partitionsPath;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import java.nio.file.Path;
@@ -96,6 +97,7 @@ public ComponentWorkingDir cmgWorkDir(SystemLocalConfiguration systemConfigurati
     @Singleton
     @Named("partitions")
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1500)
     public LogStorageManager partitionsLogStorageManager(
             NodeSeedParams seedParams,
             RaftConfiguration raftConfiguration,
@@ -113,6 +115,7 @@ public LogStorageManager partitionsLogStorageManager(
     @Singleton
     @Named("metastorage")
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1600)
     public LogStorageManager msLogStorageManager(
             NodeSeedParams seedParams,
             @Named("metastorage") ComponentWorkingDir metastorageWorkDir
@@ -129,6 +132,7 @@ public LogStorageManager msLogStorageManager(
     @Singleton
     @Named("cmg")
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1700)
     public LogStorageManager cmgLogStorageManager(
             NodeSeedParams seedParams,
             @Named("cmg") ComponentWorkingDir cmgWorkDir
@@ -210,6 +214,7 @@ public GroupStoragesDestructionIntents groupStoragesDestructionIntents(VaultMana
     /** Creates the Raft manager (Loza). */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(1800)
     public Loza loza(
             ClusterService clusterService,
             MetricManager metricManager,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index 7b31063ce278..b166533a0881 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
@@ -83,6 +84,7 @@ public KillCommandHandler killCommandHandler(
     /** Creates the SQL query processor. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2800)
     public SqlQueryProcessor sqlQueryProcessor(
             ClusterService clusterService,
             LogicalTopologyService logicalTopologyService,
@@ -132,6 +134,7 @@ public SqlQueryProcessor sqlQueryProcessor(
     /** Creates the IgniteSql implementation. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(3100)
     public IgniteSqlImpl igniteSql(
             SqlQueryProcessor sqlQueryProcessor,
             HybridTimestampTracker observableTimestampTracker,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 65a36d5a8869..808f5cec97d0 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
@@ -80,6 +81,7 @@ public class SystemServicesFactory {
     /** Creates the event log. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(3500)
     public EventLogImpl eventLog(
             @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry,
             Provider<ClusterManagementGroupManager> cmgManagerProvider,
@@ -128,6 +130,7 @@ public DataNodesAwarePartitionCountCalculator dataNodesAwarePartitionCountCalcul
     /** Creates the system disaster recovery manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
+    @Order(900)
     public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
             NodeSeedParams seedParams,
             ClusterService clusterService,
@@ -207,6 +210,7 @@ public CatalogCompactionRunner catalogCompactionRunner(
     /** Creates the log storage metrics. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1400)
     public LogStorageMetrics logStorageMetrics(
             NodeSeedParams seedParams,
             MetricManager metricManager,
@@ -228,6 +232,7 @@ public LogStorageMetrics logStorageMetrics(
     /** Creates the metric messaging. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1000)
     public MetricMessaging metricMessaging(
             MetricManager metricManager,
             ClusterService clusterService
@@ -238,6 +243,7 @@ public MetricMessaging metricMessaging(
     /** Creates the resource vacuum manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(3300)
     public ResourceVacuumManager resourceVacuumManager(
             NodeSeedParams seedParams,
             RemotelyTriggeredResourceRegistry resourcesRegistry,
@@ -265,6 +271,7 @@ public ResourceVacuumManager resourceVacuumManager(
     /** Creates the system properties component. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(3200)
     public SystemPropertiesComponent systemPropertiesComponent(
             SystemDistributedConfiguration systemDistributedConfiguration
     ) {
@@ -274,6 +281,7 @@ public SystemPropertiesComponent systemPropertiesComponent(
     /** Creates the low watermark rectifier. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(200)
     public LowWatermarkRectifier lowWatermarkRectifier(
             LowWatermarkImpl lowWatermark,
             CatalogManagerImpl catalogManager
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 3800262c8053..939a8099cdb7 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -18,6 +18,7 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
@@ -98,6 +99,7 @@ public MessagingService storageOperationsMessagingService(
     /** Creates the replica service. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1600)
     public ReplicaService replicaService(
             @Named("storageOperations") MessagingService messagingService,
             ClockServiceImpl clockService,
@@ -136,6 +138,7 @@ public TransactionInflights transactionInflights(
     /** Creates the lock manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1650)
     public LockManager lockManager(
             SystemLocalConfiguration systemConfiguration,
             VolatileTxStateMetaStorage txStateVolatileStorage
@@ -158,6 +161,7 @@ public RemotelyTriggeredResourceRegistry remotelyTriggeredResourceRegistry() {
     /** Creates the transaction manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1700)
     public TxManagerImpl txManager(
             NodeSeedParams seedParams,
             TransactionConfiguration txConfig,
@@ -206,6 +210,7 @@ public TxManagerImpl txManager(
     /** Creates the shared RocksDB transaction state storage. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(1800)
     public TxStateRocksDbSharedStorage txStateRocksDbSharedStorage(
             NodeSeedParams seedParams,
             @Named("partitions") ComponentWorkingDir partitionsWorkDir,

From 0619f6822692d4a37e098594a0e1bf754f4d5dec Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 15:20:08 +0400
Subject: [PATCH 14/79] Step12

---
 .../ignite/internal/di/IgniteDiContext.java   | 100 +++++-------------
 .../internal/di/IgniteDiContextTest.java      |  42 ++------
 2 files changed, 39 insertions(+), 103 deletions(-)

diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
index c2561436d3ce..9b94aaa989c2 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
@@ -22,7 +22,6 @@
 import io.micronaut.context.ApplicationContextConfiguration;
 import io.micronaut.context.DefaultApplicationContext;
 import io.micronaut.inject.BeanDefinitionReference;
-import io.micronaut.inject.qualifiers.Qualifiers;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -56,8 +55,6 @@ public static Builder builder() {
     public static class Builder {
         private final List<Object> singletons = new ArrayList<>();
 
-        private final List<NamedSingletonEntry> namedSingletons = new ArrayList<>();
-
         private final List<String> packages = new ArrayList<>();
 
         private final List<String> excludedPackages = new ArrayList<>();
@@ -73,19 +70,6 @@ public Builder withSingleton(Object singleton) {
             return this;
         }
 
-        /**
-         * Registers a named singleton that will be available for injection via {@code @Named} qualifier.
-         *
-         * @param name The qualifier name.
-         * @param type The bean type to register under.
-         * @param singleton The object to register.
-         * @return This builder for chaining.
-         */
-        public Builder withNamedSingleton(String name, Class<?> type, Object singleton) {
-            namedSingletons.add(new NamedSingletonEntry(name, type, singleton));
-            return this;
-        }
-
         /**
          * Adds packages to scan for bean definitions.
          *
@@ -130,71 +114,45 @@ public ApplicationContext build() {
                 contextBuilder.singletons(singletons.toArray());
             }
 
-            ApplicationContext context;
-
             if (excludedPackages.isEmpty()) {
-                context = contextBuilder.start();
-            } else {
-                // Build the context manually so we can override bean discovery to exclude
-                // unwanted packages (e.g., REST module beans that conflict with core DI beans).
-                // We replicate the singleton registration that ApplicationContextBuilder.build() does,
-                // because DefaultApplicationContext(configuration) doesn't auto-register them.
-                List<String> excluded = List.copyOf(excludedPackages);
-
-                context = new DefaultApplicationContext((ApplicationContextConfiguration) contextBuilder) {
-                    @Override
-                    protected List<BeanDefinitionReference> resolveBeanDefinitionReferences() {
-                        List<BeanDefinitionReference> refs = super.resolveBeanDefinitionReferences();
-
-                        refs.removeIf(ref -> {
-                            String name = ref.getBeanDefinitionName();
-
-                            for (String pkg : excluded) {
-                                if (name.startsWith(pkg + ".")) {
-                                    return true;
-                                }
-                            }
+                return contextBuilder.start();
+            }
 
-                            return false;
-                        });
+            // Build the context manually so we can override bean discovery to exclude
+            // unwanted packages (e.g., REST module beans that conflict with core DI beans).
+            // We replicate the singleton registration that ApplicationContextBuilder.build() does,
+            // because DefaultApplicationContext(configuration) doesn't auto-register them.
+            List<String> excluded = List.copyOf(excludedPackages);
 
-                        return refs;
-                    }
-                };
+            @SuppressWarnings("rawtypes")
+            ApplicationContext context = new DefaultApplicationContext((ApplicationContextConfiguration) contextBuilder) {
+                @Override
+                protected List<BeanDefinitionReference> resolveBeanDefinitionReferences() {
+                    List<BeanDefinitionReference> refs = super.resolveBeanDefinitionReferences();
 
-                for (Object singleton : singletons) {
-                    context.registerSingleton(singleton);
-                }
+                    refs.removeIf(ref -> {
+                        String name = ref.getBeanDefinitionName();
 
-                context.start();
-            }
+                        for (String pkg : excluded) {
+                            if (name.startsWith(pkg + ".")) {
+                                return true;
+                            }
+                        }
 
-            for (NamedSingletonEntry entry : namedSingletons) {
-                registerNamedSingleton(context, entry);
-            }
+                        return false;
+                    });
 
-            return context;
-        }
+                    return refs;
+                }
+            };
 
-        @SuppressWarnings({"rawtypes", "unchecked"})
-        private static void registerNamedSingleton(ApplicationContext context, NamedSingletonEntry entry) {
-            context.registerSingleton(
-                    (Class) entry.type,
-                    entry.singleton,
-                    Qualifiers.byName(entry.name)
-            );
-        }
-    }
+            for (Object singleton : singletons) {
+                context.registerSingleton(singleton);
+            }
 
-    private static final class NamedSingletonEntry {
-        final String name;
-        final Class<?> type;
-        final Object singleton;
+            context.start();
 
-        NamedSingletonEntry(String name, Class<?> type, Object singleton) {
-            this.name = name;
-            this.type = type;
-            this.singleton = singleton;
+            return context;
         }
     }
 }
diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java
index 4054a4f0b22e..12584b2dc34a 100644
--- a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteDiContextTest.java
@@ -34,12 +34,8 @@
 public class IgniteDiContextTest {
     @Test
     void buildsRunningContext() {
-        ApplicationContext ctx = IgniteDiContext.builder().build();
-
-        try {
+        try (ApplicationContext ctx = IgniteDiContext.builder().build()) {
             assertTrue(ctx.isRunning());
-        } finally {
-            ctx.close();
         }
     }
 
@@ -47,15 +43,11 @@ void buildsRunningContext() {
     void seedSingletonsAreInjectable() {
         String seedValue = "test-node";
 
-        ApplicationContext ctx = IgniteDiContext.builder()
+        try (ApplicationContext ctx = IgniteDiContext.builder()
                 .withSingleton(seedValue)
-                .build();
-
-        try {
+                .build()) {
             String retrieved = ctx.getBean(String.class);
             assertThat(retrieved, is(sameInstance(seedValue)));
-        } finally {
-            ctx.close();
         }
     }
 
@@ -64,16 +56,12 @@ void seedSingletonsOfDifferentTypesCoexist() {
         SeedA seedA = new SeedA("a");
         SeedB seedB = new SeedB(42);
 
-        ApplicationContext ctx = IgniteDiContext.builder()
+        try (ApplicationContext ctx = IgniteDiContext.builder()
                 .withSingleton(seedA)
                 .withSingleton(seedB)
-                .build();
-
-        try {
+                .build()) {
             assertThat(ctx.getBean(SeedA.class), is(sameInstance(seedA)));
             assertThat(ctx.getBean(SeedB.class), is(sameInstance(seedB)));
-        } finally {
-            ctx.close();
         }
     }
 
@@ -82,38 +70,28 @@ void twoContextsCoexistIndependently() {
         SeedA seedForCtx1 = new SeedA("ctx1");
         SeedA seedForCtx2 = new SeedA("ctx2");
 
-        ApplicationContext ctx1 = IgniteDiContext.builder()
+        try (ApplicationContext ctx1 = IgniteDiContext.builder()
                 .withSingleton(seedForCtx1)
                 .build();
-
-        ApplicationContext ctx2 = IgniteDiContext.builder()
-                .withSingleton(seedForCtx2)
-                .build();
-
-        try {
+                ApplicationContext ctx2 = IgniteDiContext.builder()
+                        .withSingleton(seedForCtx2)
+                        .build()) {
             assertThat(ctx1.getBean(SeedA.class).value, is("ctx1"));
             assertThat(ctx2.getBean(SeedA.class).value, is("ctx2"));
 
             assertTrue(ctx1.isRunning());
             assertTrue(ctx2.isRunning());
-        } finally {
-            ctx1.close();
-            ctx2.close();
         }
     }
 
     @Test
     void contextDiscoversBeanDefinitions() {
-        ApplicationContext ctx = IgniteDiContext.builder().build();
-
-        try {
+        try (ApplicationContext ctx = IgniteDiContext.builder().build()) {
             // TestComponentFactory (from test classpath) should be discovered.
             assertThat(
                     ctx.getBean(TestComponentFactory.TestPhase1Component.class),
                     is(notNullValue())
             );
-        } finally {
-            ctx.close();
         }
     }
 

From 04c719bc3721bf334ed543e942cdaa6ac92d5516 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 20:07:11 +0400
Subject: [PATCH 15/79] Step13

---
 .../apache/ignite/internal/app/IgniteImpl.java   | 16 +++++++++++++---
 .../ignite/internal/app/LifecycleManager.java    |  8 ++++++++
 .../ignite/internal/app/di/CatalogFactory.java   | 14 ++++----------
 .../app/di/ClusterManagementFactory.java         | 10 +++++++---
 .../internal/app/di/SystemServicesFactory.java   |  3 +++
 5 files changed, 35 insertions(+), 16 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 445fe4b391de..55b39a179975 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -444,7 +444,12 @@ public class IgniteImpl implements Ignite {
         componentLifecycleManager = new IgniteComponentLifecycleManager(diContext);
         componentLifecycleManager.exclude(nodeConfigRegistry, clusterConfigRegistry, metaStorageMgr, systemViewManager);
 
+        // nodeConfigRegistry was already started above; register it for proper reverse-order shutdown.
+        componentLifecycleManager.markAsStarted(nodeConfigRegistry);
+
         // Post-construction wiring: cross-component hookups that cannot be expressed as constructor injection.
+        // These are all listener/callback registrations that just store references; they don't require
+        // components to be started yet.
         PostConstructionWiring wiring = diContext.getBean(PostConstructionWiring.class);
         wiring.wirePhase2();
 
@@ -537,7 +542,9 @@ CompletableFuture<Void> startAsync() {
             wiring.wirePhase1();
 
             // Start REST component separately (not DI-managed, depends on joinFuture).
+            // Register before PHASE_1 so it's stopped after PHASE_1 components during reverse-order shutdown.
             CompletableFuture<Void> restStartFuture = lifecycleManager.startComponentAsync(restComponent, componentContext);
+            componentLifecycleManager.markAsStarted(restComponent);
 
             // Start all PHASE_1 DI-managed components.
             CompletableFuture<Void> phase1Future = componentLifecycleManager.startPhase(StartupPhase.PHASE_1, componentContext);
@@ -597,6 +604,7 @@ CompletableFuture<Ignite> joinClusterAsync() {
                     } catch (NodeStoppingException e) {
                         throw new CompletionException(e);
                     }
+                    componentLifecycleManager.markAsStarted(metaStorageMgr);
 
                     return metaStorageMgr.recoveryFinishedFuture();
                 }, joinExecutor)
@@ -608,6 +616,7 @@ CompletableFuture<Ignite> joinClusterAsync() {
                     } catch (NodeStoppingException e) {
                         throw new CompletionException(e);
                     }
+                    componentLifecycleManager.markAsStarted(clusterConfigRegistry);
                 }, joinExecutor)
                 .thenComposeAsync(unused -> {
                     LOG.info("MetaStorage started, starting the remaining components");
@@ -625,6 +634,7 @@ CompletableFuture<Ignite> joinClusterAsync() {
                         } catch (NodeStoppingException e) {
                             throw new CompletionException(e);
                         }
+                        componentLifecycleManager.markAsStarted(systemViewManager);
                     }, joinExecutor);
                 }, joinExecutor)
                 .thenComposeAsync(v -> {
@@ -764,13 +774,13 @@ public CompletableFuture<Void> stopAsync() {
         ExecutorService lifecycleExecutor = stopExecutor();
         ComponentContext componentContext = new ComponentContext(lifecycleExecutor);
 
+        lifecycleManager.markAsStopping();
         cmgMgr.markAsStopping();
         metaStorageMgr.markAsStopping();
 
-        // Stop DI-managed components first (reverse of start order: PHASE_2, then PHASE_1),
-        // then stop manually-started components (systemViewManager, metaStorageMgr, restComponent, nodeConfigRegistry).
+        // Stop ALL components in reverse start order. The componentLifecycleManager tracks both
+        // DI-managed and manually-started components (via markAsStarted) in the correct order.
         componentLifecycleManager.stopAll(componentContext)
-                .thenCompose(v -> lifecycleManager.stopNode(componentContext))
                 // Moving to the common pool on purpose to close the stop pool and proceed user's code in the common pool.
                 .whenCompleteAsync((res, ex) -> lifecycleExecutor.shutdownNow())
                 .whenCompleteAsync(copyStateTo(stopFuture));
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/LifecycleManager.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/LifecycleManager.java
index e1361101337c..d2b774defd66 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/LifecycleManager.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/LifecycleManager.java
@@ -144,6 +144,14 @@ synchronized CompletableFuture<Void> allComponentsStartFuture(Executor startExec
                 }, startExecutor);
     }
 
+    /**
+     * Marks the node as stopping without initiating component shutdown.
+     * This is used when component shutdown is handled by the DI lifecycle manager.
+     */
+    void markAsStopping() {
+        status.set(State.STOPPING);
+    }
+
     /**
      * Stops all started components and transfers the node into the {@link State#STOPPING} state.
      *
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index a92a2feae053..807d1e958dd9 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -108,25 +108,19 @@ public PartitionCountCalculatorWrapper partitionCountCalculatorWrapper() {
         return new PartitionCountCalculatorWrapper();
     }
 
-    /** Creates the catalog update log. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(90)
-    public UpdateLogImpl updateLog(MetaStorageManagerImpl metaStorageManager, FailureManager failureManager) {
-        return new UpdateLogImpl(metaStorageManager, failureManager);
-    }
-
-    /** Creates the catalog manager. */
+    /** Creates the catalog manager. UpdateLogImpl is created inline because its lifecycle is managed by CatalogManagerImpl. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(100)
     public CatalogManagerImpl catalogManager(
-            UpdateLogImpl updateLog,
+            MetaStorageManagerImpl metaStorageManager,
             ClockServiceImpl clockService,
             FailureManager failureManager,
             SchemaSynchronizationConfiguration schemaSyncConfig,
             PartitionCountCalculatorWrapper partitionCountCalculatorWrapper
     ) {
+        UpdateLogImpl updateLog = new UpdateLogImpl(metaStorageManager, failureManager);
+
         return new CatalogManagerImpl(
                 updateLog,
                 clockService,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 70aac7a3e6fd..71043bd96418 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -53,6 +53,7 @@
 import org.apache.ignite.internal.network.recovery.InMemoryStaleIds;
 import org.apache.ignite.internal.network.scalecube.ScaleCubeClusterService;
 import org.apache.ignite.internal.network.serialization.MessageSerializationRegistry;
+import org.apache.ignite.internal.network.serialization.SerializationRegistryServiceLoader;
 import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
 import org.apache.ignite.internal.raft.RaftManager;
 import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
@@ -66,10 +67,13 @@
  */
 @Factory
 public class ClusterManagementFactory {
-    /** Creates the message serialization registry. */
+    /** Creates the message serialization registry, loading all serializers from the classpath. */
     @Singleton
-    public MessageSerializationRegistry messageSerializationRegistry() {
-        return new MessageSerializationRegistryImpl();
+    public MessageSerializationRegistry messageSerializationRegistry(NodeSeedParams seedParams) {
+        var serviceLoader = new SerializationRegistryServiceLoader(seedParams.serviceProviderClassLoader());
+        var registry = new MessageSerializationRegistryImpl();
+        serviceLoader.registerSerializationFactories(registry);
+        return registry;
     }
 
     /** Creates the cluster service. */
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 808f5cec97d0..7273f3111487 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -154,6 +154,7 @@ public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
     /** Creates the MetaStorage compaction trigger. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(3400)
     public MetaStorageCompactionTrigger metaStorageCompactionTrigger(
             NodeSeedParams seedParams,
             RocksDbKeyValueStorage storage,
@@ -175,6 +176,7 @@ public MetaStorageCompactionTrigger metaStorageCompactionTrigger(
     /** Creates the catalog compaction runner. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(300)
     public CatalogCompactionRunner catalogCompactionRunner(
             NodeSeedParams seedParams,
             CatalogManagerImpl catalogManager,
@@ -292,6 +294,7 @@ public LowWatermarkRectifier lowWatermarkRectifier(
     /** Creates the disaster recovery manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(2500)
     public DisasterRecoveryManager disasterRecoveryManager(
             ThreadPoolsManager threadPoolsManager,
             @Named("storageOperations") MessagingService messagingService,

From 02a2b7467796941877c751f17d8738677963b5fd Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 20:22:07 +0400
Subject: [PATCH 16/79] Step14

---
 .../main/java/org/apache/ignite/internal/app/IgniteImpl.java   | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 55b39a179975..7c979b45a784 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -743,7 +743,8 @@ private RuntimeException handleStartException(Throwable e) {
         ExecutorService lifecycleExecutor = stopExecutor();
 
         try {
-            lifecycleManager.stopNode(new ComponentContext(lifecycleExecutor)).get();
+            lifecycleManager.markAsStopping();
+            componentLifecycleManager.stopAll(new ComponentContext(lifecycleExecutor)).get();
         } catch (Throwable ex) {
             // We add ex as a suppressed subexception, but we don't know how the caller will handle it, so we also log it ourselves.
             LOG.error("Node stop failed after node start failure", ex);

From 3a4b4b97e7683e3be8a19e486c463a8cb8dcac11 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Thu, 5 Mar 2026 20:28:03 +0400
Subject: [PATCH 17/79] Rebase

---
 .../src/main/java/org/apache/ignite/internal/app/IgniteImpl.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 7c979b45a784..613e4972ec1c 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -17,7 +17,6 @@
 
 package org.apache.ignite.internal.app;
 
-import static java.util.stream.Collectors.toSet;
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_READ;
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_WRITE;
 import static org.apache.ignite.internal.util.CompletableFutures.copyStateTo;

From 34859950ddb1d9d4e0cafd995caaba5ba8a69c05 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Fri, 6 Mar 2026 14:55:46 +0400
Subject: [PATCH 18/79] Fix stop issue

---
 .../ignite/internal/app/IgniteImpl.java       | 40 ++++++++++++-------
 1 file changed, 26 insertions(+), 14 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 613e4972ec1c..43f3b0af2a1e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -617,31 +617,41 @@ CompletableFuture<Ignite> joinClusterAsync() {
                     }
                     componentLifecycleManager.markAsStarted(clusterConfigRegistry);
                 }, joinExecutor)
-                .thenComposeAsync(unused -> {
+                .<CompletableFuture<Void>>thenApplyAsync(unused -> {
                     LOG.info("MetaStorage started, starting the remaining components");
 
-                    // Start all PHASE_2 DI-managed components.
+                    // Fire-and-forget: start all PHASE_2 DI-managed components.
+                    // We don't wait for them here because some components' startAsync() may need
+                    // MetaStorage revision notifications (delivered by notifyRevisionUpdateListenerOnStart).
+                    // Waiting here would deadlock on restart.
                     CompletableFuture<Void> phase2Future = componentLifecycleManager.startPhase(
                             StartupPhase.PHASE_2, componentContext
                     );
 
                     // The system view manager comes last because other components
                     // must register system views before it starts.
-                    return phase2Future.thenRunAsync(() -> {
-                        try {
-                            lifecycleManager.startComponentAsync(systemViewManager, componentContext);
-                        } catch (NodeStoppingException e) {
-                            throw new CompletionException(e);
-                        }
-                        componentLifecycleManager.markAsStarted(systemViewManager);
-                    }, joinExecutor);
+                    try {
+                        lifecycleManager.startComponentAsync(systemViewManager, componentContext);
+                    } catch (NodeStoppingException e) {
+                        throw new CompletionException(e);
+                    }
+                    componentLifecycleManager.markAsStarted(systemViewManager);
+
+                    return phase2Future;
                 }, joinExecutor)
-                .thenComposeAsync(v -> {
+                .thenComposeAsync(phase2Future -> {
                     LOG.info("Components started, performing recovery");
 
                     LOG.info("Cluster configuration: {}", convertToHoconString(clusterConfigRegistry));
 
-                    return recoverComponentsStateOnStart(joinExecutor);
+                    // Wait for ALL component starts (both DI-managed PHASE_2 and manually-started)
+                    // plus revision update before deploying watches.
+                    CompletableFuture<Void> allStartsFuture = CompletableFuture.allOf(
+                            phase2Future,
+                            lifecycleManager.allComponentsStartFuture(joinExecutor)
+                    );
+
+                    return recoverComponentsStateOnStart(joinExecutor, allStartsFuture);
                 }, joinExecutor)
                 .thenComposeAsync(v -> clusterConfigRegistry.onDefaultsPersisted(), joinExecutor)
                 // Signal that local recovery is complete and the node is ready to join the cluster.
@@ -1003,8 +1013,10 @@ private CompletableFuture<Void> initializeClusterConfiguration(ExecutorService s
                 .thenRunAsync(systemDisasterRecoveryManager::markInitConfigApplied, startupExecutor);
     }
 
-    private CompletableFuture<?> recoverComponentsStateOnStart(ExecutorService startupExecutor) {
-        return metaStorageMgr.notifyRevisionUpdateListenerOnStart()
+    private CompletableFuture<?> recoverComponentsStateOnStart(ExecutorService startupExecutor, CompletableFuture<Void> startFuture) {
+        CompletableFuture<Void> startupRevisionUpdate = metaStorageMgr.notifyRevisionUpdateListenerOnStart();
+
+        return CompletableFuture.allOf(startupRevisionUpdate, startFuture)
                 .thenComposeAsync(unused -> {
                     // Deploy all registered watches because all components are ready and have registered their listeners.
                     return metaStorageMgr.deployWatches();

From 523e7d12b854d076ce7ad45e50f95c821d1c9e06 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Fri, 6 Mar 2026 16:17:11 +0400
Subject: [PATCH 19/79] ignite-di-claude Fix stop issue

---
 .../main/java/org/apache/ignite/internal/app/IgniteImpl.java    | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 43f3b0af2a1e..23ee2815114c 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -760,6 +760,7 @@ private RuntimeException handleStartException(Throwable e) {
 
             igniteException.addSuppressed(ex);
         } finally {
+            diContext.close();
             lifecycleExecutor.shutdownNow();
         }
 
@@ -791,6 +792,7 @@ public CompletableFuture<Void> stopAsync() {
         // Stop ALL components in reverse start order. The componentLifecycleManager tracks both
         // DI-managed and manually-started components (via markAsStarted) in the correct order.
         componentLifecycleManager.stopAll(componentContext)
+                .thenRunAsync(() -> diContext.close())
                 // Moving to the common pool on purpose to close the stop pool and proceed user's code in the common pool.
                 .whenCompleteAsync((res, ex) -> lifecycleExecutor.shutdownNow())
                 .whenCompleteAsync(copyStateTo(stopFuture));

From 6eba17e0a873edbfc069804f5be137cd59f179cc Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Fri, 6 Mar 2026 19:37:38 +0400
Subject: [PATCH 20/79] ignite-di-claude Fix another stop issue

---
 .../di/IgniteComponentLifecycleManager.java    |  3 ++-
 .../apache/ignite/internal/app/IgniteImpl.java | 18 +++++++-----------
 2 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
index f3ddb2d7c378..cfd6a653c94a 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
@@ -36,6 +36,7 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArrayList;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 
@@ -48,7 +49,7 @@
 public class IgniteComponentLifecycleManager {
     private final Map<StartupPhase, List<IgniteComponent>> componentsByPhase;
 
-    private final List<IgniteComponent> startedComponents = new ArrayList<>();
+    private final List<IgniteComponent> startedComponents = new CopyOnWriteArrayList<>();
 
     /**
      * Creates the lifecycle manager by collecting all {@link IgniteComponent} beans from the given context
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 23ee2815114c..4e56beb3c634 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -598,24 +598,26 @@ CompletableFuture<Ignite> joinClusterAsync() {
                 .thenComposeAsync(unused -> {
                     LOG.info("Join complete, starting MetaStorage");
 
+                    // Register with componentLifecycleManager BEFORE starting, so that stopAll()
+                    // will know about this component even if a concurrent stop races with the start.
+                    componentLifecycleManager.markAsStarted(metaStorageMgr);
                     try {
                         lifecycleManager.startComponentAsync(metaStorageMgr, componentContext);
                     } catch (NodeStoppingException e) {
                         throw new CompletionException(e);
                     }
-                    componentLifecycleManager.markAsStarted(metaStorageMgr);
 
                     return metaStorageMgr.recoveryFinishedFuture();
                 }, joinExecutor)
                 .thenComposeAsync(unused -> initializeClusterConfiguration(joinExecutor), joinExecutor)
                 .thenRunAsync(() -> {
                     // Start cluster config registry after MetaStorage recovery (it depends on DistributedConfigurationStorage).
+                    componentLifecycleManager.markAsStarted(clusterConfigRegistry);
                     try {
                         lifecycleManager.startComponentAsync(clusterConfigRegistry, componentContext);
                     } catch (NodeStoppingException e) {
                         throw new CompletionException(e);
                     }
-                    componentLifecycleManager.markAsStarted(clusterConfigRegistry);
                 }, joinExecutor)
                 .<CompletableFuture<Void>>thenApplyAsync(unused -> {
                     LOG.info("MetaStorage started, starting the remaining components");
@@ -630,12 +632,12 @@ CompletableFuture<Ignite> joinClusterAsync() {
 
                     // The system view manager comes last because other components
                     // must register system views before it starts.
+                    componentLifecycleManager.markAsStarted(systemViewManager);
                     try {
                         lifecycleManager.startComponentAsync(systemViewManager, componentContext);
                     } catch (NodeStoppingException e) {
                         throw new CompletionException(e);
                     }
-                    componentLifecycleManager.markAsStarted(systemViewManager);
 
                     return phase2Future;
                 }, joinExecutor)
@@ -749,19 +751,13 @@ private RuntimeException handleStartException(Throwable e) {
             LOG.error(errMsg, igniteException);
         }
 
-        ExecutorService lifecycleExecutor = stopExecutor();
-
         try {
-            lifecycleManager.markAsStopping();
-            componentLifecycleManager.stopAll(new ComponentContext(lifecycleExecutor)).get();
+            stopAsync().get();
         } catch (Throwable ex) {
             // We add ex as a suppressed subexception, but we don't know how the caller will handle it, so we also log it ourselves.
             LOG.error("Node stop failed after node start failure", ex);
 
             igniteException.addSuppressed(ex);
-        } finally {
-            diContext.close();
-            lifecycleExecutor.shutdownNow();
         }
 
         return igniteException;
@@ -792,7 +788,7 @@ public CompletableFuture<Void> stopAsync() {
         // Stop ALL components in reverse start order. The componentLifecycleManager tracks both
         // DI-managed and manually-started components (via markAsStarted) in the correct order.
         componentLifecycleManager.stopAll(componentContext)
-                .thenRunAsync(() -> diContext.close())
+                .thenRunAsync(diContext::close)
                 // Moving to the common pool on purpose to close the stop pool and proceed user's code in the common pool.
                 .whenCompleteAsync((res, ex) -> lifecycleExecutor.shutdownNow())
                 .whenCompleteAsync(copyStateTo(stopFuture));

From adaa0576584fa24e1fc67ba451ba4a3082537c10 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Fri, 6 Mar 2026 20:59:35 +0400
Subject: [PATCH 21/79] Fix partition test

---
 .../app/di/PostConstructionWiring.java        | 23 ++++++++++++++++++-
 .../app/di/SystemServicesFactory.java         | 17 --------------
 2 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java
index 6af1212ee1ef..01176fab69fc 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/PostConstructionWiring.java
@@ -24,6 +24,8 @@
 import org.apache.ignite.client.handler.ClientHandlerModule;
 import org.apache.ignite.internal.app.NodePropertiesImpl;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.catalog.DataNodesAwarePartitionCountCalculator;
+import org.apache.ignite.internal.catalog.PartitionCountCalculatorWrapper;
 import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
 import org.apache.ignite.internal.cluster.management.NodeAttributesCollector;
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
@@ -35,6 +37,7 @@
 import org.apache.ignite.internal.compute.executor.ComputeExecutorImpl;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
+import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.metastorage.cache.IdempotentCacheVacuumizer;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.metrics.MetricManagerImpl;
@@ -50,6 +53,7 @@
 import org.apache.ignite.internal.sql.engine.api.kill.CancellableOperationType;
 import org.apache.ignite.internal.sql.engine.api.kill.OperationKillHandler;
 import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
+import org.apache.ignite.internal.system.CpuInformationProvider;
 import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
 import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
 import org.apache.ignite.internal.table.distributed.schema.CheckCatalogVersionOnActionRequest;
@@ -86,6 +90,9 @@ public class PostConstructionWiring {
     private final PartitionModificationCounterFactory partitionModificationCounterFactory;
     private final SystemDistributedConfiguration systemDistributedConfiguration;
     private final ConfigurationRegistry clusterConfigRegistry;
+    private final DistributionZoneManager distributionZoneManager;
+    private final CpuInformationProvider cpuInformationProvider;
+    private final PartitionCountCalculatorWrapper partitionCountCalculatorWrapper;
 
     /** Constructor. */
     public PostConstructionWiring(
@@ -111,7 +118,10 @@ public PostConstructionWiring(
             ClientHandlerModule clientHandlerModule,
             PartitionModificationCounterFactory partitionModificationCounterFactory,
             SystemDistributedConfiguration systemDistributedConfiguration,
-            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry,
+            DistributionZoneManager distributionZoneManager,
+            CpuInformationProvider cpuInformationProvider,
+            PartitionCountCalculatorWrapper partitionCountCalculatorWrapper
     ) {
         this.metricManager = metricManager;
         this.clockServiceMetricSource = clockServiceMetricSource;
@@ -136,6 +146,9 @@ public PostConstructionWiring(
         this.partitionModificationCounterFactory = partitionModificationCounterFactory;
         this.systemDistributedConfiguration = systemDistributedConfiguration;
         this.clusterConfigRegistry = clusterConfigRegistry;
+        this.distributionZoneManager = distributionZoneManager;
+        this.cpuInformationProvider = cpuInformationProvider;
+        this.partitionCountCalculatorWrapper = partitionCountCalculatorWrapper;
     }
 
     /**
@@ -162,6 +175,14 @@ public void wirePhase1() {
      * This includes MetaStorage listeners, Raft interceptors, system view registrations, and kill handlers.
      */
     public void wirePhase2() {
+        // Wire the data-nodes-aware partition count calculator into the wrapper.
+        partitionCountCalculatorWrapper.setPartitionCountCalculator(
+                new DataNodesAwarePartitionCountCalculator(
+                        distributionZoneManager::estimatedDataNodesCount,
+                        cpuInformationProvider
+                )
+        );
+
         // MetaStorage configuration and listeners.
         metaStorageManager.configure(systemDistributedConfiguration);
         metricManager.configure(clusterConfigRegistry.getConfiguration(MetricExtensionConfiguration.KEY).metrics());
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 7273f3111487..022e3d364a32 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -26,8 +26,6 @@
 import org.apache.ignite.internal.app.SystemPropertiesComponent;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
-import org.apache.ignite.internal.catalog.DataNodesAwarePartitionCountCalculator;
-import org.apache.ignite.internal.catalog.PartitionCountCalculatorWrapper;
 import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
@@ -111,21 +109,6 @@ public CpuInformationProvider cpuInformationProvider() {
         return new JvmCpuInformationProvider();
     }
 
-    /** Creates the data-nodes-aware partition count calculator and wires it into the wrapper. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    public DataNodesAwarePartitionCountCalculator dataNodesAwarePartitionCountCalculator(
-            DistributionZoneManager distributionZoneManager,
-            CpuInformationProvider cpuInformationProvider,
-            PartitionCountCalculatorWrapper partitionCountCalculatorWrapper
-    ) {
-        DataNodesAwarePartitionCountCalculator calculator = new DataNodesAwarePartitionCountCalculator(
-                distributionZoneManager::estimatedDataNodesCount,
-                cpuInformationProvider
-        );
-        partitionCountCalculatorWrapper.setPartitionCountCalculator(calculator);
-        return calculator;
-    }
 
     /** Creates the system disaster recovery manager. */
     @Singleton

From 727405214bca8e540b58b97cefd0da51264e5196 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Fri, 6 Mar 2026 21:37:08 +0400
Subject: [PATCH 22/79] Fix JDBC tests

---
 .../org/apache/ignite/internal/app/IgniteImpl.java  |  7 +++++++
 .../internal/app/di/ClientHandlerFactory.java       | 13 +++----------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 7c47cf75d3b3..8f4f8c7d9e46 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -48,6 +48,7 @@
 import org.apache.ignite.catalog.IgniteCatalog;
 import org.apache.ignite.client.handler.ClientHandlerModule;
 import org.apache.ignite.client.handler.ClientInboundMessageHandler;
+import org.apache.ignite.client.handler.ClusterInfo;
 import org.apache.ignite.compute.IgniteCompute;
 import org.apache.ignite.internal.app.di.NodeSeedParams;
 import org.apache.ignite.internal.app.di.PostConstructionWiring;
@@ -475,6 +476,12 @@ private ClusterState clusterState() {
         return localClusterState;
     }
 
+    /** Returns cluster info from the cached cluster state. Used by the client handler to avoid blocking RPC calls. */
+    public ClusterInfo clusterInfo() {
+        ClusterState state = clusterState();
+        return new ClusterInfo(state.clusterTag(), state.clusterIdHistory());
+    }
+
     private RestComponent createRestComponent(String name) {
         RestManager restManager = new RestManager();
         Supplier<RestFactory> presentationsFactory = () -> new PresentationsFactory(nodeConfigRegistry, clusterConfigRegistry);
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
index fcaf23d6a8c3..535ac028337f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -20,17 +20,14 @@
 import io.micronaut.context.annotation.Factory;
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
-import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
 import org.apache.ignite.client.handler.ClientHandlerMetricSource;
 import org.apache.ignite.client.handler.ClientHandlerModule;
-import org.apache.ignite.client.handler.ClusterInfo;
 import org.apache.ignite.client.handler.configuration.ClientConnectorConfiguration;
 import org.apache.ignite.client.handler.configuration.ClientConnectorExtensionConfiguration;
+import org.apache.ignite.internal.app.IgniteImpl;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
-import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
-import org.apache.ignite.internal.cluster.management.ClusterState;
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SuggestionsClusterExtensionConfiguration;
@@ -104,7 +101,7 @@ public ClientHandlerModule clientHandlerModule(
             IgniteComputeInternal compute,
             ClusterService clusterService,
             NettyBootstrapFactory nettyBootstrapFactory,
-            Provider<ClusterManagementGroupManager> cmgManagerProvider,
+            IgniteImpl igniteImpl,
             MetricManager metricManager,
             AuthenticationManager authenticationManager,
             ClockServiceImpl clockService,
@@ -124,11 +121,7 @@ public ClientHandlerModule clientHandlerModule(
                 compute,
                 clusterService,
                 nettyBootstrapFactory,
-                () -> {
-                    ClusterState clusterState = cmgManagerProvider.get().clusterState().join();
-
-                    return new ClusterInfo(clusterState.clusterTag(), clusterState.clusterIdHistory());
-                },
+                igniteImpl::clusterInfo,
                 metricManager,
                 new ClientHandlerMetricSource(),
                 authenticationManager,

From 354c0671637186e5a94e6e690302fc42affe1f60 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sat, 7 Mar 2026 10:40:16 +0400
Subject: [PATCH 23/79] Remove duiplicated code

---
 .../di/IgniteComponentLifecycleManager.java   | 23 ++-----------------
 1 file changed, 2 insertions(+), 21 deletions(-)

diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
index cfd6a653c94a..58ea86790d8c 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
@@ -19,8 +19,6 @@
 
 import static java.util.Collections.reverse;
 import static java.util.concurrent.CompletableFuture.allOf;
-import static java.util.concurrent.CompletableFuture.failedFuture;
-import static org.apache.ignite.internal.util.IgniteUtils.closeAll;
 
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.BeanRegistration;
@@ -32,13 +30,13 @@
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CopyOnWriteArrayList;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
+import org.apache.ignite.internal.util.IgniteUtils;
 
 /**
  * Manages the lifecycle of {@link IgniteComponent} beans obtained from a Micronaut {@link ApplicationContext}.
@@ -139,24 +137,7 @@ public CompletableFuture<Void> stopAll(ComponentContext componentContext) {
         List<IgniteComponent> components = new ArrayList<>(startedComponents);
         reverse(components);
 
-        try {
-            closeAll(components.stream().filter(Objects::nonNull).map(c -> c::beforeNodeStop));
-        } catch (Exception e) {
-            return failedFuture(e);
-        }
-
-        CompletableFuture<?>[] stopFutures = components.stream()
-                .filter(Objects::nonNull)
-                .map(component -> {
-                    try {
-                        return component.stopAsync(componentContext);
-                    } catch (Throwable e) {
-                        return failedFuture(e);
-                    }
-                })
-                .toArray(CompletableFuture[]::new);
-
-        return allOf(stopFutures);
+        return IgniteUtils.stopAsync(componentContext, components);
     }
 
     /**

From 85d747b442f4a32f670071bde879ff94e95e2cee Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 00:17:06 +0400
Subject: [PATCH 24/79] Fix tests

---
 .../org/apache/ignite/internal/app/IgniteImpl.java    | 11 +++++++++++
 .../ignite/internal/app/di/DataPathFactory.java       |  9 ++++++++-
 .../ignite/internal/app/di/SystemServicesFactory.java |  3 +--
 3 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 8f4f8c7d9e46..518beb33c4cf 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -146,6 +146,7 @@
 import org.apache.ignite.internal.sql.engine.QueryProcessor;
 import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
 import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
+import org.apache.ignite.internal.storage.DataStorageManager;
 import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
 import org.apache.ignite.internal.systemview.api.SystemViewManager;
 import org.apache.ignite.internal.table.distributed.PublicApiThreadingIgniteTables;
@@ -330,6 +331,10 @@ public class IgniteImpl implements Ignite {
 
     private final PartitionCountCalculatorWrapper partitionCountCalculatorWrapper;
 
+    /** Data storage manager, kept as a field for reflective access by compatibility tests (CheckpointJob). */
+    @SuppressWarnings("unused")
+    private final DataStorageManager dataStorageMgr;
+
     /** Future that completes when the node has joined the cluster. */
     private final CompletableFuture<Ignite> joinFuture = new CompletableFuture<>();
 
@@ -436,6 +441,7 @@ public class IgniteImpl implements Ignite {
         partitionCountCalculatorWrapper = diContext.getBean(PartitionCountCalculatorWrapper.class);
         systemViewManager = diContext.getBean(SystemViewManagerImpl.class);
         observableTimestampTracker = diContext.getBean(HybridTimestampTracker.class);
+        dataStorageMgr = diContext.getBean(DataStorageManager.class);
 
         // Initialize the DI component lifecycle manager. Exclude components with special startup ordering:
         // nodeConfigRegistry — started early in constructor, before other beans are created
@@ -865,6 +871,11 @@ public TableManager distributedTableManager() {
         return distributedTblMgr;
     }
 
+    @TestOnly
+    public DataStorageManager dataStorageManager() {
+        return dataStorageMgr;
+    }
+
     /** {@inheritDoc} */
     @Override
     public IgniteTransactions transactions() {
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 0df9a84fe96c..e17d726ffa3d 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -391,6 +391,12 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
         );
     }
 
+    /** Creates the shared minimum required time collector service. */
+    @Singleton
+    public MinimumRequiredTimeCollectorServiceImpl minimumRequiredTimeCollectorService() {
+        return new MinimumRequiredTimeCollectorServiceImpl();
+    }
+
     /** Creates the table manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
@@ -423,6 +429,7 @@ public TableManager tableManager(
             TransactionInflights transactionInflights,
             IndexMetaStorage indexMetaStorage,
             PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            MinimumRequiredTimeCollectorServiceImpl minTimeCollectorService,
             SystemDistributedConfiguration systemDistributedConfiguration,
             MetricManager metricManager,
             PartitionModificationCounterFactory partitionModificationCounterFactory
@@ -456,7 +463,7 @@ public TableManager tableManager(
                 transactionInflights,
                 indexMetaStorage,
                 partitionReplicaLifecycleManager,
-                new MinimumRequiredTimeCollectorServiceImpl(),
+                minTimeCollectorService,
                 systemDistributedConfiguration,
                 metricManager,
                 partitionModificationCounterFactory
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 022e3d364a32..a2ee6846b4c8 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -171,10 +171,9 @@ public CatalogCompactionRunner catalogCompactionRunner(
             SchemaSyncServiceImpl schemaSyncService,
             LowWatermarkImpl lowWatermark,
             IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker,
+            MinimumRequiredTimeCollectorServiceImpl minTimeCollectorService,
             MetaStorageManagerImpl metaStorageManager
     ) {
-        MinimumRequiredTimeCollectorServiceImpl minTimeCollectorService = new MinimumRequiredTimeCollectorServiceImpl();
-
         return new CatalogCompactionRunner(
                 seedParams.nodeName(),
                 catalogManager,

From 7102390ed97d199091a5fea0b7fe99809a77930f Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 00:18:01 +0400
Subject: [PATCH 25/79] refactor to reduce amount of fabrics

---
 modules/cluster-management/build.gradle       |  2 +
 .../management/ClusterInitializer.java        |  5 +-
 .../management/NodeAttributesCollector.java   |  2 +
 .../raft/ClusterStateStorageManager.java      |  2 +
 .../management/raft/ValidationManager.java    |  2 +
 .../topology/LogicalTopologyImpl.java         |  2 +
 .../topology/LogicalTopologyServiceImpl.java  |  2 +
 modules/core/build.gradle                     |  4 ++
 .../ignite/internal/hlc/HybridClockImpl.java  |  4 ++
 modules/metastorage/build.gradle              |  3 +
 .../MetaStorageRevisionListenerRegistry.java  |  2 +
 .../ReadOperationForCompactionTracker.java    |  2 +
 modules/metrics/build.gradle                  |  2 +
 .../sources/ClockServiceMetricSource.java     |  2 +
 modules/partition-replicator/build.gradle     |  2 +
 .../CatalogValidationSchemasSource.java       |  2 +
 modules/raft/build.gradle                     |  5 ++
 .../org/apache/ignite/internal/raft/Loza.java |  9 +++
 .../VaultGroupStoragesDestructionIntents.java |  2 +
 .../impl/RaftGroupEventsClientListener.java   |  2 +
 .../internal/app/LowWatermarkRectifier.java   |  7 +++
 .../internal/app/NodePropertiesImpl.java      |  7 +++
 .../app/SystemPropertiesComponent.java        |  7 +++
 .../internal/app/di/CatalogFactory.java       | 12 ----
 .../internal/app/di/ClientHandlerFactory.java | 12 ----
 .../app/di/ClusterManagementFactory.java      | 63 -------------------
 .../app/di/CoreComponentsFactory.java         | 27 --------
 .../internal/app/di/DataPathFactory.java      | 38 -----------
 .../internal/app/di/MetaStorageFactory.java   |  6 --
 .../app/di/NetworkComponentsFactory.java      |  9 ---
 .../ignite/internal/app/di/RaftFactory.java   | 48 --------------
 .../app/di/SystemServicesFactory.java         | 32 ----------
 .../internal/app/di/TransactionFactory.java   | 25 --------
 .../PartitionCountCalculatorWrapper.java      |  2 +
 .../system/JvmCpuInformationProvider.java     |  3 +
 modules/schema/build.gradle                   |  5 ++
 .../ignite/internal/schema/SchemaManager.java |  7 +++
 modules/security/build.gradle                 |  3 +
 .../AuthenticationManagerImpl.java            |  7 +++
 modules/system-disaster-recovery/build.gradle |  4 ++
 .../disaster/system/ClusterIdService.java     |  7 +++
 .../system/SystemDisasterRecoveryStorage.java |  2 +
 modules/table/build.gradle                    |  5 ++
 .../distributed/index/IndexMetaStorage.java   |  7 +++
 modules/transactions/build.gradle             |  3 +
 .../internal/tx/impl/HeapLockManager.java     |  4 ++
 .../RemotelyTriggeredResourceRegistry.java    |  2 +
 .../tx/impl/VolatileTxStateMetaStorage.java   |  2 +
 modules/vault/build.gradle                    |  6 ++
 .../ignite/internal/vault/VaultManager.java   |  7 +++
 50 files changed, 154 insertions(+), 273 deletions(-)

diff --git a/modules/cluster-management/build.gradle b/modules/cluster-management/build.gradle
index b1ccf3346406..878a5cf608cc 100644
--- a/modules/cluster-management/build.gradle
+++ b/modules/cluster-management/build.gradle
@@ -46,6 +46,7 @@ dependencies {
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
 
     testImplementation project(':ignite-core')
     testImplementation project(':ignite-configuration')
@@ -74,6 +75,7 @@ dependencies {
     testFixturesImplementation testFixtures(project(':ignite-metrics'))
     testFixturesImplementation testFixtures(project(':ignite-raft'))
     testFixturesImplementation testFixtures(project(':ignite-failure-handler'))
+    testFixturesImplementation libs.micronaut.inject
 
     integrationTestAnnotationProcessor libs.micronaut.inject.annotation.processor
     integrationTestImplementation project(':ignite-rest')
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterInitializer.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterInitializer.java
index 3393e5c85946..e62ef5908cbb 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterInitializer.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterInitializer.java
@@ -21,6 +21,8 @@
 import static java.util.stream.Collectors.toUnmodifiableSet;
 import static org.apache.ignite.internal.lang.IgniteStringFormatter.format;
 
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
@@ -55,6 +57,7 @@
 /**
  * Class for performing cluster initialization.
  */
+@Singleton
 public class ClusterInitializer {
     private static final IgniteLogger LOG = Loggers.forClass(ClusterInitializer.class);
 
@@ -72,7 +75,7 @@ public class ClusterInitializer {
     public ClusterInitializer(
             ClusterService clusterService,
             ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher,
-            ConfigurationValidator clusterConfigurationValidator
+            @Named("distributed") ConfigurationValidator clusterConfigurationValidator
     ) {
         this.clusterService = clusterService;
         this.configurationDynamicDefaultsPatcher = configurationDynamicDefaultsPatcher;
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/NodeAttributesCollector.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/NodeAttributesCollector.java
index 6d67ef123d16..119f12b8caf3 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/NodeAttributesCollector.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/NodeAttributesCollector.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.cluster.management;
 
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -32,6 +33,7 @@
  * This class is responsible for retrieving local node attributes
  * from system components before the local node joins the cluster.
  */
+@Singleton
 public class NodeAttributesCollector implements NodeAttributes {
     private final List<NodeAttributesProvider> systemAttributesProviders = new ArrayList<>();
 
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ClusterStateStorageManager.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ClusterStateStorageManager.java
index 895cec946060..04c409e3df04 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ClusterStateStorageManager.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ClusterStateStorageManager.java
@@ -22,6 +22,7 @@
 import static org.apache.ignite.internal.util.ByteUtils.longToBytes;
 import static org.apache.ignite.internal.util.ByteUtils.uuidToBytes;
 
+import jakarta.inject.Singleton;
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.List;
@@ -37,6 +38,7 @@
 /**
  * A wrapper around a {@link ClusterStateStorage} which provides convenient methods.
  */
+@Singleton
 public class ClusterStateStorageManager {
     /** Storage key for the CMG state. */
     private static final byte[] CMG_STATE_KEY = "cmg_state".getBytes(UTF_8);
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ValidationManager.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ValidationManager.java
index 35b3bad60971..21b670f3f8e8 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ValidationManager.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/ValidationManager.java
@@ -20,6 +20,7 @@
 import static java.util.stream.Collectors.toSet;
 import static org.apache.ignite.internal.lang.IgniteSystemProperties.COLOCATION_FEATURE_FLAG;
 
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.Set;
@@ -41,6 +42,7 @@
  * After the node finishes local recovery procedures, it sends a {@link JoinReadyCommand} containing the validation token. If the local
  * token and the received token match, the node will be added to the logical topology and the token will be invalidated.
  */
+@Singleton
 public class ValidationManager {
     protected final ClusterStateStorageManager storageManager;
 
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyImpl.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyImpl.java
index 855a695fb7b2..a333e960e442 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyImpl.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyImpl.java
@@ -24,6 +24,7 @@
 import static java.util.stream.Collectors.toMap;
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -49,6 +50,7 @@
 /**
  * Implementation of {@link LogicalTopology}.
  */
+@Singleton
 public class LogicalTopologyImpl implements LogicalTopology {
     private static final IgniteLogger LOG = Loggers.forClass(LogicalTopologyImpl.class);
 
diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyServiceImpl.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyServiceImpl.java
index afb212043fbc..9fefb2d4ef42 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyServiceImpl.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/topology/LogicalTopologyServiceImpl.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.cluster.management.topology;
 
+import jakarta.inject.Singleton;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
@@ -28,6 +29,7 @@
 /**
  * {@link LogicalTopologyService} implementation.
  */
+@Singleton
 public class LogicalTopologyServiceImpl implements LogicalTopologyService {
     private final LogicalTopology logicalTopology;
 
diff --git a/modules/core/build.gradle b/modules/core/build.gradle
index 19e1e2cc0a9f..8117f8df0aca 100644
--- a/modules/core/build.gradle
+++ b/modules/core/build.gradle
@@ -23,12 +23,15 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 description = 'ignite-core'
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     compileOnly libs.spotbugs.annotations
 
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.caffeine
     implementation project(':ignite-api')
+    implementation libs.micronaut.inject
 
     testAnnotationProcessor libs.auto.service
     testAnnotationProcessor libs.jmh.annotation.processor
@@ -46,6 +49,7 @@ dependencies {
     testFixturesImplementation libs.auto.service.annotations
     testFixturesImplementation libs.junit.testkit
     testFixturesImplementation libs.awaitility
+    testFixturesImplementation libs.micronaut.inject
 }
 
 test {
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/hlc/HybridClockImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/hlc/HybridClockImpl.java
index d2f434c0e1f6..c460374ead64 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/hlc/HybridClockImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/hlc/HybridClockImpl.java
@@ -21,6 +21,8 @@
 import static org.apache.ignite.internal.hlc.HybridTimestamp.LOGICAL_TIME_BITS_SIZE;
 import static org.apache.ignite.internal.hlc.HybridTimestamp.hybridTimestamp;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicLongFieldUpdater;
@@ -36,6 +38,7 @@
 /**
  * A Hybrid Logical Clock implementation.
  */
+@Singleton
 public class HybridClockImpl implements HybridClock {
     private final IgniteLogger log = Loggers.forClass(HybridClockImpl.class);
 
@@ -56,6 +59,7 @@ public HybridClockImpl() {
         this.failureProcessor = null;
     }
 
+    @Inject
     public HybridClockImpl(FailureProcessor failureProcessor) {
         this.failureProcessor = failureProcessor;
     }
diff --git a/modules/metastorage/build.gradle b/modules/metastorage/build.gradle
index bf0c0a4fe85f..fd39fc3c9eba 100644
--- a/modules/metastorage/build.gradle
+++ b/modules/metastorage/build.gradle
@@ -43,6 +43,8 @@ dependencies {
     implementation libs.auto.service.annotations
 
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
+    implementation libs.micronaut.inject
 
     testImplementation testFixtures(project(':ignite-core'))
     testImplementation testFixtures(project(':ignite-vault'))
@@ -93,6 +95,7 @@ dependencies {
     testFixturesImplementation testFixtures(project(':ignite-core'))
     testFixturesImplementation testFixtures(project(':ignite-failure-handler'))
     testFixturesImplementation testFixtures(project(':ignite-metrics'))
+    testFixturesImplementation libs.micronaut.inject
 }
 
 description = 'ignite-metastorage'
diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageRevisionListenerRegistry.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageRevisionListenerRegistry.java
index e2a5c78c119c..b7f208b8aa5d 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageRevisionListenerRegistry.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageRevisionListenerRegistry.java
@@ -17,11 +17,13 @@
 
 package org.apache.ignite.internal.metastorage.impl;
 
+import jakarta.inject.Singleton;
 import org.apache.ignite.internal.causality.RevisionListener;
 import org.apache.ignite.internal.causality.RevisionListenerRegistry;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
 
 /** Implementation based on {@link MetaStorageManager}. */
+@Singleton
 public class MetaStorageRevisionListenerRegistry implements RevisionListenerRegistry {
     private final MetaStorageManager metaStorageManager;
 
diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/ReadOperationForCompactionTracker.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/ReadOperationForCompactionTracker.java
index 2baae964773a..9a5586b52825 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/ReadOperationForCompactionTracker.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/ReadOperationForCompactionTracker.java
@@ -20,6 +20,7 @@
 import static java.util.stream.Collectors.collectingAndThen;
 import static java.util.stream.Collectors.toList;
 
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.concurrent.CompletableFuture;
@@ -45,6 +46,7 @@
  *     ({@link KeyValueStorage#setCompactionRevision}) for a new compaction revision.</li>
  * </ul>
  */
+@Singleton
 public class ReadOperationForCompactionTracker {
     private final Map<ReadOperationKey, CompletableFuture<Void>> readOperationFutureByKey = new ConcurrentHashMap<>();
 
diff --git a/modules/metrics/build.gradle b/modules/metrics/build.gradle
index 288f8ff5fc39..da4ab0d4743e 100644
--- a/modules/metrics/build.gradle
+++ b/modules/metrics/build.gradle
@@ -31,6 +31,7 @@ dependencies {
     implementation project(':ignite-configuration-root')
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
 
     annotationProcessor libs.auto.service
 
@@ -51,6 +52,7 @@ dependencies {
     integrationTestImplementation libs.auto.service.annotations
 
     testFixturesImplementation project(':ignite-core')
+    testFixturesImplementation libs.micronaut.inject
 }
 
 description = 'ignite-metrics'
diff --git a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/sources/ClockServiceMetricSource.java b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/sources/ClockServiceMetricSource.java
index edfb9893f371..c986c41f81f5 100644
--- a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/sources/ClockServiceMetricSource.java
+++ b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/sources/ClockServiceMetricSource.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.metrics.sources;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import org.apache.ignite.internal.metrics.AbstractMetricSource;
 import org.apache.ignite.internal.metrics.DistributionMetric;
@@ -26,6 +27,7 @@
 /**
  * Metric source, which provides clock service metrics.
  */
+@Singleton
 public class ClockServiceMetricSource extends AbstractMetricSource<Holder> {
     /** Source name. */
     public static final String SOURCE_NAME = "clock.service";
diff --git a/modules/partition-replicator/build.gradle b/modules/partition-replicator/build.gradle
index bd5deaaf6666..cca4cbcf77b8 100644
--- a/modules/partition-replicator/build.gradle
+++ b/modules/partition-replicator/build.gradle
@@ -23,7 +23,9 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 
 dependencies {
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
 
     implementation project(':ignite-core')
diff --git a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/schema/CatalogValidationSchemasSource.java b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/schema/CatalogValidationSchemasSource.java
index 2dd18c495ea6..4240237dc406 100644
--- a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/schema/CatalogValidationSchemasSource.java
+++ b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/schema/CatalogValidationSchemasSource.java
@@ -19,6 +19,7 @@
 
 import static java.util.stream.Collectors.toList;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
@@ -35,6 +36,7 @@
 /**
  * An implementation over {@link CatalogService}.
  */
+@Singleton
 public class CatalogValidationSchemasSource implements ValidationSchemasSource {
     private final CatalogService catalogService;
 
diff --git a/modules/raft/build.gradle b/modules/raft/build.gradle
index d9b56187f2f0..284540c92c78 100644
--- a/modules/raft/build.gradle
+++ b/modules/raft/build.gradle
@@ -53,9 +53,12 @@ dependencies {
     implementation libs.jctools.core
     implementation libs.auto.service.annotations
     implementation libs.jna
+    implementation libs.micronaut.inject
+    implementation project(':ignite-di')
 
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     testAnnotationProcessor project(':ignite-network-annotation-processor')
     testAnnotationProcessor libs.jmh.annotation.processor
@@ -82,6 +85,8 @@ dependencies {
     testFixturesImplementation testFixtures(project(':ignite-metrics'))
     testFixturesImplementation testFixtures(project(':ignite-network'))
     testFixturesImplementation testFixtures(project(':ignite-failure-handler'))
+    testFixturesImplementation project(':ignite-di')
+    testFixturesImplementation libs.micronaut.inject
 
     integrationTestAnnotationProcessor project(':ignite-network-annotation-processor')
     integrationTestAnnotationProcessor project(':ignite-configuration-annotation-processor')
diff --git a/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java b/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
index 5ab01ec725ec..d8a4f80142f1 100644
--- a/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
+++ b/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
@@ -20,6 +20,9 @@
 import static java.util.Objects.requireNonNullElse;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
@@ -31,6 +34,8 @@
 import java.util.function.BiConsumer;
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
 import org.apache.ignite.internal.configuration.SystemPropertyConfiguration;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.lang.IgniteInternalException;
@@ -78,6 +83,9 @@
  */
 // TODO: Encapsulate RaftGroupOptions and move other methods to the RaftManager interface,
 //  see https://issues.apache.org/jira/browse/IGNITE-18273
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1800)
 public class Loza implements RaftManager {
     /** Factory. */
     public static final RaftMessagesFactory FACTORY = new RaftMessagesFactory();
@@ -156,6 +164,7 @@ public Loza(
      * @param groupStoragesDestructionIntents Storage to persist {@link StorageDestructionIntent}s.
      * @param groupStoragesContextResolver Resolver to get {@link StoragesDestructionContext}s for storage destruction.
      */
+    @Inject
     public Loza(
             ClusterService clusterNetSvc,
             MetricManager metricManager,
diff --git a/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VaultGroupStoragesDestructionIntents.java b/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VaultGroupStoragesDestructionIntents.java
index d870dab9468f..3dd8253aa948 100644
--- a/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VaultGroupStoragesDestructionIntents.java
+++ b/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VaultGroupStoragesDestructionIntents.java
@@ -19,6 +19,7 @@
 
 import static java.nio.charset.StandardCharsets.UTF_8;
 
+import jakarta.inject.Singleton;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.ArrayList;
@@ -31,6 +32,7 @@
 import org.apache.ignite.internal.versioned.VersionedSerialization;
 
 /** Uses VaultManager to store destruction intents. */
+@Singleton
 public class VaultGroupStoragesDestructionIntents implements GroupStoragesDestructionIntents {
     private static final byte[] GROUP_STORAGE_DESTRUCTION_PREFIX = "destroy.group.storages.".getBytes(UTF_8);
     private static final ByteOrder BYTE_UTILS_BYTE_ORDER = ByteOrder.BIG_ENDIAN;
diff --git a/modules/raft/src/main/java/org/apache/ignite/raft/jraft/rpc/impl/RaftGroupEventsClientListener.java b/modules/raft/src/main/java/org/apache/ignite/raft/jraft/rpc/impl/RaftGroupEventsClientListener.java
index 4be25a7c0340..6263ebb5cd74 100644
--- a/modules/raft/src/main/java/org/apache/ignite/raft/jraft/rpc/impl/RaftGroupEventsClientListener.java
+++ b/modules/raft/src/main/java/org/apache/ignite/raft/jraft/rpc/impl/RaftGroupEventsClientListener.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.raft.jraft.rpc.impl;
 
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.List;
@@ -30,6 +31,7 @@
 /**
 * Listener for Raft group events on client side.
 */
+@Singleton
 public class RaftGroupEventsClientListener {
     private static final IgniteLogger LOG = Loggers.forClass(RaftGroupEventsClientListener.class);
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
index 2ec177ac0576..7583a24a46fb 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
@@ -20,8 +20,12 @@
 import static org.apache.ignite.internal.hlc.HybridTimestamp.hybridTimestamp;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.catalog.CatalogService;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -31,6 +35,9 @@
 /**
  * Component that rectifies the low watermark on node startup if it is lower than the earliest catalog timestamp.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(200)
 public class LowWatermarkRectifier implements IgniteComponent {
     private final LowWatermark lowWatermark;
     private final CatalogService catalogService;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
index b58ab68ff1a7..0e1c8c52aab3 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
@@ -22,10 +22,14 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.ILLEGAL_ARGUMENT_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Common.UNSUPPORTED_TABLE_BASED_REPLICATION_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.NodeAttributesProvider;
 import org.apache.ignite.internal.components.NodeProperties;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.lang.ByteArray;
 import org.apache.ignite.internal.lang.IgniteSystemProperties;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -39,6 +43,9 @@
 /**
  * Default implementation of {@link NodeProperties} using {@link VaultManager} for persistence.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(300)
 public class NodePropertiesImpl implements NodeProperties, IgniteComponent, NodeAttributesProvider {
     private static final IgniteLogger LOG = Loggers.forClass(NodePropertiesImpl.class);
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
index 0d5633299596..cad3a885a9db 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
@@ -17,9 +17,13 @@
 
 package org.apache.ignite.internal.app;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 import org.apache.ignite.internal.tostring.IgniteToStringBuilder;
@@ -28,6 +32,9 @@
 /**
  * System properties initialization.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(3200)
 public class SystemPropertiesComponent implements IgniteComponent {
 
     /**
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index 807d1e958dd9..eb45710919a5 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -53,12 +53,6 @@
  */
 @Factory
 public class CatalogFactory {
-    /** Creates the clock service metric source. */
-    @Singleton
-    public ClockServiceMetricSource clockServiceMetricSource() {
-        return new ClockServiceMetricSource();
-    }
-
     /** Creates the clock service. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
@@ -102,12 +96,6 @@ public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
         );
     }
 
-    /** Creates the partition count calculator wrapper. */
-    @Singleton
-    public PartitionCountCalculatorWrapper partitionCountCalculatorWrapper() {
-        return new PartitionCountCalculatorWrapper();
-    }
-
     /** Creates the catalog manager. UpdateLogImpl is created inline because its lifecycle is managed by CatalogManagerImpl. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
index 535ac028337f..eafcb6928012 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -42,7 +42,6 @@
 import org.apache.ignite.internal.network.NettyBootstrapFactory;
 import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
 import org.apache.ignite.internal.security.authentication.AuthenticationManager;
-import org.apache.ignite.internal.security.authentication.AuthenticationManagerImpl;
 import org.apache.ignite.internal.security.configuration.SecurityConfiguration;
 import org.apache.ignite.internal.security.configuration.SecurityExtensionConfiguration;
 import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
@@ -63,17 +62,6 @@ public SecurityConfiguration securityConfiguration(
         return clusterConfigRegistry.getConfiguration(SecurityExtensionConfiguration.KEY).security();
     }
 
-    /** Creates the authentication manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(2850)
-    public AuthenticationManager authenticationManager(
-            SecurityConfiguration securityConfiguration,
-            EventLogImpl eventLog
-    ) {
-        return new AuthenticationManagerImpl(securityConfiguration, eventLog);
-    }
-
     /** Creates the client connector configuration from the node config registry. */
     @Singleton
     public ClientConnectorConfiguration clientConnectorConfiguration(
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 71043bd96418..3838e1f0c4ec 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -31,7 +31,6 @@
 import org.apache.ignite.internal.cluster.management.raft.RocksDbClusterStateStorage;
 import org.apache.ignite.internal.cluster.management.raft.ValidationManager;
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
-import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyServiceImpl;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationDynamicDefaultsPatcherImpl;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
@@ -127,31 +126,6 @@ public RocksDbClusterStateStorage clusterStateStorage(@Named("cmg") ComponentWor
         return new RocksDbClusterStateStorage(cmgWorkDir.dbPath(), seedParams.nodeName());
     }
 
-    /** Creates the cluster state storage manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(710)
-    public ClusterStateStorageManager clusterStateStorageManager(RocksDbClusterStateStorage clusterStateStorage) {
-        return new ClusterStateStorageManager(clusterStateStorage);
-    }
-
-    /** Creates the logical topology implementation. */
-    @Singleton
-    public LogicalTopologyImpl logicalTopology(RocksDbClusterStateStorage clusterStateStorage, FailureManager failureManager) {
-        return new LogicalTopologyImpl(clusterStateStorage, failureManager);
-    }
-
-    /** Creates the validation manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(720)
-    public ValidationManager validationManager(
-            ClusterStateStorageManager clusterStateStorageManager,
-            LogicalTopologyImpl logicalTopology
-    ) {
-        return new ValidationManager(clusterStateStorageManager, logicalTopology);
-    }
-
     /** Creates the distributed configuration tree generator. */
     @Singleton
     @Named("distributed")
@@ -182,33 +156,6 @@ public ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher(
         return new ConfigurationDynamicDefaultsPatcherImpl(modules.distributed(), generator);
     }
 
-    /** Creates the cluster initializer. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(1310)
-    public ClusterInitializer clusterInitializer(
-            ClusterService clusterService,
-            ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher,
-            @Named("distributed") ConfigurationValidator distributedCfgValidator
-    ) {
-        return new ClusterInitializer(clusterService, configurationDynamicDefaultsPatcher, distributedCfgValidator);
-    }
-
-    /** Creates the node attributes collector. */
-    @Singleton
-    public NodeAttributesCollector nodeAttributesCollector(
-            NodeAttributesConfiguration nodeAttributesConfiguration,
-            StorageConfiguration storageConfiguration
-    ) {
-        return new NodeAttributesCollector(nodeAttributesConfiguration, storageConfiguration);
-    }
-
-    /** Creates the system disaster recovery storage. */
-    @Singleton
-    public SystemDisasterRecoveryStorage systemDisasterRecoveryStorage(VaultManager vaultManager) {
-        return new SystemDisasterRecoveryStorage(vaultManager);
-    }
-
     /** Creates the cluster management group manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
@@ -245,14 +192,4 @@ public ClusterManagementGroupManager clusterManagementGroupManager(
         );
     }
 
-    /** Creates the logical topology service. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(1910)
-    public LogicalTopologyServiceImpl logicalTopologyService(
-            LogicalTopologyImpl logicalTopology,
-            ClusterManagementGroupManager cmgManager
-    ) {
-        return new LogicalTopologyServiceImpl(logicalTopology, cmgManager);
-    }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
index d6c1f59b0815..93c3960c0ac2 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
@@ -20,18 +20,12 @@
 import io.micronaut.context.annotation.Factory;
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Singleton;
-import org.apache.ignite.internal.app.NodePropertiesImpl;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.components.LongJvmPauseDetector;
 import org.apache.ignite.internal.di.IgniteStartupPhase;
 import org.apache.ignite.internal.di.StartupPhase;
-import org.apache.ignite.internal.failure.FailureProcessor;
-import org.apache.ignite.internal.hlc.HybridClock;
-import org.apache.ignite.internal.hlc.HybridClockImpl;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.metrics.MetricManagerImpl;
-import org.apache.ignite.internal.vault.VaultManager;
-import org.apache.ignite.internal.vault.VaultService;
 
 /**
  * Micronaut factory for leaf Ignite components that have few or no dependencies on other components.
@@ -46,14 +40,6 @@ public LongJvmPauseDetector longJvmPauseDetector(NodeSeedParams seedParams) {
         return new LongJvmPauseDetector(seedParams.nodeName());
     }
 
-    /** Creates the vault manager backed by persistent storage. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(200)
-    public VaultManager vaultManager(VaultService vaultService) {
-        return new VaultManager(vaultService);
-    }
-
     /**
      * Creates the metric manager.
      *
@@ -74,17 +60,4 @@ public ThreadPoolsManager threadPoolsManager(NodeSeedParams seedParams, MetricMa
         return new ThreadPoolsManager(seedParams.nodeName(), metricManager);
     }
 
-    /** Creates the hybrid logical clock. */
-    @Singleton
-    public HybridClock hybridClock(FailureProcessor failureProcessor) {
-        return new HybridClockImpl(failureProcessor);
-    }
-
-    /** Creates the node properties component. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(300)
-    public NodePropertiesImpl nodeProperties(VaultManager vaultManager) {
-        return new NodePropertiesImpl(vaultManager);
-    }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index e17d726ffa3d..9a32799d5ac8 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -110,12 +110,6 @@ public VolatileLogStorageManagerCreator volatileLogStorageManagerCreator(NodeSee
         );
     }
 
-    /** Creates the MetaStorage revision listener registry. */
-    @Singleton
-    public MetaStorageRevisionListenerRegistry revisionListenerRegistry(MetaStorageManagerImpl metaStorageManager) {
-        return new MetaStorageRevisionListenerRegistry(metaStorageManager);
-    }
-
     /** Creates the schema safe time tracker. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
@@ -134,26 +128,6 @@ public SchemaSyncServiceImpl schemaSyncService(
         return new SchemaSyncServiceImpl(schemaSafeTimeTracker, delayDurationMsSupplier);
     }
 
-    /** Creates the schema manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(2000)
-    public SchemaManager schemaManager(
-            MetaStorageRevisionListenerRegistry revisionListenerRegistry,
-            CatalogManagerImpl catalogManager
-    ) {
-        return new SchemaManager(revisionListenerRegistry, catalogManager);
-    }
-
-    /** Creates the catalog validation schemas source. */
-    @Singleton
-    public CatalogValidationSchemasSource catalogValidationSchemasSource(
-            CatalogManagerImpl catalogManager,
-            SchemaManager schemaManager
-    ) {
-        return new CatalogValidationSchemasSource(catalogManager, schemaManager);
-    }
-
     /** Creates the index node finished rw transactions checker. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
@@ -297,18 +271,6 @@ public LowWatermarkImpl lowWatermark(
         );
     }
 
-    /** Creates the index meta storage. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(400)
-    public IndexMetaStorage indexMetaStorage(
-            CatalogManagerImpl catalogManager,
-            LowWatermarkImpl lowWatermark,
-            MetaStorageManagerImpl metaStorageManager
-    ) {
-        return new IndexMetaStorage(catalogManager, lowWatermark, metaStorageManager);
-    }
-
     /** Creates the distribution zone manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index 56203d47f896..513fa7127bdc 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -72,12 +72,6 @@ public TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory
         );
     }
 
-    /** Creates the read operation for compaction tracker. */
-    @Singleton
-    public ReadOperationForCompactionTracker readOperationForCompactionTracker() {
-        return new ReadOperationForCompactionTracker();
-    }
-
     /** Creates the RocksDB key-value storage for metastorage. */
     @Singleton
     public RocksDbKeyValueStorage metastorageKeyValueStorage(
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index 4a7614ae04d8..334a100f875a 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -27,7 +27,6 @@
 import org.apache.ignite.internal.configuration.SystemLocalExtensionConfiguration;
 import org.apache.ignite.internal.di.IgniteStartupPhase;
 import org.apache.ignite.internal.di.StartupPhase;
-import org.apache.ignite.internal.disaster.system.ClusterIdService;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
@@ -37,7 +36,6 @@
 import org.apache.ignite.internal.network.NettyWorkersRegistrar;
 import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
 import org.apache.ignite.internal.network.configuration.NetworkExtensionConfiguration;
-import org.apache.ignite.internal.vault.VaultManager;
 import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
 import org.apache.ignite.internal.worker.CriticalWorkerWatchdog;
 
@@ -129,11 +127,4 @@ public ClockWaiter clockWaiter(NodeSeedParams seedParams, HybridClock clock, Thr
         return new ClockWaiter(seedParams.nodeName(), clock, threadPoolsManager.commonScheduler());
     }
 
-    /** Creates the cluster ID service. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(800)
-    public ClusterIdService clusterIdService(VaultManager vaultManager) {
-        return new ClusterIdService(vaultManager);
-    }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
index 66a0f1fd7d67..1fc4bdfa74ef 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
@@ -34,23 +34,14 @@
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
 import org.apache.ignite.internal.di.IgniteStartupPhase;
 import org.apache.ignite.internal.di.StartupPhase;
-import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
-import org.apache.ignite.internal.metrics.MetricManager;
-import org.apache.ignite.internal.network.ClusterService;
-import org.apache.ignite.internal.raft.Loza;
 import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
 import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
 import org.apache.ignite.internal.raft.configuration.RaftExtensionConfiguration;
 import org.apache.ignite.internal.raft.server.impl.GroupStoragesContextResolver;
-import org.apache.ignite.internal.raft.storage.GroupStoragesDestructionIntents;
 import org.apache.ignite.internal.raft.storage.LogStorageManager;
-import org.apache.ignite.internal.raft.storage.impl.VaultGroupStoragesDestructionIntents;
 import org.apache.ignite.internal.raft.util.SharedLogStorageManagerUtils;
 import org.apache.ignite.internal.replicator.PartitionGroupId;
-import org.apache.ignite.internal.vault.VaultManager;
-import org.apache.ignite.raft.jraft.rpc.impl.RaftGroupEventsClientListener;
 
 /**
  * Micronaut factory for Raft infrastructure components.
@@ -66,12 +57,6 @@ public RaftConfiguration raftConfiguration(@Named("nodeConfig") ConfigurationReg
         return nodeConfigRegistry.getConfiguration(RaftExtensionConfiguration.KEY).raft();
     }
 
-    /** Creates the Raft group events client listener. */
-    @Singleton
-    public RaftGroupEventsClientListener raftGroupEventsClientListener() {
-        return new RaftGroupEventsClientListener();
-    }
-
     /** Creates the partitions working directory. */
     @Singleton
     @Named("partitions")
@@ -205,37 +190,4 @@ public GroupStoragesContextResolver groupStoragesContextResolver(
         );
     }
 
-    /** Creates the group storages destruction intents backed by vault. */
-    @Singleton
-    public GroupStoragesDestructionIntents groupStoragesDestructionIntents(VaultManager vaultManager) {
-        return new VaultGroupStoragesDestructionIntents(vaultManager);
-    }
-
-    /** Creates the Raft manager (Loza). */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(1800)
-    public Loza loza(
-            ClusterService clusterService,
-            MetricManager metricManager,
-            RaftConfiguration raftConfiguration,
-            SystemLocalConfiguration systemConfiguration,
-            HybridClock clock,
-            RaftGroupEventsClientListener raftGroupEventsClientListener,
-            FailureManager failureManager,
-            GroupStoragesDestructionIntents groupStoragesDestructionIntents,
-            GroupStoragesContextResolver groupStoragesContextResolver
-    ) {
-        return new Loza(
-                clusterService,
-                metricManager,
-                raftConfiguration,
-                systemConfiguration,
-                clock,
-                raftGroupEventsClientListener,
-                failureManager,
-                groupStoragesDestructionIntents,
-                groupStoragesContextResolver
-        );
-    }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index a2ee6846b4c8..3ded70a075c6 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -22,8 +22,6 @@
 import jakarta.inject.Named;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
-import org.apache.ignite.internal.app.LowWatermarkRectifier;
-import org.apache.ignite.internal.app.SystemPropertiesComponent;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
@@ -58,8 +56,6 @@
 import org.apache.ignite.internal.raft.storage.LogStorageManager;
 import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
 import org.apache.ignite.internal.replicator.ReplicaService;
-import org.apache.ignite.internal.system.CpuInformationProvider;
-import org.apache.ignite.internal.system.JvmCpuInformationProvider;
 import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
 import org.apache.ignite.internal.table.distributed.TableManager;
 import org.apache.ignite.internal.table.distributed.disaster.DisasterRecoveryManager;
@@ -103,13 +99,6 @@ public SystemViewManagerImpl systemViewManager(
         return new SystemViewManagerImpl(seedParams.nodeName(), catalogManager, failureManager);
     }
 
-    /** Creates the CPU information provider. */
-    @Singleton
-    public CpuInformationProvider cpuInformationProvider() {
-        return new JvmCpuInformationProvider();
-    }
-
-
     /** Creates the system disaster recovery manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
@@ -252,27 +241,6 @@ public ResourceVacuumManager resourceVacuumManager(
         );
     }
 
-    /** Creates the system properties component. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(3200)
-    public SystemPropertiesComponent systemPropertiesComponent(
-            SystemDistributedConfiguration systemDistributedConfiguration
-    ) {
-        return new SystemPropertiesComponent(systemDistributedConfiguration);
-    }
-
-    /** Creates the low watermark rectifier. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(200)
-    public LowWatermarkRectifier lowWatermarkRectifier(
-            LowWatermarkImpl lowWatermark,
-            CatalogManagerImpl catalogManager
-    ) {
-        return new LowWatermarkRectifier(lowWatermark, catalogManager);
-    }
-
     /** Creates the disaster recovery manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 939a8099cdb7..742c6e739513 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -26,7 +26,6 @@
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
-import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
 import org.apache.ignite.internal.di.IgniteStartupPhase;
 import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.failure.FailureManager;
@@ -46,7 +45,6 @@
 import org.apache.ignite.internal.tx.LockManager;
 import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
 import org.apache.ignite.internal.tx.configuration.TransactionExtensionConfiguration;
-import org.apache.ignite.internal.tx.impl.HeapLockManager;
 import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
 import org.apache.ignite.internal.tx.impl.TransactionIdGenerator;
 import org.apache.ignite.internal.tx.impl.TransactionInflights;
@@ -115,12 +113,6 @@ public ReplicaService replicaService(
         );
     }
 
-    /** Creates the volatile transaction state meta storage. */
-    @Singleton
-    public VolatileTxStateMetaStorage volatileTxStateMetaStorage() {
-        return new VolatileTxStateMetaStorage();
-    }
-
     /** Creates the transaction inflights tracker. */
     @Singleton
     public TransactionInflights transactionInflights(
@@ -135,29 +127,12 @@ public TransactionInflights transactionInflights(
         );
     }
 
-    /** Creates the lock manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1650)
-    public LockManager lockManager(
-            SystemLocalConfiguration systemConfiguration,
-            VolatileTxStateMetaStorage txStateVolatileStorage
-    ) {
-        return new HeapLockManager(systemConfiguration, txStateVolatileStorage);
-    }
-
     /** Creates the transaction ID generator. */
     @Singleton
     public TransactionIdGenerator transactionIdGenerator(ClusterService clusterService) {
         return new TransactionIdGenerator(() -> clusterService.nodeName().hashCode());
     }
 
-    /** Creates the remotely triggered resource registry. */
-    @Singleton
-    public RemotelyTriggeredResourceRegistry remotelyTriggeredResourceRegistry() {
-        return new RemotelyTriggeredResourceRegistry();
-    }
-
     /** Creates the transaction manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java b/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java
index 32749d0b80ed..2c8a93264891 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java
@@ -17,11 +17,13 @@
 
 package org.apache.ignite.internal.catalog;
 
+import jakarta.inject.Singleton;
 import org.apache.ignite.internal.catalog.commands.CatalogUtils;
 
 /**
  * Wrapper that allows to apply and use different partition count computing approaches.
  */
+@Singleton
 public final class PartitionCountCalculatorWrapper implements PartitionCountCalculator {
     /** Wrapped delegate to compute partition count. */
     private volatile PartitionCountCalculator delegate;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/system/JvmCpuInformationProvider.java b/modules/runner/src/main/java/org/apache/ignite/internal/system/JvmCpuInformationProvider.java
index 912de39c798c..c9dfdd9a1abc 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/system/JvmCpuInformationProvider.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/system/JvmCpuInformationProvider.java
@@ -17,9 +17,12 @@
 
 package org.apache.ignite.internal.system;
 
+import jakarta.inject.Singleton;
+
 /**
  * Provides CPU information based on JVM {@link Runtime} instance.
  */
+@Singleton
 public class JvmCpuInformationProvider implements CpuInformationProvider {
     @Override
     public int availableProcessors() {
diff --git a/modules/schema/build.gradle b/modules/schema/build.gradle
index 6e22b4fc92c6..dc38447abaea 100644
--- a/modules/schema/build.gradle
+++ b/modules/schema/build.gradle
@@ -25,6 +25,7 @@ description = 'ignite-schema'
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     api project(':ignite-binary-tuple')
     api project(':ignite-marshaller-common')
@@ -38,6 +39,8 @@ dependencies {
     implementation project(':ignite-configuration-root')
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
+    implementation project(':ignite-di')
 
     testAnnotationProcessor project(':ignite-configuration-annotation-processor')
     testAnnotationProcessor libs.jmh.annotation.processor
@@ -61,4 +64,6 @@ dependencies {
     testFixturesImplementation project(':ignite-configuration-api')
     testFixturesImplementation project(':ignite-catalog')
     testFixturesImplementation testFixtures(project(':ignite-core'))
+    testFixturesImplementation project(':ignite-di')
+    testFixturesImplementation libs.micronaut.inject
 }
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java
index cde708250a0f..88fb5491cc7d 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java
@@ -25,6 +25,8 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
@@ -39,6 +41,8 @@
 import org.apache.ignite.internal.catalog.events.TableEventParameters;
 import org.apache.ignite.internal.causality.IncrementalVersionedValue;
 import org.apache.ignite.internal.causality.RevisionListenerRegistry;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -52,6 +56,9 @@
 /**
  * This class services management of table schemas.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2000)
 public class SchemaManager implements IgniteComponent {
     /** Busy lock to stop synchronously. */
     private final IgniteSpinBusyLock busyLock = new IgniteSpinBusyLock();
diff --git a/modules/security/build.gradle b/modules/security/build.gradle
index 032453b4ab01..4eb707406bb5 100644
--- a/modules/security/build.gradle
+++ b/modules/security/build.gradle
@@ -31,9 +31,12 @@ dependencies {
     implementation project(':ignite-eventlog')
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
+    implementation project(':ignite-di')
 
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     testAnnotationProcessor project(':ignite-configuration-annotation-processor')
     testImplementation project(':ignite-configuration')
diff --git a/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java b/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java
index 543e9ee19c66..8081f5b80176 100644
--- a/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java
+++ b/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java
@@ -22,6 +22,8 @@
 import static org.apache.ignite.internal.security.authentication.AuthenticationUtils.findBasicProviderName;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
@@ -30,6 +32,8 @@
 import java.util.stream.Collectors;
 import org.apache.ignite.configuration.NamedListView;
 import org.apache.ignite.configuration.notifications.ConfigurationListener;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.event.AbstractEventProducer;
 import org.apache.ignite.internal.eventlog.api.EventLog;
 import org.apache.ignite.internal.eventlog.api.IgniteEventType;
@@ -55,6 +59,9 @@
 /**
  * Implementation of {@link Authenticator}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2850)
 public class AuthenticationManagerImpl
         extends AbstractEventProducer<AuthenticationEvent, AuthenticationEventParameters>
         implements AuthenticationManager {
diff --git a/modules/system-disaster-recovery/build.gradle b/modules/system-disaster-recovery/build.gradle
index c6198d547e42..5ce494a6211a 100644
--- a/modules/system-disaster-recovery/build.gradle
+++ b/modules/system-disaster-recovery/build.gradle
@@ -22,9 +22,13 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     api project(':ignite-system-disaster-recovery-api')
 
     implementation project(':ignite-core')
+    implementation project(':ignite-di')
+    implementation libs.micronaut.inject
     implementation project(':ignite-network-api')
     implementation project(':ignite-vault')
     implementation project(':ignite-cluster-management')
diff --git a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java
index 731827fc0438..3d6a5814bfa8 100644
--- a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java
+++ b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java
@@ -19,10 +19,14 @@
 
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.ClusterIdStore;
 import org.apache.ignite.internal.cluster.management.ClusterState;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.disaster.system.message.ResetClusterMessage;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
@@ -35,6 +39,9 @@
  *
  * <p>This MUST be started after the Vault, but before networking.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(800)
 public class ClusterIdService implements ClusterIdSupplier, ClusterIdStore, IgniteComponent {
     private final SystemDisasterRecoveryStorage storage;
 
diff --git a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryStorage.java b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryStorage.java
index 6aa905b4ee4d..dc5223c9ef10 100644
--- a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryStorage.java
+++ b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryStorage.java
@@ -20,6 +20,7 @@
 import static org.apache.ignite.internal.util.ArrayUtils.BYTE_EMPTY_ARRAY;
 import static org.apache.ignite.internal.util.ByteUtils.uuidToBytes;
 
+import jakarta.inject.Singleton;
 import java.util.UUID;
 import org.apache.ignite.internal.cluster.management.ClusterState;
 import org.apache.ignite.internal.cluster.management.ClusterStatePersistentSerializer;
@@ -35,6 +36,7 @@
 /**
  * Storage used by tools for disaster recovery of system groups.
  */
+@Singleton
 public class SystemDisasterRecoveryStorage implements ClusterResetStorage {
     private static final ByteArray INIT_CONFIG_APPLIED_VAULT_KEY = new ByteArray("systemRecovery.initConfigApplied");
     private static final ByteArray CLUSTER_STATE_VAULT_KEY = new ByteArray("systemRecovery.clusterState");
diff --git a/modules/table/build.gradle b/modules/table/build.gradle
index 3e54807d2b43..2233d3c006e5 100644
--- a/modules/table/build.gradle
+++ b/modules/table/build.gradle
@@ -25,6 +25,7 @@ dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-api')
     implementation project(':ignite-schema')
@@ -54,6 +55,8 @@ dependencies {
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
+    implementation project(':ignite-di')
 
     testAnnotationProcessor libs.jmh.annotation.processor
     testImplementation project(':ignite-configuration')
@@ -124,6 +127,8 @@ dependencies {
     testFixturesImplementation testFixtures(project(':ignite-marshaller-common'))
     testFixturesImplementation testFixtures(project(':ignite-schema'))
     testFixturesImplementation libs.fastutil.core
+    testFixturesImplementation project(':ignite-di')
+    testFixturesImplementation libs.micronaut.inject
 
 
     integrationTestImplementation project(':ignite-raft-api')
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java
index 9a6afb2df4c4..7fd6fcc9d8f9 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java
@@ -45,6 +45,8 @@
 import static org.apache.ignite.internal.util.CompletableFutures.falseCompletedFuture;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
@@ -69,6 +71,8 @@
 import org.apache.ignite.internal.catalog.events.StartBuildingIndexEventParameters;
 import org.apache.ignite.internal.catalog.events.StoppingIndexEventParameters;
 import org.apache.ignite.internal.catalog.events.TableEventParameters;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.event.EventListener;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lang.ByteArray;
@@ -111,6 +115,9 @@
  *     less than or equal to the active catalog version for the new watermark.</li>
  * </ul>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(400)
 public class IndexMetaStorage implements IgniteComponent {
     private static final String INDEX_META_VERSION_KEY_PREFIX = "index.meta.version.";
 
diff --git a/modules/transactions/build.gradle b/modules/transactions/build.gradle
index fae253133f63..dd7f412c9967 100644
--- a/modules/transactions/build.gradle
+++ b/modules/transactions/build.gradle
@@ -26,6 +26,7 @@ dependencies {
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     api project(':ignite-configuration-system')
     api project(':ignite-storage-api')
@@ -49,6 +50,7 @@ dependencies {
     implementation libs.auto.service.annotations
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
+    implementation libs.micronaut.inject
 
     testImplementation project(':ignite-core')
     testImplementation testFixtures(project(':ignite-core'))
@@ -108,6 +110,7 @@ dependencies {
     testFixturesImplementation project(':ignite-distribution-zones')
     testFixturesImplementation project(':ignite-table')
     testFixturesImplementation testFixtures(project(':ignite-core'))
+    testFixturesImplementation libs.micronaut.inject
 }
 
 description = 'ignite-transactions'
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
index b9ae7002c0f9..c2403f6afa42 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/HeapLockManager.java
@@ -23,6 +23,8 @@
 import static org.apache.ignite.internal.tx.event.LockEvent.LOCK_CONFLICT;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Comparator;
@@ -77,6 +79,7 @@
  *
  * <p>Additionally limits the lock map size.
  */
+@Singleton
 public class HeapLockManager extends AbstractEventProducer<LockEvent, LockEventParameters> implements LockManager {
     /** Table size. */
     public static final int DEFAULT_SLOTS = 1_048_576;
@@ -124,6 +127,7 @@ public static HeapLockManager smallInstance() {
     }
 
     /** Constructor. */
+    @Inject
     public HeapLockManager(SystemLocalConfiguration systemProperties, VolatileTxStateMetaStorage txStateVolatileStorage) {
         this(intProperty(systemProperties, LOCK_MAP_SIZE_PROPERTY_NAME, DEFAULT_SLOTS), txStateVolatileStorage);
     }
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/RemotelyTriggeredResourceRegistry.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/RemotelyTriggeredResourceRegistry.java
index 823434b37410..8e8df2134901 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/RemotelyTriggeredResourceRegistry.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/RemotelyTriggeredResourceRegistry.java
@@ -20,6 +20,7 @@
 import static java.util.Collections.unmodifiableMap;
 import static java.util.Collections.unmodifiableSet;
 
+import jakarta.inject.Singleton;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -37,6 +38,7 @@
 /**
  * This registry keeps track of the resources that were created by remote nodes.
  */
+@Singleton
 public class RemotelyTriggeredResourceRegistry {
     /** The logger. */
     private static final IgniteLogger LOG = Loggers.forClass(RemotelyTriggeredResourceRegistry.class);
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/VolatileTxStateMetaStorage.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/VolatileTxStateMetaStorage.java
index 19396b007ad2..f78904e3bc60 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/VolatileTxStateMetaStorage.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/VolatileTxStateMetaStorage.java
@@ -20,6 +20,7 @@
 import static org.apache.ignite.internal.tx.TxState.PENDING;
 import static org.apache.ignite.internal.tx.TxState.checkTransitionCorrectness;
 
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -45,6 +46,7 @@
 /**
  * The class represents volatile transaction state storage that stores a transaction state meta until the node stops.
  */
+@Singleton
 public class VolatileTxStateMetaStorage {
     /** The local map for tx states. */
     private ConcurrentHashMap<UUID, TxStateMeta> txStateMap;
diff --git a/modules/vault/build.gradle b/modules/vault/build.gradle
index b9d81a5fff4f..0498c7b5f51d 100644
--- a/modules/vault/build.gradle
+++ b/modules/vault/build.gradle
@@ -21,7 +21,11 @@ apply from: "$rootDir/buildscripts/java-junit5.gradle"
 apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     implementation project(':ignite-core')
+    implementation project(':ignite-di')
+    implementation libs.micronaut.inject
     implementation project(':ignite-rocksdb-common')
     implementation libs.jetbrains.annotations
     implementation libs.rocksdb.jni
@@ -30,6 +34,8 @@ dependencies {
     testImplementation testFixtures(project(':ignite-core'))
 
     testFixturesImplementation project(':ignite-core')
+    testFixturesImplementation project(':ignite-di')
+    testFixturesImplementation libs.micronaut.inject
 }
 
 description = 'ignite-vault'
diff --git a/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java b/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java
index c390c4068e61..783eca44f294 100644
--- a/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java
+++ b/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java
@@ -21,8 +21,12 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.internal.util.StringUtils.incrementLastChar;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.di.IgniteStartupPhase;
+import org.apache.ignite.internal.di.StartupPhase;
 import org.apache.ignite.internal.lang.ByteArray;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
@@ -32,6 +36,9 @@
 /**
  * VaultManager is responsible for handling {@link VaultService} lifecycle and providing interface for managing local keys.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(200)
 public class VaultManager implements IgniteComponent {
     /** Special key, which reserved for storing the name of the current node. */
     public static final ByteArray NODE_NAME = new ByteArray("node_name");

From b66029b1340cdfc77f5ae593877111f193cf902c Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 08:15:01 +0400
Subject: [PATCH 26/79] ignite-di-claude Fix stackoverflow issue

---
 .../internal/catalog/PartitionCountCalculatorWrapper.java       | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java b/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java
index 2c8a93264891..6cd114295663 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/catalog/PartitionCountCalculatorWrapper.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.catalog;
 
+import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.catalog.commands.CatalogUtils;
 
@@ -37,6 +38,7 @@ public PartitionCountCalculatorWrapper(PartitionCountCalculator delegate) {
      * Constructor that uses {@link PartitionCountCalculator#staticPartitionCountCalculator} with
      * {@link CatalogUtils#DEFAULT_PARTITION_COUNT} as static calculation result.
      * */
+    @Inject
     public PartitionCountCalculatorWrapper() {
         this(PartitionCountCalculator.staticPartitionCountCalculator(CatalogUtils.DEFAULT_PARTITION_COUNT));
     }

From 9de238f2f20624012915b1673c905f7213b656db Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 10:23:27 +0400
Subject: [PATCH 27/79] ignite-di-claude Fix bean discoverability in rest

---
 .../ignite/internal/rest/RestComponent.java    | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java b/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
index 66635ddde64d..806f96b08736 100644
--- a/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
+++ b/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
@@ -23,6 +23,7 @@
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.DefaultApplicationContext;
+import io.micronaut.inject.BeanDefinitionReference;
 import io.micronaut.core.convert.ConversionService;
 import io.micronaut.core.convert.DefaultConversionService;
 import io.micronaut.http.HttpMethod;
@@ -355,6 +356,9 @@ public String hostName() {
     private static class IgniteMicronaut extends Micronaut {
         private final ConversionService conversionService = new DefaultConversionService();
 
+        private static final String IGNITE_PACKAGE_PREFIX = "org.apache.ignite.internal.";
+        private static final String REST_PACKAGE_PREFIX = "org.apache.ignite.internal.rest.";
+
         @Override
         protected ApplicationContext newApplicationContext() {
             return new DefaultApplicationContext(this) {
@@ -362,6 +366,20 @@ protected ApplicationContext newApplicationContext() {
                 protected ConversionService createConversionService() {
                     return conversionService;
                 }
+
+                @Override
+                protected List<BeanDefinitionReference> resolveBeanDefinitionReferences() {
+                    List<BeanDefinitionReference> refs = super.resolveBeanDefinitionReferences();
+
+                    // Exclude Ignite beans that are not in the REST package to prevent
+                    // duplicate bean registration (REST factories register them explicitly).
+                    refs.removeIf(ref -> {
+                        String name = ref.getBeanDefinitionName();
+                        return name.startsWith(IGNITE_PACKAGE_PREFIX) && !name.startsWith(REST_PACKAGE_PREFIX);
+                    });
+
+                    return refs;
+                }
             };
         }
 

From aee63cf09a06da79e774807fdbecb7d192c50fe8 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 11:27:30 +0400
Subject: [PATCH 28/79] Fix cehckstyle

---
 .../java/org/apache/ignite/internal/rest/RestComponent.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java b/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
index 806f96b08736..7ad6d8832283 100644
--- a/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
+++ b/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
@@ -23,12 +23,12 @@
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.DefaultApplicationContext;
-import io.micronaut.inject.BeanDefinitionReference;
 import io.micronaut.core.convert.ConversionService;
 import io.micronaut.core.convert.DefaultConversionService;
 import io.micronaut.http.HttpMethod;
 import io.micronaut.http.server.exceptions.ServerStartupException;
 import io.micronaut.http.ssl.ClientAuthentication;
+import io.micronaut.inject.BeanDefinitionReference;
 import io.micronaut.management.endpoint.health.HealthEndpoint;
 import io.micronaut.runtime.Micronaut;
 import io.micronaut.runtime.exceptions.ApplicationStartupException;

From 35e8d2d319d1056856584763a1bed9472f8d1ddc Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 12:57:06 +0400
Subject: [PATCH 29/79] expand singleton scan range

---
 .../main/java/org/apache/ignite/internal/app/IgniteImpl.java  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 518beb33c4cf..dadfc8e40a3e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -372,8 +372,8 @@ public class IgniteImpl implements Ignite {
         diContext = IgniteDiContext.builder()
                 .withSingleton(seedParams)
                 .withSingleton(this)
-                .withPackages("org.apache.ignite.internal.app.di")
-                .withExcludedPackages("org.apache.ignite.internal.rest")
+                .withPackages("org.apache.ignite.internal")
+                .withExcludedPackages("org.apache.ignite.internal.rest", "org.apache.ignite.internal.cli")
                 .build();
 
         // Start local configuration early — factory methods read config values during bean construction.

From 555474ee40e02ca42e7967195f2422bf61988320 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 13:14:09 +0400
Subject: [PATCH 30/79] Refactor core components

---
 .../components}/IgniteStartupPhase.java       |  5 +-
 .../components/LongJvmPauseDetector.java      | 12 ++++
 .../internal/components/NodeIdentity.java     | 58 +++++++++++++++++
 .../internal/components}/StartupPhase.java    |  2 +-
 .../di/IgniteComponentLifecycleManager.java   |  2 +
 .../internal/metrics/MetricManagerImpl.java   | 15 +++++
 .../org/apache/ignite/internal/raft/Loza.java |  4 +-
 .../ignite/internal/app/IgniteImpl.java       |  2 +-
 .../internal/app/LowWatermarkRectifier.java   |  4 +-
 .../internal/app/NodePropertiesImpl.java      |  4 +-
 .../app/SystemPropertiesComponent.java        |  4 +-
 .../internal/app/ThreadPoolsManager.java      | 15 +++++
 .../internal/app/di/CatalogFactory.java       |  4 +-
 .../internal/app/di/ClientHandlerFactory.java |  4 +-
 .../app/di/ClusterManagementFactory.java      |  4 +-
 .../internal/app/di/ComputeFactory.java       |  4 +-
 .../app/di/CoreComponentsFactory.java         | 63 -------------------
 .../internal/app/di/DataPathFactory.java      |  4 +-
 .../app/di/IgniteNodeSeedFactory.java         |  7 +++
 .../internal/app/di/MetaStorageFactory.java   |  4 +-
 .../app/di/NetworkComponentsFactory.java      |  4 +-
 .../ignite/internal/app/di/RaftFactory.java   |  4 +-
 .../ignite/internal/app/di/SqlFactory.java    |  4 +-
 .../app/di/SystemServicesFactory.java         |  4 +-
 .../internal/app/di/TransactionFactory.java   |  4 +-
 .../ignite/internal/schema/SchemaManager.java |  4 +-
 .../AuthenticationManagerImpl.java            |  4 +-
 .../disaster/system/ClusterIdService.java     |  4 +-
 .../distributed/index/IndexMetaStorage.java   |  4 +-
 .../ignite/internal/vault/VaultManager.java   |  4 +-
 30 files changed, 152 insertions(+), 109 deletions(-)
 rename modules/{di/src/main/java/org/apache/ignite/internal/di => core/src/main/java/org/apache/ignite/internal/components}/IgniteStartupPhase.java (88%)
 create mode 100644 modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
 rename modules/{di/src/main/java/org/apache/ignite/internal/di => core/src/main/java/org/apache/ignite/internal/components}/StartupPhase.java (96%)
 delete mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java

diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteStartupPhase.java b/modules/core/src/main/java/org/apache/ignite/internal/components/IgniteStartupPhase.java
similarity index 88%
rename from modules/di/src/main/java/org/apache/ignite/internal/di/IgniteStartupPhase.java
rename to modules/core/src/main/java/org/apache/ignite/internal/components/IgniteStartupPhase.java
index 559cf4f6b163..a951bd2a04a0 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteStartupPhase.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/IgniteStartupPhase.java
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.ignite.internal.di;
+package org.apache.ignite.internal.components;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
@@ -27,9 +27,6 @@
  * Marks an {@link org.apache.ignite.internal.manager.IgniteComponent} bean with the startup phase
  * in which it should be started.
  *
- * <p>This annotation is used by {@link IgniteComponentLifecycleManager} to group components
- * and start them in the correct phase during node startup.
- *
  * <p>Components without this annotation default to {@link StartupPhase#PHASE_1}.
  */
 @Documented
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/components/LongJvmPauseDetector.java b/modules/core/src/main/java/org/apache/ignite/internal/components/LongJvmPauseDetector.java
index 5cd306d64ce5..a722be404aa8 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/components/LongJvmPauseDetector.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/LongJvmPauseDetector.java
@@ -21,6 +21,9 @@
 import static org.apache.ignite.internal.lang.IgniteSystemProperties.getInteger;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.concurrent.CompletableFuture;
@@ -42,6 +45,9 @@
  * properties IGNITE_JVM_PAUSE_DETECTOR_PRECISION, IGNITE_JVM_PAUSE_DETECTOR_THRESHOLD and IGNITE_JVM_PAUSE_DETECTOR_LAST_EVENTS_COUNT
  * accordingly.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(100)
 public class LongJvmPauseDetector implements IgniteComponent {
     private final IgniteLogger log = Loggers.forClass(LongJvmPauseDetector.class);
 
@@ -91,6 +97,12 @@ public LongJvmPauseDetector(String nodeName) {
         this.nodeName = nodeName;
     }
 
+    /** Constructor for DI injection. */
+    @Inject
+    public LongJvmPauseDetector(NodeIdentity nodeIdentity) {
+        this(nodeIdentity.nodeName());
+    }
+
     /** {@inheritDoc} */
     @Override
     public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java b/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
new file mode 100644
index 000000000000..dff95b5ed7aa
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.components;
+
+import java.nio.file.Path;
+import java.util.UUID;
+import java.util.function.Supplier;
+
+/**
+ * Holds basic node identity and environment parameters that components across all modules commonly need.
+ *
+ * <p>This POJO is created early during node startup and registered as a singleton bean in the DI context,
+ * so any module that depends on {@code ignite-core} can inject it without creating a dependency on the runner module.
+ */
+public class NodeIdentity {
+    private final String nodeName;
+
+    private final Path workDir;
+
+    private final Supplier<UUID> clusterIdSupplier;
+
+    /** Constructor. */
+    public NodeIdentity(String nodeName, Path workDir, Supplier<UUID> clusterIdSupplier) {
+        this.nodeName = nodeName;
+        this.workDir = workDir;
+        this.clusterIdSupplier = clusterIdSupplier;
+    }
+
+    /** Node name. */
+    public String nodeName() {
+        return nodeName;
+    }
+
+    /** Node working directory. */
+    public Path workDir() {
+        return workDir;
+    }
+
+    /** Supplier of the cluster ID; resolved lazily after cluster initialization. */
+    public Supplier<UUID> clusterIdSupplier() {
+        return clusterIdSupplier;
+    }
+}
diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/StartupPhase.java b/modules/core/src/main/java/org/apache/ignite/internal/components/StartupPhase.java
similarity index 96%
rename from modules/di/src/main/java/org/apache/ignite/internal/di/StartupPhase.java
rename to modules/core/src/main/java/org/apache/ignite/internal/components/StartupPhase.java
index e7c529dc40e2..ea1046ab6265 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/StartupPhase.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/StartupPhase.java
@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-package org.apache.ignite.internal.di;
+package org.apache.ignite.internal.components;
 
 /**
  * Defines the startup phase in which an {@link org.apache.ignite.internal.manager.IgniteComponent} should be started.
diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
index 58ea86790d8c..a8e794a70ab8 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManager.java
@@ -34,6 +34,8 @@
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CopyOnWriteArrayList;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 import org.apache.ignite.internal.util.IgniteUtils;
diff --git a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java
index 1ec0cd2520bf..2da213f9c14b 100644
--- a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java
+++ b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java
@@ -22,6 +22,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockSafe;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.ServiceLoader;
 import java.util.ServiceLoader.Provider;
@@ -39,6 +42,9 @@
 import org.apache.ignite.internal.metrics.exporters.configuration.ExporterView;
 import org.apache.ignite.internal.metrics.exporters.configuration.LogPushExporterConfigurationSchema;
 import org.apache.ignite.internal.metrics.exporters.configuration.LogPushExporterView;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.metrics.exporters.log.LogPushExporter;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.annotations.VisibleForTesting;
@@ -46,6 +52,9 @@
 /**
  * Metric manager.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(900)
 public class MetricManagerImpl extends AbstractMetricManager {
     // This field cannot be static, because its used by the Thin Client.
     // However, it is expected that MetricManagerImpl will be used only on the server side.
@@ -63,6 +72,12 @@ public MetricManagerImpl(String nodeName, Supplier<UUID> clusterIdSupplier) {
         this.clusterIdSupplier = clusterIdSupplier;
     }
 
+    /** Constructor for DI injection. */
+    @Inject
+    public MetricManagerImpl(NodeIdentity nodeIdentity) {
+        this(nodeIdentity.nodeName(), nodeIdentity.clusterIdSupplier());
+    }
+
     /** Constructor for smoother testing. */
     @TestOnly
     public MetricManagerImpl(String nodeName, Supplier<UUID> clusterIdSupplier, MetricConfiguration metricConfiguration) {
diff --git a/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java b/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
index d8a4f80142f1..f46ba2e4951b 100644
--- a/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
+++ b/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
@@ -34,8 +34,8 @@
 import java.util.function.BiConsumer;
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
 import org.apache.ignite.internal.configuration.SystemPropertyConfiguration;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.lang.IgniteInternalException;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index dadfc8e40a3e..3202aac26916 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -82,7 +82,7 @@
 import org.apache.ignite.internal.deployunit.IgniteDeployment;
 import org.apache.ignite.internal.di.IgniteComponentLifecycleManager;
 import org.apache.ignite.internal.di.IgniteDiContext;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
 import org.apache.ignite.internal.disaster.system.ServerRestarter;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManager;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
index 7583a24a46fb..8fbe0ee3795b 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/LowWatermarkRectifier.java
@@ -24,8 +24,8 @@
 import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.catalog.CatalogService;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.manager.ComponentContext;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
index 0e1c8c52aab3..b435b53283f9 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
@@ -28,8 +28,8 @@
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.NodeAttributesProvider;
 import org.apache.ignite.internal.components.NodeProperties;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.ByteArray;
 import org.apache.ignite.internal.lang.IgniteSystemProperties;
 import org.apache.ignite.internal.logger.IgniteLogger;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
index cad3a885a9db..a825852c4f00 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
@@ -22,8 +22,8 @@
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 import org.apache.ignite.internal.tostring.IgniteToStringBuilder;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
index 3f8f9bb5c4e6..9fe7e16832c5 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
@@ -25,6 +25,9 @@
 import static org.apache.ignite.internal.thread.ThreadOperation.TX_STATE_STORAGE_ACCESS;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -36,6 +39,9 @@
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.metrics.sources.ThreadPoolMetricSource;
 import org.apache.ignite.internal.thread.IgniteThreadFactory;
@@ -44,6 +50,9 @@
 /**
  * Component that hosts thread pools which do not belong to a certain component and which are global to an Ignite instance.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(400)
 public class ThreadPoolsManager implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(ThreadPoolsManager.class);
 
@@ -67,6 +76,12 @@ public class ThreadPoolsManager implements IgniteComponent {
 
     private final List<ThreadPoolMetricSource> metricSources;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public ThreadPoolsManager(NodeIdentity nodeIdentity, MetricManager metricManager) {
+        this(nodeIdentity.nodeName(), metricManager);
+    }
+
     /**
      * Constructor.
      */
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index eb45710919a5..f22629db9672 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -29,8 +29,8 @@
 import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
index eafcb6928012..fe17fc5f0510 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -32,8 +32,8 @@
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SuggestionsClusterExtensionConfiguration;
 import org.apache.ignite.internal.configuration.SuggestionsConfiguration;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 3838e1f0c4ec..a0c78ab0e3b8 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -38,8 +38,8 @@
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
 import org.apache.ignite.internal.failure.FailureManager;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index 7aeced19571f..2e672fb26fdd 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -39,8 +39,8 @@
 import org.apache.ignite.internal.deployunit.loader.UnitsClassLoaderFactory;
 import org.apache.ignite.internal.deployunit.loader.UnitsContextManager;
 import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.hlc.HybridClock;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
deleted file mode 100644
index 93c3960c0ac2..000000000000
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CoreComponentsFactory.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.app.di;
-
-import io.micronaut.context.annotation.Factory;
-import io.micronaut.core.annotation.Order;
-import jakarta.inject.Singleton;
-import org.apache.ignite.internal.app.ThreadPoolsManager;
-import org.apache.ignite.internal.components.LongJvmPauseDetector;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
-import org.apache.ignite.internal.metrics.MetricManager;
-import org.apache.ignite.internal.metrics.MetricManagerImpl;
-
-/**
- * Micronaut factory for leaf Ignite components that have few or no dependencies on other components.
- */
-@Factory
-public class CoreComponentsFactory {
-    /** Creates the JVM pause detector. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(100)
-    public LongJvmPauseDetector longJvmPauseDetector(NodeSeedParams seedParams) {
-        return new LongJvmPauseDetector(seedParams.nodeName());
-    }
-
-    /**
-     * Creates the metric manager.
-     *
-     * @param seedParams Node seed parameters.
-     */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(900)
-    public MetricManagerImpl metricManager(NodeSeedParams seedParams) {
-        return new MetricManagerImpl(seedParams.nodeName(), seedParams.clusterIdSupplier());
-    }
-
-    /** Creates the thread pools manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(400)
-    public ThreadPoolsManager threadPoolsManager(NodeSeedParams seedParams, MetricManager metricManager) {
-        return new ThreadPoolsManager(seedParams.nodeName(), metricManager);
-    }
-
-}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 9a32799d5ac8..d500525818b9 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -39,8 +39,8 @@
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
index 40086571b918..b6d5677fbd8a 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
@@ -22,6 +22,7 @@
 import io.micronaut.context.annotation.Factory;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.vault.VaultService;
 import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
 
@@ -36,6 +37,12 @@ public IgniteNodeSeedFactory(NodeSeedParams seedParams) {
         this.seedParams = seedParams;
     }
 
+    /** Creates the node identity POJO for injection into components across modules. */
+    @Singleton
+    public NodeIdentity nodeIdentity() {
+        return new NodeIdentity(seedParams.nodeName(), seedParams.workDir(), seedParams.clusterIdSupplier());
+    }
+
     /** Creates the persistent vault service backed by the node's work directory. */
     @Singleton
     public VaultService vaultService() {
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index 513fa7127bdc..b5541720d166 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -33,8 +33,8 @@
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.MetastorageRepairImpl;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
 import org.apache.ignite.internal.failure.FailureManager;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index 334a100f875a..4ab92486b678 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -25,8 +25,8 @@
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
 import org.apache.ignite.internal.configuration.SystemLocalExtensionConfiguration;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
index 1fc4bdfa74ef..5de5a64040c5 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
@@ -32,8 +32,8 @@
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
 import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
 import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index b166533a0881..8a3b91cc5853 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -25,8 +25,8 @@
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 3ded70a075c6..9d89e21fe54f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -29,8 +29,8 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManagerImpl;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 742c6e739513..7f996f1cf540 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -26,8 +26,8 @@
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
diff --git a/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java b/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java
index 88fb5491cc7d..bb49ff90271a 100644
--- a/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java
+++ b/modules/schema/src/main/java/org/apache/ignite/internal/schema/SchemaManager.java
@@ -41,8 +41,8 @@
 import org.apache.ignite.internal.catalog.events.TableEventParameters;
 import org.apache.ignite.internal.causality.IncrementalVersionedValue;
 import org.apache.ignite.internal.causality.RevisionListenerRegistry;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.manager.ComponentContext;
diff --git a/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java b/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java
index 8081f5b80176..8638dc5dc7e5 100644
--- a/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java
+++ b/modules/security/src/main/java/org/apache/ignite/internal/security/authentication/AuthenticationManagerImpl.java
@@ -32,8 +32,8 @@
 import java.util.stream.Collectors;
 import org.apache.ignite.configuration.NamedListView;
 import org.apache.ignite.configuration.notifications.ConfigurationListener;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.event.AbstractEventProducer;
 import org.apache.ignite.internal.eventlog.api.EventLog;
 import org.apache.ignite.internal.eventlog.api.IgniteEventType;
diff --git a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java
index 3d6a5814bfa8..35f21e4dff00 100644
--- a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java
+++ b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/ClusterIdService.java
@@ -25,8 +25,8 @@
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.ClusterIdStore;
 import org.apache.ignite.internal.cluster.management.ClusterState;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.message.ResetClusterMessage;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java
index 7fd6fcc9d8f9..9a8d6bc85bd8 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/index/IndexMetaStorage.java
@@ -71,8 +71,8 @@
 import org.apache.ignite.internal.catalog.events.StartBuildingIndexEventParameters;
 import org.apache.ignite.internal.catalog.events.StoppingIndexEventParameters;
 import org.apache.ignite.internal.catalog.events.TableEventParameters;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.event.EventListener;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lang.ByteArray;
diff --git a/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java b/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java
index 783eca44f294..2eb144d16715 100644
--- a/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java
+++ b/modules/vault/src/main/java/org/apache/ignite/internal/vault/VaultManager.java
@@ -25,8 +25,8 @@
 import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
-import org.apache.ignite.internal.di.IgniteStartupPhase;
-import org.apache.ignite.internal.di.StartupPhase;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.ByteArray;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;

From 966453c7c823ebf0b304f602e42765610d3480f6 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 13:42:25 +0400
Subject: [PATCH 31/79] Refactor system view

---
 .../di/IgniteComponentLifecycleManagerTest.java   |  1 +
 .../ignite/internal/di/TestComponentFactory.java  |  2 ++
 .../apache/ignite/internal/app/IgniteImpl.java    |  2 +-
 .../ignite/internal/app/NodePropertiesImpl.java   |  2 +-
 .../internal/app/SystemPropertiesComponent.java   |  4 ++--
 .../ignite/internal/app/ThreadPoolsManager.java   |  6 +++---
 .../internal/app/di/ClientHandlerFactory.java     |  4 ++--
 .../internal/app/di/ClusterManagementFactory.java |  4 ++--
 .../ignite/internal/app/di/ComputeFactory.java    |  4 ++--
 .../ignite/internal/app/di/DataPathFactory.java   |  4 ++--
 .../internal/app/di/IgniteNodeSeedFactory.java    |  2 +-
 .../internal/app/di/MetaStorageFactory.java       |  4 ++--
 .../internal/app/di/NetworkComponentsFactory.java |  4 ++--
 .../ignite/internal/app/di/RaftFactory.java       |  4 ++--
 .../apache/ignite/internal/app/di/SqlFactory.java |  2 +-
 .../internal/app/di/SystemServicesFactory.java    | 15 ++-------------
 .../internal/app/di/TransactionFactory.java       |  4 ++--
 modules/system-view/build.gradle                  |  3 +++
 .../systemview/SystemViewManagerImpl.java         | 13 +++++++++++++
 19 files changed, 46 insertions(+), 38 deletions(-)

diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
index 76139e259fa4..0bf316035b60 100644
--- a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
@@ -31,6 +31,7 @@
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 import org.junit.jupiter.api.AfterEach;
diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java b/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java
index 93f90436b75a..0b6feb35b97e 100644
--- a/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/TestComponentFactory.java
@@ -21,6 +21,8 @@
 import io.micronaut.context.annotation.Factory;
 import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 3202aac26916..d5406bfd1b2a 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -68,6 +68,7 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
 import org.apache.ignite.internal.components.NodeProperties;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.AntiHijackIgniteCompute;
 import org.apache.ignite.internal.compute.ComputeComponentImpl;
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
@@ -82,7 +83,6 @@
 import org.apache.ignite.internal.deployunit.IgniteDeployment;
 import org.apache.ignite.internal.di.IgniteComponentLifecycleManager;
 import org.apache.ignite.internal.di.IgniteDiContext;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
 import org.apache.ignite.internal.disaster.system.ServerRestarter;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManager;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
index b435b53283f9..8a89c9fb9bf9 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/NodePropertiesImpl.java
@@ -27,8 +27,8 @@
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.NodeAttributesProvider;
-import org.apache.ignite.internal.components.NodeProperties;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeProperties;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.ByteArray;
 import org.apache.ignite.internal.lang.IgniteSystemProperties;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
index a825852c4f00..129bc533de00 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/SystemPropertiesComponent.java
@@ -20,10 +20,10 @@
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
-import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
-import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
+import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 import org.apache.ignite.internal.tostring.IgniteToStringBuilder;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
index 9fe7e16832c5..a0c986e5bdd6 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
@@ -35,13 +35,13 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadPoolExecutor;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.metrics.sources.ThreadPoolMetricSource;
 import org.apache.ignite.internal.thread.IgniteThreadFactory;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
index fe17fc5f0510..bed201076fb3 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -28,12 +28,12 @@
 import org.apache.ignite.internal.app.IgniteImpl;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SuggestionsClusterExtensionConfiguration;
 import org.apache.ignite.internal.configuration.SuggestionsConfiguration;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index a0c78ab0e3b8..a7ce70c45d6b 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -31,6 +31,8 @@
 import org.apache.ignite.internal.cluster.management.raft.RocksDbClusterStateStorage;
 import org.apache.ignite.internal.cluster.management.raft.ValidationManager;
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationDynamicDefaultsPatcherImpl;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
@@ -38,8 +40,6 @@
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
 import org.apache.ignite.internal.failure.FailureManager;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index 2e672fb26fdd..aa52d7feb866 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -25,6 +25,8 @@
 import org.apache.ignite.Ignite;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.ComputeComponentImpl;
 import org.apache.ignite.internal.compute.IgniteComputeImpl;
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
@@ -39,8 +41,6 @@
 import org.apache.ignite.internal.deployunit.loader.UnitsClassLoaderFactory;
 import org.apache.ignite.internal.deployunit.loader.UnitsContextManager;
 import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.hlc.HybridClock;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index d500525818b9..18c30a9b4617 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -35,12 +35,12 @@
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.LongJvmPauseDetector;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
index b6d5677fbd8a..20985c33cfe7 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
@@ -21,8 +21,8 @@
 
 import io.micronaut.context.annotation.Factory;
 import jakarta.inject.Singleton;
-import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.vault.VaultService;
 import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index b5541720d166..fc1fcf74d84f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -27,14 +27,14 @@
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.MetastorageRepairImpl;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
 import org.apache.ignite.internal.failure.FailureManager;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index 4ab92486b678..62fc08c35320 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -22,11 +22,11 @@
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
 import org.apache.ignite.internal.configuration.SystemLocalExtensionConfiguration;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
index 5de5a64040c5..1638cfa51e9f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
@@ -28,12 +28,12 @@
 import java.nio.file.Path;
 import java.util.Map;
 import org.apache.ignite.internal.cluster.management.CmgGroupId;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
 import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
 import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index 8a3b91cc5853..e3ec7f5d1e55 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -24,9 +24,9 @@
 import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
-import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 9d89e21fe54f..c5701703e85f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -27,10 +27,10 @@
 import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
-import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManagerImpl;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
@@ -88,17 +88,6 @@ public EventLogImpl eventLog(
         );
     }
 
-    /** Creates the system view manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    public SystemViewManagerImpl systemViewManager(
-            NodeSeedParams seedParams,
-            CatalogManagerImpl catalogManager,
-            FailureManager failureManager
-    ) {
-        return new SystemViewManagerImpl(seedParams.nodeName(), catalogManager, failureManager);
-    }
-
     /** Creates the system disaster recovery manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 7f996f1cf540..4dc2cfb940cf 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -22,12 +22,12 @@
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.app.ThreadPoolsManager;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
diff --git a/modules/system-view/build.gradle b/modules/system-view/build.gradle
index 239c5b1ba136..9f59ff444cc0 100644
--- a/modules/system-view/build.gradle
+++ b/modules/system-view/build.gradle
@@ -21,10 +21,13 @@ apply from: "$rootDir/buildscripts/java-junit5.gradle"
 apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     implementation project(':ignite-system-view-api')
 
     implementation project(':ignite-api')
     implementation project(':ignite-core')
+    implementation libs.micronaut.inject
     implementation project(':ignite-catalog')
     implementation project(':ignite-schema')
     implementation project(':ignite-network-api')
diff --git a/modules/system-view/src/main/java/org/apache/ignite/internal/systemview/SystemViewManagerImpl.java b/modules/system-view/src/main/java/org/apache/ignite/internal/systemview/SystemViewManagerImpl.java
index a873afaba6ab..fabc5f341503 100644
--- a/modules/system-view/src/main/java/org/apache/ignite/internal/systemview/SystemViewManagerImpl.java
+++ b/modules/system-view/src/main/java/org/apache/ignite/internal/systemview/SystemViewManagerImpl.java
@@ -23,6 +23,8 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.nio.ByteBuffer;
@@ -50,6 +52,9 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.lang.IgniteInternalException;
@@ -70,6 +75,8 @@
 /**
  * SQL system views manager implementation.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
 public class SystemViewManagerImpl implements SystemViewManager, NodeAttributesProvider, LogicalTopologyEventListener {
     public static final String NODE_ATTRIBUTES_KEY = "sql-system-views";
 
@@ -102,6 +109,12 @@ public class SystemViewManagerImpl implements SystemViewManager, NodeAttributesP
 
     private volatile Map<String, List<String>> owningNodesByViewName = Map.of();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public SystemViewManagerImpl(NodeIdentity nodeIdentity, CatalogManager catalogManager, FailureProcessor failureProcessor) {
+        this(nodeIdentity.nodeName(), catalogManager, failureProcessor);
+    }
+
     /** Creates a system view manager. */
     public SystemViewManagerImpl(String localNodeName, CatalogManager catalogManager, FailureProcessor failureProcessor) {
         this.localNodeName = localNodeName;

From 513b796acddfe74f05078b2896f0a0da5bf50588 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 13:45:45 +0400
Subject: [PATCH 32/79] Refactor InMemoryComputeStateMachine

---
 modules/compute/build.gradle                           |  3 +++
 .../compute/state/InMemoryComputeStateMachine.java     | 10 ++++++++++
 .../apache/ignite/internal/app/di/ComputeFactory.java  |  9 ---------
 3 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/modules/compute/build.gradle b/modules/compute/build.gradle
index 0be2d5189ff3..e1e045336e6c 100644
--- a/modules/compute/build.gradle
+++ b/modules/compute/build.gradle
@@ -22,6 +22,8 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 apply from: 'jobs.gradle'
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     implementation project(':ignite-api')
     implementation project(':ignite-network')
     implementation project(':ignite-table')
@@ -38,6 +40,7 @@ dependencies {
     implementation project(':ignite-system-view-api')
     implementation project(':ignite-security-api')
     implementation project(':ignite-eventlog')
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.auto.service.annotations
diff --git a/modules/compute/src/main/java/org/apache/ignite/internal/compute/state/InMemoryComputeStateMachine.java b/modules/compute/src/main/java/org/apache/ignite/internal/compute/state/InMemoryComputeStateMachine.java
index cfab1d1362cd..a77c2008caa1 100644
--- a/modules/compute/src/main/java/org/apache/ignite/internal/compute/state/InMemoryComputeStateMachine.java
+++ b/modules/compute/src/main/java/org/apache/ignite/internal/compute/state/InMemoryComputeStateMachine.java
@@ -24,6 +24,8 @@
 import static org.apache.ignite.compute.JobStatus.FAILED;
 import static org.apache.ignite.compute.JobStatus.QUEUED;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.time.Instant;
 import java.util.Map;
 import java.util.UUID;
@@ -31,6 +33,7 @@
 import java.util.function.Function;
 import org.apache.ignite.compute.JobState;
 import org.apache.ignite.compute.JobStatus;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.compute.Cleaner;
 import org.apache.ignite.internal.compute.JobStateImpl;
 import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
@@ -40,6 +43,7 @@
 /**
  * In memory implementation of {@link ComputeStateMachine}.
  */
+@Singleton
 public class InMemoryComputeStateMachine implements ComputeStateMachine {
     private static final IgniteLogger LOG = Loggers.forClass(InMemoryComputeStateMachine.class);
 
@@ -51,6 +55,12 @@ public class InMemoryComputeStateMachine implements ComputeStateMachine {
 
     private final Map<UUID, JobState> states = new ConcurrentHashMap<>();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public InMemoryComputeStateMachine(ComputeConfiguration configuration, NodeIdentity nodeIdentity) {
+        this(configuration, nodeIdentity.nodeName());
+    }
+
     public InMemoryComputeStateMachine(ComputeConfiguration configuration, String nodeName) {
         this.configuration = configuration;
         this.nodeName = nodeName;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index aa52d7feb866..f2e697d09f13 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -71,15 +71,6 @@ public DeploymentConfiguration deploymentConfiguration(
         return nodeConfigRegistry.getConfiguration(DeploymentExtensionConfiguration.KEY).deployment();
     }
 
-    /** Creates the in-memory compute state machine. */
-    @Singleton
-    public InMemoryComputeStateMachine inMemoryComputeStateMachine(
-            ComputeConfiguration computeConfiguration,
-            NodeSeedParams seedParams
-    ) {
-        return new InMemoryComputeStateMachine(computeConfiguration, seedParams.nodeName());
-    }
-
     /** Creates the compute executor. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)

From bd0520b398e1b21596eea0ace5a81cec8a593a2a Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 14:03:03 +0400
Subject: [PATCH 33/79] Named beans for executors

---
 .../internal/app/ThreadPoolsManager.java      | 22 ++++++----
 .../internal/app/di/CatalogFactory.java       | 11 ++---
 .../internal/app/di/ClientHandlerFactory.java |  6 +--
 .../internal/app/di/DataPathFactory.java      | 40 +++++++++++--------
 .../internal/app/di/MetaStorageFactory.java   | 10 ++---
 .../app/di/NetworkComponentsFactory.java      | 18 +++++----
 .../ignite/internal/app/di/SqlFactory.java    | 10 ++---
 .../app/di/SystemServicesFactory.java         |  6 +--
 .../internal/app/di/TransactionFactory.java   | 32 ++++++++-------
 9 files changed, 88 insertions(+), 67 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
index a0c986e5bdd6..e63d9ab63798 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/ThreadPoolsManager.java
@@ -17,6 +17,7 @@
 
 package org.apache.ignite.internal.app;
 
+import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.apache.ignite.internal.metrics.sources.ThreadPoolMetricSource.THREAD_POOLS_METRICS_SOURCE_NAME;
 import static org.apache.ignite.internal.thread.ThreadOperation.PROCESS_RAFT_REQ;
@@ -25,8 +26,9 @@
 import static org.apache.ignite.internal.thread.ThreadOperation.TX_STATE_STORAGE_ACCESS;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
-import io.micronaut.core.annotation.Order;
+import io.micronaut.context.annotation.Factory;
 import jakarta.inject.Inject;
+import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
@@ -35,9 +37,7 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadPoolExecutor;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -50,9 +50,7 @@
 /**
  * Component that hosts thread pools which do not belong to a certain component and which are global to an Ignite instance.
  */
-@Singleton
-@IgniteStartupPhase(StartupPhase.PHASE_1)
-@Order(400)
+@Factory
 public class ThreadPoolsManager implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(ThreadPoolsManager.class);
 
@@ -107,9 +105,9 @@ public ThreadPoolsManager(String nodeName, MetricManager metricManager) {
                 )
         );
 
-        commonScheduler = Executors.newSingleThreadScheduledExecutor(IgniteThreadFactory.create(nodeName, "common-scheduler", LOG));
+        commonScheduler = newSingleThreadScheduledExecutor(IgniteThreadFactory.create(nodeName, "common-scheduler", LOG));
 
-        rebalanceScheduler = Executors.newSingleThreadScheduledExecutor(IgniteThreadFactory.create(nodeName, "rebalance-scheduler", LOG));
+        rebalanceScheduler = newSingleThreadScheduledExecutor(IgniteThreadFactory.create(nodeName, "rebalance-scheduler", LOG));
 
         this.metricManager = metricManager;
 
@@ -145,6 +143,8 @@ public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
     /**
      * Returns executor used to create/destroy storages, start partition Raft groups, create index storages...
      */
+    @Singleton
+    @Named("tableIoExecutor")
     public ScheduledExecutorService tableIoExecutor() {
         return tableIoExecutor;
     }
@@ -152,6 +152,8 @@ public ScheduledExecutorService tableIoExecutor() {
     /**
      * Returns the executor of partition operations.
      */
+    @Singleton
+    @Named("partitionOperationsExecutor")
     public ExecutorService partitionOperationsExecutor() {
         return partitionOperationsExecutor;
     }
@@ -159,11 +161,15 @@ public ExecutorService partitionOperationsExecutor() {
     /**
      * Returns a global {@link ScheduledExecutorService}. Only small tasks should be scheduled.
      */
+    @Singleton
+    @Named("commonScheduler")
     public ScheduledExecutorService commonScheduler() {
         return commonScheduler;
     }
 
     /** Returns executor for scheduling rebalance routine. */
+    @Singleton
+    @Named("rebalanceScheduler")
     public ScheduledExecutorService rebalanceScheduler() {
         return rebalanceScheduler;
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index f22629db9672..a4d19fd4d147 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -19,10 +19,11 @@
 
 import io.micronaut.context.annotation.Factory;
 import io.micronaut.core.annotation.Order;
+import jakarta.inject.Named;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
-import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.catalog.PartitionCountCalculatorWrapper;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
@@ -77,7 +78,7 @@ public ClockServiceImpl clockService(
     @Order(600)
     public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
             NodeSeedParams seedParams,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             MetaStorageManagerImpl metaStorageManager,
             RaftConfiguration raftConfiguration,
             ClockServiceImpl clockService,
@@ -85,7 +86,7 @@ public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
     ) {
         return new IdempotentCacheVacuumizer(
                 seedParams.nodeName(),
-                threadPoolsManager.commonScheduler(),
+                commonScheduler,
                 metaStorageManager::evictIdempotentCommandsCache,
                 raftConfiguration.retryTimeoutMillis(),
                 clockService,
@@ -133,7 +134,7 @@ public PlacementDriverManager placementDriverManager(
             ClockServiceImpl clockService,
             FailureManager failureManager,
             ReplicationConfiguration replicationConfiguration,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             MetricManager metricManager,
             Provider<DistributionZoneManager> distributionZoneManagerProvider
     ) {
@@ -149,7 +150,7 @@ public PlacementDriverManager placementDriverManager(
                 clockService,
                 failureManager,
                 replicationConfiguration,
-                threadPoolsManager.commonScheduler(),
+                commonScheduler,
                 metricManager,
                 zoneId -> distributionZoneManagerProvider.get().currentDataNodes(zoneId)
         );
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
index bed201076fb3..42cb116ffa8d 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -21,12 +21,12 @@
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
+import java.util.concurrent.ExecutorService;
 import org.apache.ignite.client.handler.ClientHandlerMetricSource;
 import org.apache.ignite.client.handler.ClientHandlerModule;
 import org.apache.ignite.client.handler.configuration.ClientConnectorConfiguration;
 import org.apache.ignite.client.handler.configuration.ClientConnectorExtensionConfiguration;
 import org.apache.ignite.internal.app.IgniteImpl;
-import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
@@ -99,7 +99,7 @@ public ClientHandlerModule clientHandlerModule(
             ClientConnectorConfiguration clientConnectorConfiguration,
             EventLogImpl eventLog,
             LowWatermarkImpl lowWatermark,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             SuggestionsConfiguration suggestionsConfiguration
     ) {
         return new ClientHandlerModule(
@@ -120,7 +120,7 @@ public ClientHandlerModule clientHandlerModule(
                 clientConnectorConfiguration,
                 eventLog,
                 lowWatermark,
-                threadPoolsManager.partitionOperationsExecutor(),
+                partitionOperationsExecutor,
                 () -> suggestionsConfiguration.sequentialDdlExecution().enabled().value()
         );
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 18c30a9b4617..500a4aa5f47e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -29,8 +29,9 @@
 import java.util.Map;
 import java.util.ServiceLoader;
 import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.function.LongSupplier;
-import org.apache.ignite.internal.app.ThreadPoolsManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
@@ -157,7 +158,7 @@ public ReplicaManager replicaManager(
             MetaStorageManagerImpl metaStorageManager,
             ClockServiceImpl clockService,
             PlacementDriverManager placementDriverManager,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             ReplicationConfiguration replicationConfiguration,
             FailureManager failureManager,
             CatalogValidationSchemasSource validationSchemasSource,
@@ -166,7 +167,9 @@ public ReplicaManager replicaManager(
             TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
             RaftManager raftManager,
             @Named("partitions") RaftGroupOptionsConfigurer partitionRaftConfigurer,
-            VolatileLogStorageManagerCreator volatileLogStorageManagerCreator
+            VolatileLogStorageManagerCreator volatileLogStorageManagerCreator,
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
     ) {
         return new ReplicaManager(
                 seedParams.nodeName(),
@@ -179,7 +182,7 @@ public ReplicaManager replicaManager(
                         TxMessageGroup.class
                 ),
                 placementDriverManager.placementDriver(),
-                threadPoolsManager.partitionOperationsExecutor(),
+                partitionOperationsExecutor,
                 () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
                 failureManager,
                 new ThreadLocalPartitionCommandsMarshaller(
@@ -190,13 +193,13 @@ public ReplicaManager replicaManager(
                 raftManager,
                 partitionRaftConfigurer,
                 volatileLogStorageManagerCreator,
-                threadPoolsManager.tableIoExecutor(),
+                tableIoExecutor,
                 replicaGrpId -> metaStorageManager.get(
                         pendingPartAssignmentsQueueKey((TablePartitionId) replicaGrpId)
                 ).thenApply(entry -> new VersionedAssignments(
                         entry.value(), entry.revision()
                 )),
-                threadPoolsManager.commonScheduler()
+                commonScheduler
         );
     }
 
@@ -213,7 +216,7 @@ public DataStorageManager dataStorageManager(
             FailureManager failureManager,
             @Named("partitions") LogStorageManager partitionsLogStorageManager,
             HybridClock clock,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             StorageConfiguration storageConfiguration
     ) {
         DataStorageModules dataStorageModules = new DataStorageModules(
@@ -231,7 +234,7 @@ public DataStorageManager dataStorageManager(
                 failureManager,
                 partitionsLogStorageManager.logSyncer(),
                 clock,
-                threadPoolsManager.commonScheduler()
+                commonScheduler
         );
 
         return new DataStorageManager(storageEngines, storageConfiguration);
@@ -313,7 +316,9 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
             ClusterService clusterService,
             LowWatermarkImpl lowWatermark,
             FailureManager failureManager,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
+            @Named("rebalanceScheduler") ScheduledExecutorService rebalanceScheduler,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             ClockServiceImpl clockService,
             PlacementDriverManager placementDriverManager,
             SchemaSyncServiceImpl schemaSyncService,
@@ -335,9 +340,9 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
                 clusterService.topologyService(),
                 lowWatermark,
                 failureManager,
-                threadPoolsManager.tableIoExecutor(),
-                threadPoolsManager.rebalanceScheduler(),
-                threadPoolsManager.partitionOperationsExecutor(),
+                tableIoExecutor,
+                rebalanceScheduler,
+                partitionOperationsExecutor,
                 clockService,
                 placementDriverManager.placementDriver(),
                 schemaSyncService,
@@ -377,7 +382,8 @@ public TableManager tableManager(
             MetaStorageManagerImpl metaStorageManager,
             SchemaManager schemaManager,
             CatalogValidationSchemasSource validationSchemasSource,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             ClockServiceImpl clockService,
             OutgoingSnapshotsManager outgoingSnapshotsManager,
             SchemaSyncServiceImpl schemaSyncService,
@@ -410,8 +416,8 @@ public TableManager tableManager(
                 metaStorageManager,
                 schemaManager,
                 validationSchemasSource,
-                threadPoolsManager.tableIoExecutor(),
-                threadPoolsManager.partitionOperationsExecutor(),
+                tableIoExecutor,
+                partitionOperationsExecutor,
                 clockService,
                 outgoingSnapshotsManager,
                 schemaSyncService,
@@ -449,7 +455,7 @@ public IndexManager indexManager(
             SchemaManager schemaManager,
             TableManager tableManager,
             CatalogManagerImpl catalogManager,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
             MetaStorageRevisionListenerRegistry revisionListenerRegistry,
             LowWatermarkImpl lowWatermark
     ) {
@@ -457,7 +463,7 @@ public IndexManager indexManager(
                 schemaManager,
                 tableManager,
                 catalogManager,
-                threadPoolsManager.tableIoExecutor(),
+                tableIoExecutor,
                 revisionListenerRegistry,
                 lowWatermark
         );
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index fc1fcf74d84f..fc5ea8ac0356 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -21,7 +21,7 @@
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
-import org.apache.ignite.internal.app.ThreadPoolsManager;
+import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
@@ -79,14 +79,14 @@ public RocksDbKeyValueStorage metastorageKeyValueStorage(
             @Named("metastorage") ComponentWorkingDir metastorageWorkDir,
             FailureManager failureManager,
             ReadOperationForCompactionTracker readOperationForCompactionTracker,
-            ThreadPoolsManager threadPoolsManager
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
     ) {
         return new RocksDbKeyValueStorage(
                 seedParams.nodeName(),
                 metastorageWorkDir.dbPath(),
                 failureManager,
                 readOperationForCompactionTracker,
-                threadPoolsManager.commonScheduler()
+                commonScheduler
         );
     }
 
@@ -121,7 +121,7 @@ public MetaStorageManagerImpl metaStorageManager(
             MetastorageRepairImpl metastorageRepair,
             @Named("metastorage") RaftGroupOptionsConfigurer msRaftConfigurer,
             ReadOperationForCompactionTracker readOperationForCompactionTracker,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
             FailureManager failureManager
     ) {
         return new MetaStorageManagerImpl(
@@ -137,7 +137,7 @@ public MetaStorageManagerImpl metaStorageManager(
                 metastorageRepair,
                 msRaftConfigurer,
                 readOperationForCompactionTracker,
-                threadPoolsManager.tableIoExecutor(),
+                tableIoExecutor,
                 failureManager
         );
     }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index 62fc08c35320..a8bc24cc22a6 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -21,7 +21,7 @@
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
-import org.apache.ignite.internal.app.ThreadPoolsManager;
+import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
@@ -81,12 +81,12 @@ public FailureManager failureManager(
     @Order(1000)
     public CriticalWorkerWatchdog criticalWorkerWatchdog(
             SystemLocalConfiguration systemConfiguration,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             FailureManager failureManager
     ) {
         return new CriticalWorkerWatchdog(
                 systemConfiguration.criticalWorkers(),
-                threadPoolsManager.commonScheduler(),
+                commonScheduler,
                 failureManager
         );
     }
@@ -105,14 +105,14 @@ public NettyBootstrapFactory nettyBootstrapFactory(NodeSeedParams seedParams, Ne
     @Order(1200)
     public NettyWorkersRegistrar nettyWorkersRegistrar(
             CriticalWorkerRegistry criticalWorkerRegistry,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             NettyBootstrapFactory nettyBootstrapFactory,
             SystemLocalConfiguration systemConfiguration,
             FailureManager failureManager
     ) {
         return new NettyWorkersRegistrar(
                 criticalWorkerRegistry,
-                threadPoolsManager.commonScheduler(),
+                commonScheduler,
                 nettyBootstrapFactory,
                 systemConfiguration.criticalWorkers(),
                 failureManager
@@ -123,8 +123,12 @@ public NettyWorkersRegistrar nettyWorkersRegistrar(
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
     @Order(500)
-    public ClockWaiter clockWaiter(NodeSeedParams seedParams, HybridClock clock, ThreadPoolsManager threadPoolsManager) {
-        return new ClockWaiter(seedParams.nodeName(), clock, threadPoolsManager.commonScheduler());
+    public ClockWaiter clockWaiter(
+            NodeSeedParams seedParams,
+            HybridClock clock,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
+    ) {
+        return new ClockWaiter(seedParams.nodeName(), clock, commonScheduler);
     }
 
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index e3ec7f5d1e55..b03b32f93135 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -21,7 +21,7 @@
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
-import org.apache.ignite.internal.app.ThreadPoolsManager;
+import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
@@ -103,7 +103,7 @@ public SqlQueryProcessor sqlQueryProcessor(
             TransactionInflights transactionInflights,
             TxManager txManager,
             LowWatermarkImpl lowWatermark,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             KillCommandHandler killCommandHandler,
             EventLogImpl eventLog
     ) {
@@ -125,7 +125,7 @@ public SqlQueryProcessor sqlQueryProcessor(
                 transactionInflights,
                 txManager,
                 lowWatermark,
-                threadPoolsManager.commonScheduler(),
+                commonScheduler,
                 killCommandHandler,
                 eventLog
         );
@@ -138,8 +138,8 @@ public SqlQueryProcessor sqlQueryProcessor(
     public IgniteSqlImpl igniteSql(
             SqlQueryProcessor sqlQueryProcessor,
             HybridTimestampTracker observableTimestampTracker,
-            ThreadPoolsManager threadPoolsManager
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
     ) {
-        return new IgniteSqlImpl(sqlQueryProcessor, observableTimestampTracker, threadPoolsManager.commonScheduler());
+        return new IgniteSqlImpl(sqlQueryProcessor, observableTimestampTracker, commonScheduler);
     }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index c5701703e85f..563fa65b63ab 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -22,7 +22,7 @@
 import jakarta.inject.Named;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
-import org.apache.ignite.internal.app.ThreadPoolsManager;
+import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
@@ -235,7 +235,7 @@ public ResourceVacuumManager resourceVacuumManager(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(2500)
     public DisasterRecoveryManager disasterRecoveryManager(
-            ThreadPoolsManager threadPoolsManager,
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
             @Named("storageOperations") MessagingService messagingService,
             MetaStorageManagerImpl metaStorageManager,
             CatalogManagerImpl catalogManager,
@@ -250,7 +250,7 @@ public DisasterRecoveryManager disasterRecoveryManager(
             SystemViewManagerImpl systemViewManager
     ) {
         return new DisasterRecoveryManager(
-                threadPoolsManager.tableIoExecutor(),
+                tableIoExecutor,
                 messagingService,
                 metaStorageManager,
                 catalogManager,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 4dc2cfb940cf..0d8ef5ee53d7 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -21,7 +21,8 @@
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
-import org.apache.ignite.internal.app.ThreadPoolsManager;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
@@ -85,12 +86,12 @@ public GcConfiguration gcConfiguration(@Named("clusterConfig") ConfigurationRegi
     public MessagingService storageOperationsMessagingService(
             ClusterService clusterService,
             NodeSeedParams seedParams,
-            ThreadPoolsManager threadPoolsManager
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor
     ) {
         return new JumpToExecutorByConsistentIdAfterSend(
                 clusterService.messagingService(),
                 seedParams.nodeName(),
-                message -> threadPoolsManager.partitionOperationsExecutor()
+                message -> partitionOperationsExecutor
         );
     }
 
@@ -101,15 +102,16 @@ public MessagingService storageOperationsMessagingService(
     public ReplicaService replicaService(
             @Named("storageOperations") MessagingService messagingService,
             ClockServiceImpl clockService,
-            ThreadPoolsManager threadPoolsManager,
-            ReplicationConfiguration replicationConfiguration
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
+            ReplicationConfiguration replicationConfiguration,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
     ) {
         return new ReplicaService(
                 messagingService,
                 clockService,
-                threadPoolsManager.partitionOperationsExecutor(),
+                partitionOperationsExecutor,
                 replicationConfiguration,
-                threadPoolsManager.commonScheduler()
+                commonScheduler
         );
     }
 
@@ -151,12 +153,13 @@ public TxManagerImpl txManager(
             PlacementDriverManager placementDriverManager,
             ReplicationConfiguration replicationConfiguration,
             IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             RemotelyTriggeredResourceRegistry resourcesRegistry,
             TransactionInflights transactionInflights,
             LowWatermark lowWatermark,
             FailureManager failureManager,
-            MetricManager metricManager
+            MetricManager metricManager,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
     ) {
         return new TxManagerImpl(
                 seedParams.nodeName(),
@@ -172,11 +175,11 @@ public TxManagerImpl txManager(
                 placementDriverManager.placementDriver(),
                 () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
                 indexNodeFinishedRwTransactionsChecker,
-                threadPoolsManager.partitionOperationsExecutor(),
+                partitionOperationsExecutor,
                 resourcesRegistry,
                 transactionInflights,
                 lowWatermark,
-                threadPoolsManager.commonScheduler(),
+                commonScheduler,
                 failureManager,
                 metricManager
         );
@@ -189,15 +192,16 @@ public TxManagerImpl txManager(
     public TxStateRocksDbSharedStorage txStateRocksDbSharedStorage(
             NodeSeedParams seedParams,
             @Named("partitions") ComponentWorkingDir partitionsWorkDir,
-            ThreadPoolsManager threadPoolsManager,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
             @Named("partitions") LogStorageManager partitionsLogStorageManager,
             FailureManager failureManager
     ) {
         return new TxStateRocksDbSharedStorage(
                 seedParams.nodeName(),
                 partitionsWorkDir.dbPath().resolve("tx-state"),
-                threadPoolsManager.commonScheduler(),
-                threadPoolsManager.tableIoExecutor(),
+                commonScheduler,
+                tableIoExecutor,
                 partitionsLogStorageManager.logSyncer(),
                 failureManager
         );

From 371091551488304c0081a5755caf4ca5c8013419 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 14:12:27 +0400
Subject: [PATCH 34/79] Small factories refactoring

---
 .../app/di/ClusterManagementFactory.java      | 15 ++++++++++
 .../internal/app/di/ComputeFactory.java       | 17 ++++++-----
 .../internal/app/di/DataPathFactory.java      | 29 ++++++++++---------
 .../internal/app/di/MetaStorageFactory.java   |  5 ++--
 .../ignite/internal/app/di/SqlFactory.java    |  5 ++--
 .../app/di/SystemServicesFactory.java         | 29 ++++++++++---------
 .../internal/app/di/TransactionFactory.java   |  9 +++---
 7 files changed, 67 insertions(+), 42 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index a7ce70c45d6b..6ab10acbd654 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -47,7 +47,9 @@
 import org.apache.ignite.internal.network.ChannelTypeRegistryProvider;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessageSerializationRegistryImpl;
+import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.NettyBootstrapFactory;
+import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
 import org.apache.ignite.internal.network.recovery.InMemoryStaleIds;
 import org.apache.ignite.internal.network.scalecube.ScaleCubeClusterService;
@@ -104,6 +106,19 @@ public ClusterService clusterService(
         );
     }
 
+    /** Exposes the cluster messaging service as a named bean. */
+    @Singleton
+    @Named("clusterMessaging")
+    public MessagingService clusterMessagingService(ClusterService clusterService) {
+        return clusterService.messagingService();
+    }
+
+    /** Exposes the cluster topology service as a bean. */
+    @Singleton
+    public TopologyService clusterTopologyService(ClusterService clusterService) {
+        return clusterService.topologyService();
+    }
+
     /** Creates the node attributes configuration from the node config registry. */
     @Singleton
     public NodeAttributesConfiguration nodeAttributesConfiguration(
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index f2e697d09f13..4e41dada51da 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -47,6 +47,8 @@
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.MessagingService;
+import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
 import org.apache.ignite.internal.table.distributed.TableManager;
 
@@ -79,7 +81,7 @@ public ComputeExecutorImpl computeExecutor(
             Provider<Ignite> igniteProvider,
             InMemoryComputeStateMachine stateMachine,
             ComputeConfiguration computeConfiguration,
-            ClusterService clusterService,
+            TopologyService topologyService,
             ClockServiceImpl clockService,
             EventLogImpl eventLog
     ) {
@@ -87,7 +89,7 @@ public ComputeExecutorImpl computeExecutor(
                 igniteProvider.get(),
                 stateMachine,
                 computeConfiguration,
-                clusterService.topologyService(),
+                topologyService,
                 clockService,
                 eventLog
         );
@@ -124,7 +126,8 @@ public DeploymentManagerImpl deploymentManager(
     @Order(1200)
     public ComputeComponentImpl computeComponent(
             NodeSeedParams seedParams,
-            ClusterService clusterService,
+            @Named("clusterMessaging") MessagingService clusterMessagingService,
+            TopologyService topologyService,
             LogicalTopologyService logicalTopologyService,
             DeploymentManagerImpl deploymentManager,
             ComputeExecutorImpl computeExecutor,
@@ -134,8 +137,8 @@ public ComputeComponentImpl computeComponent(
     ) {
         return new ComputeComponentImpl(
                 seedParams.nodeName(),
-                clusterService.messagingService(),
-                clusterService.topologyService(),
+                clusterMessagingService,
+                topologyService,
                 logicalTopologyService,
                 new UnitsContextManager(
                         deploymentManager,
@@ -156,7 +159,7 @@ public ComputeComponentImpl computeComponent(
     public IgniteComputeInternal igniteCompute(
             NodeSeedParams seedParams,
             PlacementDriverManager placementDriverManager,
-            ClusterService clusterService,
+            TopologyService topologyService,
             TableManager tableManager,
             ComputeComponentImpl computeComponent,
             HybridClock clock,
@@ -165,7 +168,7 @@ public IgniteComputeInternal igniteCompute(
         return new IgniteComputeImpl(
                 seedParams.nodeName(),
                 placementDriverManager.placementDriver(),
-                clusterService.topologyService(),
+                topologyService,
                 tableManager,
                 computeComponent,
                 clock,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 500a4aa5f47e..89035533a592 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -56,6 +56,7 @@
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
+import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
 import org.apache.ignite.internal.partition.replicator.network.PartitionReplicationMessageGroup;
 import org.apache.ignite.internal.partition.replicator.raft.snapshot.outgoing.OutgoingSnapshotsManager;
@@ -135,10 +136,10 @@ public SchemaSyncServiceImpl schemaSyncService(
     @Order(1600)
     public IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker(
             CatalogManagerImpl catalogManager,
-            ClusterService clusterService,
+            @Named("clusterMessaging") MessagingService clusterMessagingService,
             HybridClock clock
     ) {
-        return new IndexNodeFinishedRwTransactionsChecker(catalogManager, clusterService.messagingService(), clock);
+        return new IndexNodeFinishedRwTransactionsChecker(catalogManager, clusterMessagingService, clock);
     }
 
     /** Creates the observable hybrid timestamp tracker. */
@@ -246,10 +247,10 @@ public DataStorageManager dataStorageManager(
     @Order(2100)
     public OutgoingSnapshotsManager outgoingSnapshotsManager(
             NodeSeedParams seedParams,
-            ClusterService clusterService,
+            @Named("clusterMessaging") MessagingService clusterMessagingService,
             FailureManager failureManager
     ) {
-        return new OutgoingSnapshotsManager(seedParams.nodeName(), clusterService.messagingService(), failureManager);
+        return new OutgoingSnapshotsManager(seedParams.nodeName(), clusterMessagingService, failureManager);
     }
 
     /** Creates the low watermark. */
@@ -262,7 +263,7 @@ public LowWatermarkImpl lowWatermark(
             ClockServiceImpl clockService,
             VaultManager vaultManager,
             FailureManager failureManager,
-            ClusterService clusterService
+            @Named("clusterMessaging") MessagingService clusterMessagingService
     ) {
         return new LowWatermarkImpl(
                 seedParams.nodeName(),
@@ -270,7 +271,7 @@ public LowWatermarkImpl lowWatermark(
                 clockService,
                 vaultManager,
                 failureManager,
-                clusterService.messagingService()
+                clusterMessagingService
         );
     }
 
@@ -280,7 +281,7 @@ public LowWatermarkImpl lowWatermark(
     @Order(1100)
     public DistributionZoneManager distributionZoneManager(
             NodeSeedParams seedParams,
-            ClusterService clusterService,
+            TopologyService topologyService,
             MetaStorageManagerImpl metaStorageManager,
             LogicalTopologyService logicalTopologyService,
             FailureManager failureManager,
@@ -292,7 +293,7 @@ public DistributionZoneManager distributionZoneManager(
     ) {
         return new DistributionZoneManager(
                 seedParams.nodeName(),
-                () -> clusterService.topologyService().localMember().id(),
+                () -> topologyService.localMember().id(),
                 metaStorageManager,
                 logicalTopologyService,
                 failureManager,
@@ -313,7 +314,7 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
             ReplicaManager replicaManager,
             DistributionZoneManager distributionZoneManager,
             MetaStorageManagerImpl metaStorageManager,
-            ClusterService clusterService,
+            TopologyService topologyService,
             LowWatermarkImpl lowWatermark,
             FailureManager failureManager,
             @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
@@ -337,7 +338,7 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
                 replicaManager,
                 distributionZoneManager,
                 metaStorageManager,
-                clusterService.topologyService(),
+                topologyService,
                 lowWatermark,
                 failureManager,
                 tableIoExecutor,
@@ -374,7 +375,7 @@ public TableManager tableManager(
             GcConfiguration gcConfiguration,
             ReplicationConfiguration replicationConfiguration,
             @Named("storageOperations") MessagingService messagingService,
-            ClusterService clusterService,
+            TopologyService topologyService,
             LockManager lockManager,
             ReplicaService replicaService,
             TxManager txManager,
@@ -408,7 +409,7 @@ public TableManager tableManager(
                 gcConfiguration,
                 replicationConfiguration,
                 messagingService,
-                clusterService.topologyService(),
+                topologyService,
                 lockManager,
                 replicaService,
                 txManager,
@@ -442,9 +443,9 @@ public TableManager tableManager(
     @Singleton
     public PartitionModificationCounterFactory partitionModificationCounterFactory(
             ClockServiceImpl clockService,
-            ClusterService clusterService
+            @Named("clusterMessaging") MessagingService clusterMessagingService
     ) {
-        return new PartitionModificationCounterFactory(clockService::current, clusterService.messagingService());
+        return new PartitionModificationCounterFactory(clockService::current, clusterMessagingService);
     }
 
     /** Creates the index manager. */
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index fc5ea8ac0356..37658afee5a7 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -44,6 +44,7 @@
 import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.raft.Loza;
 import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
 import org.apache.ignite.internal.raft.RaftManager;
@@ -93,12 +94,12 @@ public RocksDbKeyValueStorage metastorageKeyValueStorage(
     /** Creates the metastorage repair implementation. */
     @Singleton
     public MetastorageRepairImpl metastorageRepair(
-            ClusterService clusterService,
+            @Named("clusterMessaging") MessagingService clusterMessagingService,
             LogicalTopologyImpl logicalTopology,
             ClusterManagementGroupManager cmgManager
     ) {
         return new MetastorageRepairImpl(
-                clusterService.messagingService(),
+                clusterMessagingService,
                 logicalTopology,
                 cmgManager
         );
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index b03b32f93135..929113a5cdfb 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -34,6 +34,7 @@
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.schema.SchemaManager;
@@ -76,9 +77,9 @@ public SqlLocalConfiguration sqlLocalConfiguration(
     public KillCommandHandler killCommandHandler(
             NodeSeedParams seedParams,
             LogicalTopologyService logicalTopologyService,
-            ClusterService clusterService
+            @Named("clusterMessaging") MessagingService clusterMessagingService
     ) {
-        return new KillCommandHandler(seedParams.nodeName(), logicalTopologyService, clusterService.messagingService());
+        return new KillCommandHandler(seedParams.nodeName(), logicalTopologyService, clusterMessagingService);
     }
 
     /** Creates the SQL query processor. */
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 563fa65b63ab..1e277a9b6ee4 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -48,8 +48,8 @@
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.metrics.logstorage.LogStorageMetrics;
 import org.apache.ignite.internal.metrics.messaging.MetricMessaging;
-import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
+import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
 import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
 import org.apache.ignite.internal.raft.Loza;
@@ -94,7 +94,8 @@ public EventLogImpl eventLog(
     @Order(900)
     public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
             NodeSeedParams seedParams,
-            ClusterService clusterService,
+            TopologyService topologyService,
+            @Named("clusterMessaging") MessagingService clusterMessagingService,
             VaultManager vaultManager,
             MetaStorageManagerImpl metaStorageManager,
             ClusterManagementGroupManager cmgManager,
@@ -102,8 +103,8 @@ public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
     ) {
         return new SystemDisasterRecoveryManagerImpl(
                 seedParams.nodeName(),
-                clusterService.topologyService(),
-                clusterService.messagingService(),
+                topologyService,
+                clusterMessagingService,
                 vaultManager,
                 seedParams.restarter(),
                 metaStorageManager,
@@ -141,7 +142,8 @@ public MetaStorageCompactionTrigger metaStorageCompactionTrigger(
     public CatalogCompactionRunner catalogCompactionRunner(
             NodeSeedParams seedParams,
             CatalogManagerImpl catalogManager,
-            ClusterService clusterService,
+            @Named("clusterMessaging") MessagingService clusterMessagingService,
+            TopologyService topologyService,
             LogicalTopologyService logicalTopologyService,
             PlacementDriverManager placementDriverManager,
             ReplicaService replicaService,
@@ -155,13 +157,13 @@ public CatalogCompactionRunner catalogCompactionRunner(
         return new CatalogCompactionRunner(
                 seedParams.nodeName(),
                 catalogManager,
-                clusterService.messagingService(),
+                clusterMessagingService,
                 logicalTopologyService,
                 placementDriverManager.placementDriver(),
                 replicaService,
                 clockService,
                 schemaSyncService,
-                clusterService.topologyService(),
+                topologyService,
                 lowWatermark,
                 indexNodeFinishedRwTransactionsChecker,
                 minTimeCollectorService,
@@ -197,9 +199,10 @@ public LogStorageMetrics logStorageMetrics(
     @Order(1000)
     public MetricMessaging metricMessaging(
             MetricManager metricManager,
-            ClusterService clusterService
+            @Named("clusterMessaging") MessagingService clusterMessagingService,
+            TopologyService topologyService
     ) {
-        return new MetricMessaging(metricManager, clusterService.messagingService(), clusterService.topologyService());
+        return new MetricMessaging(metricManager, clusterMessagingService, topologyService);
     }
 
     /** Creates the resource vacuum manager. */
@@ -209,7 +212,7 @@ public MetricMessaging metricMessaging(
     public ResourceVacuumManager resourceVacuumManager(
             NodeSeedParams seedParams,
             RemotelyTriggeredResourceRegistry resourcesRegistry,
-            ClusterService clusterService,
+            TopologyService topologyService,
             @Named("storageOperations") MessagingService messagingService,
             TransactionInflights transactionInflights,
             TxManager txManager,
@@ -220,7 +223,7 @@ public ResourceVacuumManager resourceVacuumManager(
         return new ResourceVacuumManager(
                 seedParams.nodeName(),
                 resourcesRegistry,
-                clusterService.topologyService(),
+                topologyService,
                 messagingService,
                 transactionInflights,
                 txManager,
@@ -241,7 +244,7 @@ public DisasterRecoveryManager disasterRecoveryManager(
             CatalogManagerImpl catalogManager,
             DistributionZoneManager distributionZoneManager,
             Loza raftManager,
-            ClusterService clusterService,
+            TopologyService topologyService,
             LogicalTopologyService logicalTopologyService,
             TableManager tableManager,
             MetricManager metricManager,
@@ -256,7 +259,7 @@ public DisasterRecoveryManager disasterRecoveryManager(
                 catalogManager,
                 distributionZoneManager,
                 raftManager,
-                clusterService.topologyService(),
+                topologyService,
                 logicalTopologyService,
                 tableManager,
                 metricManager,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 0d8ef5ee53d7..1b49d5317429 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -36,6 +36,7 @@
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
+import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.network.wrapper.JumpToExecutorByConsistentIdAfterSend;
 import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
 import org.apache.ignite.internal.raft.storage.LogStorageManager;
@@ -84,12 +85,12 @@ public GcConfiguration gcConfiguration(@Named("clusterConfig") ConfigurationRegi
     @Singleton
     @Named("storageOperations")
     public MessagingService storageOperationsMessagingService(
-            ClusterService clusterService,
+            @Named("clusterMessaging") MessagingService clusterMessagingService,
             NodeSeedParams seedParams,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor
     ) {
         return new JumpToExecutorByConsistentIdAfterSend(
-                clusterService.messagingService(),
+                clusterMessagingService,
                 seedParams.nodeName(),
                 message -> partitionOperationsExecutor
         );
@@ -144,7 +145,7 @@ public TxManagerImpl txManager(
             TransactionConfiguration txConfig,
             SystemDistributedConfiguration systemDistributedConfiguration,
             @Named("storageOperations") MessagingService messagingService,
-            ClusterService clusterService,
+            TopologyService topologyService,
             ReplicaService replicaService,
             LockManager lockManager,
             VolatileTxStateMetaStorage txStateVolatileStorage,
@@ -166,7 +167,7 @@ public TxManagerImpl txManager(
                 txConfig,
                 systemDistributedConfiguration,
                 messagingService,
-                clusterService.topologyService(),
+                topologyService,
                 replicaService,
                 lockManager,
                 txStateVolatileStorage,

From e1eb9b56f84e40a1932a8527ce6db6d5587cac16 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 14:17:17 +0400
Subject: [PATCH 35/79] Refactor affecting placement driver

---
 .../ignite/internal/app/di/CatalogFactory.java |  7 +++++++
 .../internal/app/di/ClientHandlerFactory.java  |  6 +++---
 .../ignite/internal/app/di/ComputeFactory.java |  6 +++---
 .../internal/app/di/DataPathFactory.java       | 18 +++++++++---------
 .../ignite/internal/app/di/SqlFactory.java     |  6 +++---
 .../internal/app/di/SystemServicesFactory.java |  6 +++---
 .../internal/app/di/TransactionFactory.java    | 10 +++++-----
 7 files changed, 33 insertions(+), 26 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index a4d19fd4d147..652da91d1539 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -43,6 +43,7 @@
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.metrics.sources.ClockServiceMetricSource;
 import org.apache.ignite.internal.network.ClusterService;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
 import org.apache.ignite.internal.raft.RaftManager;
 import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
@@ -155,5 +156,11 @@ public PlacementDriverManager placementDriverManager(
                 zoneId -> distributionZoneManagerProvider.get().currentDataNodes(zoneId)
         );
     }
+
+    /** Exposes the placement driver as a bean. */
+    @Singleton
+    public PlacementDriver placementDriver(PlacementDriverManager placementDriverManager) {
+        return placementDriverManager.placementDriver();
+    }
 }
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
index 42cb116ffa8d..16959a494b25 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -40,7 +40,7 @@
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.NettyBootstrapFactory;
-import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.security.authentication.AuthenticationManager;
 import org.apache.ignite.internal.security.configuration.SecurityConfiguration;
 import org.apache.ignite.internal.security.configuration.SecurityExtensionConfiguration;
@@ -95,7 +95,7 @@ public ClientHandlerModule clientHandlerModule(
             ClockServiceImpl clockService,
             SchemaSyncServiceImpl schemaSyncService,
             CatalogManagerImpl catalogManager,
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             ClientConnectorConfiguration clientConnectorConfiguration,
             EventLogImpl eventLog,
             LowWatermarkImpl lowWatermark,
@@ -116,7 +116,7 @@ public ClientHandlerModule clientHandlerModule(
                 clockService,
                 schemaSyncService,
                 catalogManager,
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 clientConnectorConfiguration,
                 eventLog,
                 lowWatermark,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index 4e41dada51da..a69f0be4f54c 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -49,7 +49,7 @@
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
-import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.table.distributed.TableManager;
 
 /**
@@ -158,7 +158,7 @@ public ComputeComponentImpl computeComponent(
     @Order(1300)
     public IgniteComputeInternal igniteCompute(
             NodeSeedParams seedParams,
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             TopologyService topologyService,
             TableManager tableManager,
             ComputeComponentImpl computeComponent,
@@ -167,7 +167,7 @@ public IgniteComputeInternal igniteCompute(
     ) {
         return new IgniteComputeImpl(
                 seedParams.nodeName(),
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 topologyService,
                 tableManager,
                 computeComponent,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 89035533a592..6d1d346962c5 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -61,7 +61,7 @@
 import org.apache.ignite.internal.partition.replicator.network.PartitionReplicationMessageGroup;
 import org.apache.ignite.internal.partition.replicator.raft.snapshot.outgoing.OutgoingSnapshotsManager;
 import org.apache.ignite.internal.partition.replicator.schema.CatalogValidationSchemasSource;
-import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
 import org.apache.ignite.internal.raft.RaftManager;
 import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
@@ -158,7 +158,7 @@ public ReplicaManager replicaManager(
             ClusterManagementGroupManager cmgManager,
             MetaStorageManagerImpl metaStorageManager,
             ClockServiceImpl clockService,
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             ReplicationConfiguration replicationConfiguration,
             FailureManager failureManager,
@@ -182,7 +182,7 @@ public ReplicaManager replicaManager(
                         PartitionReplicationMessageGroup.class,
                         TxMessageGroup.class
                 ),
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 partitionOperationsExecutor,
                 () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
                 failureManager,
@@ -321,7 +321,7 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
             @Named("rebalanceScheduler") ScheduledExecutorService rebalanceScheduler,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             ClockServiceImpl clockService,
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             SchemaSyncServiceImpl schemaSyncService,
             SystemDistributedConfiguration systemDistributedConfiguration,
             TxStateRocksDbSharedStorage sharedTxStateStorage,
@@ -345,7 +345,7 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
                 rebalanceScheduler,
                 partitionOperationsExecutor,
                 clockService,
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 schemaSyncService,
                 systemDistributedConfiguration,
                 sharedTxStateStorage,
@@ -391,7 +391,7 @@ public TableManager tableManager(
             CatalogManagerImpl catalogManager,
             FailureManager failureManager,
             HybridTimestampTracker observableTimestampTracker,
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             Provider<IgniteSql> sqlProvider,
             RemotelyTriggeredResourceRegistry resourcesRegistry,
             LowWatermarkImpl lowWatermark,
@@ -425,7 +425,7 @@ public TableManager tableManager(
                 catalogManager,
                 failureManager,
                 observableTimestampTracker,
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 sqlProvider::get,
                 resourcesRegistry,
                 lowWatermark,
@@ -481,7 +481,7 @@ public IndexBuildingManager indexBuildingManager(
             MetaStorageManagerImpl metaStorageManager,
             IndexManager indexManager,
             IndexMetaStorage indexMetaStorage,
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             ClusterService clusterService,
             LogicalTopologyService logicalTopologyService,
             ClockServiceImpl clockService,
@@ -498,7 +498,7 @@ public IndexBuildingManager indexBuildingManager(
                 metaStorageManager,
                 indexManager,
                 indexMetaStorage,
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 clusterService,
                 logicalTopologyService,
                 clockService,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index 929113a5cdfb..bdf62a89facf 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -35,7 +35,7 @@
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
-import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.schema.SchemaManager;
 import org.apache.ignite.internal.sql.api.IgniteSqlImpl;
@@ -98,7 +98,7 @@ public SqlQueryProcessor sqlQueryProcessor(
             MetricManager metricManager,
             SystemViewManagerImpl systemViewManager,
             FailureManager failureManager,
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             SqlDistributedConfiguration sqlDistributedConfiguration,
             SqlLocalConfiguration sqlLocalConfiguration,
             TransactionInflights transactionInflights,
@@ -120,7 +120,7 @@ public SqlQueryProcessor sqlQueryProcessor(
                 metricManager,
                 systemViewManager,
                 failureManager,
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 sqlDistributedConfiguration,
                 sqlLocalConfiguration,
                 transactionInflights,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 1e277a9b6ee4..ea1d88adc7d2 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -51,7 +51,7 @@
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
-import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.raft.Loza;
 import org.apache.ignite.internal.raft.storage.LogStorageManager;
 import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
@@ -145,7 +145,7 @@ public CatalogCompactionRunner catalogCompactionRunner(
             @Named("clusterMessaging") MessagingService clusterMessagingService,
             TopologyService topologyService,
             LogicalTopologyService logicalTopologyService,
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             ReplicaService replicaService,
             ClockServiceImpl clockService,
             SchemaSyncServiceImpl schemaSyncService,
@@ -159,7 +159,7 @@ public CatalogCompactionRunner catalogCompactionRunner(
                 catalogManager,
                 clusterMessagingService,
                 logicalTopologyService,
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 replicaService,
                 clockService,
                 schemaSyncService,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 1b49d5317429..0c83a0562725 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -38,7 +38,7 @@
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.network.wrapper.JumpToExecutorByConsistentIdAfterSend;
-import org.apache.ignite.internal.placementdriver.PlacementDriverManager;
+import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.raft.storage.LogStorageManager;
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
@@ -119,12 +119,12 @@ public ReplicaService replicaService(
     /** Creates the transaction inflights tracker. */
     @Singleton
     public TransactionInflights transactionInflights(
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             ClockServiceImpl clockService,
             VolatileTxStateMetaStorage txStateVolatileStorage
     ) {
         return new TransactionInflights(
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 clockService,
                 txStateVolatileStorage
         );
@@ -151,7 +151,7 @@ public TxManagerImpl txManager(
             VolatileTxStateMetaStorage txStateVolatileStorage,
             ClockServiceImpl clockService,
             TransactionIdGenerator transactionIdGenerator,
-            PlacementDriverManager placementDriverManager,
+            PlacementDriver placementDriver,
             ReplicationConfiguration replicationConfiguration,
             IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
@@ -173,7 +173,7 @@ public TxManagerImpl txManager(
                 txStateVolatileStorage,
                 clockService,
                 transactionIdGenerator,
-                placementDriverManager.placementDriver(),
+                placementDriver,
                 () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
                 indexNodeFinishedRwTransactionsChecker,
                 partitionOperationsExecutor,

From 7984a94f6a638e93dc409e6958810d30142133cd Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 14:20:36 +0400
Subject: [PATCH 36/79] Migrate more components

---
 modules/configuration-storage/build.gradle    |  3 +++
 .../DistributedConfigurationStorage.java      | 11 ++++++++
 modules/index/build.gradle                    |  2 ++
 ...ndexNodeFinishedRwTransactionsChecker.java | 18 +++++++++++++
 .../internal/app/di/MetaStorageFactory.java   | 25 -------------------
 .../internal/app/di/TransactionFactory.java   | 14 -----------
 .../system/MetastorageRepairImpl.java         |  7 +++++-
 .../tx/impl/TransactionInflights.java         |  4 +++
 8 files changed, 44 insertions(+), 40 deletions(-)

diff --git a/modules/configuration-storage/build.gradle b/modules/configuration-storage/build.gradle
index bf1f6da720f2..b63490177278 100644
--- a/modules/configuration-storage/build.gradle
+++ b/modules/configuration-storage/build.gradle
@@ -22,8 +22,11 @@ apply from: "$rootDir/buildscripts/publishing.gradle"
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-metastorage-api')
+    implementation project(':ignite-metastorage')
+    implementation libs.micronaut.inject
     implementation project(':ignite-configuration-api')
     implementation project(':ignite-configuration')
     implementation project(':ignite-core')
diff --git a/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java b/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java
index 90c4b5d5c83f..6a8028b9b9ed 100644
--- a/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java
+++ b/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java
@@ -23,6 +23,8 @@
 import static org.apache.ignite.internal.util.CompletableFutures.falseCompletedFuture;
 import static org.apache.ignite.internal.util.StringUtils.toStringWithoutPrefix;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -36,6 +38,7 @@
 import java.util.concurrent.Flow.Subscription;
 import java.util.concurrent.TimeUnit;
 import org.apache.ignite.configuration.annotation.ConfigurationType;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.configuration.util.ConfigurationSerializationUtil;
 import org.apache.ignite.internal.future.InFlightFutures;
 import org.apache.ignite.internal.lang.ByteArray;
@@ -44,6 +47,7 @@
 import org.apache.ignite.internal.metastorage.Entry;
 import org.apache.ignite.internal.metastorage.EntryEvent;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
+import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.metastorage.dsl.Condition;
 import org.apache.ignite.internal.metastorage.dsl.Operation;
 import org.apache.ignite.internal.metastorage.dsl.Operations;
@@ -55,6 +59,7 @@
 /**
  * Distributed configuration storage.
  */
+@Singleton
 public class DistributedConfigurationStorage implements ConfigurationStorage {
     /** Logger. */
     private static final IgniteLogger LOG = Loggers.forClass(DistributedConfigurationStorage.class);
@@ -93,6 +98,12 @@ public class DistributedConfigurationStorage implements ConfigurationStorage {
 
     private final InFlightFutures futureTracker = new InFlightFutures();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public DistributedConfigurationStorage(NodeIdentity nodeIdentity, MetaStorageManagerImpl metaStorageManager) {
+        this(nodeIdentity.nodeName(), metaStorageManager);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/index/build.gradle b/modules/index/build.gradle
index 7313e8efd76d..ce97ce498836 100644
--- a/modules/index/build.gradle
+++ b/modules/index/build.gradle
@@ -23,6 +23,7 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 dependencies {
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-api')
     implementation project(':ignite-catalog')
@@ -43,6 +44,7 @@ dependencies {
     implementation project(':ignite-partition-distribution')
     implementation project(':ignite-failure-handler')
     implementation libs.jetbrains.annotations
+    implementation libs.micronaut.inject
 
     testImplementation testFixtures(project(':ignite-configuration'))
     testImplementation testFixtures(project(':ignite-core'))
diff --git a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java
index f01b1faaffa0..38d22e2db27d 100644
--- a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java
+++ b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java
@@ -31,7 +31,13 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Supplier;
 import org.apache.ignite.internal.catalog.Catalog;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.catalog.CatalogService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.index.message.IndexMessageGroup;
@@ -52,6 +58,8 @@
  * Local node RW transaction completion checker for indexes. Main task is to handle the
  * {@link IsNodeFinishedRwTransactionsStartedBeforeRequest}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
 public class IndexNodeFinishedRwTransactionsChecker implements LocalRwTxCounter, ActiveLocalTxMinimumRequiredTimeProvider,
         IgniteComponent {
     private static final IndexMessagesFactory FACTORY = new IndexMessagesFactory();
@@ -72,6 +80,16 @@ public class IndexNodeFinishedRwTransactionsChecker implements LocalRwTxCounter,
 
     private final AtomicBoolean stopGuard = new AtomicBoolean();
 
+    /** Constructor for dependency injection. */
+    @Inject
+    public IndexNodeFinishedRwTransactionsChecker(
+            CatalogManagerImpl catalogManager,
+            @Named("clusterMessaging") MessagingService messagingService,
+            HybridClock clock
+    ) {
+        this((CatalogService) catalogManager, messagingService, clock);
+    }
+
     /** Constructor. */
     public IndexNodeFinishedRwTransactionsChecker(
             CatalogService catalogService,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index 37658afee5a7..5a02ce3d8143 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -25,7 +25,6 @@
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
-import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
@@ -44,7 +43,6 @@
 import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
-import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.raft.Loza;
 import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
 import org.apache.ignite.internal.raft.RaftManager;
@@ -91,20 +89,6 @@ public RocksDbKeyValueStorage metastorageKeyValueStorage(
         );
     }
 
-    /** Creates the metastorage repair implementation. */
-    @Singleton
-    public MetastorageRepairImpl metastorageRepair(
-            @Named("clusterMessaging") MessagingService clusterMessagingService,
-            LogicalTopologyImpl logicalTopology,
-            ClusterManagementGroupManager cmgManager
-    ) {
-        return new MetastorageRepairImpl(
-                clusterMessagingService,
-                logicalTopology,
-                cmgManager
-        );
-    }
-
     /** Creates the MetaStorage manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
@@ -143,15 +127,6 @@ public MetaStorageManagerImpl metaStorageManager(
         );
     }
 
-    /** Creates the distributed configuration storage backed by MetaStorage. */
-    @Singleton
-    public DistributedConfigurationStorage distributedConfigurationStorage(
-            NodeSeedParams seedParams,
-            MetaStorageManagerImpl metaStorageManager
-    ) {
-        return new DistributedConfigurationStorage(seedParams.nodeName(), metaStorageManager);
-    }
-
     /** Creates the cluster (distributed) configuration registry. */
     @Singleton
     @Named("clusterConfig")
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 0c83a0562725..0bce12b2b36f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -116,20 +116,6 @@ public ReplicaService replicaService(
         );
     }
 
-    /** Creates the transaction inflights tracker. */
-    @Singleton
-    public TransactionInflights transactionInflights(
-            PlacementDriver placementDriver,
-            ClockServiceImpl clockService,
-            VolatileTxStateMetaStorage txStateVolatileStorage
-    ) {
-        return new TransactionInflights(
-                placementDriver,
-                clockService,
-                txStateVolatileStorage
-        );
-    }
-
     /** Creates the transaction ID generator. */
     @Singleton
     public TransactionIdGenerator transactionIdGenerator(ClusterService clusterService) {
diff --git a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/MetastorageRepairImpl.java b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/MetastorageRepairImpl.java
index 2c5accaea8b4..bf4ac78b155c 100644
--- a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/MetastorageRepairImpl.java
+++ b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/MetastorageRepairImpl.java
@@ -23,6 +23,9 @@
 import static org.apache.ignite.internal.util.CollectionUtils.difference;
 import static org.apache.ignite.internal.util.CompletableFutures.allOf;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
@@ -50,6 +53,7 @@
 /**
  * Implementation of {@link MetastorageRepair}.
  */
+@Singleton
 public class MetastorageRepairImpl implements MetastorageRepair {
     private static final IgniteLogger LOG = Loggers.forClass(MetastorageRepairImpl.class);
 
@@ -63,8 +67,9 @@ public class MetastorageRepairImpl implements MetastorageRepair {
     private final SystemDisasterRecoveryMessagesFactory messagesFactory = new SystemDisasterRecoveryMessagesFactory();
 
     /** Constructor. */
+    @Inject
     public MetastorageRepairImpl(
-            MessagingService messagingService,
+            @Named("clusterMessaging") MessagingService messagingService,
             LogicalTopology logicalTopology,
             ClusterManagementGroupManager cmgManager
     ) {
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionInflights.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionInflights.java
index 83934e5773a2..1ef0e11833da 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionInflights.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionInflights.java
@@ -27,6 +27,8 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.unwrapCause;
 import static org.apache.ignite.lang.ErrorGroups.Transactions.TX_PRIMARY_REPLICA_EXPIRED_ERR;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.Map;
 import java.util.Map.Entry;
@@ -50,6 +52,7 @@
  * Read-only transactions can't be included into {@link org.apache.ignite.internal.tx.message.FinishedTransactionsBatchMessage} when
  * some requests are in-flight.
  */
+@Singleton
 public class TransactionInflights {
     /** Hint for maximum concurrent txns. */
     private static final int MAX_CONCURRENT_TXNS = 1024;
@@ -70,6 +73,7 @@ public class TransactionInflights {
      * @param clockService Clock service.
      * @param txStateVolatileStorage Volatile transaction meta storage.
      */
+    @Inject
     public TransactionInflights(
             PlacementDriver placementDriver,
             ClockService clockService,

From 861d84a23b225b28a58b3173e80e0fa2fc49864d Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 14:50:22 +0400
Subject: [PATCH 37/79] Migrate remaining components to dependency injection

---
 .../ignite/internal/hlc/ClockWaiter.java      | 16 ++++++++++++
 modules/network/build.gradle                  |  2 ++
 .../network/NettyBootstrapFactory.java        | 15 +++++++++++
 .../app/di/NetworkComponentsFactory.java      | 22 ----------------
 .../ignite/internal/app/di/SqlFactory.java    | 24 -----------------
 modules/sql-engine/build.gradle               |  2 ++
 .../internal/sql/api/IgniteSqlImpl.java       | 26 +++++++++++++++++++
 .../engine/exec/kill/KillCommandHandler.java  | 15 +++++++++++
 8 files changed, 76 insertions(+), 46 deletions(-)

diff --git a/modules/core/src/main/java/org/apache/ignite/internal/hlc/ClockWaiter.java b/modules/core/src/main/java/org/apache/ignite/internal/hlc/ClockWaiter.java
index cef1c7d7b503..af73bac73b22 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/hlc/ClockWaiter.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/hlc/ClockWaiter.java
@@ -21,6 +21,10 @@
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedBlockingQueue;
@@ -29,6 +33,9 @@
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -41,6 +48,9 @@
  * Allows to wait for the supplied clock to reach a required timestamp. It only uses the clock itself,
  * no SafeTime mechanisms are involved.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(500)
 public class ClockWaiter implements IgniteComponent {
     private final HybridClock clock;
 
@@ -60,6 +70,12 @@ public class ClockWaiter implements IgniteComponent {
     /** Executor that executes completion of futures returned to the user, so it might take arbitrarily heavy operations. */
     private final ExecutorService futureExecutor;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public ClockWaiter(NodeIdentity identity, HybridClock clock, @Named("commonScheduler") ScheduledExecutorService scheduler) {
+        this(identity.nodeName(), clock, scheduler);
+    }
+
     /**
      * Creates a new {@link ClockWaiter}.
      *
diff --git a/modules/network/build.gradle b/modules/network/build.gradle
index bf931fa03ccd..d86747934f40 100644
--- a/modules/network/build.gradle
+++ b/modules/network/build.gradle
@@ -43,11 +43,13 @@ dependencies {
     implementation libs.jackson.core
     implementation libs.jackson.databind
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
     compileOnly libs.jsr305 // Fix unknown enum constant warning
 
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     testAnnotationProcessor project(':ignite-network-annotation-processor')
     testAnnotationProcessor libs.jmh.annotation.processor
diff --git a/modules/network/src/main/java/org/apache/ignite/internal/network/NettyBootstrapFactory.java b/modules/network/src/main/java/org/apache/ignite/internal/network/NettyBootstrapFactory.java
index f2bcff10105a..ef79e028a96f 100644
--- a/modules/network/src/main/java/org/apache/ignite/internal/network/NettyBootstrapFactory.java
+++ b/modules/network/src/main/java/org/apache/ignite/internal/network/NettyBootstrapFactory.java
@@ -21,6 +21,7 @@
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.ChannelOption;
@@ -29,9 +30,14 @@
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.channel.socket.nio.NioSocketChannel;
 import io.netty.util.concurrent.EventExecutor;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 import org.apache.ignite.internal.network.configuration.InboundView;
@@ -46,6 +52,9 @@
 /**
  * Netty bootstrap factory. Holds shared {@link EventLoopGroup} instances and encapsulates common Netty {@link Bootstrap} creation logic.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1100)
 public class NettyBootstrapFactory implements IgniteComponent {
     /** Network configuration. */
     private final NetworkConfiguration networkConfiguration;
@@ -61,6 +70,12 @@ public class NettyBootstrapFactory implements IgniteComponent {
 
     private volatile HandshakeEventLoopSwitcher handshakeEventLoopSwitcher;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public NettyBootstrapFactory(NetworkConfiguration networkConfiguration, NodeIdentity nodeIdentity) {
+        this(networkConfiguration, nodeIdentity.nodeName());
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index a8bc24cc22a6..5c0b6ed0910b 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -30,8 +30,6 @@
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
-import org.apache.ignite.internal.hlc.ClockWaiter;
-import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.network.NettyBootstrapFactory;
 import org.apache.ignite.internal.network.NettyWorkersRegistrar;
 import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
@@ -91,14 +89,6 @@ public CriticalWorkerWatchdog criticalWorkerWatchdog(
         );
     }
 
-    /** Creates the netty bootstrap factory. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(1100)
-    public NettyBootstrapFactory nettyBootstrapFactory(NodeSeedParams seedParams, NetworkConfiguration networkConfiguration) {
-        return new NettyBootstrapFactory(networkConfiguration, seedParams.nodeName());
-    }
-
     /** Creates the netty workers registrar. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
@@ -119,16 +109,4 @@ public NettyWorkersRegistrar nettyWorkersRegistrar(
         );
     }
 
-    /** Creates the clock waiter. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(500)
-    public ClockWaiter clockWaiter(
-            NodeSeedParams seedParams,
-            HybridClock clock,
-            @Named("commonScheduler") ScheduledExecutorService commonScheduler
-    ) {
-        return new ClockWaiter(seedParams.nodeName(), clock, commonScheduler);
-    }
-
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index bdf62a89facf..b444f5611ba1 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -30,15 +30,12 @@
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
-import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
-import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.schema.SchemaManager;
-import org.apache.ignite.internal.sql.api.IgniteSqlImpl;
 import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
 import org.apache.ignite.internal.sql.configuration.distributed.SqlDistributedConfiguration;
 import org.apache.ignite.internal.sql.configuration.local.SqlLocalConfiguration;
@@ -72,16 +69,6 @@ public SqlLocalConfiguration sqlLocalConfiguration(
         return nodeConfigRegistry.getConfiguration(SqlNodeExtensionConfiguration.KEY).sql();
     }
 
-    /** Creates the kill command handler. */
-    @Singleton
-    public KillCommandHandler killCommandHandler(
-            NodeSeedParams seedParams,
-            LogicalTopologyService logicalTopologyService,
-            @Named("clusterMessaging") MessagingService clusterMessagingService
-    ) {
-        return new KillCommandHandler(seedParams.nodeName(), logicalTopologyService, clusterMessagingService);
-    }
-
     /** Creates the SQL query processor. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
@@ -132,15 +119,4 @@ public SqlQueryProcessor sqlQueryProcessor(
         );
     }
 
-    /** Creates the IgniteSql implementation. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(3100)
-    public IgniteSqlImpl igniteSql(
-            SqlQueryProcessor sqlQueryProcessor,
-            HybridTimestampTracker observableTimestampTracker,
-            @Named("commonScheduler") ScheduledExecutorService commonScheduler
-    ) {
-        return new IgniteSqlImpl(sqlQueryProcessor, observableTimestampTracker, commonScheduler);
-    }
 }
diff --git a/modules/sql-engine/build.gradle b/modules/sql-engine/build.gradle
index e495f7d54192..6637cc81f60f 100644
--- a/modules/sql-engine/build.gradle
+++ b/modules/sql-engine/build.gradle
@@ -79,9 +79,11 @@ dependencies {
     implementation libs.auto.service.annotations
     implementation libs.jsr305
     implementation libs.guava
+    implementation libs.micronaut.inject
 
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor project(':ignite-configuration-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.value.annotation.processor
     annotationProcessor libs.auto.service
 
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/IgniteSqlImpl.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/IgniteSqlImpl.java
index 958a2b301f32..67e53b771f4f 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/IgniteSqlImpl.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/api/IgniteSqlImpl.java
@@ -22,7 +22,11 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.EnumSet;
@@ -34,6 +38,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -41,6 +46,8 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Supplier;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -83,6 +90,9 @@
 /**
  * Embedded implementation of the Ignite SQL query facade.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(3100)
 @SuppressWarnings("rawtypes")
 public class IgniteSqlImpl implements IgniteSql, IgniteComponent, Wrapper {
     private static final IgniteLogger LOG = Loggers.forClass(IgniteSqlImpl.class);
@@ -103,6 +113,22 @@ public class IgniteSqlImpl implements IgniteSql, IgniteComponent, Wrapper {
 
     private final Executor commonExecutor;
 
+    /**
+     * Constructor for dependency injection.
+     *
+     * @param queryProcessor Query processor.
+     * @param observableTimestampTracker Tracker of the latest time observed by client.
+     * @param commonScheduler Executor that is used to close cursors when executing a script.
+     */
+    @Inject
+    public IgniteSqlImpl(
+            QueryProcessor queryProcessor,
+            HybridTimestampTracker observableTimestampTracker,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
+    ) {
+        this(queryProcessor, observableTimestampTracker, (Executor) commonScheduler);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/kill/KillCommandHandler.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/kill/KillCommandHandler.java
index d4f2fc432197..ebe0a31694c8 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/kill/KillCommandHandler.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/exec/kill/KillCommandHandler.java
@@ -17,10 +17,14 @@
 
 package org.apache.ignite.internal.sql.engine.exec.kill;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.EnumMap;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.lang.IgniteStringFormatter;
 import org.apache.ignite.internal.network.InternalClusterNode;
 import org.apache.ignite.internal.network.MessagingService;
@@ -40,6 +44,7 @@
 /**
  * Handler of SQL KILL command.
  */
+@Singleton
 public class KillCommandHandler implements KillHandlerRegistry {
     private static final SqlQueryMessagesFactory FACTORY = new SqlQueryMessagesFactory();
 
@@ -53,6 +58,16 @@ public class KillCommandHandler implements KillHandlerRegistry {
 
     private final MessagingService messageService;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public KillCommandHandler(
+            NodeIdentity nodeIdentity,
+            LogicalTopologyService logicalTopologyService,
+            @Named("clusterMessaging") MessagingService messageService
+    ) {
+        this(nodeIdentity.nodeName(), logicalTopologyService, messageService);
+    }
+
     /**
      * Constructor.
      */

From fa04106c674e2c95faeb11e1dcfae0aeffc5bb96 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 15:39:29 +0400
Subject: [PATCH 38/79] Migrate additional core components to dependency
 injection

---
 modules/cluster-metrics/build.gradle          |  2 +
 .../metrics/messaging/MetricMessaging.java    | 16 ++++++-
 .../outgoing/OutgoingSnapshotsManager.java    | 20 ++++++++
 modules/replicator/build.gradle               |  2 +
 .../internal/replicator/ReplicaService.java   | 29 +++++++++++
 .../internal/app/di/DataPathFactory.java      | 12 -----
 .../app/di/SystemServicesFactory.java         | 45 -----------------
 .../internal/app/di/TransactionFactory.java   | 20 --------
 .../tx/impl/ResourceVacuumManager.java        | 48 +++++++++++++++++++
 9 files changed, 116 insertions(+), 78 deletions(-)

diff --git a/modules/cluster-metrics/build.gradle b/modules/cluster-metrics/build.gradle
index 5bbf01c091f2..f795b2c4604c 100644
--- a/modules/cluster-metrics/build.gradle
+++ b/modules/cluster-metrics/build.gradle
@@ -22,9 +22,11 @@ description = 'ignite-cluster-metrics'
 
 dependencies {
     annotationProcessor project(":ignite-network-annotation-processor")
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-core')
     implementation project(':ignite-metrics')
     implementation project(':ignite-network')
     implementation libs.jetbrains.annotations
+    implementation libs.micronaut.inject
 }
diff --git a/modules/cluster-metrics/src/main/java/org/apache/ignite/internal/metrics/messaging/MetricMessaging.java b/modules/cluster-metrics/src/main/java/org/apache/ignite/internal/metrics/messaging/MetricMessaging.java
index 9ea0360f3640..108b9703253c 100644
--- a/modules/cluster-metrics/src/main/java/org/apache/ignite/internal/metrics/messaging/MetricMessaging.java
+++ b/modules/cluster-metrics/src/main/java/org/apache/ignite/internal/metrics/messaging/MetricMessaging.java
@@ -26,6 +26,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -33,6 +37,8 @@
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -55,6 +61,9 @@
 /**
  * Metrics messaging service.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1000)
 public class MetricMessaging implements IgniteComponent {
     private static final long NETWORK_TIMEOUT_MILLIS = Long.MAX_VALUE;
 
@@ -75,7 +84,12 @@ public class MetricMessaging implements IgniteComponent {
      * @param messagingService Messaging service.
      * @param topologyService Topology service.
      */
-    public MetricMessaging(MetricManager metricManager, MessagingService messagingService, TopologyService topologyService) {
+    @Inject
+    public MetricMessaging(
+            MetricManager metricManager,
+            @Named("clusterMessaging") MessagingService messagingService,
+            TopologyService topologyService
+    ) {
         this.metricManager = metricManager;
         this.messagingService = messagingService;
         this.topologyService = topologyService;
diff --git a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManager.java b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManager.java
index fde77ca77bd8..f75cef5b3cc2 100644
--- a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManager.java
+++ b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManager.java
@@ -24,6 +24,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -34,6 +38,9 @@
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.lang.NodeStoppingException;
@@ -58,6 +65,9 @@
 /**
  * Outgoing snapshots manager. Manages a collection of all outgoing snapshots, currently present on the Ignite node.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2100)
 public class OutgoingSnapshotsManager implements PartitionsSnapshots, IgniteComponent {
     /**
      * Logger.
@@ -81,6 +91,16 @@ public class OutgoingSnapshotsManager implements PartitionsSnapshots, IgniteComp
 
     private volatile ExecutorService executor;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public OutgoingSnapshotsManager(
+            NodeIdentity identity,
+            @Named("clusterMessaging") MessagingService messagingService,
+            FailureProcessor failureProcessor
+    ) {
+        this(identity.nodeName(), messagingService, failureProcessor);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/replicator/build.gradle b/modules/replicator/build.gradle
index 4b7eacdcec6a..5327b96917c9 100644
--- a/modules/replicator/build.gradle
+++ b/modules/replicator/build.gradle
@@ -25,6 +25,7 @@ dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-core')
     implementation project(':ignite-raft')
@@ -40,6 +41,7 @@ dependencies {
     implementation libs.jetbrains.annotations
     implementation libs.fastutil.core
     implementation libs.auto.service.annotations
+    implementation libs.micronaut.inject
 
     integrationTestImplementation project(':ignite-raft')
     integrationTestImplementation project(':ignite-raft-api')
diff --git a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
index 9259d34beb4d..d7411cd9cb02 100644
--- a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
+++ b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
@@ -29,15 +29,23 @@
 import static org.apache.ignite.lang.ErrorGroups.Replicator.REPLICA_TIMEOUT_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Transactions.ACQUIRE_LOCK_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeoutException;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.ClockService;
+import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.network.InternalClusterNode;
 import org.apache.ignite.internal.network.MessagingService;
@@ -58,6 +66,9 @@
 import org.jetbrains.annotations.TestOnly;
 
 /** The service is intended to execute requests on replicas. */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1600)
 public class ReplicaService {
     private static final List<Integer> RETRIABLE_ERRORS = List.of(
             ACQUIRE_LOCK_ERR,
@@ -84,6 +95,24 @@ public class ReplicaService {
     /** Replicator network message factory. */
     private static final ReplicaMessagesFactory REPLICA_MESSAGES_FACTORY = new ReplicaMessagesFactory();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public ReplicaService(
+            @Named("storageOperations") MessagingService messagingService,
+            ClockServiceImpl clockService,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
+            ReplicationConfiguration replicationConfiguration,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler
+    ) {
+        this(
+                messagingService,
+                clockService,
+                (Executor) partitionOperationsExecutor,
+                replicationConfiguration,
+                commonScheduler
+        );
+    }
+
     /**
      * The constructor of replica client.
      *
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 6d1d346962c5..32a4d8338e23 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -241,18 +241,6 @@ public DataStorageManager dataStorageManager(
         return new DataStorageManager(storageEngines, storageConfiguration);
     }
 
-    /** Creates the outgoing snapshots manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(2100)
-    public OutgoingSnapshotsManager outgoingSnapshotsManager(
-            NodeSeedParams seedParams,
-            @Named("clusterMessaging") MessagingService clusterMessagingService,
-            FailureManager failureManager
-    ) {
-        return new OutgoingSnapshotsManager(seedParams.nodeName(), clusterMessagingService, failureManager);
-    }
-
     /** Creates the low watermark. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index ea1d88adc7d2..44abfadcfe19 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -47,7 +47,6 @@
 import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.metrics.logstorage.LogStorageMetrics;
-import org.apache.ignite.internal.metrics.messaging.MetricMessaging;
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
@@ -61,10 +60,6 @@
 import org.apache.ignite.internal.table.distributed.disaster.DisasterRecoveryManager;
 import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorServiceImpl;
 import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
-import org.apache.ignite.internal.tx.TxManager;
-import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
-import org.apache.ignite.internal.tx.impl.ResourceVacuumManager;
-import org.apache.ignite.internal.tx.impl.TransactionInflights;
 import org.apache.ignite.internal.vault.VaultManager;
 
 /**
@@ -193,46 +188,6 @@ public LogStorageMetrics logStorageMetrics(
         );
     }
 
-    /** Creates the metric messaging. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1000)
-    public MetricMessaging metricMessaging(
-            MetricManager metricManager,
-            @Named("clusterMessaging") MessagingService clusterMessagingService,
-            TopologyService topologyService
-    ) {
-        return new MetricMessaging(metricManager, clusterMessagingService, topologyService);
-    }
-
-    /** Creates the resource vacuum manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(3300)
-    public ResourceVacuumManager resourceVacuumManager(
-            NodeSeedParams seedParams,
-            RemotelyTriggeredResourceRegistry resourcesRegistry,
-            TopologyService topologyService,
-            @Named("storageOperations") MessagingService messagingService,
-            TransactionInflights transactionInflights,
-            TxManager txManager,
-            LowWatermarkImpl lowWatermark,
-            FailureManager failureManager,
-            MetricManager metricManager
-    ) {
-        return new ResourceVacuumManager(
-                seedParams.nodeName(),
-                resourcesRegistry,
-                topologyService,
-                messagingService,
-                transactionInflights,
-                txManager,
-                lowWatermark,
-                failureManager,
-                metricManager
-        );
-    }
-
     /** Creates the disaster recovery manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 0bce12b2b36f..6c8ac1398386 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -96,26 +96,6 @@ public MessagingService storageOperationsMessagingService(
         );
     }
 
-    /** Creates the replica service. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1600)
-    public ReplicaService replicaService(
-            @Named("storageOperations") MessagingService messagingService,
-            ClockServiceImpl clockService,
-            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
-            ReplicationConfiguration replicationConfiguration,
-            @Named("commonScheduler") ScheduledExecutorService commonScheduler
-    ) {
-        return new ReplicaService(
-                messagingService,
-                clockService,
-                partitionOperationsExecutor,
-                replicationConfiguration,
-                commonScheduler
-        );
-    }
-
     /** Creates the transaction ID generator. */
     @Singleton
     public TransactionIdGenerator transactionIdGenerator(ClusterService clusterService) {
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/ResourceVacuumManager.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/ResourceVacuumManager.java
index bcbaaf9fc0b7..1c50fe126a8e 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/ResourceVacuumManager.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/ResourceVacuumManager.java
@@ -21,6 +21,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.internal.util.IgniteUtils.shutdownAndAwaitTermination;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -28,6 +32,9 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.lang.IgniteSystemProperties;
@@ -48,6 +55,9 @@
 /**
  * Manager responsible from cleaning up the transaction resources.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(3300)
 public class ResourceVacuumManager implements IgniteComponent {
     /** The logger. */
     private static final IgniteLogger LOG = Loggers.forClass(ResourceVacuumManager.class);
@@ -86,6 +96,44 @@ public class ResourceVacuumManager implements IgniteComponent {
     private volatile ScheduledFuture<?> vacuumOperationFuture;
     private volatile ScheduledFuture<?> broadcastClosedTransactionsFuture;
 
+    /**
+     * Constructor for dependency injection.
+     *
+     * @param nodeIdentity Node identity.
+     * @param resourceRegistry Resources registry.
+     * @param topologyService Topology service.
+     * @param messagingService Messaging service.
+     * @param transactionInflights Transaction inflights.
+     * @param txManager Transactional manager.
+     * @param lowWatermark Low watermark.
+     * @param failureProcessor Failure processor.
+     * @param metricManager Metric manager.
+     */
+    @Inject
+    public ResourceVacuumManager(
+            NodeIdentity nodeIdentity,
+            RemotelyTriggeredResourceRegistry resourceRegistry,
+            TopologyService topologyService,
+            @Named("storageOperations") MessagingService messagingService,
+            TransactionInflights transactionInflights,
+            TxManager txManager,
+            LowWatermark lowWatermark,
+            FailureProcessor failureProcessor,
+            MetricManager metricManager
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                resourceRegistry,
+                topologyService,
+                messagingService,
+                transactionInflights,
+                txManager,
+                lowWatermark,
+                failureProcessor,
+                metricManager
+        );
+    }
+
     /**
      * Constructor.
      *

From 6614ccd6836cf7bdaf5e6a7af315c198da551ef7 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 15:55:49 +0400
Subject: [PATCH 39/79] Migrate index-related components and dependencies to
 dependency injection

---
 modules/configuration-storage/build.gradle    |  1 -
 .../DistributedConfigurationStorage.java      |  3 +-
 modules/index/build.gradle                    |  2 +
 .../internal/index/IndexBuildingManager.java  | 46 +++++++++
 .../ignite/internal/index/IndexManager.java   | 14 ++-
 ...ndexNodeFinishedRwTransactionsChecker.java | 20 +---
 .../impl/MetaStorageCompactionTrigger.java    | 38 ++++++++
 .../internal/replicator/ReplicaService.java   |  3 +-
 .../internal/app/di/DataPathFactory.java      | 63 ------------
 .../app/di/SystemServicesFactory.java         | 95 -------------------
 .../metrics/logstorage/LogStorageMetrics.java | 24 +++++
 .../disaster/DisasterRecoveryManager.java     | 44 +++++++++
 12 files changed, 174 insertions(+), 179 deletions(-)

diff --git a/modules/configuration-storage/build.gradle b/modules/configuration-storage/build.gradle
index b63490177278..004d47199275 100644
--- a/modules/configuration-storage/build.gradle
+++ b/modules/configuration-storage/build.gradle
@@ -25,7 +25,6 @@ dependencies {
     annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-metastorage-api')
-    implementation project(':ignite-metastorage')
     implementation libs.micronaut.inject
     implementation project(':ignite-configuration-api')
     implementation project(':ignite-configuration')
diff --git a/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java b/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java
index 6a8028b9b9ed..c73e0959721a 100644
--- a/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java
+++ b/modules/configuration-storage/src/main/java/org/apache/ignite/internal/configuration/storage/DistributedConfigurationStorage.java
@@ -47,7 +47,6 @@
 import org.apache.ignite.internal.metastorage.Entry;
 import org.apache.ignite.internal.metastorage.EntryEvent;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.metastorage.dsl.Condition;
 import org.apache.ignite.internal.metastorage.dsl.Operation;
 import org.apache.ignite.internal.metastorage.dsl.Operations;
@@ -100,7 +99,7 @@ public class DistributedConfigurationStorage implements ConfigurationStorage {
 
     /** Constructor for DI injection. */
     @Inject
-    public DistributedConfigurationStorage(NodeIdentity nodeIdentity, MetaStorageManagerImpl metaStorageManager) {
+    public DistributedConfigurationStorage(NodeIdentity nodeIdentity, MetaStorageManager metaStorageManager) {
         this(nodeIdentity.nodeName(), metaStorageManager);
     }
 
diff --git a/modules/index/build.gradle b/modules/index/build.gradle
index ce97ce498836..a018ffe307d4 100644
--- a/modules/index/build.gradle
+++ b/modules/index/build.gradle
@@ -36,12 +36,14 @@ dependencies {
     implementation project(':ignite-network-api')
     implementation project(':ignite-raft-api')
     implementation project(':ignite-metastorage-api')
+    implementation project(':ignite-metastorage')
     implementation project(':ignite-placement-driver-api')
     implementation project(':ignite-replicator')
     implementation project(':ignite-cluster-management')
     implementation project(':ignite-low-watermark')
     implementation project(':ignite-partition-replicator')
     implementation project(':ignite-partition-distribution')
+    implementation project(':ignite-system-view-api')
     implementation project(':ignite-failure-handler')
     implementation libs.jetbrains.annotations
     implementation libs.micronaut.inject
diff --git a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexBuildingManager.java b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexBuildingManager.java
index 6c640ae740a4..0a04f3d64763 100644
--- a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexBuildingManager.java
+++ b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexBuildingManager.java
@@ -25,6 +25,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.internal.util.IgniteUtils.shutdownAndAwaitTermination;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
@@ -34,6 +37,9 @@
 import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogIndexStatus;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -62,6 +68,9 @@
  *
  * @see CatalogIndexDescriptor#status()
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2700)
 public class IndexBuildingManager implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(IndexBuildingManager.class);
 
@@ -81,6 +90,43 @@ public class IndexBuildingManager implements IgniteComponent {
 
     private final AtomicBoolean stopGuard = new AtomicBoolean();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public IndexBuildingManager(
+            ClusterService clusterService,
+            ReplicaService replicaService,
+            CatalogManager catalogManager,
+            MetaStorageManager metaStorageManager,
+            IndexManager indexManager,
+            IndexMetaStorage indexMetaStorage,
+            PlacementDriver placementDriver,
+            LogicalTopologyService logicalTopologyService,
+            ClockService clockService,
+            FailureManager failureManager,
+            LowWatermark lowWatermark,
+            TxManager txManager,
+            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            MetricManager metricManager
+    ) {
+        this(
+                clusterService.nodeName(),
+                replicaService,
+                catalogManager,
+                metaStorageManager,
+                indexManager,
+                indexMetaStorage,
+                placementDriver,
+                clusterService,
+                logicalTopologyService,
+                clockService,
+                failureManager,
+                lowWatermark,
+                txManager,
+                partitionReplicaLifecycleManager,
+                metricManager
+        );
+    }
+
     /** Constructor. */
     public IndexBuildingManager(
             String nodeName,
diff --git a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexManager.java b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexManager.java
index ffd00ef62b13..d1d14e93147c 100644
--- a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexManager.java
+++ b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexManager.java
@@ -30,6 +30,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
@@ -45,6 +49,8 @@
 import org.apache.ignite.internal.catalog.events.RemoveIndexEventParameters;
 import org.apache.ignite.internal.causality.IncrementalVersionedValue;
 import org.apache.ignite.internal.causality.RevisionListenerRegistry;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -70,6 +76,9 @@
  * <p>To avoid errors when using indexes while applying replication log during node recovery, the registration of indexes was moved to the
  * start of the tables.</p>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2600)
 public class IndexManager implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(IndexManager.class);
 
@@ -108,12 +117,15 @@ public class IndexManager implements IgniteComponent {
      * @param tableManager Table manager.
      * @param catalogService Catalog service.
      * @param ioExecutor Separate executor for IO operations like storage initialization.
+     * @param registry Revision listener registry.
+     * @param lowWatermark Low watermark.
      */
+    @Inject
     public IndexManager(
             SchemaManager schemaManager,
             TableManager tableManager,
             CatalogService catalogService,
-            ExecutorService ioExecutor,
+            @Named("tableIoExecutor") ExecutorService ioExecutor,
             RevisionListenerRegistry registry,
             LowWatermark lowWatermark
     ) {
diff --git a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java
index 38d22e2db27d..6e7a1856ca6e 100644
--- a/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java
+++ b/modules/index/src/main/java/org/apache/ignite/internal/index/IndexNodeFinishedRwTransactionsChecker.java
@@ -21,6 +21,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.NavigableMap;
@@ -31,10 +34,6 @@
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Supplier;
 import org.apache.ignite.internal.catalog.Catalog;
-import jakarta.inject.Inject;
-import jakarta.inject.Named;
-import jakarta.inject.Singleton;
-import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.catalog.CatalogService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
@@ -80,20 +79,11 @@ public class IndexNodeFinishedRwTransactionsChecker implements LocalRwTxCounter,
 
     private final AtomicBoolean stopGuard = new AtomicBoolean();
 
-    /** Constructor for dependency injection. */
-    @Inject
-    public IndexNodeFinishedRwTransactionsChecker(
-            CatalogManagerImpl catalogManager,
-            @Named("clusterMessaging") MessagingService messagingService,
-            HybridClock clock
-    ) {
-        this((CatalogService) catalogManager, messagingService, clock);
-    }
-
     /** Constructor. */
+    @Inject
     public IndexNodeFinishedRwTransactionsChecker(
             CatalogService catalogService,
-            MessagingService messagingService,
+            @Named("clusterMessaging") MessagingService messagingService,
             HybridClock clock
     ) {
         this.catalogService = catalogService;
diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageCompactionTrigger.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageCompactionTrigger.java
index 222a1deb0c86..4f8b5a92640b 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageCompactionTrigger.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageCompactionTrigger.java
@@ -26,6 +26,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockSafe;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 import java.util.concurrent.RejectedExecutionException;
@@ -36,6 +39,9 @@
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Function;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
@@ -80,6 +86,9 @@
  *     in the {@link MetaStorageManager#deployWatches}.</li>
  * </ul>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(3400)
 public class MetaStorageCompactionTrigger implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(MetaStorageCompactionTrigger.class);
 
@@ -117,6 +126,35 @@ public class MetaStorageCompactionTrigger implements IgniteComponent {
 
     private final AtomicBoolean stopGuard = new AtomicBoolean();
 
+    /**
+     * Constructor for dependency injection.
+     *
+     * @param nodeIdentity Node identity.
+     * @param storage Storage.
+     * @param metaStorageManager Metastorage manager.
+     * @param failureProcessor Failure processor.
+     * @param readOperationForCompactionTracker Tracker of read operations, both local and from the leader.
+     * @param systemDistributedConfig Distributed system configuration.
+     */
+    @Inject
+    public MetaStorageCompactionTrigger(
+            NodeIdentity nodeIdentity,
+            KeyValueStorage storage,
+            MetaStorageManager metaStorageManager,
+            FailureProcessor failureProcessor,
+            ReadOperationForCompactionTracker readOperationForCompactionTracker,
+            SystemDistributedConfiguration systemDistributedConfig
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                storage,
+                (MetaStorageManagerImpl) metaStorageManager,
+                failureProcessor,
+                readOperationForCompactionTracker,
+                systemDistributedConfig
+        );
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
index d7411cd9cb02..9f1384a57243 100644
--- a/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
+++ b/modules/replicator/src/main/java/org/apache/ignite/internal/replicator/ReplicaService.java
@@ -45,7 +45,6 @@
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.ClockService;
-import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.network.InternalClusterNode;
 import org.apache.ignite.internal.network.MessagingService;
@@ -99,7 +98,7 @@ public class ReplicaService {
     @Inject
     public ReplicaService(
             @Named("storageOperations") MessagingService messagingService,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             ReplicationConfiguration replicationConfiguration,
             @Named("commonScheduler") ScheduledExecutorService commonScheduler
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 32a4d8338e23..48bcd9af1c84 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -47,8 +47,6 @@
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
-import org.apache.ignite.internal.index.IndexBuildingManager;
-import org.apache.ignite.internal.index.IndexManager;
 import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
@@ -436,66 +434,5 @@ public PartitionModificationCounterFactory partitionModificationCounterFactory(
         return new PartitionModificationCounterFactory(clockService::current, clusterMessagingService);
     }
 
-    /** Creates the index manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(2600)
-    public IndexManager indexManager(
-            SchemaManager schemaManager,
-            TableManager tableManager,
-            CatalogManagerImpl catalogManager,
-            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
-            MetaStorageRevisionListenerRegistry revisionListenerRegistry,
-            LowWatermarkImpl lowWatermark
-    ) {
-        return new IndexManager(
-                schemaManager,
-                tableManager,
-                catalogManager,
-                tableIoExecutor,
-                revisionListenerRegistry,
-                lowWatermark
-        );
-    }
-
-    /** Creates the index building manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(2700)
-    public IndexBuildingManager indexBuildingManager(
-            NodeSeedParams seedParams,
-            ReplicaService replicaService,
-            CatalogManagerImpl catalogManager,
-            MetaStorageManagerImpl metaStorageManager,
-            IndexManager indexManager,
-            IndexMetaStorage indexMetaStorage,
-            PlacementDriver placementDriver,
-            ClusterService clusterService,
-            LogicalTopologyService logicalTopologyService,
-            ClockServiceImpl clockService,
-            FailureManager failureManager,
-            LowWatermarkImpl lowWatermark,
-            TxManager txManager,
-            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
-            MetricManager metricManager
-    ) {
-        return new IndexBuildingManager(
-                seedParams.nodeName(),
-                replicaService,
-                catalogManager,
-                metaStorageManager,
-                indexManager,
-                indexMetaStorage,
-                placementDriver,
-                clusterService,
-                logicalTopologyService,
-                clockService,
-                failureManager,
-                lowWatermark,
-                txManager,
-                partitionReplicaLifecycleManager,
-                metricManager
-        );
-    }
 }
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 44abfadcfe19..aedea7d4b524 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -22,7 +22,6 @@
 import jakarta.inject.Named;
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
-import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
@@ -30,34 +29,19 @@
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManagerImpl;
-import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
 import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
-import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageCompactionTrigger;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
-import org.apache.ignite.internal.metastorage.server.ReadOperationForCompactionTracker;
-import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
-import org.apache.ignite.internal.metrics.MetricManager;
-import org.apache.ignite.internal.metrics.logstorage.LogStorageMetrics;
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
-import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
-import org.apache.ignite.internal.raft.Loza;
-import org.apache.ignite.internal.raft.storage.LogStorageManager;
-import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
 import org.apache.ignite.internal.replicator.ReplicaService;
-import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
-import org.apache.ignite.internal.table.distributed.TableManager;
-import org.apache.ignite.internal.table.distributed.disaster.DisasterRecoveryManager;
 import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorServiceImpl;
 import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
 import org.apache.ignite.internal.vault.VaultManager;
@@ -108,28 +92,6 @@ public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
         );
     }
 
-    /** Creates the MetaStorage compaction trigger. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(3400)
-    public MetaStorageCompactionTrigger metaStorageCompactionTrigger(
-            NodeSeedParams seedParams,
-            RocksDbKeyValueStorage storage,
-            MetaStorageManagerImpl metaStorageManager,
-            FailureManager failureManager,
-            ReadOperationForCompactionTracker readOperationForCompactionTracker,
-            SystemDistributedConfiguration systemDistributedConfiguration
-    ) {
-        return new MetaStorageCompactionTrigger(
-                seedParams.nodeName(),
-                storage,
-                metaStorageManager,
-                failureManager,
-                readOperationForCompactionTracker,
-                systemDistributedConfiguration
-        );
-    }
-
     /** Creates the catalog compaction runner. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
@@ -166,61 +128,4 @@ public CatalogCompactionRunner catalogCompactionRunner(
         );
     }
 
-    /** Creates the log storage metrics. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1400)
-    public LogStorageMetrics logStorageMetrics(
-            NodeSeedParams seedParams,
-            MetricManager metricManager,
-            @Named("cmg") LogStorageManager cmgLogStorageManager,
-            @Named("metastorage") LogStorageManager msLogStorageManager,
-            @Named("partitions") LogStorageManager partitionsLogStorageManager,
-            VolatileLogStorageManagerCreator volatileLogStorageManagerCreator
-    ) {
-        return new LogStorageMetrics(
-                seedParams.nodeName(),
-                metricManager,
-                cmgLogStorageManager,
-                msLogStorageManager,
-                partitionsLogStorageManager,
-                volatileLogStorageManagerCreator
-        );
-    }
-
-    /** Creates the disaster recovery manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(2500)
-    public DisasterRecoveryManager disasterRecoveryManager(
-            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
-            @Named("storageOperations") MessagingService messagingService,
-            MetaStorageManagerImpl metaStorageManager,
-            CatalogManagerImpl catalogManager,
-            DistributionZoneManager distributionZoneManager,
-            Loza raftManager,
-            TopologyService topologyService,
-            LogicalTopologyService logicalTopologyService,
-            TableManager tableManager,
-            MetricManager metricManager,
-            FailureManager failureManager,
-            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
-            SystemViewManagerImpl systemViewManager
-    ) {
-        return new DisasterRecoveryManager(
-                tableIoExecutor,
-                messagingService,
-                metaStorageManager,
-                catalogManager,
-                distributionZoneManager,
-                raftManager,
-                topologyService,
-                logicalTopologyService,
-                tableManager,
-                metricManager,
-                failureManager,
-                partitionReplicaLifecycleManager,
-                systemViewManager
-        );
-    }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/metrics/logstorage/LogStorageMetrics.java b/modules/runner/src/main/java/org/apache/ignite/internal/metrics/logstorage/LogStorageMetrics.java
index f5f073b26cf8..c0f5b286d523 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/metrics/logstorage/LogStorageMetrics.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/metrics/logstorage/LogStorageMetrics.java
@@ -22,10 +22,17 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
@@ -39,6 +46,9 @@
 /**
  * Component that collects metrics about log storages.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1400)
 public class LogStorageMetrics implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(LogStorageMetrics.class);
 
@@ -60,6 +70,20 @@ public class LogStorageMetrics implements IgniteComponent {
     private volatile ScheduledExecutorService executorService;
     private volatile ScheduledFuture<?> taskFuture;
 
+    /** Constructor for DI injection. */
+    @Inject
+    public LogStorageMetrics(
+            NodeIdentity nodeIdentity,
+            MetricManager metricManager,
+            @Named("cmg") LogStorageManager cmgLogStorageManager,
+            @Named("metastorage") LogStorageManager metastorageLogStorageManager,
+            @Named("partitions") LogStorageManager partitionsLogStorageManager,
+            VolatileLogStorageManagerCreator volatileLogStorageManagerCreator
+    ) {
+        this(nodeIdentity.nodeName(), metricManager, cmgLogStorageManager, metastorageLogStorageManager,
+                partitionsLogStorageManager, volatileLogStorageManagerCreator);
+    }
+
     /** Constructor. */
     public LogStorageMetrics(
             String nodeName,
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/disaster/DisasterRecoveryManager.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/disaster/DisasterRecoveryManager.java
index 1ef6aac79f03..5a0182422df7 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/disaster/DisasterRecoveryManager.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/disaster/DisasterRecoveryManager.java
@@ -47,6 +47,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.lang.ErrorGroups.DisasterRecovery.PARTITION_STATE_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -59,6 +63,7 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.apache.ignite.internal.catalog.Catalog;
@@ -72,6 +77,8 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.distributionzones.DistributionZonesUtil;
 import org.apache.ignite.internal.distributionzones.NodeWithAttributes;
@@ -144,6 +151,9 @@
  * such as {@link #resetPartitions(String, Set)}.
  * More details are in the <a href="https://issues.apache.org/jira/browse/IGNITE-21140">epic</a>.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2500)
 public class DisasterRecoveryManager implements IgniteComponent, SystemViewProvider {
     /** Logger. */
     static final IgniteLogger LOG = Loggers.forClass(DisasterRecoveryManager.class);
@@ -223,6 +233,40 @@ public class DisasterRecoveryManager implements IgniteComponent, SystemViewProvi
 
     private final Map<UUID, MultiNodeOperations> operationsByNodeId = new ConcurrentHashMap<>();
 
+    /** Constructor for DI injection. */
+    @Inject
+    public DisasterRecoveryManager(
+            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
+            @Named("storageOperations") MessagingService messagingService,
+            MetaStorageManager metaStorageManager,
+            CatalogManager catalogManager,
+            DistributionZoneManager distributionZoneManager,
+            Loza raftManager,
+            TopologyService topologyService,
+            LogicalTopologyService logicalTopologyService,
+            TableManager tableManager,
+            MetricManager metricManager,
+            FailureManager failureManager,
+            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            SystemViewManager systemViewManager
+    ) {
+        this(
+                (ExecutorService) tableIoExecutor,
+                messagingService,
+                metaStorageManager,
+                catalogManager,
+                distributionZoneManager,
+                raftManager,
+                topologyService,
+                logicalTopologyService,
+                tableManager,
+                metricManager,
+                failureManager,
+                partitionReplicaLifecycleManager,
+                systemViewManager
+        );
+    }
+
     /** Constructor. */
     public DisasterRecoveryManager(
             ExecutorService threadPool,

From e9b08baedebc5c5bac62983b7249e5b0b730b634 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 16:33:54 +0400
Subject: [PATCH 40/79] Migrate ClockService and related components to
 dependency injection

---
 .../internal/app/di/CatalogFactory.java       |  8 ++--
 .../internal/app/di/ClientHandlerFactory.java |  4 +-
 .../internal/app/di/ComputeFactory.java       |  4 +-
 .../internal/app/di/DataPathFactory.java      | 48 ++++++-------------
 .../ignite/internal/app/di/SqlFactory.java    |  4 +-
 .../internal/app/di/TransactionFactory.java   |  5 +-
 ...nimumRequiredTimeCollectorServiceImpl.java |  2 +
 7 files changed, 29 insertions(+), 46 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index 652da91d1539..4d5a8d36f348 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -34,6 +34,7 @@
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.hlc.ClockWaiter;
 import org.apache.ignite.internal.hlc.HybridClock;
@@ -82,7 +83,7 @@ public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
             @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             MetaStorageManagerImpl metaStorageManager,
             RaftConfiguration raftConfiguration,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             FailureManager failureManager
     ) {
         return new IdempotentCacheVacuumizer(
@@ -104,7 +105,7 @@ public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
     @Order(100)
     public CatalogManagerImpl catalogManager(
             MetaStorageManagerImpl metaStorageManager,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             FailureManager failureManager,
             SchemaSynchronizationConfiguration schemaSyncConfig,
             PartitionCountCalculatorWrapper partitionCountCalculatorWrapper
@@ -132,7 +133,7 @@ public PlacementDriverManager placementDriverManager(
             LogicalTopologyService logicalTopologyService,
             RaftManager raftManager,
             TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             FailureManager failureManager,
             ReplicationConfiguration replicationConfiguration,
             @Named("commonScheduler") ScheduledExecutorService commonScheduler,
@@ -163,4 +164,3 @@ public PlacementDriver placementDriver(PlacementDriverManager placementDriverMan
         return placementDriverManager.placementDriver();
     }
 }
-
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
index 16959a494b25..93f33ea5d616 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -35,7 +35,7 @@
 import org.apache.ignite.internal.configuration.SuggestionsClusterExtensionConfiguration;
 import org.apache.ignite.internal.configuration.SuggestionsConfiguration;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
-import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
@@ -92,7 +92,7 @@ public ClientHandlerModule clientHandlerModule(
             IgniteImpl igniteImpl,
             MetricManager metricManager,
             AuthenticationManager authenticationManager,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             SchemaSyncServiceImpl schemaSyncService,
             CatalogManagerImpl catalogManager,
             PlacementDriver placementDriver,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index a69f0be4f54c..9e1aadad4e2f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -42,7 +42,7 @@
 import org.apache.ignite.internal.deployunit.loader.UnitsContextManager;
 import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
-import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
@@ -82,7 +82,7 @@ public ComputeExecutorImpl computeExecutor(
             InMemoryComputeStateMachine stateMachine,
             ComputeConfiguration computeConfiguration,
             TopologyService topologyService,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             EventLogImpl eventLog
     ) {
         return new ComputeExecutorImpl(
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 48bcd9af1c84..cd3c7f3df51b 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -44,10 +44,10 @@
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
-import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
+import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageRevisionListenerRegistry;
@@ -72,6 +72,7 @@
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.schema.SchemaManager;
 import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
+import org.apache.ignite.internal.schema.SchemaSyncService;
 import org.apache.ignite.internal.schema.configuration.GcConfiguration;
 import org.apache.ignite.internal.storage.DataStorageManager;
 import org.apache.ignite.internal.storage.DataStorageModule;
@@ -128,18 +129,6 @@ public SchemaSyncServiceImpl schemaSyncService(
         return new SchemaSyncServiceImpl(schemaSafeTimeTracker, delayDurationMsSupplier);
     }
 
-    /** Creates the index node finished rw transactions checker. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1600)
-    public IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker(
-            CatalogManagerImpl catalogManager,
-            @Named("clusterMessaging") MessagingService clusterMessagingService,
-            HybridClock clock
-    ) {
-        return new IndexNodeFinishedRwTransactionsChecker(catalogManager, clusterMessagingService, clock);
-    }
-
     /** Creates the observable hybrid timestamp tracker. */
     @Singleton
     public HybridTimestampTracker hybridTimestampTracker() {
@@ -155,14 +144,14 @@ public ReplicaManager replicaManager(
             ClusterService clusterService,
             ClusterManagementGroupManager cmgManager,
             MetaStorageManagerImpl metaStorageManager,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             PlacementDriver placementDriver,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             ReplicationConfiguration replicationConfiguration,
             FailureManager failureManager,
             CatalogValidationSchemasSource validationSchemasSource,
             CatalogManagerImpl catalogManager,
-            SchemaSyncServiceImpl schemaSyncService,
+            SchemaSyncService schemaSyncService,
             TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
             RaftManager raftManager,
             @Named("partitions") RaftGroupOptionsConfigurer partitionRaftConfigurer,
@@ -246,7 +235,7 @@ public DataStorageManager dataStorageManager(
     public LowWatermarkImpl lowWatermark(
             NodeSeedParams seedParams,
             GcConfiguration gcConfiguration,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             VaultManager vaultManager,
             FailureManager failureManager,
             @Named("clusterMessaging") MessagingService clusterMessagingService
@@ -273,9 +262,9 @@ public DistributionZoneManager distributionZoneManager(
             FailureManager failureManager,
             CatalogManagerImpl catalogManager,
             SystemDistributedConfiguration systemDistributedConfiguration,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             MetricManager metricManager,
-            LowWatermarkImpl lowWatermark
+            LowWatermark lowWatermark
     ) {
         return new DistributionZoneManager(
                 seedParams.nodeName(),
@@ -301,14 +290,14 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
             DistributionZoneManager distributionZoneManager,
             MetaStorageManagerImpl metaStorageManager,
             TopologyService topologyService,
-            LowWatermarkImpl lowWatermark,
+            LowWatermark lowWatermark,
             FailureManager failureManager,
             @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
             @Named("rebalanceScheduler") ScheduledExecutorService rebalanceScheduler,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             PlacementDriver placementDriver,
-            SchemaSyncServiceImpl schemaSyncService,
+            SchemaSyncService schemaSyncService,
             SystemDistributedConfiguration systemDistributedConfiguration,
             TxStateRocksDbSharedStorage sharedTxStateStorage,
             TxManager txManager,
@@ -345,12 +334,6 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
         );
     }
 
-    /** Creates the shared minimum required time collector service. */
-    @Singleton
-    public MinimumRequiredTimeCollectorServiceImpl minimumRequiredTimeCollectorService() {
-        return new MinimumRequiredTimeCollectorServiceImpl();
-    }
-
     /** Creates the table manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
@@ -371,16 +354,16 @@ public TableManager tableManager(
             CatalogValidationSchemasSource validationSchemasSource,
             @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             OutgoingSnapshotsManager outgoingSnapshotsManager,
-            SchemaSyncServiceImpl schemaSyncService,
+            SchemaSyncService schemaSyncService,
             CatalogManagerImpl catalogManager,
             FailureManager failureManager,
             HybridTimestampTracker observableTimestampTracker,
             PlacementDriver placementDriver,
             Provider<IgniteSql> sqlProvider,
             RemotelyTriggeredResourceRegistry resourcesRegistry,
-            LowWatermarkImpl lowWatermark,
+            LowWatermark lowWatermark,
             TransactionInflights transactionInflights,
             IndexMetaStorage indexMetaStorage,
             PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
@@ -428,11 +411,10 @@ public TableManager tableManager(
     /** Creates the partition modification counter factory. */
     @Singleton
     public PartitionModificationCounterFactory partitionModificationCounterFactory(
-            ClockServiceImpl clockService,
+            ClockService clockService,
             @Named("clusterMessaging") MessagingService clusterMessagingService
     ) {
         return new PartitionModificationCounterFactory(clockService::current, clusterMessagingService);
     }
 
 }
-
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index b444f5611ba1..3ec6e80de465 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -29,7 +29,7 @@
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
 import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
@@ -79,7 +79,7 @@ public SqlQueryProcessor sqlQueryProcessor(
             TableManager tableManager,
             SchemaManager schemaManager,
             ReplicaService replicaService,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             SchemaSyncServiceImpl schemaSyncService,
             CatalogManagerImpl catalogManager,
             MetricManager metricManager,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 6c8ac1398386..71627890f53a 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -30,7 +30,7 @@
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
 import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
 import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.metrics.MetricManager;
@@ -115,7 +115,7 @@ public TxManagerImpl txManager(
             ReplicaService replicaService,
             LockManager lockManager,
             VolatileTxStateMetaStorage txStateVolatileStorage,
-            ClockServiceImpl clockService,
+            ClockService clockService,
             TransactionIdGenerator transactionIdGenerator,
             PlacementDriver placementDriver,
             ReplicationConfiguration replicationConfiguration,
@@ -174,4 +174,3 @@ public TxStateRocksDbSharedStorage txStateRocksDbSharedStorage(
         );
     }
 }
-
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/raft/MinimumRequiredTimeCollectorServiceImpl.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/raft/MinimumRequiredTimeCollectorServiceImpl.java
index c20c8bb7360b..f5e45e388f5e 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/raft/MinimumRequiredTimeCollectorServiceImpl.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/raft/MinimumRequiredTimeCollectorServiceImpl.java
@@ -17,12 +17,14 @@
 
 package org.apache.ignite.internal.table.distributed.raft;
 
+import jakarta.inject.Singleton;
 import java.util.Collections;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import org.apache.ignite.internal.replicator.TablePartitionId;
 
 /** Collects minimum required timestamp for each partition. */
+@Singleton
 public class MinimumRequiredTimeCollectorServiceImpl implements MinimumRequiredTimeCollectorService {
     private final ConcurrentHashMap<TablePartitionId, Long> partitions = new ConcurrentHashMap<>();
 

From 539bf5f90fca670b2a0d9e2a6ace224ea3e0f33a Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 16:52:44 +0400
Subject: [PATCH 41/79] Migrate remaining classes to use interfaces over
 implementations in dependency injection

---
 .../internal/app/di/CatalogFactory.java       |  5 +++--
 .../internal/app/di/ClientHandlerFactory.java | 16 +++++++-------
 .../internal/app/di/ComputeFactory.java       | 10 ++++-----
 .../internal/app/di/DataPathFactory.java      | 22 +++++++++----------
 .../ignite/internal/app/di/SqlFactory.java    | 20 ++++++++---------
 .../app/di/SystemServicesFactory.java         | 19 ++++++++--------
 6 files changed, 47 insertions(+), 45 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index 4d5a8d36f348..f5155f2090d2 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -38,6 +38,7 @@
 import org.apache.ignite.internal.hlc.ClockServiceImpl;
 import org.apache.ignite.internal.hlc.ClockWaiter;
 import org.apache.ignite.internal.hlc.HybridClock;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.metastorage.cache.IdempotentCacheVacuumizer;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
@@ -104,7 +105,7 @@ public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(100)
     public CatalogManagerImpl catalogManager(
-            MetaStorageManagerImpl metaStorageManager,
+            MetaStorageManager metaStorageManager,
             ClockService clockService,
             FailureManager failureManager,
             SchemaSynchronizationConfiguration schemaSyncConfig,
@@ -127,7 +128,7 @@ public CatalogManagerImpl catalogManager(
     @Order(800)
     public PlacementDriverManager placementDriverManager(
             NodeSeedParams seedParams,
-            MetaStorageManagerImpl metaStorageManager,
+            MetaStorageManager metaStorageManager,
             ClusterService clusterService,
             ClusterManagementGroupManager cmgManager,
             LogicalTopologyService logicalTopologyService,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
index 93f33ea5d616..c67dd2a1c576 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClientHandlerFactory.java
@@ -27,26 +27,26 @@
 import org.apache.ignite.client.handler.configuration.ClientConnectorConfiguration;
 import org.apache.ignite.client.handler.configuration.ClientConnectorExtensionConfiguration;
 import org.apache.ignite.internal.app.IgniteImpl;
-import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SuggestionsClusterExtensionConfiguration;
 import org.apache.ignite.internal.configuration.SuggestionsConfiguration;
-import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
+import org.apache.ignite.internal.eventlog.api.EventLog;
 import org.apache.ignite.internal.hlc.ClockService;
-import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
+import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.NettyBootstrapFactory;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
+import org.apache.ignite.internal.schema.SchemaSyncService;
 import org.apache.ignite.internal.security.authentication.AuthenticationManager;
 import org.apache.ignite.internal.security.configuration.SecurityConfiguration;
 import org.apache.ignite.internal.security.configuration.SecurityExtensionConfiguration;
 import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
 import org.apache.ignite.internal.table.distributed.TableManager;
-import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
 import org.apache.ignite.internal.tx.TxManager;
 
 /**
@@ -93,12 +93,12 @@ public ClientHandlerModule clientHandlerModule(
             MetricManager metricManager,
             AuthenticationManager authenticationManager,
             ClockService clockService,
-            SchemaSyncServiceImpl schemaSyncService,
-            CatalogManagerImpl catalogManager,
+            SchemaSyncService schemaSyncService,
+            CatalogManager catalogManager,
             PlacementDriver placementDriver,
             ClientConnectorConfiguration clientConnectorConfiguration,
-            EventLogImpl eventLog,
-            LowWatermarkImpl lowWatermark,
+            EventLog eventLog,
+            LowWatermark lowWatermark,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             SuggestionsConfiguration suggestionsConfiguration
     ) {
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index 9e1aadad4e2f..56fd34ff578e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -41,11 +41,11 @@
 import org.apache.ignite.internal.deployunit.loader.UnitsClassLoaderFactory;
 import org.apache.ignite.internal.deployunit.loader.UnitsContextManager;
 import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
-import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
+import org.apache.ignite.internal.eventlog.api.EventLog;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
@@ -83,7 +83,7 @@ public ComputeExecutorImpl computeExecutor(
             ComputeConfiguration computeConfiguration,
             TopologyService topologyService,
             ClockService clockService,
-            EventLogImpl eventLog
+            EventLog eventLog
     ) {
         return new ComputeExecutorImpl(
                 igniteProvider.get(),
@@ -101,7 +101,7 @@ public ComputeExecutorImpl computeExecutor(
     @Order(3000)
     public DeploymentManagerImpl deploymentManager(
             ClusterService clusterService,
-            MetaStorageManagerImpl metaStorageManager,
+            MetaStorageManager metaStorageManager,
             LogicalTopologyService logicalTopologyService,
             NodeSeedParams seedParams,
             DeploymentConfiguration deploymentConfiguration,
@@ -132,7 +132,7 @@ public ComputeComponentImpl computeComponent(
             DeploymentManagerImpl deploymentManager,
             ComputeExecutorImpl computeExecutor,
             ComputeConfiguration computeConfiguration,
-            EventLogImpl eventLog,
+            EventLog eventLog,
             HybridTimestampTracker observableTimestampTracker
     ) {
         return new ComputeComponentImpl(
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index cd3c7f3df51b..d7daa995346c 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -32,7 +32,7 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.function.LongSupplier;
-import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
@@ -49,7 +49,7 @@
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageRevisionListenerRegistry;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
@@ -115,7 +115,7 @@ public VolatileLogStorageManagerCreator volatileLogStorageManagerCreator(NodeSee
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(1900)
-    public SchemaSafeTimeTrackerImpl schemaSafeTimeTracker(MetaStorageManagerImpl metaStorageManager) {
+    public SchemaSafeTimeTrackerImpl schemaSafeTimeTracker(MetaStorageManager metaStorageManager) {
         return new SchemaSafeTimeTrackerImpl(metaStorageManager.clusterTime());
     }
 
@@ -143,14 +143,14 @@ public ReplicaManager replicaManager(
             NodeSeedParams seedParams,
             ClusterService clusterService,
             ClusterManagementGroupManager cmgManager,
-            MetaStorageManagerImpl metaStorageManager,
+            MetaStorageManager metaStorageManager,
             ClockService clockService,
             PlacementDriver placementDriver,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
             ReplicationConfiguration replicationConfiguration,
             FailureManager failureManager,
             CatalogValidationSchemasSource validationSchemasSource,
-            CatalogManagerImpl catalogManager,
+            CatalogManager catalogManager,
             SchemaSyncService schemaSyncService,
             TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
             RaftManager raftManager,
@@ -257,10 +257,10 @@ public LowWatermarkImpl lowWatermark(
     public DistributionZoneManager distributionZoneManager(
             NodeSeedParams seedParams,
             TopologyService topologyService,
-            MetaStorageManagerImpl metaStorageManager,
+            MetaStorageManager metaStorageManager,
             LogicalTopologyService logicalTopologyService,
             FailureManager failureManager,
-            CatalogManagerImpl catalogManager,
+            CatalogManager catalogManager,
             SystemDistributedConfiguration systemDistributedConfiguration,
             ClockService clockService,
             MetricManager metricManager,
@@ -285,10 +285,10 @@ public DistributionZoneManager distributionZoneManager(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(2300)
     public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
-            CatalogManagerImpl catalogManager,
+            CatalogManager catalogManager,
             ReplicaManager replicaManager,
             DistributionZoneManager distributionZoneManager,
-            MetaStorageManagerImpl metaStorageManager,
+            MetaStorageManager metaStorageManager,
             TopologyService topologyService,
             LowWatermark lowWatermark,
             FailureManager failureManager,
@@ -349,7 +349,7 @@ public TableManager tableManager(
             ReplicaService replicaService,
             TxManager txManager,
             DataStorageManager dataStorageManager,
-            MetaStorageManagerImpl metaStorageManager,
+            MetaStorageManager metaStorageManager,
             SchemaManager schemaManager,
             CatalogValidationSchemasSource validationSchemasSource,
             @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
@@ -357,7 +357,7 @@ public TableManager tableManager(
             ClockService clockService,
             OutgoingSnapshotsManager outgoingSnapshotsManager,
             SchemaSyncService schemaSyncService,
-            CatalogManagerImpl catalogManager,
+            CatalogManager catalogManager,
             FailureManager failureManager,
             HybridTimestampTracker observableTimestampTracker,
             PlacementDriver placementDriver,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index 3ec6e80de465..2db60e6d68ce 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -22,29 +22,29 @@
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import java.util.concurrent.ScheduledExecutorService;
-import org.apache.ignite.internal.catalog.CatalogManagerImpl;
+import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
+import org.apache.ignite.internal.eventlog.api.EventLog;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockService;
-import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
+import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.schema.SchemaManager;
+import org.apache.ignite.internal.schema.SchemaSyncService;
 import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
 import org.apache.ignite.internal.sql.configuration.distributed.SqlDistributedConfiguration;
 import org.apache.ignite.internal.sql.configuration.local.SqlLocalConfiguration;
 import org.apache.ignite.internal.sql.configuration.local.SqlNodeExtensionConfiguration;
 import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
 import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
-import org.apache.ignite.internal.systemview.SystemViewManagerImpl;
+import org.apache.ignite.internal.systemview.api.SystemViewManager;
 import org.apache.ignite.internal.table.distributed.TableManager;
-import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
 import org.apache.ignite.internal.tx.TxManager;
 import org.apache.ignite.internal.tx.impl.TransactionInflights;
 
@@ -80,20 +80,20 @@ public SqlQueryProcessor sqlQueryProcessor(
             SchemaManager schemaManager,
             ReplicaService replicaService,
             ClockService clockService,
-            SchemaSyncServiceImpl schemaSyncService,
-            CatalogManagerImpl catalogManager,
+            SchemaSyncService schemaSyncService,
+            CatalogManager catalogManager,
             MetricManager metricManager,
-            SystemViewManagerImpl systemViewManager,
+            SystemViewManager systemViewManager,
             FailureManager failureManager,
             PlacementDriver placementDriver,
             SqlDistributedConfiguration sqlDistributedConfiguration,
             SqlLocalConfiguration sqlLocalConfiguration,
             TransactionInflights transactionInflights,
             TxManager txManager,
-            LowWatermarkImpl lowWatermark,
+            LowWatermark lowWatermark,
             @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             KillCommandHandler killCommandHandler,
-            EventLogImpl eventLog
+            EventLog eventLog
     ) {
         return new SqlQueryProcessor(
                 clusterService,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index aedea7d4b524..8ddb520654f4 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -34,16 +34,17 @@
 import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
 import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
-import org.apache.ignite.internal.hlc.ClockServiceImpl;
+import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
-import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
+import org.apache.ignite.internal.lowwatermark.LowWatermark;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.replicator.ReplicaService;
-import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorServiceImpl;
-import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
+import org.apache.ignite.internal.schema.SchemaSyncService;
+import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorService;
 import org.apache.ignite.internal.vault.VaultManager;
 
 /**
@@ -104,12 +105,12 @@ public CatalogCompactionRunner catalogCompactionRunner(
             LogicalTopologyService logicalTopologyService,
             PlacementDriver placementDriver,
             ReplicaService replicaService,
-            ClockServiceImpl clockService,
-            SchemaSyncServiceImpl schemaSyncService,
-            LowWatermarkImpl lowWatermark,
+            ClockService clockService,
+            SchemaSyncService schemaSyncService,
+            LowWatermark lowWatermark,
             IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker,
-            MinimumRequiredTimeCollectorServiceImpl minTimeCollectorService,
-            MetaStorageManagerImpl metaStorageManager
+            MinimumRequiredTimeCollectorService minTimeCollectorService,
+            MetaStorageManager metaStorageManager
     ) {
         return new CatalogCompactionRunner(
                 seedParams.nodeName(),

From ac6a9047586b9f90e82897dde11e0e73a320dcc3 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 17:15:22 +0400
Subject: [PATCH 42/79] Migrate additional components to use interfaces over
 implementations in dependency injection

---
 .../internal/app/di/ClusterManagementFactory.java      | 10 +++++-----
 .../apache/ignite/internal/app/di/DataPathFactory.java |  7 ++++---
 .../ignite/internal/app/di/MetaStorageFactory.java     |  4 ++--
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 6ab10acbd654..99f525bdf777 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -24,13 +24,13 @@
 import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
 import org.apache.ignite.internal.cluster.management.ClusterInitializer;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
-import org.apache.ignite.internal.cluster.management.NodeAttributesCollector;
+import org.apache.ignite.internal.cluster.management.NodeAttributes;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesConfiguration;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesExtensionConfiguration;
 import org.apache.ignite.internal.cluster.management.raft.ClusterStateStorageManager;
 import org.apache.ignite.internal.cluster.management.raft.RocksDbClusterStateStorage;
 import org.apache.ignite.internal.cluster.management.raft.ValidationManager;
-import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
+import org.apache.ignite.internal.cluster.management.topology.LogicalTopology;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
@@ -182,9 +182,9 @@ public ClusterManagementGroupManager clusterManagementGroupManager(
             ClusterInitializer clusterInitializer,
             RaftManager raftManager,
             ClusterStateStorageManager clusterStateStorageManager,
-            LogicalTopologyImpl logicalTopology,
+            LogicalTopology logicalTopology,
             ValidationManager validationManager,
-            NodeAttributesCollector nodeAttributesCollector,
+            NodeAttributes nodeAttributes,
             FailureManager failureManager,
             ClusterIdService clusterIdService,
             @Named("cmg") RaftGroupOptionsConfigurer cmgRaftConfigurer,
@@ -199,7 +199,7 @@ public ClusterManagementGroupManager clusterManagementGroupManager(
                 clusterStateStorageManager,
                 logicalTopology,
                 validationManager,
-                nodeAttributesCollector,
+                nodeAttributes,
                 failureManager,
                 clusterIdService,
                 cmgRaftConfigurer,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index d7daa995346c..739a527a9f7c 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -71,6 +71,7 @@
 import org.apache.ignite.internal.replicator.VersionedAssignments;
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.schema.SchemaManager;
+import org.apache.ignite.internal.schema.SchemaSafeTimeTracker;
 import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
 import org.apache.ignite.internal.schema.SchemaSyncService;
 import org.apache.ignite.internal.schema.configuration.GcConfiguration;
@@ -82,7 +83,7 @@
 import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
 import org.apache.ignite.internal.table.distributed.TableManager;
 import org.apache.ignite.internal.table.distributed.index.IndexMetaStorage;
-import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorServiceImpl;
+import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorService;
 import org.apache.ignite.internal.table.distributed.raft.PartitionSafeTimeValidator;
 import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
 import org.apache.ignite.internal.table.distributed.schema.ThreadLocalPartitionCommandsMarshaller;
@@ -122,7 +123,7 @@ public SchemaSafeTimeTrackerImpl schemaSafeTimeTracker(MetaStorageManager metaSt
     /** Creates the schema sync service. */
     @Singleton
     public SchemaSyncServiceImpl schemaSyncService(
-            SchemaSafeTimeTrackerImpl schemaSafeTimeTracker,
+            SchemaSafeTimeTracker schemaSafeTimeTracker,
             SchemaSynchronizationConfiguration schemaSyncConfig
     ) {
         LongSupplier delayDurationMsSupplier = () -> schemaSyncConfig.delayDurationMillis().value();
@@ -367,7 +368,7 @@ public TableManager tableManager(
             TransactionInflights transactionInflights,
             IndexMetaStorage indexMetaStorage,
             PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
-            MinimumRequiredTimeCollectorServiceImpl minTimeCollectorService,
+            MinimumRequiredTimeCollectorService minTimeCollectorService,
             SystemDistributedConfiguration systemDistributedConfiguration,
             MetricManager metricManager,
             PartitionModificationCounterFactory partitionModificationCounterFactory
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index 5a02ce3d8143..521f100bb512 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -34,8 +34,8 @@
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
-import org.apache.ignite.internal.disaster.system.MetastorageRepairImpl;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
+import org.apache.ignite.internal.disaster.system.repair.MetastorageRepair;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
@@ -103,7 +103,7 @@ public MetaStorageManagerImpl metaStorageManager(
             TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
             MetricManager metricManager,
             SystemDisasterRecoveryStorage systemDisasterRecoveryStorage,
-            MetastorageRepairImpl metastorageRepair,
+            MetastorageRepair metastorageRepair,
             @Named("metastorage") RaftGroupOptionsConfigurer msRaftConfigurer,
             ReadOperationForCompactionTracker readOperationForCompactionTracker,
             @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,

From f0cff0775f30d53f5c30a968c9b1e36e792f51ca Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 17:38:57 +0400
Subject: [PATCH 43/79] ignite-di-claude Migrate components from
 `NodeSeedParams` to `NodeIdentity` in dependency injection

---
 .../internal/app/di/CatalogFactory.java       |  9 ++++---
 .../app/di/ClusterManagementFactory.java      |  8 +++---
 .../internal/app/di/ComputeFactory.java       | 15 ++++++-----
 .../internal/app/di/DataPathFactory.java      | 26 ++++++++++---------
 .../app/di/IgniteConfigurationFactory.java    |  9 +++++--
 .../internal/app/di/MetaStorageFactory.java   |  5 ++--
 .../app/di/NetworkComponentsFactory.java      |  4 ++-
 .../ignite/internal/app/di/RaftFactory.java   | 25 +++++++++---------
 .../app/di/SystemServicesFactory.java         | 12 +++++----
 .../internal/app/di/TransactionFactory.java   | 13 +++++-----
 10 files changed, 72 insertions(+), 54 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index f5155f2090d2..cdb48b2c8790 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -31,6 +31,7 @@
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
 import org.apache.ignite.internal.failure.FailureManager;
@@ -80,7 +81,7 @@ public ClockServiceImpl clockService(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(600)
     public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             MetaStorageManagerImpl metaStorageManager,
             RaftConfiguration raftConfiguration,
@@ -88,7 +89,7 @@ public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
             FailureManager failureManager
     ) {
         return new IdempotentCacheVacuumizer(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 commonScheduler,
                 metaStorageManager::evictIdempotentCommandsCache,
                 raftConfiguration.retryTimeoutMillis(),
@@ -127,7 +128,7 @@ public CatalogManagerImpl catalogManager(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(800)
     public PlacementDriverManager placementDriverManager(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             MetaStorageManager metaStorageManager,
             ClusterService clusterService,
             ClusterManagementGroupManager cmgManager,
@@ -142,7 +143,7 @@ public PlacementDriverManager placementDriverManager(
             Provider<DistributionZoneManager> distributionZoneManagerProvider
     ) {
         return new PlacementDriverManager(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 metaStorageManager,
                 MetastorageGroupId.INSTANCE,
                 clusterService,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 99f525bdf777..b19ab04dce72 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -32,6 +32,7 @@
 import org.apache.ignite.internal.cluster.management.raft.ValidationManager;
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopology;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationDynamicDefaultsPatcherImpl;
@@ -82,6 +83,7 @@ public MessageSerializationRegistry messageSerializationRegistry(NodeSeedParams
     @IgniteStartupPhase(StartupPhase.PHASE_1)
     @Order(1300)
     public ClusterService clusterService(
+            NodeIdentity nodeIdentity,
             NodeSeedParams seedParams,
             NetworkConfiguration networkConfiguration,
             NettyBootstrapFactory nettyBootstrapFactory,
@@ -92,7 +94,7 @@ public ClusterService clusterService(
             MetricManager metricManager
     ) {
         return new ScaleCubeClusterService(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 networkConfiguration,
                 nettyBootstrapFactory,
                 serializationRegistry,
@@ -137,8 +139,8 @@ public StorageConfiguration storageConfiguration(@Named("nodeConfig") Configurat
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
     @Order(700)
-    public RocksDbClusterStateStorage clusterStateStorage(@Named("cmg") ComponentWorkingDir cmgWorkDir, NodeSeedParams seedParams) {
-        return new RocksDbClusterStateStorage(cmgWorkDir.dbPath(), seedParams.nodeName());
+    public RocksDbClusterStateStorage clusterStateStorage(@Named("cmg") ComponentWorkingDir cmgWorkDir, NodeIdentity nodeIdentity) {
+        return new RocksDbClusterStateStorage(cmgWorkDir.dbPath(), nodeIdentity.nodeName());
     }
 
     /** Creates the distributed configuration tree generator. */
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index 56fd34ff578e..325eb27a99b8 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -26,6 +26,7 @@
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.ComputeComponentImpl;
 import org.apache.ignite.internal.compute.IgniteComputeImpl;
@@ -103,7 +104,7 @@ public DeploymentManagerImpl deploymentManager(
             ClusterService clusterService,
             MetaStorageManager metaStorageManager,
             LogicalTopologyService logicalTopologyService,
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             DeploymentConfiguration deploymentConfiguration,
             ClusterManagementGroupManager cmgManager,
             ComputeExecutorImpl computeExecutor
@@ -112,10 +113,10 @@ public DeploymentManagerImpl deploymentManager(
                 clusterService,
                 new DeploymentUnitStoreImpl(metaStorageManager),
                 logicalTopologyService,
-                seedParams.workDir(),
+                nodeIdentity.workDir(),
                 deploymentConfiguration,
                 cmgManager,
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 computeExecutor::onUnitRemoving
         );
     }
@@ -125,7 +126,7 @@ public DeploymentManagerImpl deploymentManager(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(1200)
     public ComputeComponentImpl computeComponent(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             @Named("clusterMessaging") MessagingService clusterMessagingService,
             TopologyService topologyService,
             LogicalTopologyService logicalTopologyService,
@@ -136,7 +137,7 @@ public ComputeComponentImpl computeComponent(
             HybridTimestampTracker observableTimestampTracker
     ) {
         return new ComputeComponentImpl(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 clusterMessagingService,
                 topologyService,
                 logicalTopologyService,
@@ -157,7 +158,7 @@ public ComputeComponentImpl computeComponent(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(1300)
     public IgniteComputeInternal igniteCompute(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             PlacementDriver placementDriver,
             TopologyService topologyService,
             TableManager tableManager,
@@ -166,7 +167,7 @@ public IgniteComputeInternal igniteCompute(
             HybridTimestampTracker observableTimestampTracker
     ) {
         return new IgniteComputeImpl(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 placementDriver,
                 topologyService,
                 tableManager,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 739a527a9f7c..2f2b74c738c9 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -38,6 +38,7 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.LongJvmPauseDetector;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
@@ -105,10 +106,10 @@ public class DataPathFactory {
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(1300)
-    public VolatileLogStorageManagerCreator volatileLogStorageManagerCreator(NodeSeedParams seedParams) {
+    public VolatileLogStorageManagerCreator volatileLogStorageManagerCreator(NodeIdentity nodeIdentity) {
         return new VolatileLogStorageManagerCreator(
-                seedParams.nodeName(),
-                seedParams.workDir().resolve("volatile-log-spillout")
+                nodeIdentity.nodeName(),
+                nodeIdentity.workDir().resolve("volatile-log-spillout")
         );
     }
 
@@ -141,7 +142,7 @@ public HybridTimestampTracker hybridTimestampTracker() {
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(1500)
     public ReplicaManager replicaManager(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             ClusterService clusterService,
             ClusterManagementGroupManager cmgManager,
             MetaStorageManager metaStorageManager,
@@ -161,7 +162,7 @@ public ReplicaManager replicaManager(
             @Named("commonScheduler") ScheduledExecutorService commonScheduler
     ) {
         return new ReplicaManager(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 clusterService,
                 cmgManager,
                 groupId -> zonePartitionStableAssignments(metaStorageManager, groupId),
@@ -197,6 +198,7 @@ public ReplicaManager replicaManager(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(1800)
     public DataStorageManager dataStorageManager(
+            NodeIdentity nodeIdentity,
             NodeSeedParams seedParams,
             MetricManager metricManager,
             @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry,
@@ -215,7 +217,7 @@ public DataStorageManager dataStorageManager(
         Path storagePath = partitionsWorkDir.dbPath();
 
         Map<String, StorageEngine> storageEngines = dataStorageModules.createStorageEngines(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 metricManager,
                 nodeConfigRegistry,
                 storagePath,
@@ -234,7 +236,7 @@ public DataStorageManager dataStorageManager(
     @IgniteStartupPhase(StartupPhase.PHASE_1)
     @Order(2000)
     public LowWatermarkImpl lowWatermark(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             GcConfiguration gcConfiguration,
             ClockService clockService,
             VaultManager vaultManager,
@@ -242,7 +244,7 @@ public LowWatermarkImpl lowWatermark(
             @Named("clusterMessaging") MessagingService clusterMessagingService
     ) {
         return new LowWatermarkImpl(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 gcConfiguration.lowWatermark(),
                 clockService,
                 vaultManager,
@@ -256,7 +258,7 @@ public LowWatermarkImpl lowWatermark(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(1100)
     public DistributionZoneManager distributionZoneManager(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             TopologyService topologyService,
             MetaStorageManager metaStorageManager,
             LogicalTopologyService logicalTopologyService,
@@ -268,7 +270,7 @@ public DistributionZoneManager distributionZoneManager(
             LowWatermark lowWatermark
     ) {
         return new DistributionZoneManager(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 () -> topologyService.localMember().id(),
                 metaStorageManager,
                 logicalTopologyService,
@@ -340,7 +342,7 @@ public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(2400)
     public TableManager tableManager(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             MetaStorageRevisionListenerRegistry revisionListenerRegistry,
             GcConfiguration gcConfiguration,
             ReplicationConfiguration replicationConfiguration,
@@ -374,7 +376,7 @@ public TableManager tableManager(
             PartitionModificationCounterFactory partitionModificationCounterFactory
     ) {
         return new TableManager(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 revisionListenerRegistry,
                 gcConfiguration,
                 replicationConfiguration,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
index 14cd233199eb..d21648c7aa7f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
@@ -20,6 +20,7 @@
 import io.micronaut.context.annotation.Factory;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
@@ -36,11 +37,15 @@
  */
 @Factory
 public class IgniteConfigurationFactory {
+    private final NodeIdentity nodeIdentity;
+
     private final NodeSeedParams seedParams;
 
     private final ConfigurationModules modules;
 
-    public IgniteConfigurationFactory(NodeSeedParams seedParams, ConfigurationModules modules) {
+    /** Constructor. */
+    public IgniteConfigurationFactory(NodeIdentity nodeIdentity, NodeSeedParams seedParams, ConfigurationModules modules) {
+        this.nodeIdentity = nodeIdentity;
         this.seedParams = seedParams;
         this.modules = modules;
     }
@@ -62,7 +67,7 @@ public LocalFileConfigurationStorage localFileConfigurationStorage(
             @Named("local") ConfigurationTreeGenerator generator
     ) {
         return new LocalFileConfigurationStorage(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 seedParams.configPath(),
                 generator,
                 modules.local()
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index 521f100bb512..549d0823e496 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -27,6 +27,7 @@
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
@@ -74,14 +75,14 @@ public TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory
     /** Creates the RocksDB key-value storage for metastorage. */
     @Singleton
     public RocksDbKeyValueStorage metastorageKeyValueStorage(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             @Named("metastorage") ComponentWorkingDir metastorageWorkDir,
             FailureManager failureManager,
             ReadOperationForCompactionTracker readOperationForCompactionTracker,
             @Named("commonScheduler") ScheduledExecutorService commonScheduler
     ) {
         return new RocksDbKeyValueStorage(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 metastorageWorkDir.dbPath(),
                 failureManager,
                 readOperationForCompactionTracker,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index 5c0b6ed0910b..00d1a136f540 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -23,6 +23,7 @@
 import jakarta.inject.Singleton;
 import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
@@ -67,10 +68,11 @@ public SystemLocalConfiguration systemLocalConfiguration(@Named("nodeConfig") Co
     @IgniteStartupPhase(StartupPhase.PHASE_1)
     @Order(600)
     public FailureManager failureManager(
+            NodeIdentity nodeIdentity,
             NodeSeedParams seedParams,
             FailureProcessorConfiguration failureProcessorConfiguration
     ) {
-        return new FailureManager(seedParams.nodeName(), seedParams.node()::shutdown, failureProcessorConfiguration);
+        return new FailureManager(nodeIdentity.nodeName(), seedParams.node()::shutdown, failureProcessorConfiguration);
     }
 
     /** Creates the critical worker watchdog. */
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
index 1638cfa51e9f..8cff5d8fc406 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
@@ -29,6 +29,7 @@
 import java.util.Map;
 import org.apache.ignite.internal.cluster.management.CmgGroupId;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
@@ -60,22 +61,22 @@ public RaftConfiguration raftConfiguration(@Named("nodeConfig") ConfigurationReg
     /** Creates the partitions working directory. */
     @Singleton
     @Named("partitions")
-    public ComponentWorkingDir partitionsWorkDir(SystemLocalConfiguration systemConfiguration, NodeSeedParams seedParams) {
-        return partitionsPath(systemConfiguration, seedParams.workDir());
+    public ComponentWorkingDir partitionsWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
+        return partitionsPath(systemConfiguration, nodeIdentity.workDir());
     }
 
     /** Creates the metastorage working directory. */
     @Singleton
     @Named("metastorage")
-    public ComponentWorkingDir metastorageWorkDir(SystemLocalConfiguration systemConfiguration, NodeSeedParams seedParams) {
-        return metastoragePath(systemConfiguration, seedParams.workDir());
+    public ComponentWorkingDir metastorageWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
+        return metastoragePath(systemConfiguration, nodeIdentity.workDir());
     }
 
     /** Creates the CMG working directory. */
     @Singleton
     @Named("cmg")
-    public ComponentWorkingDir cmgWorkDir(SystemLocalConfiguration systemConfiguration, NodeSeedParams seedParams) {
-        return cmgPath(systemConfiguration, seedParams.workDir());
+    public ComponentWorkingDir cmgWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
+        return cmgPath(systemConfiguration, nodeIdentity.workDir());
     }
 
     /** Creates the partitions log storage manager. */
@@ -84,13 +85,13 @@ public ComponentWorkingDir cmgWorkDir(SystemLocalConfiguration systemConfigurati
     @IgniteStartupPhase(StartupPhase.PHASE_1)
     @Order(1500)
     public LogStorageManager partitionsLogStorageManager(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             RaftConfiguration raftConfiguration,
             @Named("partitions") ComponentWorkingDir partitionsWorkDir
     ) {
         return SharedLogStorageManagerUtils.create(
                 "table data log",
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 partitionsWorkDir.raftLogPath(),
                 raftConfiguration.fsync().value()
         );
@@ -102,12 +103,12 @@ public LogStorageManager partitionsLogStorageManager(
     @IgniteStartupPhase(StartupPhase.PHASE_1)
     @Order(1600)
     public LogStorageManager msLogStorageManager(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             @Named("metastorage") ComponentWorkingDir metastorageWorkDir
     ) {
         return SharedLogStorageManagerUtils.create(
                 "meta-storage log",
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 metastorageWorkDir.raftLogPath(),
                 true
         );
@@ -119,12 +120,12 @@ public LogStorageManager msLogStorageManager(
     @IgniteStartupPhase(StartupPhase.PHASE_1)
     @Order(1700)
     public LogStorageManager cmgLogStorageManager(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             @Named("cmg") ComponentWorkingDir cmgWorkDir
     ) {
         return SharedLogStorageManagerUtils.create(
                 "cluster-management-group log",
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 cmgWorkDir.raftLogPath(),
                 true
         );
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 8ddb520654f4..6bf3901a82b3 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -27,6 +27,7 @@
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
@@ -59,12 +60,12 @@ public class SystemServicesFactory {
     public EventLogImpl eventLog(
             @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry,
             Provider<ClusterManagementGroupManager> cmgManagerProvider,
-            NodeSeedParams seedParams
+            NodeIdentity nodeIdentity
     ) {
         return new EventLogImpl(
                 clusterConfigRegistry.getConfiguration(EventLogExtensionConfiguration.KEY).eventlog(),
                 () -> cmgManagerProvider.get().clusterState().join().clusterTag().clusterId(),
-                seedParams.nodeName()
+                nodeIdentity.nodeName()
         );
     }
 
@@ -73,6 +74,7 @@ public EventLogImpl eventLog(
     @IgniteStartupPhase(StartupPhase.PHASE_1)
     @Order(900)
     public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
+            NodeIdentity nodeIdentity,
             NodeSeedParams seedParams,
             TopologyService topologyService,
             @Named("clusterMessaging") MessagingService clusterMessagingService,
@@ -82,7 +84,7 @@ public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
             ClusterIdService clusterIdService
     ) {
         return new SystemDisasterRecoveryManagerImpl(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 topologyService,
                 clusterMessagingService,
                 vaultManager,
@@ -98,7 +100,7 @@ public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(300)
     public CatalogCompactionRunner catalogCompactionRunner(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             CatalogManagerImpl catalogManager,
             @Named("clusterMessaging") MessagingService clusterMessagingService,
             TopologyService topologyService,
@@ -113,7 +115,7 @@ public CatalogCompactionRunner catalogCompactionRunner(
             MetaStorageManager metaStorageManager
     ) {
         return new CatalogCompactionRunner(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 catalogManager,
                 clusterMessagingService,
                 logicalTopologyService,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 71627890f53a..e1d35a28991e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -24,6 +24,7 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
@@ -86,12 +87,12 @@ public GcConfiguration gcConfiguration(@Named("clusterConfig") ConfigurationRegi
     @Named("storageOperations")
     public MessagingService storageOperationsMessagingService(
             @Named("clusterMessaging") MessagingService clusterMessagingService,
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor
     ) {
         return new JumpToExecutorByConsistentIdAfterSend(
                 clusterMessagingService,
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 message -> partitionOperationsExecutor
         );
     }
@@ -107,7 +108,7 @@ public TransactionIdGenerator transactionIdGenerator(ClusterService clusterServi
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(1700)
     public TxManagerImpl txManager(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             TransactionConfiguration txConfig,
             SystemDistributedConfiguration systemDistributedConfiguration,
             @Named("storageOperations") MessagingService messagingService,
@@ -129,7 +130,7 @@ public TxManagerImpl txManager(
             @Named("commonScheduler") ScheduledExecutorService commonScheduler
     ) {
         return new TxManagerImpl(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 txConfig,
                 systemDistributedConfiguration,
                 messagingService,
@@ -157,7 +158,7 @@ public TxManagerImpl txManager(
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(1800)
     public TxStateRocksDbSharedStorage txStateRocksDbSharedStorage(
-            NodeSeedParams seedParams,
+            NodeIdentity nodeIdentity,
             @Named("partitions") ComponentWorkingDir partitionsWorkDir,
             @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
@@ -165,7 +166,7 @@ public TxStateRocksDbSharedStorage txStateRocksDbSharedStorage(
             FailureManager failureManager
     ) {
         return new TxStateRocksDbSharedStorage(
-                seedParams.nodeName(),
+                nodeIdentity.nodeName(),
                 partitionsWorkDir.dbPath().resolve("tx-state"),
                 commonScheduler,
                 tableIoExecutor,

From c971a48c79fd0e6e05296bf6ac7bc13a675a3e14 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 17:59:29 +0400
Subject: [PATCH 44/79] Optimize imports in `MetricManagerImpl` and `Loza`
 classes.

---
 .../apache/ignite/internal/metrics/MetricManagerImpl.java   | 6 +++---
 .../src/main/java/org/apache/ignite/internal/raft/Loza.java | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java
index 2da213f9c14b..88710e47ae97 100644
--- a/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java
+++ b/modules/metrics/src/main/java/org/apache/ignite/internal/metrics/MetricManagerImpl.java
@@ -34,6 +34,9 @@
 import java.util.function.Supplier;
 import org.apache.ignite.configuration.notifications.ConfigurationNamedListListener;
 import org.apache.ignite.configuration.notifications.ConfigurationNotificationEvent;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -42,9 +45,6 @@
 import org.apache.ignite.internal.metrics.exporters.configuration.ExporterView;
 import org.apache.ignite.internal.metrics.exporters.configuration.LogPushExporterConfigurationSchema;
 import org.apache.ignite.internal.metrics.exporters.configuration.LogPushExporterView;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.metrics.exporters.log.LogPushExporter;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.annotations.VisibleForTesting;
diff --git a/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java b/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
index f46ba2e4951b..3d78c636335a 100644
--- a/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
+++ b/modules/raft/src/main/java/org/apache/ignite/internal/raft/Loza.java
@@ -32,10 +32,10 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
-import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
-import org.apache.ignite.internal.configuration.SystemPropertyConfiguration;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
+import org.apache.ignite.internal.configuration.SystemPropertyConfiguration;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.lang.IgniteInternalException;

From 8183163f748dea5c689cfa588f207a9e31a9086e Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 18:38:07 +0400
Subject: [PATCH 45/79] Migrate `configPath` handling from `NodeSeedParams` to
 `NodeIdentity` across components

---
 .../ignite/internal/components/NodeIdentity.java       | 10 +++++++++-
 .../internal/app/di/IgniteConfigurationFactory.java    |  7 ++-----
 .../ignite/internal/app/di/IgniteNodeSeedFactory.java  |  2 +-
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java b/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
index dff95b5ed7aa..233e4ff9c6d7 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
@@ -32,12 +32,15 @@ public class NodeIdentity {
 
     private final Path workDir;
 
+    private final Path configPath;
+
     private final Supplier<UUID> clusterIdSupplier;
 
     /** Constructor. */
-    public NodeIdentity(String nodeName, Path workDir, Supplier<UUID> clusterIdSupplier) {
+    public NodeIdentity(String nodeName, Path workDir, Path configPath, Supplier<UUID> clusterIdSupplier) {
         this.nodeName = nodeName;
         this.workDir = workDir;
+        this.configPath = configPath;
         this.clusterIdSupplier = clusterIdSupplier;
     }
 
@@ -51,6 +54,11 @@ public Path workDir() {
         return workDir;
     }
 
+    /** Path to the node configuration file. */
+    public Path configPath() {
+        return configPath;
+    }
+
     /** Supplier of the cluster ID; resolved lazily after cluster initialization. */
     public Supplier<UUID> clusterIdSupplier() {
         return clusterIdSupplier;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
index d21648c7aa7f..c0e7d79e7a2e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
@@ -39,14 +39,11 @@
 public class IgniteConfigurationFactory {
     private final NodeIdentity nodeIdentity;
 
-    private final NodeSeedParams seedParams;
-
     private final ConfigurationModules modules;
 
     /** Constructor. */
-    public IgniteConfigurationFactory(NodeIdentity nodeIdentity, NodeSeedParams seedParams, ConfigurationModules modules) {
+    public IgniteConfigurationFactory(NodeIdentity nodeIdentity, ConfigurationModules modules) {
         this.nodeIdentity = nodeIdentity;
-        this.seedParams = seedParams;
         this.modules = modules;
     }
 
@@ -68,7 +65,7 @@ public LocalFileConfigurationStorage localFileConfigurationStorage(
     ) {
         return new LocalFileConfigurationStorage(
                 nodeIdentity.nodeName(),
-                seedParams.configPath(),
+                nodeIdentity.configPath(),
                 generator,
                 modules.local()
         );
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
index 20985c33cfe7..9069a41c38e2 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
@@ -40,7 +40,7 @@ public IgniteNodeSeedFactory(NodeSeedParams seedParams) {
     /** Creates the node identity POJO for injection into components across modules. */
     @Singleton
     public NodeIdentity nodeIdentity() {
-        return new NodeIdentity(seedParams.nodeName(), seedParams.workDir(), seedParams.clusterIdSupplier());
+        return new NodeIdentity(seedParams.nodeName(), seedParams.workDir(), seedParams.configPath(), seedParams.clusterIdSupplier());
     }
 
     /** Creates the persistent vault service backed by the node's work directory. */

From f1d6fe122523758dfc34a99a8055559bb08f34e1 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 18:45:57 +0400
Subject: [PATCH 46/79] Add support for including specific packages in bean
 discovery through `IgniteDiContext`

---
 .../ignite/internal/di/IgniteDiContext.java   | 28 +++++++++++++++++--
 .../IgniteComponentLifecycleManagerTest.java  | 20 +++++++++----
 2 files changed, 40 insertions(+), 8 deletions(-)

diff --git a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
index 9b94aaa989c2..c430704c4406 100644
--- a/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
+++ b/modules/di/src/main/java/org/apache/ignite/internal/di/IgniteDiContext.java
@@ -59,6 +59,8 @@ public static class Builder {
 
         private final List<String> excludedPackages = new ArrayList<>();
 
+        private final List<String> includedPackages = new ArrayList<>();
+
         /**
          * Registers a seed singleton that will be available for injection in the context.
          *
@@ -96,6 +98,18 @@ public Builder withExcludedPackages(String... packagePrefixes) {
             return this;
         }
 
+        /**
+         * Restricts bean discovery to only the specified packages. Bean definitions whose generated class name
+         * does not start with any of the given package prefixes will not be loaded into the context.
+         *
+         * @param packagePrefixes Package prefixes to include (e.g., {@code "org.apache.ignite.internal.di"}).
+         * @return This builder for chaining.
+         */
+        public Builder withIncludedPackages(String... packagePrefixes) {
+            Collections.addAll(includedPackages, packagePrefixes);
+            return this;
+        }
+
         /**
          * Builds and starts the Micronaut {@link ApplicationContext}.
          *
@@ -114,15 +128,16 @@ public ApplicationContext build() {
                 contextBuilder.singletons(singletons.toArray());
             }
 
-            if (excludedPackages.isEmpty()) {
+            if (excludedPackages.isEmpty() && includedPackages.isEmpty()) {
                 return contextBuilder.start();
             }
 
-            // Build the context manually so we can override bean discovery to exclude
+            // Build the context manually so we can override bean discovery to filter
             // unwanted packages (e.g., REST module beans that conflict with core DI beans).
             // We replicate the singleton registration that ApplicationContextBuilder.build() does,
             // because DefaultApplicationContext(configuration) doesn't auto-register them.
             List<String> excluded = List.copyOf(excludedPackages);
+            List<String> included = List.copyOf(includedPackages);
 
             @SuppressWarnings("rawtypes")
             ApplicationContext context = new DefaultApplicationContext((ApplicationContextConfiguration) contextBuilder) {
@@ -139,6 +154,15 @@ protected List<BeanDefinitionReference> resolveBeanDefinitionReferences() {
                             }
                         }
 
+                        if (!included.isEmpty() && name.startsWith("org.apache.ignite.")) {
+                            for (String pkg : included) {
+                                if (name.startsWith(pkg + ".")) {
+                                    return false;
+                                }
+                            }
+                            return true;
+                        }
+
                         return false;
                     });
 
diff --git a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
index 0bf316035b60..ce568a0413e0 100644
--- a/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
+++ b/modules/di/src/test/java/org/apache/ignite/internal/di/IgniteComponentLifecycleManagerTest.java
@@ -56,7 +56,9 @@ void tearDown() {
 
     @Test
     void componentsGroupedByPhase() {
-        appContext = ApplicationContext.builder().start();
+        appContext = IgniteDiContext.builder()
+                .withIncludedPackages("org.apache.ignite.internal.di")
+                .build();
 
         IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
 
@@ -67,7 +69,9 @@ void componentsGroupedByPhase() {
 
     @Test
     void startPhaseStartsComponentsAndTracksOrder() {
-        appContext = ApplicationContext.builder().start();
+        appContext = IgniteDiContext.builder()
+                .withIncludedPackages("org.apache.ignite.internal.di")
+                .build();
 
         IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
 
@@ -87,9 +91,11 @@ void stopAllStopsInReverseStartOrder() {
         TrackingComponentA compA = new TrackingComponentA();
         TrackingComponentB compB = new TrackingComponentB();
 
-        appContext = ApplicationContext.builder()
-                .singletons(compA, compB)
-                .start();
+        appContext = IgniteDiContext.builder()
+                .withSingleton(compA)
+                .withSingleton(compB)
+                .withIncludedPackages("org.apache.ignite.internal.di")
+                .build();
 
         IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
 
@@ -146,7 +152,9 @@ void stopAllStopsInReverseStartOrder() {
 
     @Test
     void multiPhaseStartAndStop() {
-        appContext = ApplicationContext.builder().start();
+        appContext = IgniteDiContext.builder()
+                .withIncludedPackages("org.apache.ignite.internal.di")
+                .build();
 
         IgniteComponentLifecycleManager manager = new IgniteComponentLifecycleManager(appContext);
 

From ff82123bffe004ce0d3cf9c5a61a62c149e4783c Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 18:50:28 +0400
Subject: [PATCH 47/79] Migrate components to use `serviceProviderClassLoader`
 from `NodeSeedParams` in dependency injection

---
 .../app/di/ClusterManagementFactory.java      | 11 ++++++----
 .../internal/app/di/DataPathFactory.java      |  5 +++--
 .../app/di/IgniteNodeSeedFactory.java         | 20 +++++++++++++++----
 3 files changed, 26 insertions(+), 10 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index b19ab04dce72..ef7ae3d53792 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -63,6 +63,7 @@
 import org.apache.ignite.internal.vault.VaultManager;
 import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
 import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Micronaut factory for cluster management components.
@@ -71,8 +72,10 @@
 public class ClusterManagementFactory {
     /** Creates the message serialization registry, loading all serializers from the classpath. */
     @Singleton
-    public MessageSerializationRegistry messageSerializationRegistry(NodeSeedParams seedParams) {
-        var serviceLoader = new SerializationRegistryServiceLoader(seedParams.serviceProviderClassLoader());
+    public MessageSerializationRegistry messageSerializationRegistry(
+            @Named("serviceProviderClassLoader") @Nullable ClassLoader serviceProviderClassLoader
+    ) {
+        var serviceLoader = new SerializationRegistryServiceLoader(serviceProviderClassLoader);
         var registry = new MessageSerializationRegistryImpl();
         serviceLoader.registerSerializationFactories(registry);
         return registry;
@@ -84,7 +87,7 @@ public MessageSerializationRegistry messageSerializationRegistry(NodeSeedParams
     @Order(1300)
     public ClusterService clusterService(
             NodeIdentity nodeIdentity,
-            NodeSeedParams seedParams,
+            @Named("serviceProviderClassLoader") @Nullable ClassLoader serviceProviderClassLoader,
             NetworkConfiguration networkConfiguration,
             NettyBootstrapFactory nettyBootstrapFactory,
             MessageSerializationRegistry serializationRegistry,
@@ -102,7 +105,7 @@ public ClusterService clusterService(
                 clusterIdService,
                 criticalWorkerRegistry,
                 failureManager,
-                ChannelTypeRegistryProvider.loadByServiceLoader(seedParams.serviceProviderClassLoader()),
+                ChannelTypeRegistryProvider.loadByServiceLoader(serviceProviderClassLoader),
                 new DefaultIgniteProductVersionSource(),
                 metricManager
         );
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 2f2b74c738c9..f8497a473006 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -96,6 +96,7 @@
 import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
 import org.apache.ignite.internal.vault.VaultManager;
 import org.apache.ignite.sql.IgniteSql;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Micronaut factory for data path components.
@@ -199,7 +200,7 @@ public ReplicaManager replicaManager(
     @Order(1800)
     public DataStorageManager dataStorageManager(
             NodeIdentity nodeIdentity,
-            NodeSeedParams seedParams,
+            @Named("serviceProviderClassLoader") @Nullable ClassLoader serviceProviderClassLoader,
             MetricManager metricManager,
             @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry,
             @Named("partitions") ComponentWorkingDir partitionsWorkDir,
@@ -211,7 +212,7 @@ public DataStorageManager dataStorageManager(
             StorageConfiguration storageConfiguration
     ) {
         DataStorageModules dataStorageModules = new DataStorageModules(
-                ServiceLoader.load(DataStorageModule.class, seedParams.serviceProviderClassLoader())
+                ServiceLoader.load(DataStorageModule.class, serviceProviderClassLoader)
         );
 
         Path storagePath = partitionsWorkDir.dbPath();
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
index 9069a41c38e2..2ac4782577bb 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
@@ -20,11 +20,13 @@
 import static org.apache.ignite.internal.configuration.IgnitePaths.vaultPath;
 
 import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.vault.VaultService;
 import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Micronaut factory that produces infrastructure beans derived from {@link NodeSeedParams}.
@@ -45,13 +47,23 @@ public NodeIdentity nodeIdentity() {
 
     /** Creates the persistent vault service backed by the node's work directory. */
     @Singleton
-    public VaultService vaultService() {
-        return new PersistentVaultService(vaultPath(seedParams.workDir()));
+    public VaultService vaultService(NodeIdentity nodeIdentity) {
+        return new PersistentVaultService(vaultPath(nodeIdentity.workDir()));
+    }
+
+    /** Exposes the service provider class loader for ServiceLoader discovery. */
+    @Singleton
+    @Named("serviceProviderClassLoader")
+    @Nullable
+    public ClassLoader serviceProviderClassLoader() {
+        return seedParams.serviceProviderClassLoader();
     }
 
     /** Discovers configuration modules from the service provider class loader. */
     @Singleton
-    public ConfigurationModules configurationModules() {
-        return ConfigurationModules.create(seedParams.serviceProviderClassLoader());
+    public ConfigurationModules configurationModules(
+            @Named("serviceProviderClassLoader") @Nullable ClassLoader serviceProviderClassLoader
+    ) {
+        return ConfigurationModules.create(serviceProviderClassLoader);
     }
 }

From 01d665fa3b1e156873e3a339ae116c786cf74d52 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 19:06:46 +0400
Subject: [PATCH 48/79] Remove `NodeSeedParams` and migrate all dependencies to
 use `NodeIdentity`.

---
 .../internal/components/NodeIdentity.java     |  19 ++-
 .../ignite/internal/app/IgniteImpl.java       |  11 +-
 .../app/di/ClusterManagementFactory.java      |  10 +-
 .../internal/app/di/DataPathFactory.java      |   4 +-
 .../app/di/IgniteNodeSeedFactory.java         |  30 +----
 .../app/di/NetworkComponentsFactory.java      |   5 +-
 .../internal/app/di/NodeSeedParams.java       | 108 ------------------
 .../app/di/SystemServicesFactory.java         |   5 +-
 8 files changed, 36 insertions(+), 156 deletions(-)
 delete mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java

diff --git a/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java b/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
index 233e4ff9c6d7..d68d727de680 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/components/NodeIdentity.java
@@ -20,6 +20,7 @@
 import java.nio.file.Path;
 import java.util.UUID;
 import java.util.function.Supplier;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * Holds basic node identity and environment parameters that components across all modules commonly need.
@@ -34,13 +35,23 @@ public class NodeIdentity {
 
     private final Path configPath;
 
+    @Nullable
+    private final ClassLoader serviceProviderClassLoader;
+
     private final Supplier<UUID> clusterIdSupplier;
 
     /** Constructor. */
-    public NodeIdentity(String nodeName, Path workDir, Path configPath, Supplier<UUID> clusterIdSupplier) {
+    public NodeIdentity(
+            String nodeName,
+            Path workDir,
+            Path configPath,
+            @Nullable ClassLoader serviceProviderClassLoader,
+            Supplier<UUID> clusterIdSupplier
+    ) {
         this.nodeName = nodeName;
         this.workDir = workDir;
         this.configPath = configPath;
+        this.serviceProviderClassLoader = serviceProviderClassLoader;
         this.clusterIdSupplier = clusterIdSupplier;
     }
 
@@ -59,6 +70,12 @@ public Path configPath() {
         return configPath;
     }
 
+    /** Class loader used to discover service providers, or {@code null} for the system class loader. */
+    @Nullable
+    public ClassLoader serviceProviderClassLoader() {
+        return serviceProviderClassLoader;
+    }
+
     /** Supplier of the cluster ID; resolved lazily after cluster initialization. */
     public Supplier<UUID> clusterIdSupplier() {
         return clusterIdSupplier;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index d5406bfd1b2a..33838b6a70ca 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -50,7 +50,6 @@
 import org.apache.ignite.client.handler.ClientInboundMessageHandler;
 import org.apache.ignite.client.handler.ClusterInfo;
 import org.apache.ignite.compute.IgniteCompute;
-import org.apache.ignite.internal.app.di.NodeSeedParams;
 import org.apache.ignite.internal.app.di.PostConstructionWiring;
 import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
@@ -67,6 +66,7 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.NodeProperties;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.AntiHijackIgniteCompute;
@@ -364,13 +364,12 @@ public class IgniteImpl implements Ignite {
         // Build the Micronaut DI context with seed singletons.
         Supplier<UUID> clusterIdSupplier = () -> clusterState().clusterTag().clusterId();
 
-        NodeSeedParams seedParams = new NodeSeedParams(
-                node, restarter, configPath, workDir, serviceProviderClassLoader, asyncContinuationExecutor,
-                clusterIdSupplier
-        );
+        NodeIdentity nodeIdentity = new NodeIdentity(name, workDir, configPath, serviceProviderClassLoader, clusterIdSupplier);
 
         diContext = IgniteDiContext.builder()
-                .withSingleton(seedParams)
+                .withSingleton(nodeIdentity)
+                .withSingleton(node)
+                .withSingleton(restarter)
                 .withSingleton(this)
                 .withPackages("org.apache.ignite.internal")
                 .withExcludedPackages("org.apache.ignite.internal.rest", "org.apache.ignite.internal.cli")
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index ef7ae3d53792..4b68ff7f7ed1 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -63,7 +63,6 @@
 import org.apache.ignite.internal.vault.VaultManager;
 import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
 import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * Micronaut factory for cluster management components.
@@ -72,10 +71,8 @@
 public class ClusterManagementFactory {
     /** Creates the message serialization registry, loading all serializers from the classpath. */
     @Singleton
-    public MessageSerializationRegistry messageSerializationRegistry(
-            @Named("serviceProviderClassLoader") @Nullable ClassLoader serviceProviderClassLoader
-    ) {
-        var serviceLoader = new SerializationRegistryServiceLoader(serviceProviderClassLoader);
+    public MessageSerializationRegistry messageSerializationRegistry(NodeIdentity nodeIdentity) {
+        var serviceLoader = new SerializationRegistryServiceLoader(nodeIdentity.serviceProviderClassLoader());
         var registry = new MessageSerializationRegistryImpl();
         serviceLoader.registerSerializationFactories(registry);
         return registry;
@@ -87,7 +84,6 @@ public MessageSerializationRegistry messageSerializationRegistry(
     @Order(1300)
     public ClusterService clusterService(
             NodeIdentity nodeIdentity,
-            @Named("serviceProviderClassLoader") @Nullable ClassLoader serviceProviderClassLoader,
             NetworkConfiguration networkConfiguration,
             NettyBootstrapFactory nettyBootstrapFactory,
             MessageSerializationRegistry serializationRegistry,
@@ -105,7 +101,7 @@ public ClusterService clusterService(
                 clusterIdService,
                 criticalWorkerRegistry,
                 failureManager,
-                ChannelTypeRegistryProvider.loadByServiceLoader(serviceProviderClassLoader),
+                ChannelTypeRegistryProvider.loadByServiceLoader(nodeIdentity.serviceProviderClassLoader()),
                 new DefaultIgniteProductVersionSource(),
                 metricManager
         );
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index f8497a473006..df0d301ba575 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -96,7 +96,6 @@
 import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
 import org.apache.ignite.internal.vault.VaultManager;
 import org.apache.ignite.sql.IgniteSql;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * Micronaut factory for data path components.
@@ -200,7 +199,6 @@ public ReplicaManager replicaManager(
     @Order(1800)
     public DataStorageManager dataStorageManager(
             NodeIdentity nodeIdentity,
-            @Named("serviceProviderClassLoader") @Nullable ClassLoader serviceProviderClassLoader,
             MetricManager metricManager,
             @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry,
             @Named("partitions") ComponentWorkingDir partitionsWorkDir,
@@ -212,7 +210,7 @@ public DataStorageManager dataStorageManager(
             StorageConfiguration storageConfiguration
     ) {
         DataStorageModules dataStorageModules = new DataStorageModules(
-                ServiceLoader.load(DataStorageModule.class, serviceProviderClassLoader)
+                ServiceLoader.load(DataStorageModule.class, nodeIdentity.serviceProviderClassLoader())
         );
 
         Path storagePath = partitionsWorkDir.dbPath();
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
index 2ac4782577bb..ff12e5e3a414 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
@@ -20,50 +20,26 @@
 import static org.apache.ignite.internal.configuration.IgnitePaths.vaultPath;
 
 import io.micronaut.context.annotation.Factory;
-import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.vault.VaultService;
 import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
-import org.jetbrains.annotations.Nullable;
 
 /**
- * Micronaut factory that produces infrastructure beans derived from {@link NodeSeedParams}.
+ * Micronaut factory that produces infrastructure beans from seed singletons registered in the DI context.
  */
 @Factory
 public class IgniteNodeSeedFactory {
-    private final NodeSeedParams seedParams;
-
-    public IgniteNodeSeedFactory(NodeSeedParams seedParams) {
-        this.seedParams = seedParams;
-    }
-
-    /** Creates the node identity POJO for injection into components across modules. */
-    @Singleton
-    public NodeIdentity nodeIdentity() {
-        return new NodeIdentity(seedParams.nodeName(), seedParams.workDir(), seedParams.configPath(), seedParams.clusterIdSupplier());
-    }
-
     /** Creates the persistent vault service backed by the node's work directory. */
     @Singleton
     public VaultService vaultService(NodeIdentity nodeIdentity) {
         return new PersistentVaultService(vaultPath(nodeIdentity.workDir()));
     }
 
-    /** Exposes the service provider class loader for ServiceLoader discovery. */
-    @Singleton
-    @Named("serviceProviderClassLoader")
-    @Nullable
-    public ClassLoader serviceProviderClassLoader() {
-        return seedParams.serviceProviderClassLoader();
-    }
-
     /** Discovers configuration modules from the service provider class loader. */
     @Singleton
-    public ConfigurationModules configurationModules(
-            @Named("serviceProviderClassLoader") @Nullable ClassLoader serviceProviderClassLoader
-    ) {
-        return ConfigurationModules.create(serviceProviderClassLoader);
+    public ConfigurationModules configurationModules(NodeIdentity nodeIdentity) {
+        return ConfigurationModules.create(nodeIdentity.serviceProviderClassLoader());
     }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index 00d1a136f540..d292b3202a5e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -22,6 +22,7 @@
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import java.util.concurrent.ScheduledExecutorService;
+import org.apache.ignite.IgniteServer;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
@@ -69,10 +70,10 @@ public SystemLocalConfiguration systemLocalConfiguration(@Named("nodeConfig") Co
     @Order(600)
     public FailureManager failureManager(
             NodeIdentity nodeIdentity,
-            NodeSeedParams seedParams,
+            IgniteServer igniteServer,
             FailureProcessorConfiguration failureProcessorConfiguration
     ) {
-        return new FailureManager(nodeIdentity.nodeName(), seedParams.node()::shutdown, failureProcessorConfiguration);
+        return new FailureManager(nodeIdentity.nodeName(), igniteServer::shutdown, failureProcessorConfiguration);
     }
 
     /** Creates the critical worker watchdog. */
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java
deleted file mode 100644
index d316ced7c10b..000000000000
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NodeSeedParams.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.app.di;
-
-import java.nio.file.Path;
-import java.util.UUID;
-import java.util.concurrent.Executor;
-import java.util.function.Supplier;
-import org.apache.ignite.IgniteServer;
-import org.apache.ignite.internal.disaster.system.ServerRestarter;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * Holds the seed parameters provided to an Ignite node at construction time.
- * Registered as a singleton bean in the core DI context so that factories and components
- * can inject it to access node identity, paths, and bootstrap objects.
- */
-public class NodeSeedParams {
-    private final IgniteServer node;
-
-    private final ServerRestarter restarter;
-
-    private final Path configPath;
-
-    private final Path workDir;
-
-    @Nullable
-    private final ClassLoader serviceProviderClassLoader;
-
-    private final Executor asyncContinuationExecutor;
-
-    private final Supplier<UUID> clusterIdSupplier;
-
-    /** Constructor. */
-    public NodeSeedParams(
-            IgniteServer node,
-            ServerRestarter restarter,
-            Path configPath,
-            Path workDir,
-            @Nullable ClassLoader serviceProviderClassLoader,
-            Executor asyncContinuationExecutor,
-            Supplier<UUID> clusterIdSupplier
-    ) {
-        this.node = node;
-        this.restarter = restarter;
-        this.configPath = configPath;
-        this.workDir = workDir;
-        this.serviceProviderClassLoader = serviceProviderClassLoader;
-        this.asyncContinuationExecutor = asyncContinuationExecutor;
-        this.clusterIdSupplier = clusterIdSupplier;
-    }
-
-    /** Node name. */
-    public String nodeName() {
-        return node.name();
-    }
-
-    /** The Ignite server instance. */
-    public IgniteServer node() {
-        return node;
-    }
-
-    /** Server restarter for handling node restarts. */
-    public ServerRestarter restarter() {
-        return restarter;
-    }
-
-    /** Path to the node configuration file. */
-    public Path configPath() {
-        return configPath;
-    }
-
-    /** Node working directory. */
-    public Path workDir() {
-        return workDir;
-    }
-
-    /** Class loader used to discover service providers, or {@code null} for the system class loader. */
-    @Nullable
-    public ClassLoader serviceProviderClassLoader() {
-        return serviceProviderClassLoader;
-    }
-
-    /** Executor in which user-facing futures will be completed. */
-    public Executor asyncContinuationExecutor() {
-        return asyncContinuationExecutor;
-    }
-
-    /** Supplier of the cluster ID; resolved lazily after cluster initialization. */
-    public Supplier<UUID> clusterIdSupplier() {
-        return clusterIdSupplier;
-    }
-}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 6bf3901a82b3..9666bc0dc69b 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -31,6 +31,7 @@
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
+import org.apache.ignite.internal.disaster.system.ServerRestarter;
 import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManagerImpl;
 import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
 import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
@@ -75,7 +76,7 @@ public EventLogImpl eventLog(
     @Order(900)
     public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
             NodeIdentity nodeIdentity,
-            NodeSeedParams seedParams,
+            ServerRestarter serverRestarter,
             TopologyService topologyService,
             @Named("clusterMessaging") MessagingService clusterMessagingService,
             VaultManager vaultManager,
@@ -88,7 +89,7 @@ public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
                 topologyService,
                 clusterMessagingService,
                 vaultManager,
-                seedParams.restarter(),
+                serverRestarter,
                 metaStorageManager,
                 cmgManager,
                 clusterIdService

From 557b09ab37d6aedecaf26f58f821801e819df6cb Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 19:24:48 +0400
Subject: [PATCH 49/79] ignite-di-claude Migrate `SqlQueryProcessor` and
 `ClusterManagementGroupManager` to dependency injection; remove factory
 methods.

---
 .../ClusterManagementGroupManager.java        | 12 +++-
 .../app/di/ClusterManagementFactory.java      | 46 ------------
 .../ignite/internal/app/di/SqlFactory.java    | 72 -------------------
 .../sql/engine/SqlQueryProcessor.java         | 12 +++-
 4 files changed, 22 insertions(+), 120 deletions(-)

diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterManagementGroupManager.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterManagementGroupManager.java
index 45a0b6ecf319..f37125288f60 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterManagementGroupManager.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/ClusterManagementGroupManager.java
@@ -31,6 +31,10 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Rest.CLUSTER_NOT_INIT_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
@@ -71,6 +75,8 @@
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopology;
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.message.ResetClusterMessage;
 import org.apache.ignite.internal.disaster.system.storage.ClusterResetStorage;
 import org.apache.ignite.internal.event.AbstractEventProducer;
@@ -115,6 +121,9 @@
  * <a href="https://cwiki.apache.org/confluence/display/IGNITE/IEP-77%3A+Node+Join+Protocol+and+Initialization+for+Ignite+3">IEP-77</a>
  * for the description of the Cluster Management Group and its responsibilities.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1900)
 public class ClusterManagementGroupManager extends AbstractEventProducer<ClusterManagerGroupEvent, EventParameters>
         implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(ClusterManagementGroupManager.class);
@@ -193,6 +202,7 @@ public class ClusterManagementGroupManager extends AbstractEventProducer<Cluster
     private final Consumer<RaftGroupConfiguration> onConfigurationCommittedListener;
 
     /** Constructor. */
+    @Inject
     public ClusterManagementGroupManager(
             VaultManager vault,
             ClusterResetStorage clusterResetStorage,
@@ -205,7 +215,7 @@ public ClusterManagementGroupManager(
             NodeAttributes nodeAttributes,
             FailureProcessor failureProcessor,
             ClusterIdStore clusterIdStore,
-            RaftGroupOptionsConfigurer raftGroupOptionsConfigurer,
+            @Named("cmg") RaftGroupOptionsConfigurer raftGroupOptionsConfigurer,
             MetricManager metricManager
     ) {
         this(
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 4b68ff7f7ed1..ebaf9ac4c065 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -22,15 +22,9 @@
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
-import org.apache.ignite.internal.cluster.management.ClusterInitializer;
-import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
-import org.apache.ignite.internal.cluster.management.NodeAttributes;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesConfiguration;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesExtensionConfiguration;
-import org.apache.ignite.internal.cluster.management.raft.ClusterStateStorageManager;
 import org.apache.ignite.internal.cluster.management.raft.RocksDbClusterStateStorage;
-import org.apache.ignite.internal.cluster.management.raft.ValidationManager;
-import org.apache.ignite.internal.cluster.management.topology.LogicalTopology;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
@@ -42,7 +36,6 @@
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
 import org.apache.ignite.internal.disaster.system.ClusterIdService;
-import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ChannelTypeRegistryProvider;
@@ -56,11 +49,8 @@
 import org.apache.ignite.internal.network.scalecube.ScaleCubeClusterService;
 import org.apache.ignite.internal.network.serialization.MessageSerializationRegistry;
 import org.apache.ignite.internal.network.serialization.SerializationRegistryServiceLoader;
-import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
-import org.apache.ignite.internal.raft.RaftManager;
 import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
 import org.apache.ignite.internal.storage.configurations.StorageExtensionConfiguration;
-import org.apache.ignite.internal.vault.VaultManager;
 import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
 import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
 
@@ -172,40 +162,4 @@ public ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher(
         return new ConfigurationDynamicDefaultsPatcherImpl(modules.distributed(), generator);
     }
 
-    /** Creates the cluster management group manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(1900)
-    public ClusterManagementGroupManager clusterManagementGroupManager(
-            VaultManager vaultManager,
-            SystemDisasterRecoveryStorage systemDisasterRecoveryStorage,
-            ClusterService clusterService,
-            ClusterInitializer clusterInitializer,
-            RaftManager raftManager,
-            ClusterStateStorageManager clusterStateStorageManager,
-            LogicalTopology logicalTopology,
-            ValidationManager validationManager,
-            NodeAttributes nodeAttributes,
-            FailureManager failureManager,
-            ClusterIdService clusterIdService,
-            @Named("cmg") RaftGroupOptionsConfigurer cmgRaftConfigurer,
-            MetricManager metricManager
-    ) {
-        return new ClusterManagementGroupManager(
-                vaultManager,
-                systemDisasterRecoveryStorage,
-                clusterService,
-                clusterInitializer,
-                raftManager,
-                clusterStateStorageManager,
-                logicalTopology,
-                validationManager,
-                nodeAttributes,
-                failureManager,
-                clusterIdService,
-                cmgRaftConfigurer,
-                metricManager
-        );
-    }
-
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
index 2db60e6d68ce..c8df337a079f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
@@ -18,35 +18,13 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
-import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
-import java.util.concurrent.ScheduledExecutorService;
-import org.apache.ignite.internal.catalog.CatalogManager;
-import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.eventlog.api.EventLog;
-import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.hlc.ClockService;
-import org.apache.ignite.internal.lowwatermark.LowWatermark;
-import org.apache.ignite.internal.metrics.MetricManager;
-import org.apache.ignite.internal.network.ClusterService;
-import org.apache.ignite.internal.placementdriver.PlacementDriver;
-import org.apache.ignite.internal.replicator.ReplicaService;
-import org.apache.ignite.internal.schema.SchemaManager;
-import org.apache.ignite.internal.schema.SchemaSyncService;
 import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
 import org.apache.ignite.internal.sql.configuration.distributed.SqlDistributedConfiguration;
 import org.apache.ignite.internal.sql.configuration.local.SqlLocalConfiguration;
 import org.apache.ignite.internal.sql.configuration.local.SqlNodeExtensionConfiguration;
-import org.apache.ignite.internal.sql.engine.SqlQueryProcessor;
-import org.apache.ignite.internal.sql.engine.exec.kill.KillCommandHandler;
-import org.apache.ignite.internal.systemview.api.SystemViewManager;
-import org.apache.ignite.internal.table.distributed.TableManager;
-import org.apache.ignite.internal.tx.TxManager;
-import org.apache.ignite.internal.tx.impl.TransactionInflights;
 
 /**
  * Micronaut factory for SQL engine components.
@@ -69,54 +47,4 @@ public SqlLocalConfiguration sqlLocalConfiguration(
         return nodeConfigRegistry.getConfiguration(SqlNodeExtensionConfiguration.KEY).sql();
     }
 
-    /** Creates the SQL query processor. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(2800)
-    public SqlQueryProcessor sqlQueryProcessor(
-            ClusterService clusterService,
-            LogicalTopologyService logicalTopologyService,
-            TableManager tableManager,
-            SchemaManager schemaManager,
-            ReplicaService replicaService,
-            ClockService clockService,
-            SchemaSyncService schemaSyncService,
-            CatalogManager catalogManager,
-            MetricManager metricManager,
-            SystemViewManager systemViewManager,
-            FailureManager failureManager,
-            PlacementDriver placementDriver,
-            SqlDistributedConfiguration sqlDistributedConfiguration,
-            SqlLocalConfiguration sqlLocalConfiguration,
-            TransactionInflights transactionInflights,
-            TxManager txManager,
-            LowWatermark lowWatermark,
-            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
-            KillCommandHandler killCommandHandler,
-            EventLog eventLog
-    ) {
-        return new SqlQueryProcessor(
-                clusterService,
-                logicalTopologyService,
-                tableManager,
-                schemaManager,
-                replicaService,
-                clockService,
-                schemaSyncService,
-                catalogManager,
-                metricManager,
-                systemViewManager,
-                failureManager,
-                placementDriver,
-                sqlDistributedConfiguration,
-                sqlLocalConfiguration,
-                transactionInflights,
-                txManager,
-                lowWatermark,
-                commonScheduler,
-                killCommandHandler,
-                eventLog
-        );
-    }
-
 }
diff --git a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
index 6b8a5c175ae4..d33b93258955 100644
--- a/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
+++ b/modules/sql-engine/src/main/java/org/apache/ignite/internal/sql/engine/SqlQueryProcessor.java
@@ -27,6 +27,10 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Sql.EXECUTION_CANCELLED_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -39,6 +43,8 @@
 import java.util.function.Supplier;
 import org.apache.ignite.internal.catalog.CatalogManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.eventlog.api.EventLog;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockService;
@@ -128,6 +134,9 @@
 /**
  *  Main implementation of {@link QueryProcessor}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2800)
 public class SqlQueryProcessor implements QueryProcessor, SystemViewProvider {
 
     private static final int PARSED_RESULT_CACHE_SIZE = 10_000;
@@ -210,6 +219,7 @@ public class SqlQueryProcessor implements QueryProcessor, SystemViewProvider {
     private final SqlExpressionFactory expressionFactory;
 
     /** Constructor. */
+    @Inject
     public SqlQueryProcessor(
             ClusterService clusterSrvc,
             LogicalTopologyService logicalTopologyService,
@@ -228,7 +238,7 @@ public SqlQueryProcessor(
             TransactionInflights transactionInflights,
             TxManager txManager,
             LowWatermark lowWaterMark,
-            ScheduledExecutorService commonScheduler,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
             KillCommandHandler killCommandHandler,
             EventLog eventLog
     ) {

From b7b12fd1e235a45e61155d0ce82156792d6d1557 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 19:30:22 +0400
Subject: [PATCH 50/79] Migrate `SystemDisasterRecoveryManagerImpl` and
 `MetaStorageManagerImpl` to dependency injection; remove factory methods.

---
 .../impl/MetaStorageManagerImpl.java          | 14 +++++-
 .../internal/app/di/MetaStorageFactory.java   | 49 -------------------
 .../app/di/SystemServicesFactory.java         | 31 ------------
 .../SystemDisasterRecoveryManagerImpl.java    | 26 ++++++++++
 4 files changed, 38 insertions(+), 82 deletions(-)

diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageManagerImpl.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageManagerImpl.java
index 20cc515ff44b..b6be340cef25 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageManagerImpl.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/impl/MetaStorageManagerImpl.java
@@ -28,6 +28,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -50,6 +54,8 @@
 import org.apache.ignite.internal.cluster.management.ClusterState;
 import org.apache.ignite.internal.cluster.management.MetaStorageInfo;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.disaster.system.message.ResetClusterMessage;
 import org.apache.ignite.internal.disaster.system.repair.MetastorageRepair;
@@ -128,6 +134,9 @@
  *     <li>Providing corresponding Meta storage service proxy interface</li>
  * </ul>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(200)
 public class MetaStorageManagerImpl implements MetaStorageManager, MetastorageGroupMaintenance {
     private static final IgniteLogger LOG = Loggers.forClass(MetaStorageManagerImpl.class);
 
@@ -233,6 +242,7 @@ public class MetaStorageManagerImpl implements MetaStorageManager, MetastorageGr
      * @param ioExecutor Executor to which I/O operations can be offloaded from network threads.
      * @param failureProcessor Failure processor to use when reporting failures.
      */
+    @Inject
     public MetaStorageManagerImpl(
             ClusterService clusterService,
             ClusterManagementGroupManager cmgMgr,
@@ -244,9 +254,9 @@ public MetaStorageManagerImpl(
             MetricManager metricManager,
             MetastorageRepairStorage metastorageRepairStorage,
             MetastorageRepair metastorageRepair,
-            RaftGroupOptionsConfigurer raftGroupOptionsConfigurer,
+            @Named("metastorage") RaftGroupOptionsConfigurer raftGroupOptionsConfigurer,
             ReadOperationForCompactionTracker readOperationForCompactionTracker,
-            Executor ioExecutor,
+            @Named("tableIoExecutor") Executor ioExecutor,
             FailureProcessor failureProcessor
     ) {
         this.clusterService = clusterService;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index 549d0823e496..6bd9ff24c8f3 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -18,35 +18,24 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
-import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
-import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
-import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryStorage;
-import org.apache.ignite.internal.disaster.system.repair.MetastorageRepair;
 import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.hlc.HybridClock;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.metastorage.server.ReadOperationForCompactionTracker;
 import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
-import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.raft.Loza;
-import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
-import org.apache.ignite.internal.raft.RaftManager;
 import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.replicator.configuration.ReplicationExtensionConfiguration;
@@ -90,44 +79,6 @@ public RocksDbKeyValueStorage metastorageKeyValueStorage(
         );
     }
 
-    /** Creates the MetaStorage manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(200)
-    public MetaStorageManagerImpl metaStorageManager(
-            ClusterService clusterService,
-            ClusterManagementGroupManager cmgManager,
-            LogicalTopologyService logicalTopologyService,
-            RaftManager raftManager,
-            RocksDbKeyValueStorage storage,
-            HybridClock clock,
-            TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory,
-            MetricManager metricManager,
-            SystemDisasterRecoveryStorage systemDisasterRecoveryStorage,
-            MetastorageRepair metastorageRepair,
-            @Named("metastorage") RaftGroupOptionsConfigurer msRaftConfigurer,
-            ReadOperationForCompactionTracker readOperationForCompactionTracker,
-            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
-            FailureManager failureManager
-    ) {
-        return new MetaStorageManagerImpl(
-                clusterService,
-                cmgManager,
-                logicalTopologyService,
-                raftManager,
-                storage,
-                clock,
-                topologyAwareRaftGroupServiceFactory,
-                metricManager,
-                systemDisasterRecoveryStorage,
-                metastorageRepair,
-                msRaftConfigurer,
-                readOperationForCompactionTracker,
-                tableIoExecutor,
-                failureManager
-        );
-    }
-
     /** Creates the cluster (distributed) configuration registry. */
     @Singleton
     @Named("clusterConfig")
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 9666bc0dc69b..7e28336ee99e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -30,9 +30,6 @@
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.disaster.system.ClusterIdService;
-import org.apache.ignite.internal.disaster.system.ServerRestarter;
-import org.apache.ignite.internal.disaster.system.SystemDisasterRecoveryManagerImpl;
 import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
 import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
@@ -40,14 +37,12 @@
 import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
 import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageManagerImpl;
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.schema.SchemaSyncService;
 import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorService;
-import org.apache.ignite.internal.vault.VaultManager;
 
 /**
  * Micronaut factory for system services and miscellaneous components.
@@ -70,32 +65,6 @@ public EventLogImpl eventLog(
         );
     }
 
-    /** Creates the system disaster recovery manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(900)
-    public SystemDisasterRecoveryManagerImpl systemDisasterRecoveryManager(
-            NodeIdentity nodeIdentity,
-            ServerRestarter serverRestarter,
-            TopologyService topologyService,
-            @Named("clusterMessaging") MessagingService clusterMessagingService,
-            VaultManager vaultManager,
-            MetaStorageManagerImpl metaStorageManager,
-            ClusterManagementGroupManager cmgManager,
-            ClusterIdService clusterIdService
-    ) {
-        return new SystemDisasterRecoveryManagerImpl(
-                nodeIdentity.nodeName(),
-                topologyService,
-                clusterMessagingService,
-                vaultManager,
-                serverRestarter,
-                metaStorageManager,
-                cmgManager,
-                clusterIdService
-        );
-    }
-
     /** Creates the catalog compaction runner. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryManagerImpl.java b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryManagerImpl.java
index f8cdab0671ea..127d2f229a87 100644
--- a/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryManagerImpl.java
+++ b/modules/system-disaster-recovery/src/main/java/org/apache/ignite/internal/disaster/system/SystemDisasterRecoveryManagerImpl.java
@@ -27,6 +27,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.allOf;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -42,6 +46,9 @@
 import org.apache.ignite.internal.cluster.management.ClusterState;
 import org.apache.ignite.internal.cluster.management.network.messages.CmgMessagesFactory;
 import org.apache.ignite.internal.cluster.management.network.messages.SuccessResponseMessage;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.disaster.system.exception.ClusterResetException;
 import org.apache.ignite.internal.disaster.system.exception.MigrateException;
 import org.apache.ignite.internal.disaster.system.message.BecomeMetastorageLeaderMessage;
@@ -69,6 +76,9 @@
 /**
  * Implementation of {@link SystemDisasterRecoveryManager}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(900)
 public class SystemDisasterRecoveryManagerImpl implements SystemDisasterRecoveryManager, IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(SystemDisasterRecoveryManagerImpl.class);
 
@@ -89,6 +99,22 @@ public class SystemDisasterRecoveryManagerImpl implements SystemDisasterRecovery
 
     private final ClusterManagementGroupManager cmgManager;
 
+    /** Constructor for DI. */
+    @Inject
+    public SystemDisasterRecoveryManagerImpl(
+            NodeIdentity nodeIdentity,
+            TopologyService topologyService,
+            @Named("clusterMessaging") MessagingService messagingService,
+            VaultManager vaultManager,
+            ServerRestarter restarter,
+            MetastorageGroupMaintenance metastorageGroupMaintenance,
+            ClusterManagementGroupManager cmgManager,
+            ClusterIdSupplier clusterIdSupplier
+    ) {
+        this(nodeIdentity.nodeName(), topologyService, messagingService, vaultManager,
+                restarter, metastorageGroupMaintenance, cmgManager, clusterIdSupplier);
+    }
+
     /** Constructor. */
     public SystemDisasterRecoveryManagerImpl(
             String thisNodeName,

From 10100435da981c146ec807c4b9508e5cf0138fb4 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 19:40:05 +0400
Subject: [PATCH 51/79] Migrate `IgniteComputeImpl` to dependency injection;
 remove factory methods.

---
 .../internal/compute/IgniteComputeImpl.java   | 23 +++++++++++++++
 .../internal/app/di/ComputeFactory.java       | 28 -------------------
 2 files changed, 23 insertions(+), 28 deletions(-)

diff --git a/modules/compute/src/main/java/org/apache/ignite/internal/compute/IgniteComputeImpl.java b/modules/compute/src/main/java/org/apache/ignite/internal/compute/IgniteComputeImpl.java
index 533f0b927a4e..f4d384e1f684 100644
--- a/modules/compute/src/main/java/org/apache/ignite/internal/compute/IgniteComputeImpl.java
+++ b/modules/compute/src/main/java/org/apache/ignite/internal/compute/IgniteComputeImpl.java
@@ -27,6 +27,9 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.unwrapCause;
 import static org.apache.ignite.lang.ErrorGroups.Compute.COMPUTE_JOB_FAILED_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
@@ -63,6 +66,9 @@
 import org.apache.ignite.compute.task.TaskExecution;
 import org.apache.ignite.deployment.DeploymentUnit;
 import org.apache.ignite.internal.client.proto.StreamerReceiverSerializer;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.events.ComputeEventMetadata;
 import org.apache.ignite.internal.compute.events.ComputeEventMetadata.Type;
 import org.apache.ignite.internal.compute.events.ComputeEventMetadataBuilder;
@@ -99,6 +105,9 @@
 /**
  * Implementation of {@link IgniteCompute}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1300)
 public class IgniteComputeImpl implements IgniteComputeInternal, StreamerReceiverRunner {
     private final String nodeName;
 
@@ -114,6 +123,20 @@ public class IgniteComputeImpl implements IgniteComputeInternal, StreamerReceive
 
     private final HybridTimestampTracker observableTimestampTracker;
 
+    /** Constructor for DI. */
+    @Inject
+    public IgniteComputeImpl(
+            NodeIdentity nodeIdentity,
+            PlacementDriver placementDriver,
+            TopologyService topologyService,
+            IgniteTablesInternal tables,
+            ComputeComponent computeComponent,
+            HybridClock clock,
+            HybridTimestampTracker observableTimestampTracker
+    ) {
+        this(nodeIdentity.nodeName(), placementDriver, topologyService, tables, computeComponent, clock, observableTimestampTracker);
+    }
+
     /**
      * Create new instance.
      */
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index 325eb27a99b8..03abb0fa4d05 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -29,8 +29,6 @@
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.ComputeComponentImpl;
-import org.apache.ignite.internal.compute.IgniteComputeImpl;
-import org.apache.ignite.internal.compute.IgniteComputeInternal;
 import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
 import org.apache.ignite.internal.compute.configuration.ComputeExtensionConfiguration;
 import org.apache.ignite.internal.compute.executor.ComputeExecutorImpl;
@@ -44,14 +42,11 @@
 import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
 import org.apache.ignite.internal.eventlog.api.EventLog;
 import org.apache.ignite.internal.hlc.ClockService;
-import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
-import org.apache.ignite.internal.placementdriver.PlacementDriver;
-import org.apache.ignite.internal.table.distributed.TableManager;
 
 /**
  * Micronaut factory for compute and deployment components.
@@ -153,27 +148,4 @@ public ComputeComponentImpl computeComponent(
         );
     }
 
-    /** Creates the internal compute implementation. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1300)
-    public IgniteComputeInternal igniteCompute(
-            NodeIdentity nodeIdentity,
-            PlacementDriver placementDriver,
-            TopologyService topologyService,
-            TableManager tableManager,
-            ComputeComponentImpl computeComponent,
-            HybridClock clock,
-            HybridTimestampTracker observableTimestampTracker
-    ) {
-        return new IgniteComputeImpl(
-                nodeIdentity.nodeName(),
-                placementDriver,
-                topologyService,
-                tableManager,
-                computeComponent,
-                clock,
-                observableTimestampTracker
-        );
-    }
 }

From b070c05fc3b40d22042a16b723c8c1c6ab40ad85 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 19:51:50 +0400
Subject: [PATCH 52/79] Migrate `LowWatermarkImpl`, `CriticalWorkerWatchdog`,
 `NettyWorkersRegistrar`, and related components to dependency injection;
 remove factory methods.

---
 modules/low-watermark/build.gradle            |  2 +
 .../lowwatermark/LowWatermarkImpl.java        | 23 +++++++++
 .../network/NettyWorkersRegistrar.java        | 12 ++++-
 .../internal/app/di/DataPathFactory.java      | 24 ----------
 .../app/di/NetworkComponentsFactory.java      | 48 +++----------------
 .../internal/app/di/TransactionFactory.java   |  7 +++
 modules/workers/build.gradle                  |  2 +
 .../worker/CriticalWorkerWatchdog.java        | 12 ++++-
 8 files changed, 63 insertions(+), 67 deletions(-)

diff --git a/modules/low-watermark/build.gradle b/modules/low-watermark/build.gradle
index efff3fe15901..89046eb1410e 100644
--- a/modules/low-watermark/build.gradle
+++ b/modules/low-watermark/build.gradle
@@ -23,9 +23,11 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.auto.service
 
     implementation project(':ignite-core')
+    implementation libs.micronaut.inject
     implementation project(':ignite-failure-handler')
     implementation project(':ignite-network-api')
     implementation project(':ignite-vault')
diff --git a/modules/low-watermark/src/main/java/org/apache/ignite/internal/lowwatermark/LowWatermarkImpl.java b/modules/low-watermark/src/main/java/org/apache/ignite/internal/lowwatermark/LowWatermarkImpl.java
index 5af9e48fe928..d79fced48a0c 100644
--- a/modules/low-watermark/src/main/java/org/apache/ignite/internal/lowwatermark/LowWatermarkImpl.java
+++ b/modules/low-watermark/src/main/java/org/apache/ignite/internal/lowwatermark/LowWatermarkImpl.java
@@ -27,6 +27,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
@@ -42,6 +46,9 @@
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Consumer;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.event.AbstractEventProducer;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureManager;
@@ -91,6 +98,9 @@
  *
  * @see LowWatermarkEvent
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(2000)
 public class LowWatermarkImpl extends AbstractEventProducer<LowWatermarkEvent, LowWatermarkEventParameters> implements LowWatermark,
         IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(LowWatermarkImpl.class);
@@ -133,6 +143,19 @@ public class LowWatermarkImpl extends AbstractEventProducer<LowWatermarkEvent, L
 
     private final Lock scheduleUpdateLowWatermarkTaskLock = new ReentrantLock();
 
+    /** Constructor for DI. */
+    @Inject
+    public LowWatermarkImpl(
+            NodeIdentity nodeIdentity,
+            LowWatermarkConfiguration lowWatermarkConfig,
+            ClockService clockService,
+            VaultManager vaultManager,
+            FailureManager failureManager,
+            @Named("clusterMessaging") MessagingService messagingService
+    ) {
+        this(nodeIdentity.nodeName(), lowWatermarkConfig, clockService, vaultManager, failureManager, messagingService);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/network/src/main/java/org/apache/ignite/internal/network/NettyWorkersRegistrar.java b/modules/network/src/main/java/org/apache/ignite/internal/network/NettyWorkersRegistrar.java
index 733036183ce5..326ab4ec9d01 100644
--- a/modules/network/src/main/java/org/apache/ignite/internal/network/NettyWorkersRegistrar.java
+++ b/modules/network/src/main/java/org/apache/ignite/internal/network/NettyWorkersRegistrar.java
@@ -20,9 +20,13 @@
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
 import io.netty.channel.EventLoopGroup;
 import io.netty.util.concurrent.EventExecutor;
 import io.netty.util.concurrent.SingleThreadEventExecutor;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -30,6 +34,8 @@
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.failure.FailureType;
@@ -45,6 +51,9 @@
 /**
  * This component is responsible for registering Netty workers with the {@link CriticalWorkerRegistry} and for updating their heartbeats.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1200)
 public class NettyWorkersRegistrar implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(NettyWorkersRegistrar.class);
 
@@ -78,9 +87,10 @@ public class NettyWorkersRegistrar implements IgniteComponent {
      * @param bootstrapFactory Used to obtain Netty workers.
      * @param failureManager Used to process failures.
      */
+    @Inject
     public NettyWorkersRegistrar(
             CriticalWorkerRegistry criticalWorkerRegistry,
-            ScheduledExecutorService scheduler,
+            @Named("commonScheduler") ScheduledExecutorService scheduler,
             NettyBootstrapFactory bootstrapFactory,
             CriticalWorkersConfiguration criticalWorkersConfiguration,
             FailureManager failureManager
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index df0d301ba575..8a6609304751 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -49,7 +49,6 @@
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.lowwatermark.LowWatermark;
-import org.apache.ignite.internal.lowwatermark.LowWatermarkImpl;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.metastorage.impl.MetaStorageRevisionListenerRegistry;
 import org.apache.ignite.internal.metrics.MetricManager;
@@ -94,7 +93,6 @@
 import org.apache.ignite.internal.tx.impl.TransactionInflights;
 import org.apache.ignite.internal.tx.message.TxMessageGroup;
 import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
-import org.apache.ignite.internal.vault.VaultManager;
 import org.apache.ignite.sql.IgniteSql;
 
 /**
@@ -230,28 +228,6 @@ public DataStorageManager dataStorageManager(
         return new DataStorageManager(storageEngines, storageConfiguration);
     }
 
-    /** Creates the low watermark. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(2000)
-    public LowWatermarkImpl lowWatermark(
-            NodeIdentity nodeIdentity,
-            GcConfiguration gcConfiguration,
-            ClockService clockService,
-            VaultManager vaultManager,
-            FailureManager failureManager,
-            @Named("clusterMessaging") MessagingService clusterMessagingService
-    ) {
-        return new LowWatermarkImpl(
-                nodeIdentity.nodeName(),
-                gcConfiguration.lowWatermark(),
-                clockService,
-                vaultManager,
-                failureManager,
-                clusterMessagingService
-        );
-    }
-
     /** Creates the distribution zone manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index d292b3202a5e..8186e25307c7 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -21,7 +21,6 @@
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
-import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.IgniteServer;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
@@ -32,12 +31,9 @@
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
-import org.apache.ignite.internal.network.NettyBootstrapFactory;
-import org.apache.ignite.internal.network.NettyWorkersRegistrar;
 import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
 import org.apache.ignite.internal.network.configuration.NetworkExtensionConfiguration;
-import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
-import org.apache.ignite.internal.worker.CriticalWorkerWatchdog;
+import org.apache.ignite.internal.worker.configuration.CriticalWorkersConfiguration;
 
 /**
  * Micronaut factory for network and infrastructure components.
@@ -64,6 +60,12 @@ public SystemLocalConfiguration systemLocalConfiguration(@Named("nodeConfig") Co
         return nodeConfigRegistry.getConfiguration(SystemLocalExtensionConfiguration.KEY).system();
     }
 
+    /** Creates the critical workers configuration from the system local config. */
+    @Singleton
+    public CriticalWorkersConfiguration criticalWorkersConfiguration(SystemLocalConfiguration systemConfiguration) {
+        return systemConfiguration.criticalWorkers();
+    }
+
     /** Creates the failure manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
@@ -76,40 +78,4 @@ public FailureManager failureManager(
         return new FailureManager(nodeIdentity.nodeName(), igniteServer::shutdown, failureProcessorConfiguration);
     }
 
-    /** Creates the critical worker watchdog. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(1000)
-    public CriticalWorkerWatchdog criticalWorkerWatchdog(
-            SystemLocalConfiguration systemConfiguration,
-            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
-            FailureManager failureManager
-    ) {
-        return new CriticalWorkerWatchdog(
-                systemConfiguration.criticalWorkers(),
-                commonScheduler,
-                failureManager
-        );
-    }
-
-    /** Creates the netty workers registrar. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(1200)
-    public NettyWorkersRegistrar nettyWorkersRegistrar(
-            CriticalWorkerRegistry criticalWorkerRegistry,
-            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
-            NettyBootstrapFactory nettyBootstrapFactory,
-            SystemLocalConfiguration systemConfiguration,
-            FailureManager failureManager
-    ) {
-        return new NettyWorkersRegistrar(
-                criticalWorkerRegistry,
-                commonScheduler,
-                nettyBootstrapFactory,
-                systemConfiguration.criticalWorkers(),
-                failureManager
-        );
-    }
-
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index e1d35a28991e..f6a90c643fae 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -45,6 +45,7 @@
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.schema.configuration.GcConfiguration;
 import org.apache.ignite.internal.schema.configuration.GcExtensionConfiguration;
+import org.apache.ignite.internal.schema.configuration.LowWatermarkConfiguration;
 import org.apache.ignite.internal.tx.LockManager;
 import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
 import org.apache.ignite.internal.tx.configuration.TransactionExtensionConfiguration;
@@ -82,6 +83,12 @@ public GcConfiguration gcConfiguration(@Named("clusterConfig") ConfigurationRegi
         return clusterConfigRegistry.getConfiguration(GcExtensionConfiguration.KEY).gc();
     }
 
+    /** Creates the low watermark configuration from the GC config. */
+    @Singleton
+    public LowWatermarkConfiguration lowWatermarkConfiguration(GcConfiguration gcConfiguration) {
+        return gcConfiguration.lowWatermark();
+    }
+
     /** Creates the messaging service wrapper that jumps to the storage operations thread pool. */
     @Singleton
     @Named("storageOperations")
diff --git a/modules/workers/build.gradle b/modules/workers/build.gradle
index 2bbd7c585cc5..69a31e3404a2 100644
--- a/modules/workers/build.gradle
+++ b/modules/workers/build.gradle
@@ -23,10 +23,12 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.auto.service
 
     implementation project(':ignite-api')
     implementation project(':ignite-core')
+    implementation libs.micronaut.inject
     implementation project(':ignite-configuration-api')
     implementation project(':ignite-configuration-root')
     implementation project(':ignite-failure-handler')
diff --git a/modules/workers/src/main/java/org/apache/ignite/internal/worker/CriticalWorkerWatchdog.java b/modules/workers/src/main/java/org/apache/ignite/internal/worker/CriticalWorkerWatchdog.java
index 4ed463abcdf5..ed691e15ef34 100644
--- a/modules/workers/src/main/java/org/apache/ignite/internal/worker/CriticalWorkerWatchdog.java
+++ b/modules/workers/src/main/java/org/apache/ignite/internal/worker/CriticalWorkerWatchdog.java
@@ -21,8 +21,12 @@
 import static org.apache.ignite.internal.failure.FailureType.SYSTEM_WORKER_BLOCKED;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.longs.Long2LongMap;
 import it.unimi.dsi.fastutil.longs.Long2LongOpenHashMap;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.lang.management.LockInfo;
 import java.lang.management.ManagementFactory;
 import java.lang.management.MonitorInfo;
@@ -34,6 +38,8 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -54,6 +60,9 @@
  * <p>The watchdog periodically performs a check; if it finds a worker that lags more than allowed and it is not in the
  * NOT_MONITORED state, then a logging is triggered.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1000)
 public class CriticalWorkerWatchdog implements CriticalWorkerRegistry, IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(CriticalWorkerWatchdog.class);
 
@@ -77,9 +86,10 @@ public class CriticalWorkerWatchdog implements CriticalWorkerRegistry, IgniteCom
      * @param scheduler Scheduler.
      * @param failureManager Failure processor.
      */
+    @Inject
     public CriticalWorkerWatchdog(
             CriticalWorkersConfiguration configuration,
-            ScheduledExecutorService scheduler,
+            @Named("commonScheduler") ScheduledExecutorService scheduler,
             FailureManager failureManager
     ) {
         this.configuration = configuration;

From 566a0e5839d6ce7d1462fbd723453db26ef67716 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Sun, 8 Mar 2026 20:54:17 +0400
Subject: [PATCH 53/79] Migrate tests `OutgoingSnapshotsManagerTest` and
 `IgniteComputeImplTest` to use `NodeIdentity` in dependency injection.

---
 .../apache/ignite/internal/compute/IgniteComputeImplTest.java | 4 ++++
 .../raft/snapshot/outgoing/OutgoingSnapshotsManagerTest.java  | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/modules/compute/src/test/java/org/apache/ignite/internal/compute/IgniteComputeImplTest.java b/modules/compute/src/test/java/org/apache/ignite/internal/compute/IgniteComputeImplTest.java
index 9a03d799016f..60eb57dafa76 100644
--- a/modules/compute/src/test/java/org/apache/ignite/internal/compute/IgniteComputeImplTest.java
+++ b/modules/compute/src/test/java/org/apache/ignite/internal/compute/IgniteComputeImplTest.java
@@ -54,6 +54,7 @@
 import org.apache.ignite.compute.JobTarget;
 import org.apache.ignite.deployment.DeploymentUnit;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
@@ -87,6 +88,9 @@
 class IgniteComputeImplTest extends BaseIgniteAbstractTest {
     private static final String JOB_CLASS_NAME = "org.example.SimpleJob";
 
+    @Mock
+    private NodeIdentity nodeIdentity;
+
     @Mock
     private TopologyService topologyService;
 
diff --git a/modules/partition-replicator/src/test/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManagerTest.java b/modules/partition-replicator/src/test/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManagerTest.java
index 954c9a898305..c90c150aa1c6 100644
--- a/modules/partition-replicator/src/test/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManagerTest.java
+++ b/modules/partition-replicator/src/test/java/org/apache/ignite/internal/partition/replicator/raft/snapshot/outgoing/OutgoingSnapshotsManagerTest.java
@@ -31,6 +31,7 @@
 import java.util.UUID;
 import org.apache.ignite.internal.catalog.Catalog;
 import org.apache.ignite.internal.catalog.CatalogService;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.partition.replicator.raft.snapshot.PartitionKey;
 import org.apache.ignite.internal.partition.replicator.raft.snapshot.PartitionMvStorageAccess;
 import org.apache.ignite.internal.partition.replicator.raft.snapshot.PartitionTxStateAccess;
@@ -48,6 +49,9 @@ class OutgoingSnapshotsManagerTest extends BaseIgniteAbstractTest {
     private static final int ZONE_ID = 1;
     private static final int TABLE_ID = 2;
 
+    @Mock
+    private NodeIdentity nodeIdentity;
+
     @InjectMocks
     private OutgoingSnapshotsManager manager;
 

From 13c3d31d0f026adc2c95d5f5a7b8b0a7426640bd Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Mon, 9 Mar 2026 11:13:56 +0400
Subject: [PATCH 54/79] Migrate catalog compaction, compute, and deployment
 modules to dependency injection; add Micronaut annotations and remove factory
 methods.

---
 modules/catalog-compaction/build.gradle       |  2 +
 .../compaction/CatalogCompactionRunner.java   | 33 +++++++++
 .../code-deployment-classloader/build.gradle  |  3 +
 .../loader/UnitsClassLoaderFactory.java       |  2 +
 .../loader/UnitsContextManager.java           |  2 +
 modules/code-deployment/build.gradle          |  2 +
 .../metastore/DeploymentUnitStoreImpl.java    |  2 +
 .../compute/ComputeComponentImpl.java         | 27 +++++++
 .../compute/executor/ComputeExecutorImpl.java | 22 ++++++
 .../internal/app/di/ComputeFactory.java       | 71 ++-----------------
 .../app/di/SystemServicesFactory.java         | 48 ++-----------
 11 files changed, 106 insertions(+), 108 deletions(-)

diff --git a/modules/catalog-compaction/build.gradle b/modules/catalog-compaction/build.gradle
index 5dbee3015600..e605d7e4450d 100644
--- a/modules/catalog-compaction/build.gradle
+++ b/modules/catalog-compaction/build.gradle
@@ -23,9 +23,11 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 
 dependencies {
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.auto.service
 
     implementation project(':ignite-partition-distribution')
+    implementation libs.micronaut.inject
     implementation project(':ignite-catalog')
     implementation project(':ignite-cluster-management')
     implementation project(':ignite-distribution-zones')
diff --git a/modules/catalog-compaction/src/main/java/org/apache/ignite/internal/catalog/compaction/CatalogCompactionRunner.java b/modules/catalog-compaction/src/main/java/org/apache/ignite/internal/catalog/compaction/CatalogCompactionRunner.java
index c45215647705..baea1d701da5 100644
--- a/modules/catalog-compaction/src/main/java/org/apache/ignite/internal/catalog/compaction/CatalogCompactionRunner.java
+++ b/modules/catalog-compaction/src/main/java/org/apache/ignite/internal/catalog/compaction/CatalogCompactionRunner.java
@@ -22,12 +22,16 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCause;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
 import it.unimi.dsi.fastutil.ints.Int2IntMap.Entry;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMaps;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.objects.ObjectIterator;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.Collection;
@@ -60,6 +64,9 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProvider;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
@@ -114,6 +121,9 @@
  *     (at least, all partition owners are present in the logical topology), then the catalog is compacted.</li>
  * </ol>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(300)
 public class CatalogCompactionRunner implements IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(CatalogCompactionRunner.class);
 
@@ -170,6 +180,29 @@ public class CatalogCompactionRunner implements IgniteComponent {
 
     private volatile UUID localNodeId;
 
+    /** Constructor for DI. */
+    @Inject
+    public CatalogCompactionRunner(
+            NodeIdentity nodeIdentity,
+            CatalogManagerImpl catalogManager,
+            @Named("clusterMessaging") MessagingService messagingService,
+            LogicalTopologyService logicalTopologyService,
+            PlacementDriver placementDriver,
+            ReplicaService replicaService,
+            ClockService clockService,
+            SchemaSyncService schemaSyncService,
+            TopologyService topologyService,
+            LowWatermark lowWatermark,
+            ActiveLocalTxMinimumRequiredTimeProvider activeLocalTxMinimumRequiredTimeProvider,
+            MinimumRequiredTimeCollectorService minimumRequiredTimeCollectorService,
+            RebalanceMinimumRequiredTimeProvider rebalanceMinimumRequiredTimeProvider
+    ) {
+        this(nodeIdentity.nodeName(), catalogManager, messagingService, logicalTopologyService, placementDriver,
+                replicaService, clockService, schemaSyncService, topologyService, lowWatermark,
+                activeLocalTxMinimumRequiredTimeProvider, minimumRequiredTimeCollectorService,
+                rebalanceMinimumRequiredTimeProvider);
+    }
+
     /**
      * Constructs catalog compaction runner.
      */
diff --git a/modules/code-deployment-classloader/build.gradle b/modules/code-deployment-classloader/build.gradle
index 71c0f79c1e83..bdbf0d8bb053 100644
--- a/modules/code-deployment-classloader/build.gradle
+++ b/modules/code-deployment-classloader/build.gradle
@@ -23,6 +23,9 @@ apply from: 'jobs.gradle'
 description = 'ignite-code-deployment-classloader'
 
 dependencies {
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
 
     implementation project(':ignite-core')
diff --git a/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsClassLoaderFactory.java b/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsClassLoaderFactory.java
index 9496f5ccd7b7..fe7a06e77425 100644
--- a/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsClassLoaderFactory.java
+++ b/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsClassLoaderFactory.java
@@ -17,12 +17,14 @@
 
 package org.apache.ignite.internal.deployunit.loader;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import org.apache.ignite.internal.deployunit.DisposableDeploymentUnit;
 
 /**
  * Deployment units classloader factory.
  */
+@Singleton
 public class UnitsClassLoaderFactory {
     /**
      * Create a class loader for the specified units.
diff --git a/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsContextManager.java b/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsContextManager.java
index bbcc1caee981..b169b6a69809 100644
--- a/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsContextManager.java
+++ b/modules/code-deployment-classloader/src/main/java/org/apache/ignite/internal/deployunit/loader/UnitsContextManager.java
@@ -22,6 +22,7 @@
 import static org.apache.ignite.internal.deployunit.loader.ClassLoaderExceptionsMapper.mapClassLoaderExceptions;
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
@@ -44,6 +45,7 @@
 /**
  * Manages job context.
  */
+@Singleton
 public class UnitsContextManager {
     private static final IgniteLogger LOG = Loggers.forClass(UnitsContextManager.class);
 
diff --git a/modules/code-deployment/build.gradle b/modules/code-deployment/build.gradle
index b275bf4b4af4..6831697fe493 100644
--- a/modules/code-deployment/build.gradle
+++ b/modules/code-deployment/build.gradle
@@ -26,8 +26,10 @@ description = 'ignite-code-deployment'
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor project(':ignite-network-annotation-processor')
+    annotationProcessor libs.micronaut.inject.annotation.processor
     annotationProcessor libs.auto.service
 
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
     implementation project(':ignite-core')
diff --git a/modules/code-deployment/src/main/java/org/apache/ignite/internal/deployunit/metastore/DeploymentUnitStoreImpl.java b/modules/code-deployment/src/main/java/org/apache/ignite/internal/deployunit/metastore/DeploymentUnitStoreImpl.java
index 974c5dd2df79..ba676449caef 100644
--- a/modules/code-deployment/src/main/java/org/apache/ignite/internal/deployunit/metastore/DeploymentUnitStoreImpl.java
+++ b/modules/code-deployment/src/main/java/org/apache/ignite/internal/deployunit/metastore/DeploymentUnitStoreImpl.java
@@ -28,6 +28,7 @@
 import static org.apache.ignite.internal.metastorage.dsl.Operations.remove;
 import static org.apache.ignite.internal.util.CompletableFutures.falseCompletedFuture;
 
+import jakarta.inject.Singleton;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
@@ -52,6 +53,7 @@
 /**
  * Implementation of {@link DeploymentUnitStore} based on {@link MetaStorageManager}.
  */
+@Singleton
 public class DeploymentUnitStoreImpl implements DeploymentUnitStore {
     private static final IgniteLogger LOG = Loggers.forClass(DeploymentUnitStoreImpl.class);
 
diff --git a/modules/compute/src/main/java/org/apache/ignite/internal/compute/ComputeComponentImpl.java b/modules/compute/src/main/java/org/apache/ignite/internal/compute/ComputeComponentImpl.java
index ab6e966b0197..666da561d218 100644
--- a/modules/compute/src/main/java/org/apache/ignite/internal/compute/ComputeComponentImpl.java
+++ b/modules/compute/src/main/java/org/apache/ignite/internal/compute/ComputeComponentImpl.java
@@ -22,6 +22,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.List;
 import java.util.UUID;
@@ -34,6 +38,9 @@
 import org.apache.ignite.compute.JobState;
 import org.apache.ignite.deployment.DeploymentUnit;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
 import org.apache.ignite.internal.compute.events.ComputeEventMetadataBuilder;
 import org.apache.ignite.internal.compute.executor.ComputeExecutor;
@@ -69,6 +76,9 @@
 /**
  * Implementation of {@link ComputeComponent}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1200)
 public class ComputeComponentImpl implements ComputeComponent, SystemViewProvider {
     private static final IgniteLogger LOG = Loggers.forClass(ComputeComponentImpl.class);
 
@@ -100,6 +110,23 @@ public class ComputeComponentImpl implements ComputeComponent, SystemViewProvide
 
     private final ComputeViewProvider computeViewProvider = new ComputeViewProvider();
 
+    /** Constructor for DI. */
+    @Inject
+    public ComputeComponentImpl(
+            NodeIdentity nodeIdentity,
+            @Named("clusterMessaging") MessagingService messagingService,
+            TopologyService topologyService,
+            LogicalTopologyService logicalTopologyService,
+            UnitsContextManager jobContextManager,
+            ComputeExecutor executor,
+            ComputeConfiguration computeConfiguration,
+            EventLog eventLog,
+            HybridTimestampTracker observableTimestampTracker
+    ) {
+        this(nodeIdentity.nodeName(), messagingService, topologyService, logicalTopologyService,
+                jobContextManager, executor, computeConfiguration, eventLog, observableTimestampTracker);
+    }
+
     /**
      * Creates a new instance.
      */
diff --git a/modules/compute/src/main/java/org/apache/ignite/internal/compute/executor/ComputeExecutorImpl.java b/modules/compute/src/main/java/org/apache/ignite/internal/compute/executor/ComputeExecutorImpl.java
index da589a472947..28957359f9de 100644
--- a/modules/compute/src/main/java/org/apache/ignite/internal/compute/executor/ComputeExecutorImpl.java
+++ b/modules/compute/src/main/java/org/apache/ignite/internal/compute/executor/ComputeExecutorImpl.java
@@ -24,6 +24,10 @@
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_READ;
 import static org.apache.ignite.internal.thread.ThreadOperation.STORAGE_WRITE;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
 import java.nio.file.Path;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
@@ -34,6 +38,8 @@
 import org.apache.ignite.compute.JobExecutorType;
 import org.apache.ignite.compute.task.MapReduceTask;
 import org.apache.ignite.compute.task.TaskExecutionContext;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.compute.ComputeJobDataHolder;
 import org.apache.ignite.internal.compute.ComputeJobDataType;
 import org.apache.ignite.internal.compute.ComputeUtils;
@@ -63,6 +69,9 @@
 /**
  * Base implementation of {@link ComputeExecutor}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1100)
 public class ComputeExecutorImpl implements ComputeExecutor {
     private static final IgniteLogger LOG = Loggers.forClass(ComputeExecutorImpl.class);
 
@@ -82,6 +91,19 @@ public class ComputeExecutorImpl implements ComputeExecutor {
 
     private @Nullable DotNetComputeExecutor dotNetComputeExecutor;
 
+    /** Constructor for DI. */
+    @Inject
+    public ComputeExecutorImpl(
+            Provider<Ignite> igniteProvider,
+            ComputeStateMachine stateMachine,
+            ComputeConfiguration configuration,
+            TopologyService topologyService,
+            ClockService clockService,
+            EventLog eventLog
+    ) {
+        this(igniteProvider.get(), stateMachine, configuration, topologyService, clockService, eventLog);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
index 03abb0fa4d05..ec49f9918ab4 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComputeFactory.java
@@ -20,33 +20,22 @@
 import io.micronaut.context.annotation.Factory;
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
-import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
-import org.apache.ignite.Ignite;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
-import org.apache.ignite.internal.compute.ComputeComponentImpl;
 import org.apache.ignite.internal.compute.configuration.ComputeConfiguration;
 import org.apache.ignite.internal.compute.configuration.ComputeExtensionConfiguration;
 import org.apache.ignite.internal.compute.executor.ComputeExecutorImpl;
-import org.apache.ignite.internal.compute.state.InMemoryComputeStateMachine;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.deployunit.DeploymentManagerImpl;
+import org.apache.ignite.internal.deployunit.DeploymentUnitAccessor;
 import org.apache.ignite.internal.deployunit.configuration.DeploymentConfiguration;
 import org.apache.ignite.internal.deployunit.configuration.DeploymentExtensionConfiguration;
-import org.apache.ignite.internal.deployunit.loader.UnitsClassLoaderFactory;
-import org.apache.ignite.internal.deployunit.loader.UnitsContextManager;
 import org.apache.ignite.internal.deployunit.metastore.DeploymentUnitStoreImpl;
-import org.apache.ignite.internal.eventlog.api.EventLog;
-import org.apache.ignite.internal.hlc.ClockService;
-import org.apache.ignite.internal.hlc.HybridTimestampTracker;
-import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.network.ClusterService;
-import org.apache.ignite.internal.network.MessagingService;
-import org.apache.ignite.internal.network.TopologyService;
 
 /**
  * Micronaut factory for compute and deployment components.
@@ -69,35 +58,13 @@ public DeploymentConfiguration deploymentConfiguration(
         return nodeConfigRegistry.getConfiguration(DeploymentExtensionConfiguration.KEY).deployment();
     }
 
-    /** Creates the compute executor. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1100)
-    public ComputeExecutorImpl computeExecutor(
-            Provider<Ignite> igniteProvider,
-            InMemoryComputeStateMachine stateMachine,
-            ComputeConfiguration computeConfiguration,
-            TopologyService topologyService,
-            ClockService clockService,
-            EventLog eventLog
-    ) {
-        return new ComputeExecutorImpl(
-                igniteProvider.get(),
-                stateMachine,
-                computeConfiguration,
-                topologyService,
-                clockService,
-                eventLog
-        );
-    }
-
     /** Creates the deployment manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
     @Order(3000)
     public DeploymentManagerImpl deploymentManager(
             ClusterService clusterService,
-            MetaStorageManager metaStorageManager,
+            DeploymentUnitStoreImpl deploymentUnitStore,
             LogicalTopologyService logicalTopologyService,
             NodeIdentity nodeIdentity,
             DeploymentConfiguration deploymentConfiguration,
@@ -106,7 +73,7 @@ public DeploymentManagerImpl deploymentManager(
     ) {
         return new DeploymentManagerImpl(
                 clusterService,
-                new DeploymentUnitStoreImpl(metaStorageManager),
+                deploymentUnitStore,
                 logicalTopologyService,
                 nodeIdentity.workDir(),
                 deploymentConfiguration,
@@ -116,36 +83,10 @@ public DeploymentManagerImpl deploymentManager(
         );
     }
 
-    /** Creates the compute component. */
+    /** Exposes the deployment unit accessor from the deployment manager. */
     @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1200)
-    public ComputeComponentImpl computeComponent(
-            NodeIdentity nodeIdentity,
-            @Named("clusterMessaging") MessagingService clusterMessagingService,
-            TopologyService topologyService,
-            LogicalTopologyService logicalTopologyService,
-            DeploymentManagerImpl deploymentManager,
-            ComputeExecutorImpl computeExecutor,
-            ComputeConfiguration computeConfiguration,
-            EventLog eventLog,
-            HybridTimestampTracker observableTimestampTracker
-    ) {
-        return new ComputeComponentImpl(
-                nodeIdentity.nodeName(),
-                clusterMessagingService,
-                topologyService,
-                logicalTopologyService,
-                new UnitsContextManager(
-                        deploymentManager,
-                        deploymentManager.deploymentUnitAccessor(),
-                        new UnitsClassLoaderFactory()
-                ),
-                computeExecutor,
-                computeConfiguration,
-                eventLog,
-                observableTimestampTracker
-        );
+    public DeploymentUnitAccessor deploymentUnitAccessor(DeploymentManagerImpl deploymentManager) {
+        return deploymentManager.deploymentUnitAccessor();
     }
 
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
index 7e28336ee99e..a986694a8d50 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
@@ -23,9 +23,7 @@
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.catalog.CatalogManagerImpl;
-import org.apache.ignite.internal.catalog.compaction.CatalogCompactionRunner;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
-import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
@@ -33,16 +31,7 @@
 import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
 import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
 import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
-import org.apache.ignite.internal.hlc.ClockService;
-import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
-import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
-import org.apache.ignite.internal.network.MessagingService;
-import org.apache.ignite.internal.network.TopologyService;
-import org.apache.ignite.internal.placementdriver.PlacementDriver;
-import org.apache.ignite.internal.replicator.ReplicaService;
-import org.apache.ignite.internal.schema.SchemaSyncService;
-import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorService;
 
 /**
  * Micronaut factory for system services and miscellaneous components.
@@ -65,40 +54,13 @@ public EventLogImpl eventLog(
         );
     }
 
-    /** Creates the catalog compaction runner. */
+    /** Creates the rebalance minimum required time provider. */
     @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(300)
-    public CatalogCompactionRunner catalogCompactionRunner(
-            NodeIdentity nodeIdentity,
-            CatalogManagerImpl catalogManager,
-            @Named("clusterMessaging") MessagingService clusterMessagingService,
-            TopologyService topologyService,
-            LogicalTopologyService logicalTopologyService,
-            PlacementDriver placementDriver,
-            ReplicaService replicaService,
-            ClockService clockService,
-            SchemaSyncService schemaSyncService,
-            LowWatermark lowWatermark,
-            IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker,
-            MinimumRequiredTimeCollectorService minTimeCollectorService,
-            MetaStorageManager metaStorageManager
+    public RebalanceMinimumRequiredTimeProviderImpl rebalanceMinimumRequiredTimeProvider(
+            MetaStorageManager metaStorageManager,
+            CatalogManagerImpl catalogManager
     ) {
-        return new CatalogCompactionRunner(
-                nodeIdentity.nodeName(),
-                catalogManager,
-                clusterMessagingService,
-                logicalTopologyService,
-                placementDriver,
-                replicaService,
-                clockService,
-                schemaSyncService,
-                topologyService,
-                lowWatermark,
-                indexNodeFinishedRwTransactionsChecker,
-                minTimeCollectorService,
-                new RebalanceMinimumRequiredTimeProviderImpl(metaStorageManager, catalogManager)
-        );
+        return new RebalanceMinimumRequiredTimeProviderImpl(metaStorageManager, catalogManager);
     }
 
 }

From 05713b736d70c6c6b656429715905be92bbed5b1 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Mon, 9 Mar 2026 11:38:58 +0400
Subject: [PATCH 55/79] Migrate `TableManager` and
 `PartitionReplicaLifecycleManager` to dependency injection; add Micronaut
 annotations and remove factory methods.

---
 .../PartitionReplicaLifecycleManager.java     |  18 ++-
 .../internal/app/di/DataPathFactory.java      | 143 ------------------
 .../table/distributed/TableManager.java       |  56 +++++++
 3 files changed, 70 insertions(+), 147 deletions(-)

diff --git a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/PartitionReplicaLifecycleManager.java b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/PartitionReplicaLifecycleManager.java
index e66bdea72899..b7a537746bbd 100644
--- a/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/PartitionReplicaLifecycleManager.java
+++ b/modules/partition-replicator/src/main/java/org/apache/ignite/internal/partition/replicator/PartitionReplicaLifecycleManager.java
@@ -75,7 +75,11 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -104,6 +108,8 @@
 import org.apache.ignite.internal.catalog.descriptors.ConsistencyMode;
 import org.apache.ignite.internal.catalog.events.CreateZoneEventParameters;
 import org.apache.ignite.internal.catalog.events.DropZoneEventParameters;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
@@ -205,6 +211,9 @@
  *     <li>Supporting the rebalance mechanism and starting the new replication nodes when the rebalance triggers occurred.</li>
  * </ul>
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2300)
 public class PartitionReplicaLifecycleManager extends
         AbstractEventProducer<LocalPartitionReplicaEvent, LocalPartitionReplicaEventParameters> implements IgniteComponent {
     private final CatalogService catalogService;
@@ -325,6 +334,7 @@ public class PartitionReplicaLifecycleManager extends
      * @param messagingService Messaging service.
      * @param replicaService Replica service.
      */
+    @Inject
     public PartitionReplicaLifecycleManager(
             CatalogService catalogService,
             ReplicaManager replicaMgr,
@@ -333,9 +343,9 @@ public PartitionReplicaLifecycleManager(
             TopologyService topologyService,
             LowWatermark lowWatermark,
             FailureProcessor failureProcessor,
-            ExecutorService ioExecutor,
-            ScheduledExecutorService rebalanceScheduler,
-            Executor partitionOperationsExecutor,
+            @Named("tableIoExecutor") ExecutorService ioExecutor,
+            @Named("rebalanceScheduler") ScheduledExecutorService rebalanceScheduler,
+            @Named("partitionOperationsExecutor") Executor partitionOperationsExecutor,
             ClockService clockService,
             PlacementDriver placementDriver,
             SchemaSyncService schemaSyncService,
@@ -346,7 +356,7 @@ public PartitionReplicaLifecycleManager(
             DataStorageManager dataStorageManager,
             OutgoingSnapshotsManager outgoingSnapshotsManager,
             MetricManager metricManager,
-            MessagingService messagingService,
+            @Named("storageOperations") MessagingService messagingService,
             ReplicaService replicaService
     ) {
         this(
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 8a6609304751..74a7bde9adf9 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -50,14 +50,11 @@
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
 import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
-import org.apache.ignite.internal.metastorage.impl.MetaStorageRevisionListenerRegistry;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.TopologyService;
-import org.apache.ignite.internal.partition.replicator.PartitionReplicaLifecycleManager;
 import org.apache.ignite.internal.partition.replicator.network.PartitionReplicationMessageGroup;
-import org.apache.ignite.internal.partition.replicator.raft.snapshot.outgoing.OutgoingSnapshotsManager;
 import org.apache.ignite.internal.partition.replicator.schema.CatalogValidationSchemasSource;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
@@ -66,34 +63,22 @@
 import org.apache.ignite.internal.raft.storage.LogStorageManager;
 import org.apache.ignite.internal.raft.storage.impl.VolatileLogStorageManagerCreator;
 import org.apache.ignite.internal.replicator.ReplicaManager;
-import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.replicator.TablePartitionId;
 import org.apache.ignite.internal.replicator.VersionedAssignments;
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
-import org.apache.ignite.internal.schema.SchemaManager;
 import org.apache.ignite.internal.schema.SchemaSafeTimeTracker;
 import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
 import org.apache.ignite.internal.schema.SchemaSyncService;
-import org.apache.ignite.internal.schema.configuration.GcConfiguration;
 import org.apache.ignite.internal.storage.DataStorageManager;
 import org.apache.ignite.internal.storage.DataStorageModule;
 import org.apache.ignite.internal.storage.DataStorageModules;
 import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
 import org.apache.ignite.internal.storage.engine.StorageEngine;
 import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
-import org.apache.ignite.internal.table.distributed.TableManager;
-import org.apache.ignite.internal.table.distributed.index.IndexMetaStorage;
-import org.apache.ignite.internal.table.distributed.raft.MinimumRequiredTimeCollectorService;
 import org.apache.ignite.internal.table.distributed.raft.PartitionSafeTimeValidator;
 import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
 import org.apache.ignite.internal.table.distributed.schema.ThreadLocalPartitionCommandsMarshaller;
-import org.apache.ignite.internal.tx.LockManager;
-import org.apache.ignite.internal.tx.TxManager;
-import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
-import org.apache.ignite.internal.tx.impl.TransactionInflights;
 import org.apache.ignite.internal.tx.message.TxMessageGroup;
-import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
-import org.apache.ignite.sql.IgniteSql;
 
 /**
  * Micronaut factory for data path components.
@@ -258,134 +243,6 @@ public DistributionZoneManager distributionZoneManager(
         );
     }
 
-    /** Creates the partition replica lifecycle manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(2300)
-    public PartitionReplicaLifecycleManager partitionReplicaLifecycleManager(
-            CatalogManager catalogManager,
-            ReplicaManager replicaManager,
-            DistributionZoneManager distributionZoneManager,
-            MetaStorageManager metaStorageManager,
-            TopologyService topologyService,
-            LowWatermark lowWatermark,
-            FailureManager failureManager,
-            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
-            @Named("rebalanceScheduler") ScheduledExecutorService rebalanceScheduler,
-            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
-            ClockService clockService,
-            PlacementDriver placementDriver,
-            SchemaSyncService schemaSyncService,
-            SystemDistributedConfiguration systemDistributedConfiguration,
-            TxStateRocksDbSharedStorage sharedTxStateStorage,
-            TxManager txManager,
-            SchemaManager schemaManager,
-            DataStorageManager dataStorageManager,
-            OutgoingSnapshotsManager outgoingSnapshotsManager,
-            MetricManager metricManager,
-            @Named("storageOperations") MessagingService messagingService,
-            ReplicaService replicaService
-    ) {
-        return new PartitionReplicaLifecycleManager(
-                catalogManager,
-                replicaManager,
-                distributionZoneManager,
-                metaStorageManager,
-                topologyService,
-                lowWatermark,
-                failureManager,
-                tableIoExecutor,
-                rebalanceScheduler,
-                partitionOperationsExecutor,
-                clockService,
-                placementDriver,
-                schemaSyncService,
-                systemDistributedConfiguration,
-                sharedTxStateStorage,
-                txManager,
-                schemaManager,
-                dataStorageManager,
-                outgoingSnapshotsManager,
-                metricManager,
-                messagingService,
-                replicaService
-        );
-    }
-
-    /** Creates the table manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(2400)
-    public TableManager tableManager(
-            NodeIdentity nodeIdentity,
-            MetaStorageRevisionListenerRegistry revisionListenerRegistry,
-            GcConfiguration gcConfiguration,
-            ReplicationConfiguration replicationConfiguration,
-            @Named("storageOperations") MessagingService messagingService,
-            TopologyService topologyService,
-            LockManager lockManager,
-            ReplicaService replicaService,
-            TxManager txManager,
-            DataStorageManager dataStorageManager,
-            MetaStorageManager metaStorageManager,
-            SchemaManager schemaManager,
-            CatalogValidationSchemasSource validationSchemasSource,
-            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
-            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
-            ClockService clockService,
-            OutgoingSnapshotsManager outgoingSnapshotsManager,
-            SchemaSyncService schemaSyncService,
-            CatalogManager catalogManager,
-            FailureManager failureManager,
-            HybridTimestampTracker observableTimestampTracker,
-            PlacementDriver placementDriver,
-            Provider<IgniteSql> sqlProvider,
-            RemotelyTriggeredResourceRegistry resourcesRegistry,
-            LowWatermark lowWatermark,
-            TransactionInflights transactionInflights,
-            IndexMetaStorage indexMetaStorage,
-            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
-            MinimumRequiredTimeCollectorService minTimeCollectorService,
-            SystemDistributedConfiguration systemDistributedConfiguration,
-            MetricManager metricManager,
-            PartitionModificationCounterFactory partitionModificationCounterFactory
-    ) {
-        return new TableManager(
-                nodeIdentity.nodeName(),
-                revisionListenerRegistry,
-                gcConfiguration,
-                replicationConfiguration,
-                messagingService,
-                topologyService,
-                lockManager,
-                replicaService,
-                txManager,
-                dataStorageManager,
-                metaStorageManager,
-                schemaManager,
-                validationSchemasSource,
-                tableIoExecutor,
-                partitionOperationsExecutor,
-                clockService,
-                outgoingSnapshotsManager,
-                schemaSyncService,
-                catalogManager,
-                failureManager,
-                observableTimestampTracker,
-                placementDriver,
-                sqlProvider::get,
-                resourcesRegistry,
-                lowWatermark,
-                transactionInflights,
-                indexMetaStorage,
-                partitionReplicaLifecycleManager,
-                minTimeCollectorService,
-                systemDistributedConfiguration,
-                metricManager,
-                partitionModificationCounterFactory
-        );
-    }
-
     /** Creates the partition modification counter factory. */
     @Singleton
     public PartitionModificationCounterFactory partitionModificationCounterFactory(
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/TableManager.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/TableManager.java
index 38adc3c38569..f8a99e5cc52a 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/TableManager.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/TableManager.java
@@ -51,7 +51,12 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashMap;
@@ -87,6 +92,9 @@
 import org.apache.ignite.internal.causality.IncrementalVersionedValue;
 import org.apache.ignite.internal.causality.OutdatedTokenException;
 import org.apache.ignite.internal.causality.RevisionListenerRegistry;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
 import org.apache.ignite.internal.distributionzones.DistributionZonesUtil;
@@ -189,6 +197,9 @@
 /**
  * Table manager.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(2400)
 public class TableManager implements IgniteTablesInternal, IgniteComponent {
     /** The logger. */
     private static final IgniteLogger LOG = Loggers.forClass(TableManager.class);
@@ -353,6 +364,51 @@ public class TableManager implements IgniteTablesInternal, IgniteComponent {
     private final Map<TablePartitionId, PartitionTableStatsMetricSource> partModCounterMetricSources = new ConcurrentHashMap<>();
     private final Map<TablePartitionId, LongSupplier> pendingWriteIntentsSuppliers = new ConcurrentHashMap<>();
 
+    /** Constructor for DI. */
+    @Inject
+    public TableManager(
+            NodeIdentity nodeIdentity,
+            RevisionListenerRegistry registry,
+            GcConfiguration gcConfig,
+            ReplicationConfiguration replicationConfiguration,
+            @Named("storageOperations") MessagingService messagingService,
+            TopologyService topologyService,
+            LockManager lockMgr,
+            ReplicaService replicaSvc,
+            TxManager txManager,
+            DataStorageManager dataStorageMgr,
+            MetaStorageManager metaStorageMgr,
+            SchemaManager schemaManager,
+            ValidationSchemasSource validationSchemasSource,
+            @Named("tableIoExecutor") ExecutorService ioExecutor,
+            @Named("partitionOperationsExecutor") Executor partitionOperationsExecutor,
+            ClockService clockService,
+            OutgoingSnapshotsManager outgoingSnapshotsManager,
+            SchemaSyncService schemaSyncService,
+            CatalogService catalogService,
+            FailureProcessor failureProcessor,
+            HybridTimestampTracker observableTimestampTracker,
+            PlacementDriver placementDriver,
+            Provider<IgniteSql> sqlProvider,
+            RemotelyTriggeredResourceRegistry remotelyTriggeredResourceRegistry,
+            LowWatermark lowWatermark,
+            TransactionInflights transactionInflights,
+            IndexMetaStorage indexMetaStorage,
+            PartitionReplicaLifecycleManager partitionReplicaLifecycleManager,
+            MinimumRequiredTimeCollectorService minTimeCollectorService,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            MetricManager metricManager,
+            PartitionModificationCounterFactory partitionModificationCounterFactory
+    ) {
+        this(nodeIdentity.nodeName(), registry, gcConfig, replicationConfiguration, messagingService, topologyService,
+                lockMgr, replicaSvc, txManager, dataStorageMgr, metaStorageMgr, schemaManager, validationSchemasSource,
+                ioExecutor, partitionOperationsExecutor, clockService, outgoingSnapshotsManager, schemaSyncService,
+                catalogService, failureProcessor, observableTimestampTracker, placementDriver, sqlProvider::get,
+                remotelyTriggeredResourceRegistry, lowWatermark, transactionInflights, indexMetaStorage,
+                partitionReplicaLifecycleManager, minTimeCollectorService, systemDistributedConfiguration,
+                metricManager, partitionModificationCounterFactory);
+    }
+
     /**
      * Creates a new table manager.
      *

From 8dc1a49c35676a9f24160700ec41bb48df1f5b2f Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Mon, 9 Mar 2026 11:53:47 +0400
Subject: [PATCH 56/79] Migrate `SqlFactory`, `SystemServicesFactory`, and
 related components to dependency injection; integrate SQL configuration into
 `MetaStorageFactory` and remove factory methods.

---
 .../internal/app/di/DataPathFactory.java      | 10 +++
 .../internal/app/di/MetaStorageFactory.java   | 22 ++++++-
 .../ignite/internal/app/di/SqlFactory.java    | 50 --------------
 .../app/di/SystemServicesFactory.java         | 66 -------------------
 4 files changed, 31 insertions(+), 117 deletions(-)
 delete mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
 delete mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 74a7bde9adf9..a1f08cbd8722 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -33,6 +33,7 @@
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.function.LongSupplier;
 import org.apache.ignite.internal.catalog.CatalogManager;
+import org.apache.ignite.internal.catalog.CatalogManagerImpl;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
@@ -44,6 +45,7 @@
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
+import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.HybridClock;
@@ -252,4 +254,12 @@ public PartitionModificationCounterFactory partitionModificationCounterFactory(
         return new PartitionModificationCounterFactory(clockService::current, clusterMessagingService);
     }
 
+    /** Creates the rebalance minimum required time provider. */
+    @Singleton
+    public RebalanceMinimumRequiredTimeProviderImpl rebalanceMinimumRequiredTimeProvider(
+            MetaStorageManager metaStorageManager,
+            CatalogManagerImpl catalogManager
+    ) {
+        return new RebalanceMinimumRequiredTimeProviderImpl(metaStorageManager, catalogManager);
+    }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index 6bd9ff24c8f3..bde72ef2d587 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -39,10 +39,14 @@
 import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.replicator.configuration.ReplicationExtensionConfiguration;
+import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
+import org.apache.ignite.internal.sql.configuration.distributed.SqlDistributedConfiguration;
+import org.apache.ignite.internal.sql.configuration.local.SqlLocalConfiguration;
+import org.apache.ignite.internal.sql.configuration.local.SqlNodeExtensionConfiguration;
 import org.apache.ignite.raft.jraft.rpc.impl.RaftGroupEventsClientListener;
 
 /**
- * Micronaut factory for MetaStorage and cluster configuration components.
+ * Micronaut factory for MetaStorage, cluster configuration, and SQL configuration components.
  */
 @Factory
 public class MetaStorageFactory {
@@ -108,5 +112,21 @@ public ReplicationConfiguration replicationConfiguration(
         return clusterConfigRegistry
                 .getConfiguration(ReplicationExtensionConfiguration.KEY).replication();
     }
+
+    /** Creates the SQL distributed configuration from the cluster config registry. */
+    @Singleton
+    public SqlDistributedConfiguration sqlDistributedConfiguration(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
+        return clusterConfigRegistry.getConfiguration(SqlClusterExtensionConfiguration.KEY).sql();
+    }
+
+    /** Creates the SQL local configuration from the node config registry. */
+    @Singleton
+    public SqlLocalConfiguration sqlLocalConfiguration(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
+    ) {
+        return nodeConfigRegistry.getConfiguration(SqlNodeExtensionConfiguration.KEY).sql();
+    }
 }
 
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
deleted file mode 100644
index c8df337a079f..000000000000
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SqlFactory.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.app.di;
-
-import io.micronaut.context.annotation.Factory;
-import jakarta.inject.Named;
-import jakarta.inject.Singleton;
-import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
-import org.apache.ignite.internal.sql.configuration.distributed.SqlDistributedConfiguration;
-import org.apache.ignite.internal.sql.configuration.local.SqlLocalConfiguration;
-import org.apache.ignite.internal.sql.configuration.local.SqlNodeExtensionConfiguration;
-
-/**
- * Micronaut factory for SQL engine components.
- */
-@Factory
-public class SqlFactory {
-    /** Creates the SQL distributed configuration from the cluster config registry. */
-    @Singleton
-    public SqlDistributedConfiguration sqlDistributedConfiguration(
-            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
-    ) {
-        return clusterConfigRegistry.getConfiguration(SqlClusterExtensionConfiguration.KEY).sql();
-    }
-
-    /** Creates the SQL local configuration from the node config registry. */
-    @Singleton
-    public SqlLocalConfiguration sqlLocalConfiguration(
-            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry
-    ) {
-        return nodeConfigRegistry.getConfiguration(SqlNodeExtensionConfiguration.KEY).sql();
-    }
-
-}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
deleted file mode 100644
index a986694a8d50..000000000000
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/SystemServicesFactory.java
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.ignite.internal.app.di;
-
-import io.micronaut.context.annotation.Factory;
-import io.micronaut.core.annotation.Order;
-import jakarta.inject.Named;
-import jakarta.inject.Provider;
-import jakarta.inject.Singleton;
-import org.apache.ignite.internal.catalog.CatalogManagerImpl;
-import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.components.StartupPhase;
-import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
-import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
-import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
-import org.apache.ignite.internal.metastorage.MetaStorageManager;
-
-/**
- * Micronaut factory for system services and miscellaneous components.
- */
-@Factory
-public class SystemServicesFactory {
-    /** Creates the event log. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(3500)
-    public EventLogImpl eventLog(
-            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry,
-            Provider<ClusterManagementGroupManager> cmgManagerProvider,
-            NodeIdentity nodeIdentity
-    ) {
-        return new EventLogImpl(
-                clusterConfigRegistry.getConfiguration(EventLogExtensionConfiguration.KEY).eventlog(),
-                () -> cmgManagerProvider.get().clusterState().join().clusterTag().clusterId(),
-                nodeIdentity.nodeName()
-        );
-    }
-
-    /** Creates the rebalance minimum required time provider. */
-    @Singleton
-    public RebalanceMinimumRequiredTimeProviderImpl rebalanceMinimumRequiredTimeProvider(
-            MetaStorageManager metaStorageManager,
-            CatalogManagerImpl catalogManager
-    ) {
-        return new RebalanceMinimumRequiredTimeProviderImpl(metaStorageManager, catalogManager);
-    }
-
-}

From 101839fb019b4705829082788163685a6cabad16 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Mon, 9 Mar 2026 12:31:05 +0400
Subject: [PATCH 57/79] Migrate `EventLogImpl` to dependency injection; add
 Micronaut annotations and remove factory methods.

---
 .../configuration/ComponentWorkingDir.java    |  0
 .../internal/app/di/EventLogFactory.java      | 54 +++++++++++++++++++
 2 files changed, 54 insertions(+)
 rename modules/{runner => core}/src/main/java/org/apache/ignite/internal/configuration/ComponentWorkingDir.java (100%)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/EventLogFactory.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/ComponentWorkingDir.java b/modules/core/src/main/java/org/apache/ignite/internal/configuration/ComponentWorkingDir.java
similarity index 100%
rename from modules/runner/src/main/java/org/apache/ignite/internal/configuration/ComponentWorkingDir.java
rename to modules/core/src/main/java/org/apache/ignite/internal/configuration/ComponentWorkingDir.java
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/EventLogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/EventLogFactory.java
new file mode 100644
index 000000000000..2591805b8c9b
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/EventLogFactory.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import io.micronaut.context.annotation.Factory;
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Named;
+import jakarta.inject.Provider;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.eventlog.config.schema.EventLogExtensionConfiguration;
+import org.apache.ignite.internal.eventlog.impl.EventLogImpl;
+
+/**
+ * Micronaut factory for the event log component.
+ */
+@Factory
+public class EventLogFactory {
+    /** Creates the event log. */
+    @Singleton
+    @IgniteStartupPhase(StartupPhase.PHASE_2)
+    @Order(3500)
+    public EventLogImpl eventLog(
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry,
+            Provider<ClusterManagementGroupManager> cmgManagerProvider,
+            NodeIdentity nodeIdentity
+    ) {
+        return new EventLogImpl(
+                clusterConfigRegistry.getConfiguration(EventLogExtensionConfiguration.KEY).eventlog(),
+                () -> cmgManagerProvider.get().clusterState().join().clusterTag().clusterId(),
+                nodeIdentity.nodeName()
+        );
+    }
+
+}

From c642eb05904eabf817d836dbe15bc70c4cbedad4 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Mon, 9 Mar 2026 12:34:42 +0400
Subject: [PATCH 58/79] Migrate `ComponentWorkingDir` creation to a dedicated
 factory class; add Micronaut annotations and remove factory methods.

---
 .../app/di/ComponentWorkingDirFactory.java    | 56 +++++++++++++++++++
 .../ignite/internal/app/di/RaftFactory.java   | 26 ---------
 2 files changed, 56 insertions(+), 26 deletions(-)
 create mode 100644 modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComponentWorkingDirFactory.java

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComponentWorkingDirFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComponentWorkingDirFactory.java
new file mode 100644
index 000000000000..cc11eca70ed2
--- /dev/null
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ComponentWorkingDirFactory.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.app.di;
+
+import static org.apache.ignite.internal.configuration.IgnitePaths.cmgPath;
+import static org.apache.ignite.internal.configuration.IgnitePaths.metastoragePath;
+import static org.apache.ignite.internal.configuration.IgnitePaths.partitionsPath;
+
+import io.micronaut.context.annotation.Factory;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
+import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
+
+/**
+ * Micronaut factory for component working directories.
+ */
+@Factory
+public class ComponentWorkingDirFactory {
+    /** Creates the partitions working directory. */
+    @Singleton
+    @Named("partitions")
+    public ComponentWorkingDir partitionsWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
+        return partitionsPath(systemConfiguration, nodeIdentity.workDir());
+    }
+
+    /** Creates the metastorage working directory. */
+    @Singleton
+    @Named("metastorage")
+    public ComponentWorkingDir metastorageWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
+        return metastoragePath(systemConfiguration, nodeIdentity.workDir());
+    }
+
+    /** Creates the CMG working directory. */
+    @Singleton
+    @Named("cmg")
+    public ComponentWorkingDir cmgWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
+        return cmgPath(systemConfiguration, nodeIdentity.workDir());
+    }
+}
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
index 8cff5d8fc406..d8416a1b1bc5 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
@@ -17,10 +17,6 @@
 
 package org.apache.ignite.internal.app.di;
 
-import static org.apache.ignite.internal.configuration.IgnitePaths.cmgPath;
-import static org.apache.ignite.internal.configuration.IgnitePaths.metastoragePath;
-import static org.apache.ignite.internal.configuration.IgnitePaths.partitionsPath;
-
 import io.micronaut.context.annotation.Factory;
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
@@ -34,7 +30,6 @@
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
-import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
 import org.apache.ignite.internal.metastorage.server.raft.MetastorageGroupId;
 import org.apache.ignite.internal.raft.RaftGroupOptionsConfigurer;
 import org.apache.ignite.internal.raft.configuration.RaftConfiguration;
@@ -58,27 +53,6 @@ public RaftConfiguration raftConfiguration(@Named("nodeConfig") ConfigurationReg
         return nodeConfigRegistry.getConfiguration(RaftExtensionConfiguration.KEY).raft();
     }
 
-    /** Creates the partitions working directory. */
-    @Singleton
-    @Named("partitions")
-    public ComponentWorkingDir partitionsWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
-        return partitionsPath(systemConfiguration, nodeIdentity.workDir());
-    }
-
-    /** Creates the metastorage working directory. */
-    @Singleton
-    @Named("metastorage")
-    public ComponentWorkingDir metastorageWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
-        return metastoragePath(systemConfiguration, nodeIdentity.workDir());
-    }
-
-    /** Creates the CMG working directory. */
-    @Singleton
-    @Named("cmg")
-    public ComponentWorkingDir cmgWorkDir(SystemLocalConfiguration systemConfiguration, NodeIdentity nodeIdentity) {
-        return cmgPath(systemConfiguration, nodeIdentity.workDir());
-    }
-
     /** Creates the partitions log storage manager. */
     @Singleton
     @Named("partitions")

From 14ea3775b55d2bcc992c802a6199d60a073e45d8 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 10:01:04 +0400
Subject: [PATCH 59/79] Add GitHub Actions workflows for build, unit tests,
 integration tests, and code quality checks

---
 .github/workflows/build.yml             | 30 +++++++++++++++++++
 .github/workflows/checks.yml            | 39 +++++++++++++++++++++++++
 .github/workflows/integration-tests.yml | 39 +++++++++++++++++++++++++
 .github/workflows/unit-tests.yml        | 39 +++++++++++++++++++++++++
 4 files changed, 147 insertions(+)
 create mode 100644 .github/workflows/build.yml
 create mode 100644 .github/workflows/checks.yml
 create mode 100644 .github/workflows/integration-tests.yml
 create mode 100644 .github/workflows/unit-tests.yml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
new file mode 100644
index 000000000000..524203a40116
--- /dev/null
+++ b/.github/workflows/build.yml
@@ -0,0 +1,30 @@
+name: Build
+
+on:
+  push:
+    branches: [ ignite-di-claude ]
+  pull_request:
+    branches: [ ignite-di-claude ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: false
+
+      - name: Build (skip tests and checks)
+        run: ./gradlew clean build -x assembleDist -x distTar -x distZip -x check
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
new file mode 100644
index 000000000000..aca6482e6b19
--- /dev/null
+++ b/.github/workflows/checks.yml
@@ -0,0 +1,39 @@
+name: Code Quality Checks
+
+on:
+  workflow_run:
+    workflows: [ "Build" ]
+    types: [ completed ]
+
+jobs:
+  checks:
+    name: Checkstyle, PMD, SpotBugs
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.workflow_run.head_sha }}
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run Checkstyle
+        run: ./gradlew checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
+
+      - name: Run PMD
+        if: success() || failure()
+        run: ./gradlew pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
+
+      - name: Run SpotBugs
+        if: success() || failure()
+        run: ./gradlew spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
new file mode 100644
index 000000000000..401680b31509
--- /dev/null
+++ b/.github/workflows/integration-tests.yml
@@ -0,0 +1,39 @@
+name: Integration Tests
+
+on:
+  workflow_run:
+    workflows: [ "Build" ]
+    types: [ completed ]
+
+jobs:
+  integration-tests:
+    name: Integration Tests
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.workflow_run.head_sha }}
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: ./gradlew integrationTest
+
+      - name: Upload test reports
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
new file mode 100644
index 000000000000..67fd18cac32f
--- /dev/null
+++ b/.github/workflows/unit-tests.yml
@@ -0,0 +1,39 @@
+name: Unit Tests
+
+on:
+  workflow_run:
+    workflows: [ "Build" ]
+    types: [ completed ]
+
+jobs:
+  unit-tests:
+    name: Unit Tests
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.workflow_run.head_sha }}
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: ./gradlew test
+
+      - name: Upload test reports
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports
+          retention-days: 7
+          path: '**/build/reports/tests/test/'

From 72711292b786065174fb646b38e244e0d6a9fb6e Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 10:08:03 +0400
Subject: [PATCH 60/79] Consolidate GitHub Actions workflows into a single
 `Build & Test` workflow for improved maintenance and efficiency

---
 .github/workflows/build.yml             | 92 ++++++++++++++++++++++++-
 .github/workflows/checks.yml            | 39 -----------
 .github/workflows/integration-tests.yml | 39 -----------
 .github/workflows/unit-tests.yml        | 39 -----------
 4 files changed, 91 insertions(+), 118 deletions(-)
 delete mode 100644 .github/workflows/checks.yml
 delete mode 100644 .github/workflows/integration-tests.yml
 delete mode 100644 .github/workflows/unit-tests.yml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 524203a40116..0707dd3392f1 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,4 +1,4 @@
-name: Build
+name: Build & Test
 
 on:
   push:
@@ -28,3 +28,93 @@ jobs:
 
       - name: Build (skip tests and checks)
         run: ./gradlew clean build -x assembleDist -x distTar -x distZip -x check
+
+  checks:
+    name: Checkstyle, PMD, SpotBugs
+    needs: build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run Checkstyle
+        run: ./gradlew checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
+
+      - name: Run PMD
+        if: success() || failure()
+        run: ./gradlew pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
+
+      - name: Run SpotBugs
+        if: success() || failure()
+        run: ./gradlew spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures
+
+  unit-tests:
+    name: Unit Tests
+    needs: build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: ./gradlew test
+
+      - name: Upload test reports
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  integration-tests:
+    name: Integration Tests
+    needs: build
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: ./gradlew integrationTest
+
+      - name: Upload test reports
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
deleted file mode 100644
index aca6482e6b19..000000000000
--- a/.github/workflows/checks.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-name: Code Quality Checks
-
-on:
-  workflow_run:
-    workflows: [ "Build" ]
-    types: [ completed ]
-
-jobs:
-  checks:
-    name: Checkstyle, PMD, SpotBugs
-    runs-on: ubuntu-latest
-    if: ${{ github.event.workflow_run.conclusion == 'success' }}
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.workflow_run.head_sha }}
-
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'temurin'
-          java-version: '17'
-
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v4
-        with:
-          cache-read-only: true
-
-      - name: Run Checkstyle
-        run: ./gradlew checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
-
-      - name: Run PMD
-        if: success() || failure()
-        run: ./gradlew pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
-
-      - name: Run SpotBugs
-        if: success() || failure()
-        run: ./gradlew spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
deleted file mode 100644
index 401680b31509..000000000000
--- a/.github/workflows/integration-tests.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-name: Integration Tests
-
-on:
-  workflow_run:
-    workflows: [ "Build" ]
-    types: [ completed ]
-
-jobs:
-  integration-tests:
-    name: Integration Tests
-    runs-on: ubuntu-latest
-    if: ${{ github.event.workflow_run.conclusion == 'success' }}
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.workflow_run.head_sha }}
-
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'temurin'
-          java-version: '17'
-
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v4
-        with:
-          cache-read-only: true
-
-      - name: Run integration tests
-        run: ./gradlew integrationTest
-
-      - name: Upload test reports
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: integration-test-reports
-          retention-days: 7
-          path: '**/build/reports/tests/integrationTest/'
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
deleted file mode 100644
index 67fd18cac32f..000000000000
--- a/.github/workflows/unit-tests.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-name: Unit Tests
-
-on:
-  workflow_run:
-    workflows: [ "Build" ]
-    types: [ completed ]
-
-jobs:
-  unit-tests:
-    name: Unit Tests
-    runs-on: ubuntu-latest
-    if: ${{ github.event.workflow_run.conclusion == 'success' }}
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.workflow_run.head_sha }}
-
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'temurin'
-          java-version: '17'
-
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v4
-        with:
-          cache-read-only: true
-
-      - name: Run unit tests
-        run: ./gradlew test
-
-      - name: Upload test reports
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: unit-test-reports
-          retention-days: 7
-          path: '**/build/reports/tests/test/'

From 9edd632037965e6ecac1e3ccea7ccb202f209f6b Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 10:11:42 +0400
Subject: [PATCH 61/79] Split `Build & Test` GitHub Actions workflow into
 separate workflows for build, code quality checks, unit tests, and
 integration tests for improved modularity and reusability.

---
 .github/workflows/build.yml             | 85 ++-----------------------
 .github/workflows/checks.yml            | 34 ++++++++++
 .github/workflows/integration-tests.yml | 34 ++++++++++
 .github/workflows/unit-tests.yml        | 34 ++++++++++
 4 files changed, 107 insertions(+), 80 deletions(-)
 create mode 100644 .github/workflows/checks.yml
 create mode 100644 .github/workflows/integration-tests.yml
 create mode 100644 .github/workflows/unit-tests.yml

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 0707dd3392f1..a35815fcfe53 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,4 +1,4 @@
-name: Build & Test
+name: Build
 
 on:
   push:
@@ -30,91 +30,16 @@ jobs:
         run: ./gradlew clean build -x assembleDist -x distTar -x distZip -x check
 
   checks:
-    name: Checkstyle, PMD, SpotBugs
+    name: Checks
     needs: build
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'temurin'
-          java-version: '17'
-
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v4
-        with:
-          cache-read-only: true
-
-      - name: Run Checkstyle
-        run: ./gradlew checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
-
-      - name: Run PMD
-        if: success() || failure()
-        run: ./gradlew pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
-
-      - name: Run SpotBugs
-        if: success() || failure()
-        run: ./gradlew spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures
+    uses: ./.github/workflows/checks.yml
 
   unit-tests:
     name: Unit Tests
     needs: build
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'temurin'
-          java-version: '17'
-
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v4
-        with:
-          cache-read-only: true
-
-      - name: Run unit tests
-        run: ./gradlew test
-
-      - name: Upload test reports
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: unit-test-reports
-          retention-days: 7
-          path: '**/build/reports/tests/test/'
+    uses: ./.github/workflows/unit-tests.yml
 
   integration-tests:
     name: Integration Tests
     needs: build
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          distribution: 'temurin'
-          java-version: '17'
-
-      - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@v4
-        with:
-          cache-read-only: true
-
-      - name: Run integration tests
-        run: ./gradlew integrationTest
-
-      - name: Upload test reports
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: integration-test-reports
-          retention-days: 7
-          path: '**/build/reports/tests/integrationTest/'
+    uses: ./.github/workflows/integration-tests.yml
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
new file mode 100644
index 000000000000..73ce924fa828
--- /dev/null
+++ b/.github/workflows/checks.yml
@@ -0,0 +1,34 @@
+name: Code Quality Checks
+
+on:
+  workflow_call:
+
+jobs:
+  checks:
+    name: Checkstyle, PMD, SpotBugs
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run Checkstyle
+        run: ./gradlew checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
+
+      - name: Run PMD
+        if: success() || failure()
+        run: ./gradlew pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
+
+      - name: Run SpotBugs
+        if: success() || failure()
+        run: ./gradlew spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
new file mode 100644
index 000000000000..1a2e12ed684b
--- /dev/null
+++ b/.github/workflows/integration-tests.yml
@@ -0,0 +1,34 @@
+name: Integration Tests
+
+on:
+  workflow_call:
+
+jobs:
+  integration-tests:
+    name: Integration Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: ./gradlew integrationTest
+
+      - name: Upload test reports
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
new file mode 100644
index 000000000000..e9faba6e6b15
--- /dev/null
+++ b/.github/workflows/unit-tests.yml
@@ -0,0 +1,34 @@
+name: Unit Tests
+
+on:
+  workflow_call:
+
+jobs:
+  unit-tests:
+    name: Unit Tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: ./gradlew test
+
+      - name: Upload test reports
+        if: failure()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports
+          retention-days: 7
+          path: '**/build/reports/tests/test/'

From 22fdb7d32513a7486218a7f2d545e2e4efd5159c Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 10:16:18 +0400
Subject: [PATCH 62/79] Split `Checks` GitHub Actions workflow into separate
 jobs for Checkstyle, PMD, and SpotBugs to improve modularity and execution
 clarity.

---
 .github/workflows/checks.yml | 44 ++++++++++++++++++++++++++++++++----
 1 file changed, 39 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index 73ce924fa828..332b3cc02350 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -1,11 +1,11 @@
-name: Code Quality Checks
+name: Checks
 
 on:
   workflow_call:
 
 jobs:
-  checks:
-    name: Checkstyle, PMD, SpotBugs
+  checkstyle:
+    name: Checkstyle
     runs-on: ubuntu-latest
 
     steps:
@@ -25,10 +25,44 @@ jobs:
       - name: Run Checkstyle
         run: ./gradlew checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
 
+  pmd:
+    name: PMD
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
       - name: Run PMD
-        if: success() || failure()
         run: ./gradlew pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
 
+  spotbugs:
+    name: SpotBugs
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
       - name: Run SpotBugs
-        if: success() || failure()
         run: ./gradlew spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures

From d9b78673972479aef2abb841c35664cc7d12298b Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 10:18:39 +0400
Subject: [PATCH 63/79] Allow GitHub Actions workflows to continue on error and
 always upload test reports for improved fault tolerance and debugging.

---
 .github/workflows/checks.yml            | 9 ++++++---
 .github/workflows/integration-tests.yml | 5 +++--
 .github/workflows/unit-tests.yml        | 5 +++--
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index 332b3cc02350..696022a25a38 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -7,6 +7,7 @@ jobs:
   checkstyle:
     name: Checkstyle
     runs-on: ubuntu-latest
+    continue-on-error: true
 
     steps:
       - uses: actions/checkout@v4
@@ -23,11 +24,12 @@ jobs:
           cache-read-only: true
 
       - name: Run Checkstyle
-        run: ./gradlew checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
+        run: ./gradlew --continue checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
 
   pmd:
     name: PMD
     runs-on: ubuntu-latest
+    continue-on-error: true
 
     steps:
       - uses: actions/checkout@v4
@@ -44,11 +46,12 @@ jobs:
           cache-read-only: true
 
       - name: Run PMD
-        run: ./gradlew pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
+        run: ./gradlew --continue pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
 
   spotbugs:
     name: SpotBugs
     runs-on: ubuntu-latest
+    continue-on-error: true
 
     steps:
       - uses: actions/checkout@v4
@@ -65,4 +68,4 @@ jobs:
           cache-read-only: true
 
       - name: Run SpotBugs
-        run: ./gradlew spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures
+        run: ./gradlew --continue spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index 1a2e12ed684b..d57ac7c4364a 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -7,6 +7,7 @@ jobs:
   integration-tests:
     name: Integration Tests
     runs-on: ubuntu-latest
+    continue-on-error: true
 
     steps:
       - uses: actions/checkout@v4
@@ -23,10 +24,10 @@ jobs:
           cache-read-only: true
 
       - name: Run integration tests
-        run: ./gradlew integrationTest
+        run: ./gradlew --continue integrationTest
 
       - name: Upload test reports
-        if: failure()
+        if: always()
         uses: actions/upload-artifact@v4
         with:
           name: integration-test-reports
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index e9faba6e6b15..509988e32993 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -7,6 +7,7 @@ jobs:
   unit-tests:
     name: Unit Tests
     runs-on: ubuntu-latest
+    continue-on-error: true
 
     steps:
       - uses: actions/checkout@v4
@@ -23,10 +24,10 @@ jobs:
           cache-read-only: true
 
       - name: Run unit tests
-        run: ./gradlew test
+        run: ./gradlew --continue test
 
       - name: Upload test reports
-        if: failure()
+        if: always()
         uses: actions/upload-artifact@v4
         with:
           name: unit-test-reports

From 9fb41c83f0226887a2952be97c829583f3293530 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 10:28:41 +0400
Subject: [PATCH 64/79] Split `Unit Tests` GitHub Actions workflow into modular
 jobs by component for improved maintainability and clearer test execution
 visibility.

---
 .github/workflows/unit-tests.yml | 445 ++++++++++++++++++++++++++++++-
 1 file changed, 441 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index 509988e32993..160bc9a07619 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -4,8 +4,8 @@ on:
   workflow_call:
 
 jobs:
-  unit-tests:
-    name: Unit Tests
+  core:
+    name: Core
     runs-on: ubuntu-latest
     continue-on-error: true
 
@@ -24,12 +24,449 @@ jobs:
           cache-read-only: true
 
       - name: Run unit tests
-        run: ./gradlew --continue test
+        run: >-
+          ./gradlew --continue
+          :ignite-api:test
+          :ignite-arch-test:test
+          :ignite-binary-tuple:test
+          :ignite-bytecode:test
+          :ignite-core:test
+          :ignite-di:test
+          :ignite-failure-handler:test
+          :ignite-file-io:test
+          :ignite-marshaller-common:test
+          :ignite-workers:test
+          :ignite-vault:test
+          :ignite-eventlog:test
 
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: unit-test-reports
+          name: unit-test-reports-core
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  configuration:
+    name: Configuration
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-configuration:test
+          :ignite-configuration-annotation-processor:test
+          :ignite-configuration-presentation:test
+          :ignite-configuration-storage:test
+          :ignite-configuration-system:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-configuration
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  network:
+    name: Network
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-network:test
+          :ignite-network-annotation-processor:test
+          :ignite-network-api:test
+          :ignite-file-transfer:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-network
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  storage:
+    name: Storage
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-storage-api:test
+          :ignite-storage-page-memory:test
+          :ignite-storage-rocksdb:test
+          :ignite-page-memory:test
+          :ignite-rocksdb-common:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-storage
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  sql:
+    name: SQL
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-sql-engine:test
+          :ignite-catalog:test
+          :ignite-catalog-compaction:test
+          :ignite-catalog-dsl:test
+          :ignite-jdbc:test
+          :ignite-schema:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-sql
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  raft-replication:
+    name: Raft & Replication
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-raft:test
+          :ignite-raft-api:test
+          :ignite-replicator:test
+          :ignite-partition-replicator:test
+          :ignite-metastorage:test
+          :ignite-metastorage-api:test
+          :ignite-metastorage-cache:test
+          :ignite-low-watermark:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-raft-replication
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  table-index:
+    name: Table & Index
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-table:test
+          :ignite-index:test
+          :ignite-distribution-zones:test
+          :ignite-partition-distribution:test
+          :ignite-system-view:test
+          :ignite-system-view-api:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-table-index
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  compute-deployment:
+    name: Compute & Deployment
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-compute:test
+          :ignite-code-deployment:test
+          :ignite-code-deployment-classloader:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-compute-deployment
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  client:
+    name: Client
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-client:test
+          :ignite-client-common:test
+          :ignite-client-handler:test
+          :ignite-rest:test
+          :ignite-rest-api:test
+          :ignite-cli:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-client
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  runner:
+    name: Runner
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue
+          :ignite-runner:test
+          :ignite-cluster-management:test
+          :ignite-placement-driver:test
+          :ignite-placement-driver-api:test
+          :ignite-security:test
+          :ignite-transactions:test
+          :ignite-system-disaster-recovery:test
+          :ignite-system-disaster-recovery-api:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-runner
+          retention-days: 7
+          path: '**/build/reports/tests/test/'
+
+  misc:
+    name: Misc
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run unit tests
+        run: >-
+          ./gradlew --continue test
+          -x :ignite-api:test
+          -x :ignite-arch-test:test
+          -x :ignite-binary-tuple:test
+          -x :ignite-bytecode:test
+          -x :ignite-core:test
+          -x :ignite-di:test
+          -x :ignite-failure-handler:test
+          -x :ignite-file-io:test
+          -x :ignite-marshaller-common:test
+          -x :ignite-workers:test
+          -x :ignite-vault:test
+          -x :ignite-eventlog:test
+          -x :ignite-configuration:test
+          -x :ignite-configuration-annotation-processor:test
+          -x :ignite-configuration-presentation:test
+          -x :ignite-configuration-storage:test
+          -x :ignite-configuration-system:test
+          -x :ignite-network:test
+          -x :ignite-network-annotation-processor:test
+          -x :ignite-network-api:test
+          -x :ignite-file-transfer:test
+          -x :ignite-storage-api:test
+          -x :ignite-storage-page-memory:test
+          -x :ignite-storage-rocksdb:test
+          -x :ignite-page-memory:test
+          -x :ignite-rocksdb-common:test
+          -x :ignite-sql-engine:test
+          -x :ignite-catalog:test
+          -x :ignite-catalog-compaction:test
+          -x :ignite-catalog-dsl:test
+          -x :ignite-jdbc:test
+          -x :ignite-schema:test
+          -x :ignite-raft:test
+          -x :ignite-raft-api:test
+          -x :ignite-replicator:test
+          -x :ignite-partition-replicator:test
+          -x :ignite-metastorage:test
+          -x :ignite-metastorage-api:test
+          -x :ignite-metastorage-cache:test
+          -x :ignite-low-watermark:test
+          -x :ignite-table:test
+          -x :ignite-index:test
+          -x :ignite-distribution-zones:test
+          -x :ignite-partition-distribution:test
+          -x :ignite-system-view:test
+          -x :ignite-system-view-api:test
+          -x :ignite-compute:test
+          -x :ignite-code-deployment:test
+          -x :ignite-code-deployment-classloader:test
+          -x :ignite-client:test
+          -x :ignite-client-common:test
+          -x :ignite-client-handler:test
+          -x :ignite-rest:test
+          -x :ignite-rest-api:test
+          -x :ignite-cli:test
+          -x :ignite-runner:test
+          -x :ignite-cluster-management:test
+          -x :ignite-placement-driver:test
+          -x :ignite-placement-driver-api:test
+          -x :ignite-security:test
+          -x :ignite-transactions:test
+          -x :ignite-system-disaster-recovery:test
+          -x :ignite-system-disaster-recovery-api:test
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: unit-test-reports-misc
           retention-days: 7
           path: '**/build/reports/tests/test/'

From c12dcf87d6bb4b6154ea74b2fcb06f32a290c6bc Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 10:30:16 +0400
Subject: [PATCH 65/79] Split `Integration Tests` GitHub Actions workflow into
 modular jobs by component for improved maintainability, fault tolerance, and
 clearer test execution visibility.

---
 .github/workflows/integration-tests.yml | 350 +++++++++++++++++++++++-
 1 file changed, 346 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index d57ac7c4364a..18456e499da8 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -4,8 +4,8 @@ on:
   workflow_call:
 
 jobs:
-  integration-tests:
-    name: Integration Tests
+  core:
+    name: Core
     runs-on: ubuntu-latest
     continue-on-error: true
 
@@ -24,12 +24,354 @@ jobs:
           cache-read-only: true
 
       - name: Run integration tests
-        run: ./gradlew --continue integrationTest
+        run: >-
+          ./gradlew --continue
+          :ignite-eventlog:integrationTest
+          :ignite-failure-handler:integrationTest
+          :ignite-workers:integrationTest
+          :ignite-configuration-annotation-processor:integrationTest
+          :ignite-file-transfer:integrationTest
 
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: integration-test-reports
+          name: integration-test-reports-core
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  network:
+    name: Network
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-network:integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-network
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  storage:
+    name: Storage
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-page-memory:integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-storage
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  sql:
+    name: SQL
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-sql-engine:integrationTest
+          :ignite-catalog:integrationTest
+          :ignite-catalog-compaction:integrationTest
+          :ignite-catalog-dsl:integrationTest
+          :ignite-jdbc:integrationTest
+          :ignite-schema-sync:integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-sql
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  raft-replication:
+    name: Raft & Replication
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-raft:integrationTest
+          :ignite-replicator:integrationTest
+          :ignite-partition-replicator:integrationTest
+          :ignite-metastorage:integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-raft-replication
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  table-index:
+    name: Table & Index
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-table:integrationTest
+          :ignite-index:integrationTest
+          :ignite-distribution-zones:integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-table-index
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  compute-deployment:
+    name: Compute & Deployment
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-compute:integrationTest
+          :ignite-code-deployment:integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-compute-deployment
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  client:
+    name: Client
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-client-handler:integrationTest
+          :ignite-rest:integrationTest
+          :ignite-cli:integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-client
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  runner:
+    name: Runner
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue
+          :ignite-runner:integrationTest
+          :ignite-cluster-management:integrationTest
+          :ignite-placement-driver:integrationTest
+          :ignite-security:integrationTest
+          :ignite-transactions:integrationTest
+          :ignite-system-disaster-recovery:integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-runner
+          retention-days: 7
+          path: '**/build/reports/tests/integrationTest/'
+
+  misc:
+    name: Misc
+    runs-on: ubuntu-latest
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+        with:
+          cache-read-only: true
+
+      - name: Run integration tests
+        run: >-
+          ./gradlew --continue integrationTest
+          -x :ignite-eventlog:integrationTest
+          -x :ignite-failure-handler:integrationTest
+          -x :ignite-workers:integrationTest
+          -x :ignite-configuration-annotation-processor:integrationTest
+          -x :ignite-file-transfer:integrationTest
+          -x :ignite-network:integrationTest
+          -x :ignite-page-memory:integrationTest
+          -x :ignite-sql-engine:integrationTest
+          -x :ignite-catalog:integrationTest
+          -x :ignite-catalog-compaction:integrationTest
+          -x :ignite-catalog-dsl:integrationTest
+          -x :ignite-jdbc:integrationTest
+          -x :ignite-schema-sync:integrationTest
+          -x :ignite-raft:integrationTest
+          -x :ignite-replicator:integrationTest
+          -x :ignite-partition-replicator:integrationTest
+          -x :ignite-metastorage:integrationTest
+          -x :ignite-table:integrationTest
+          -x :ignite-index:integrationTest
+          -x :ignite-distribution-zones:integrationTest
+          -x :ignite-compute:integrationTest
+          -x :ignite-code-deployment:integrationTest
+          -x :ignite-client-handler:integrationTest
+          -x :ignite-rest:integrationTest
+          -x :ignite-cli:integrationTest
+          -x :ignite-runner:integrationTest
+          -x :ignite-cluster-management:integrationTest
+          -x :ignite-placement-driver:integrationTest
+          -x :ignite-security:integrationTest
+          -x :ignite-transactions:integrationTest
+          -x :ignite-system-disaster-recovery:integrationTest
+
+      - name: Upload test reports
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: integration-test-reports-misc
           retention-days: 7
           path: '**/build/reports/tests/integrationTest/'

From 57a23d6f195601891812ef4f62207e9fd2947f71 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 10:33:12 +0400
Subject: [PATCH 66/79] Remove `continue-on-error` from code quality checks and
 update dependencies for `checks` workflow in GitHub Actions.

---
 .github/workflows/build.yml  | 4 ++--
 .github/workflows/checks.yml | 3 ---
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a35815fcfe53..89d02d3549e4 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -36,10 +36,10 @@ jobs:
 
   unit-tests:
     name: Unit Tests
-    needs: build
+    needs: checks
     uses: ./.github/workflows/unit-tests.yml
 
   integration-tests:
     name: Integration Tests
-    needs: build
+    needs: checks
     uses: ./.github/workflows/integration-tests.yml
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index 696022a25a38..1b3967878735 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -7,7 +7,6 @@ jobs:
   checkstyle:
     name: Checkstyle
     runs-on: ubuntu-latest
-    continue-on-error: true
 
     steps:
       - uses: actions/checkout@v4
@@ -29,7 +28,6 @@ jobs:
   pmd:
     name: PMD
     runs-on: ubuntu-latest
-    continue-on-error: true
 
     steps:
       - uses: actions/checkout@v4
@@ -51,7 +49,6 @@ jobs:
   spotbugs:
     name: SpotBugs
     runs-on: ubuntu-latest
-    continue-on-error: true
 
     steps:
       - uses: actions/checkout@v4

From 4f85e9b03974cf8e11012b4f5445727406f7dc28 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 10:34:50 +0400
Subject: [PATCH 67/79] ignite-di-claude Update `Integration Tests` workflow to
 depend on `Unit Tests` instead of `Checks` in GitHub Actions

---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 89d02d3549e4..8f1a967085aa 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -41,5 +41,5 @@ jobs:
 
   integration-tests:
     name: Integration Tests
-    needs: checks
+    needs: unit-tests
     uses: ./.github/workflows/integration-tests.yml

From a47f1382c65b265f4045db2cd1eb940d0d2d5265 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 12:44:28 +0400
Subject: [PATCH 68/79] ignite-di-claude Migrate RocksDB-related classes to use
 dependency injection with Micronaut annotations; remove redundant factory
 methods and constructors.

---
 .../raft/RocksDbClusterStateStorage.java      | 19 +++++++++++++
 .../persistence/RocksDbKeyValueStorage.java   | 20 ++++++++++++++
 .../VolatileLogStorageManagerCreator.java     | 17 ++++++++++++
 .../app/di/ClusterManagementFactory.java      | 10 -------
 .../internal/app/di/DataPathFactory.java      | 11 --------
 .../internal/app/di/MetaStorageFactory.java   | 24 -----------------
 .../ignite/internal/app/di/RaftFactory.java   | 10 +++++++
 .../internal/app/di/TransactionFactory.java   | 24 -----------------
 .../rocksdb/TxStateRocksDbSharedStorage.java  | 27 +++++++++++++++++++
 9 files changed, 93 insertions(+), 69 deletions(-)

diff --git a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/RocksDbClusterStateStorage.java b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/RocksDbClusterStateStorage.java
index cbc6f8360753..e77b0dc0e2fc 100644
--- a/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/RocksDbClusterStateStorage.java
+++ b/modules/cluster-management/src/main/java/org/apache/ignite/internal/cluster/management/raft/RocksDbClusterStateStorage.java
@@ -23,6 +23,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLock;
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -36,6 +40,10 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiFunction;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
@@ -58,6 +66,9 @@
 /**
  * {@link ClusterStateStorage} implementation based on RocksDB.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(700)
 public class RocksDbClusterStateStorage implements ClusterStateStorage {
     private static final IgniteLogger LOG = Loggers.forClass(RocksDbClusterStateStorage.class);
 
@@ -85,6 +96,14 @@ public class RocksDbClusterStateStorage implements ClusterStateStorage {
     /** Prevents double stopping of the component. */
     private final AtomicBoolean stopGuard = new AtomicBoolean();
 
+    /**
+     * Creates a new instance using DI-provided dependencies.
+     */
+    @Inject
+    public RocksDbClusterStateStorage(@Named("cmg") ComponentWorkingDir cmgWorkDir, NodeIdentity nodeIdentity) {
+        this(cmgWorkDir.dbPath(), nodeIdentity.nodeName());
+    }
+
     /**
      * Creates a new instance.
      *
diff --git a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/persistence/RocksDbKeyValueStorage.java b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/persistence/RocksDbKeyValueStorage.java
index c5c2f1f8f3ae..de92b4b418d2 100644
--- a/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/persistence/RocksDbKeyValueStorage.java
+++ b/modules/metastorage/src/main/java/org/apache/ignite/internal/metastorage/server/persistence/RocksDbKeyValueStorage.java
@@ -56,6 +56,9 @@
 import static org.apache.ignite.lang.ErrorGroups.MetaStorage.STARTING_STORAGE_ERR;
 import static org.rocksdb.util.SizeUnit.MB;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
@@ -77,6 +80,8 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.LongSupplier;
 import org.apache.ignite.internal.components.NoOpLogSyncer;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -147,6 +152,7 @@
  * The mapping from the key to the set of the storage's revisions is stored in the "index" column family. A key represents the key of an
  * entry and the value is a {@code byte[]} that represents a {@code long[]} where every item is a revision of the storage.
  */
+@Singleton
 public class RocksDbKeyValueStorage extends AbstractKeyValueStorage {
     private static final IgniteLogger LOG = Loggers.forClass(RocksDbKeyValueStorage.class);
 
@@ -286,6 +292,20 @@ private enum RecoveryStatus {
 
     private final AtomicBoolean closeGuard = new AtomicBoolean();
 
+    /**
+     * DI constructor.
+     */
+    @Inject
+    public RocksDbKeyValueStorage(
+            NodeIdentity nodeIdentity,
+            @Named("metastorage") ComponentWorkingDir metastorageWorkDir,
+            FailureProcessor failureProcessor,
+            ReadOperationForCompactionTracker readOperationForCompactionTracker,
+            @Named("commonScheduler") ScheduledExecutorService scheduledExecutor
+    ) {
+        this(nodeIdentity.nodeName(), metastorageWorkDir.dbPath(), failureProcessor, readOperationForCompactionTracker, scheduledExecutor);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VolatileLogStorageManagerCreator.java b/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VolatileLogStorageManagerCreator.java
index cce20e0b5072..f6e31ec0e8e4 100644
--- a/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VolatileLogStorageManagerCreator.java
+++ b/modules/raft/src/main/java/org/apache/ignite/internal/raft/storage/impl/VolatileLogStorageManagerCreator.java
@@ -22,6 +22,9 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.rocksdb.RocksDB.DEFAULT_COLUMN_FAMILY;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -31,6 +34,9 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
@@ -59,6 +65,9 @@
 /**
  * {@link LogStorageManagerCreator} for volatile log storage.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1300)
 public class VolatileLogStorageManagerCreator implements LogStorageManagerCreator, IgniteComponent {
     private static final IgniteLogger LOG = Loggers.forClass(VolatileLogStorageManagerCreator.class);
 
@@ -85,6 +94,14 @@ public class VolatileLogStorageManagerCreator implements LogStorageManagerCreato
 
     private RocksDbSizeCalculator sizeCalculator;
 
+    /**
+     * DI constructor.
+     */
+    @Inject
+    public VolatileLogStorageManagerCreator(NodeIdentity nodeIdentity) {
+        this(nodeIdentity.nodeName(), nodeIdentity.workDir().resolve("volatile-log-spillout"));
+    }
+
     /**
      * Create a new instance.
      *
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index ebaf9ac4c065..fa1c7eabacfa 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -24,11 +24,9 @@
 import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesConfiguration;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesExtensionConfiguration;
-import org.apache.ignite.internal.cluster.management.raft.RocksDbClusterStateStorage;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
-import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationDynamicDefaultsPatcherImpl;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
@@ -124,14 +122,6 @@ public StorageConfiguration storageConfiguration(@Named("nodeConfig") Configurat
         return nodeConfigRegistry.getConfiguration(StorageExtensionConfiguration.KEY).storage();
     }
 
-    /** Creates the cluster state storage backed by RocksDB. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(700)
-    public RocksDbClusterStateStorage clusterStateStorage(@Named("cmg") ComponentWorkingDir cmgWorkDir, NodeIdentity nodeIdentity) {
-        return new RocksDbClusterStateStorage(cmgWorkDir.dbPath(), nodeIdentity.nodeName());
-    }
-
     /** Creates the distributed configuration tree generator. */
     @Singleton
     @Named("distributed")
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index a1f08cbd8722..576a2dd1e912 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -87,17 +87,6 @@
  */
 @Factory
 public class DataPathFactory {
-    /** Creates the volatile log storage manager creator. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1300)
-    public VolatileLogStorageManagerCreator volatileLogStorageManagerCreator(NodeIdentity nodeIdentity) {
-        return new VolatileLogStorageManagerCreator(
-                nodeIdentity.nodeName(),
-                nodeIdentity.workDir().resolve("volatile-log-spillout")
-        );
-    }
-
     /** Creates the schema safe time tracker. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index bde72ef2d587..b4dba2b78841 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -20,20 +20,14 @@
 import io.micronaut.context.annotation.Factory;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
-import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
-import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
-import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.metastorage.server.ReadOperationForCompactionTracker;
-import org.apache.ignite.internal.metastorage.server.persistence.RocksDbKeyValueStorage;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.raft.Loza;
 import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
@@ -65,24 +59,6 @@ public TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory
         );
     }
 
-    /** Creates the RocksDB key-value storage for metastorage. */
-    @Singleton
-    public RocksDbKeyValueStorage metastorageKeyValueStorage(
-            NodeIdentity nodeIdentity,
-            @Named("metastorage") ComponentWorkingDir metastorageWorkDir,
-            FailureManager failureManager,
-            ReadOperationForCompactionTracker readOperationForCompactionTracker,
-            @Named("commonScheduler") ScheduledExecutorService commonScheduler
-    ) {
-        return new RocksDbKeyValueStorage(
-                nodeIdentity.nodeName(),
-                metastorageWorkDir.dbPath(),
-                failureManager,
-                readOperationForCompactionTracker,
-                commonScheduler
-        );
-    }
-
     /** Creates the cluster (distributed) configuration registry. */
     @Singleton
     @Named("clusterConfig")
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
index d8416a1b1bc5..0be5935d5fd0 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/RaftFactory.java
@@ -25,6 +25,7 @@
 import java.util.Map;
 import org.apache.ignite.internal.cluster.management.CmgGroupId;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.LogSyncer;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
@@ -105,6 +106,15 @@ public LogStorageManager cmgLogStorageManager(
         );
     }
 
+    /** Exposes the partitions log syncer as a named bean. */
+    @Singleton
+    @Named("partitions")
+    public LogSyncer partitionsLogSyncer(
+            @Named("partitions") LogStorageManager partitionsLogStorageManager
+    ) {
+        return partitionsLogStorageManager.logSyncer();
+    }
+
     /** Creates the partitions Raft group options configurer. */
     @Singleton
     @Named("partitions")
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index f6a90c643fae..54b3a06f4179 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -26,7 +26,6 @@
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
-import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
@@ -40,7 +39,6 @@
 import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.network.wrapper.JumpToExecutorByConsistentIdAfterSend;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
-import org.apache.ignite.internal.raft.storage.LogStorageManager;
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.schema.configuration.GcConfiguration;
@@ -54,7 +52,6 @@
 import org.apache.ignite.internal.tx.impl.TransactionInflights;
 import org.apache.ignite.internal.tx.impl.TxManagerImpl;
 import org.apache.ignite.internal.tx.impl.VolatileTxStateMetaStorage;
-import org.apache.ignite.internal.tx.storage.state.rocksdb.TxStateRocksDbSharedStorage;
 
 /**
  * Micronaut factory for transaction-related components.
@@ -160,25 +157,4 @@ public TxManagerImpl txManager(
         );
     }
 
-    /** Creates the shared RocksDB transaction state storage. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1800)
-    public TxStateRocksDbSharedStorage txStateRocksDbSharedStorage(
-            NodeIdentity nodeIdentity,
-            @Named("partitions") ComponentWorkingDir partitionsWorkDir,
-            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
-            @Named("tableIoExecutor") ScheduledExecutorService tableIoExecutor,
-            @Named("partitions") LogStorageManager partitionsLogStorageManager,
-            FailureManager failureManager
-    ) {
-        return new TxStateRocksDbSharedStorage(
-                nodeIdentity.nodeName(),
-                partitionsWorkDir.dbPath().resolve("tx-state"),
-                commonScheduler,
-                tableIoExecutor,
-                partitionsLogStorageManager.logSyncer(),
-                failureManager
-        );
-    }
 }
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/storage/state/rocksdb/TxStateRocksDbSharedStorage.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/storage/state/rocksdb/TxStateRocksDbSharedStorage.java
index 378a0335fef7..2497e2e52977 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/storage/state/rocksdb/TxStateRocksDbSharedStorage.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/storage/state/rocksdb/TxStateRocksDbSharedStorage.java
@@ -27,6 +27,10 @@
 import static org.apache.ignite.internal.util.IgniteUtils.closeAll;
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.file.Files;
@@ -42,7 +46,11 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.IntSupplier;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.LogSyncer;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
@@ -68,6 +76,9 @@
  * as well as reducing the amount of resources that would otherwise be used by multiple RocksDB instances, if they existed
  * on per-zone basis.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1800)
 public class TxStateRocksDbSharedStorage implements IgniteComponent {
     static {
         RocksDB.loadLibrary();
@@ -127,6 +138,22 @@ public class TxStateRocksDbSharedStorage implements IgniteComponent {
 
     private volatile ColumnFamily txStateMetaColumnFamily;
 
+    /**
+     * DI constructor.
+     */
+    @Inject
+    public TxStateRocksDbSharedStorage(
+            NodeIdentity nodeIdentity,
+            @Named("partitions") ComponentWorkingDir partitionsWorkDir,
+            @Named("commonScheduler") ScheduledExecutorService scheduledExecutor,
+            @Named("tableIoExecutor") ScheduledExecutorService threadPool,
+            @Named("partitions") LogSyncer logSyncer,
+            FailureProcessor failureProcessor
+    ) {
+        this(nodeIdentity.nodeName(), partitionsWorkDir.dbPath().resolve("tx-state"),
+                scheduledExecutor, threadPool, logSyncer, failureProcessor);
+    }
+
     /**
      * Constructor.
      *

From afaf63d140d1fa4de93b7b97399c11d7e2a0ec35 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 19:09:44 +0400
Subject: [PATCH 69/79] Migrate schema-related and distribution zone services
 to use Micronaut dependency injection; remove redundant factory methods and
 constructors.

---
 modules/distribution-zones/build.gradle       |  3 +
 .../DistributionZoneManager.java              | 40 +++++++++++
 ...alanceMinimumRequiredTimeProviderImpl.java |  4 ++
 .../internal/app/di/DataPathFactory.java      | 68 -------------------
 .../schema/SchemaSafeTimeTrackerImpl.java     | 17 +++++
 .../schema/SchemaSyncServiceImpl.java         | 15 ++++
 6 files changed, 79 insertions(+), 68 deletions(-)

diff --git a/modules/distribution-zones/build.gradle b/modules/distribution-zones/build.gradle
index 253355ea4f42..957dc05120f0 100644
--- a/modules/distribution-zones/build.gradle
+++ b/modules/distribution-zones/build.gradle
@@ -24,6 +24,7 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-core')
     implementation project(':ignite-configuration-api')
@@ -39,7 +40,9 @@ dependencies {
     implementation project(':ignite-raft-api')
     implementation project(':ignite-failure-handler')
     implementation project(':ignite-metrics')
+    implementation project(':ignite-network-api')
 
+    implementation libs.micronaut.inject
     implementation libs.auto.service.annotations
     implementation libs.fastutil.core
     implementation libs.jetbrains.annotations
diff --git a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java
index 4c92a01031b9..bd87dcc6f99c 100644
--- a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java
+++ b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java
@@ -58,6 +58,9 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.NODE_STOPPING_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -114,6 +117,10 @@
 import org.apache.ignite.internal.metastorage.dsl.StatementResult;
 import org.apache.ignite.internal.metastorage.dsl.Update;
 import org.apache.ignite.internal.metrics.MetricManager;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.util.IgniteSpinBusyLock;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
@@ -121,6 +128,9 @@
 /**
  * Distribution zones manager.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1100)
 public class DistributionZoneManager extends
         AbstractEventProducer<HaZoneTopologyUpdateEvent, HaZoneTopologyUpdateEventParams> implements IgniteComponent {
     /** The logger. */
@@ -192,6 +202,36 @@ public class DistributionZoneManager extends
     @Nullable
     private Predicate<NodeWithAttributes> additionalNodeFilter = null;
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public DistributionZoneManager(
+            NodeIdentity nodeIdentity,
+            TopologyService topologyService,
+            MetaStorageManager metaStorageManager,
+            LogicalTopologyService logicalTopologyService,
+            FailureProcessor failureProcessor,
+            CatalogManager catalogManager,
+            SystemDistributedConfiguration systemDistributedConfiguration,
+            ClockService clockService,
+            MetricManager metricManager,
+            LowWatermark lowWatermark
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                () -> topologyService.localMember().id(),
+                metaStorageManager,
+                logicalTopologyService,
+                failureProcessor,
+                catalogManager,
+                systemDistributedConfiguration,
+                clockService,
+                metricManager,
+                lowWatermark
+        );
+    }
+
     /**
      * Constructor.
      */
diff --git a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceMinimumRequiredTimeProviderImpl.java b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceMinimumRequiredTimeProviderImpl.java
index 7c33d76385ab..f7935de91aae 100644
--- a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceMinimumRequiredTimeProviderImpl.java
+++ b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/rebalance/RebalanceMinimumRequiredTimeProviderImpl.java
@@ -24,6 +24,8 @@
 import static org.apache.ignite.internal.distributionzones.rebalance.RebalanceUtil.STABLE_ASSIGNMENTS_PREFIX_BYTES;
 import static org.apache.ignite.internal.hlc.HybridTimestamp.hybridTimestamp;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -50,6 +52,7 @@
  * {@link RebalanceMinimumRequiredTimeProvider} implementation for the current implementation of assignments. Assumes that each table has
  * its own assignments, but assignments within a zone are still somehow coordinated.
  */
+@Singleton
 public class RebalanceMinimumRequiredTimeProviderImpl implements RebalanceMinimumRequiredTimeProvider {
     private final MetaStorageManager metaStorageManager;
     private final CatalogService catalogService;
@@ -57,6 +60,7 @@ public class RebalanceMinimumRequiredTimeProviderImpl implements RebalanceMinimu
     /**
      * Constructor.
      */
+    @Inject
     public RebalanceMinimumRequiredTimeProviderImpl(MetaStorageManager metaStorageManager, CatalogService catalogService) {
         this.metaStorageManager = metaStorageManager;
         this.catalogService = catalogService;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index 576a2dd1e912..f36d0870f508 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -31,31 +31,22 @@
 import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ScheduledExecutorService;
-import java.util.function.LongSupplier;
 import org.apache.ignite.internal.catalog.CatalogManager;
-import org.apache.ignite.internal.catalog.CatalogManagerImpl;
-import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
-import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.LongJvmPauseDetector;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
-import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
-import org.apache.ignite.internal.distributionzones.DistributionZoneManager;
-import org.apache.ignite.internal.distributionzones.rebalance.RebalanceMinimumRequiredTimeProviderImpl;
 import org.apache.ignite.internal.failure.FailureManager;
 import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.HybridClock;
 import org.apache.ignite.internal.hlc.HybridTimestampTracker;
-import org.apache.ignite.internal.lowwatermark.LowWatermark;
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
-import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.partition.replicator.network.PartitionReplicationMessageGroup;
 import org.apache.ignite.internal.partition.replicator.schema.CatalogValidationSchemasSource;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
@@ -68,8 +59,6 @@
 import org.apache.ignite.internal.replicator.TablePartitionId;
 import org.apache.ignite.internal.replicator.VersionedAssignments;
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
-import org.apache.ignite.internal.schema.SchemaSafeTimeTracker;
-import org.apache.ignite.internal.schema.SchemaSafeTimeTrackerImpl;
 import org.apache.ignite.internal.schema.SchemaSyncService;
 import org.apache.ignite.internal.storage.DataStorageManager;
 import org.apache.ignite.internal.storage.DataStorageModule;
@@ -78,7 +67,6 @@
 import org.apache.ignite.internal.storage.engine.StorageEngine;
 import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
 import org.apache.ignite.internal.table.distributed.raft.PartitionSafeTimeValidator;
-import org.apache.ignite.internal.table.distributed.schema.SchemaSyncServiceImpl;
 import org.apache.ignite.internal.table.distributed.schema.ThreadLocalPartitionCommandsMarshaller;
 import org.apache.ignite.internal.tx.message.TxMessageGroup;
 
@@ -87,24 +75,6 @@
  */
 @Factory
 public class DataPathFactory {
-    /** Creates the schema safe time tracker. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1900)
-    public SchemaSafeTimeTrackerImpl schemaSafeTimeTracker(MetaStorageManager metaStorageManager) {
-        return new SchemaSafeTimeTrackerImpl(metaStorageManager.clusterTime());
-    }
-
-    /** Creates the schema sync service. */
-    @Singleton
-    public SchemaSyncServiceImpl schemaSyncService(
-            SchemaSafeTimeTracker schemaSafeTimeTracker,
-            SchemaSynchronizationConfiguration schemaSyncConfig
-    ) {
-        LongSupplier delayDurationMsSupplier = () -> schemaSyncConfig.delayDurationMillis().value();
-        return new SchemaSyncServiceImpl(schemaSafeTimeTracker, delayDurationMsSupplier);
-    }
-
     /** Creates the observable hybrid timestamp tracker. */
     @Singleton
     public HybridTimestampTracker hybridTimestampTracker() {
@@ -204,36 +174,6 @@ public DataStorageManager dataStorageManager(
         return new DataStorageManager(storageEngines, storageConfiguration);
     }
 
-    /** Creates the distribution zone manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1100)
-    public DistributionZoneManager distributionZoneManager(
-            NodeIdentity nodeIdentity,
-            TopologyService topologyService,
-            MetaStorageManager metaStorageManager,
-            LogicalTopologyService logicalTopologyService,
-            FailureManager failureManager,
-            CatalogManager catalogManager,
-            SystemDistributedConfiguration systemDistributedConfiguration,
-            ClockService clockService,
-            MetricManager metricManager,
-            LowWatermark lowWatermark
-    ) {
-        return new DistributionZoneManager(
-                nodeIdentity.nodeName(),
-                () -> topologyService.localMember().id(),
-                metaStorageManager,
-                logicalTopologyService,
-                failureManager,
-                catalogManager,
-                systemDistributedConfiguration,
-                clockService,
-                metricManager,
-                lowWatermark
-        );
-    }
-
     /** Creates the partition modification counter factory. */
     @Singleton
     public PartitionModificationCounterFactory partitionModificationCounterFactory(
@@ -243,12 +183,4 @@ public PartitionModificationCounterFactory partitionModificationCounterFactory(
         return new PartitionModificationCounterFactory(clockService::current, clusterMessagingService);
     }
 
-    /** Creates the rebalance minimum required time provider. */
-    @Singleton
-    public RebalanceMinimumRequiredTimeProviderImpl rebalanceMinimumRequiredTimeProvider(
-            MetaStorageManager metaStorageManager,
-            CatalogManagerImpl catalogManager
-    ) {
-        return new RebalanceMinimumRequiredTimeProviderImpl(metaStorageManager, catalogManager);
-    }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/schema/SchemaSafeTimeTrackerImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/schema/SchemaSafeTimeTrackerImpl.java
index f05e79c0adaf..c574d6311ba1 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/schema/SchemaSafeTimeTrackerImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/schema/SchemaSafeTimeTrackerImpl.java
@@ -19,15 +19,21 @@
 
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.lang.NodeStoppingException;
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.manager.IgniteComponent;
 import org.apache.ignite.internal.metastorage.Entry;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.metastorage.server.NotificationEnqueuedListener;
 import org.apache.ignite.internal.metastorage.server.time.ClusterTime;
 import org.apache.ignite.internal.util.PendingComparableValuesTracker;
@@ -36,6 +42,9 @@
 /**
  * Default implementation of {@link SchemaSafeTimeTracker}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1900)
 public class SchemaSafeTimeTrackerImpl implements SchemaSafeTimeTracker, IgniteComponent, NotificationEnqueuedListener {
     private final ClusterTime clusterTime;
 
@@ -46,6 +55,14 @@ public class SchemaSafeTimeTrackerImpl implements SchemaSafeTimeTracker, IgniteC
 
     private final Object futureMutex = new Object();
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public SchemaSafeTimeTrackerImpl(MetaStorageManager metaStorageManager) {
+        this(metaStorageManager.clusterTime());
+    }
+
     public SchemaSafeTimeTrackerImpl(ClusterTime clusterTime) {
         this.clusterTime = clusterTime;
     }
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/schema/SchemaSyncServiceImpl.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/schema/SchemaSyncServiceImpl.java
index 0a1b3e6a7520..7873c6cc23cc 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/schema/SchemaSyncServiceImpl.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/schema/SchemaSyncServiceImpl.java
@@ -17,8 +17,11 @@
 
 package org.apache.ignite.internal.table.distributed.schema;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.LongSupplier;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.schema.SchemaSafeTimeTracker;
 import org.apache.ignite.internal.schema.SchemaSyncService;
@@ -26,11 +29,23 @@
 /**
  * A default implementation of {@link SchemaSyncService}.
  */
+@Singleton
 public class SchemaSyncServiceImpl implements SchemaSyncService {
     private final SchemaSafeTimeTracker schemaSafeTimeTracker;
 
     private final LongSupplier delayDurationMs;
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public SchemaSyncServiceImpl(
+            SchemaSafeTimeTracker schemaSafeTimeTracker,
+            SchemaSynchronizationConfiguration schemaSyncConfig
+    ) {
+        this(schemaSafeTimeTracker, () -> schemaSyncConfig.delayDurationMillis().value());
+    }
+
     /**
      * Constructor.
      */

From 81fcbdff655d18189f876b248c3cac4b2569c73f Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 19:18:32 +0400
Subject: [PATCH 70/79] Migrate `TransactionIdGenerator` and
 `PartitionModificationCounterFactory` to use Micronaut dependency injection;
 remove redundant factory methods.

---
 .../ignite/internal/app/di/DataPathFactory.java  | 11 -----------
 .../internal/app/di/TransactionFactory.java      |  6 ------
 .../PartitionModificationCounterFactory.java     | 16 ++++++++++++++++
 .../internal/tx/impl/TransactionIdGenerator.java | 12 ++++++++++++
 4 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
index f36d0870f508..bdfa2de0a01f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/DataPathFactory.java
@@ -46,7 +46,6 @@
 import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ClusterService;
-import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.partition.replicator.network.PartitionReplicationMessageGroup;
 import org.apache.ignite.internal.partition.replicator.schema.CatalogValidationSchemasSource;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
@@ -65,7 +64,6 @@
 import org.apache.ignite.internal.storage.DataStorageModules;
 import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
 import org.apache.ignite.internal.storage.engine.StorageEngine;
-import org.apache.ignite.internal.table.distributed.PartitionModificationCounterFactory;
 import org.apache.ignite.internal.table.distributed.raft.PartitionSafeTimeValidator;
 import org.apache.ignite.internal.table.distributed.schema.ThreadLocalPartitionCommandsMarshaller;
 import org.apache.ignite.internal.tx.message.TxMessageGroup;
@@ -174,13 +172,4 @@ public DataStorageManager dataStorageManager(
         return new DataStorageManager(storageEngines, storageConfiguration);
     }
 
-    /** Creates the partition modification counter factory. */
-    @Singleton
-    public PartitionModificationCounterFactory partitionModificationCounterFactory(
-            ClockService clockService,
-            @Named("clusterMessaging") MessagingService clusterMessagingService
-    ) {
-        return new PartitionModificationCounterFactory(clockService::current, clusterMessagingService);
-    }
-
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index 54b3a06f4179..af4bd7a32ef5 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -101,12 +101,6 @@ public MessagingService storageOperationsMessagingService(
         );
     }
 
-    /** Creates the transaction ID generator. */
-    @Singleton
-    public TransactionIdGenerator transactionIdGenerator(ClusterService clusterService) {
-        return new TransactionIdGenerator(() -> clusterService.nodeName().hashCode());
-    }
-
     /** Creates the transaction manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/PartitionModificationCounterFactory.java b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/PartitionModificationCounterFactory.java
index 5b15bb98791a..14c1d8898ea3 100644
--- a/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/PartitionModificationCounterFactory.java
+++ b/modules/table/src/main/java/org/apache/ignite/internal/table/distributed/PartitionModificationCounterFactory.java
@@ -17,11 +17,15 @@
 
 package org.apache.ignite.internal.table.distributed;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Supplier;
+import org.apache.ignite.internal.hlc.ClockService;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
 import org.apache.ignite.internal.network.InternalClusterNode;
 import org.apache.ignite.internal.network.MessagingService;
@@ -36,12 +40,24 @@
 /**
  * Factory for producing {@link PartitionModificationCounter}.
  */
+@Singleton
 public class PartitionModificationCounterFactory {
     private final Supplier<HybridTimestamp> currentTimestampSupplier;
     private final MessagingService messagingService;
     private final Map<TablePartitionId, PartitionModificationCounter> partitionsInfo = new HashMap<>();
     private static final TableMessagesFactory TABLE_MESSAGES_FACTORY = new TableMessagesFactory();
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public PartitionModificationCounterFactory(
+            ClockService clockService,
+            @Named("clusterMessaging") MessagingService messagingService
+    ) {
+        this(clockService::current, messagingService);
+    }
+
     public PartitionModificationCounterFactory(Supplier<HybridTimestamp> currentTimestampSupplier, MessagingService messagingService) {
         this.currentTimestampSupplier = currentTimestampSupplier;
         this.messagingService = messagingService;
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionIdGenerator.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionIdGenerator.java
index e40aef864523..69a3ca6e0f1e 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionIdGenerator.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TransactionIdGenerator.java
@@ -17,18 +17,30 @@
 
 package org.apache.ignite.internal.tx.impl;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.UUID;
 import org.apache.ignite.internal.hlc.HybridTimestamp;
+import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.tx.TransactionIds;
 import org.apache.ignite.internal.tx.TxPriority;
 
 /**
  * Generates transaction IDs.
  */
+@Singleton
 public class TransactionIdGenerator {
     /** Supplies nodeId for transactionId generation. */
     private final NodeIdSupplier nodeIdSupplier;
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public TransactionIdGenerator(ClusterService clusterService) {
+        this(() -> clusterService.nodeName().hashCode());
+    }
+
     public TransactionIdGenerator(NodeIdSupplier nodeIdSupplier) {
         this.nodeIdSupplier = nodeIdSupplier;
     }

From 07e68e9826412ee2f5cad35105065cc2053a1c35 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 19:28:29 +0400
Subject: [PATCH 71/79] Migrate Raft-related classes to use Micronaut
 dependency injection; remove redundant factory methods and constructors.

---
 .../TopologyAwareRaftGroupServiceFactory.java | 16 +++++
 .../internal/app/di/MetaStorageFactory.java   | 20 ------
 .../internal/app/di/TransactionFactory.java   | 70 -------------------
 .../internal/tx/impl/TxManagerImpl.java       | 61 ++++++++++++++++
 4 files changed, 77 insertions(+), 90 deletions(-)

diff --git a/modules/replicator/src/main/java/org/apache/ignite/internal/raft/client/TopologyAwareRaftGroupServiceFactory.java b/modules/replicator/src/main/java/org/apache/ignite/internal/raft/client/TopologyAwareRaftGroupServiceFactory.java
index d4e829166a12..f77b40d2fdf9 100644
--- a/modules/replicator/src/main/java/org/apache/ignite/internal/raft/client/TopologyAwareRaftGroupServiceFactory.java
+++ b/modules/replicator/src/main/java/org/apache/ignite/internal/raft/client/TopologyAwareRaftGroupServiceFactory.java
@@ -17,10 +17,13 @@
 
 package org.apache.ignite.internal.raft.client;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.concurrent.ScheduledExecutorService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.raft.ExceptionFactory;
+import org.apache.ignite.internal.raft.Loza;
 import org.apache.ignite.internal.raft.Marshaller;
 import org.apache.ignite.internal.raft.PeersAndLearners;
 import org.apache.ignite.internal.raft.RaftServiceFactory;
@@ -33,6 +36,7 @@
 /**
  * Factory for creation {@link TopologyAwareRaftGroupService}.
  */
+@Singleton
 public class TopologyAwareRaftGroupServiceFactory implements RaftServiceFactory<TopologyAwareRaftGroupService> {
     private final ClusterService clusterService;
 
@@ -42,6 +46,18 @@ public class TopologyAwareRaftGroupServiceFactory implements RaftServiceFactory<
 
     private final RaftGroupEventsClientListener eventsClientListener;
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public TopologyAwareRaftGroupServiceFactory(
+            ClusterService clusterService,
+            LogicalTopologyService logicalTopologyService,
+            RaftGroupEventsClientListener eventsClientListener
+    ) {
+        this(clusterService, logicalTopologyService, Loza.FACTORY, eventsClientListener);
+    }
+
     /**
      * Constructor.
      *
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index b4dba2b78841..6b8efa233c8f 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -22,43 +22,23 @@
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
-import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
-import org.apache.ignite.internal.network.ClusterService;
-import org.apache.ignite.internal.raft.Loza;
-import org.apache.ignite.internal.raft.client.TopologyAwareRaftGroupServiceFactory;
 import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.replicator.configuration.ReplicationExtensionConfiguration;
 import org.apache.ignite.internal.sql.configuration.distributed.SqlClusterExtensionConfiguration;
 import org.apache.ignite.internal.sql.configuration.distributed.SqlDistributedConfiguration;
 import org.apache.ignite.internal.sql.configuration.local.SqlLocalConfiguration;
 import org.apache.ignite.internal.sql.configuration.local.SqlNodeExtensionConfiguration;
-import org.apache.ignite.raft.jraft.rpc.impl.RaftGroupEventsClientListener;
 
 /**
  * Micronaut factory for MetaStorage, cluster configuration, and SQL configuration components.
  */
 @Factory
 public class MetaStorageFactory {
-    /** Creates the topology-aware Raft group service factory. */
-    @Singleton
-    public TopologyAwareRaftGroupServiceFactory topologyAwareRaftGroupServiceFactory(
-            ClusterService clusterService,
-            LogicalTopologyService logicalTopologyService,
-            RaftGroupEventsClientListener raftGroupEventsClientListener
-    ) {
-        return new TopologyAwareRaftGroupServiceFactory(
-                clusterService,
-                logicalTopologyService,
-                Loza.FACTORY,
-                raftGroupEventsClientListener
-        );
-    }
-
     /** Creates the cluster (distributed) configuration registry. */
     @Singleton
     @Named("clusterConfig")
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
index af4bd7a32ef5..f76f6d527d31 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/TransactionFactory.java
@@ -18,40 +18,20 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
-import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ScheduledExecutorService;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
-import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.hlc.ClockService;
-import org.apache.ignite.internal.index.IndexNodeFinishedRwTransactionsChecker;
-import org.apache.ignite.internal.lowwatermark.LowWatermark;
-import org.apache.ignite.internal.metrics.MetricManager;
-import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
-import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.network.wrapper.JumpToExecutorByConsistentIdAfterSend;
-import org.apache.ignite.internal.placementdriver.PlacementDriver;
-import org.apache.ignite.internal.replicator.ReplicaService;
-import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.schema.configuration.GcConfiguration;
 import org.apache.ignite.internal.schema.configuration.GcExtensionConfiguration;
 import org.apache.ignite.internal.schema.configuration.LowWatermarkConfiguration;
-import org.apache.ignite.internal.tx.LockManager;
 import org.apache.ignite.internal.tx.configuration.TransactionConfiguration;
 import org.apache.ignite.internal.tx.configuration.TransactionExtensionConfiguration;
-import org.apache.ignite.internal.tx.impl.RemotelyTriggeredResourceRegistry;
-import org.apache.ignite.internal.tx.impl.TransactionIdGenerator;
-import org.apache.ignite.internal.tx.impl.TransactionInflights;
-import org.apache.ignite.internal.tx.impl.TxManagerImpl;
-import org.apache.ignite.internal.tx.impl.VolatileTxStateMetaStorage;
 
 /**
  * Micronaut factory for transaction-related components.
@@ -101,54 +81,4 @@ public MessagingService storageOperationsMessagingService(
         );
     }
 
-    /** Creates the transaction manager. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(1700)
-    public TxManagerImpl txManager(
-            NodeIdentity nodeIdentity,
-            TransactionConfiguration txConfig,
-            SystemDistributedConfiguration systemDistributedConfiguration,
-            @Named("storageOperations") MessagingService messagingService,
-            TopologyService topologyService,
-            ReplicaService replicaService,
-            LockManager lockManager,
-            VolatileTxStateMetaStorage txStateVolatileStorage,
-            ClockService clockService,
-            TransactionIdGenerator transactionIdGenerator,
-            PlacementDriver placementDriver,
-            ReplicationConfiguration replicationConfiguration,
-            IndexNodeFinishedRwTransactionsChecker indexNodeFinishedRwTransactionsChecker,
-            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
-            RemotelyTriggeredResourceRegistry resourcesRegistry,
-            TransactionInflights transactionInflights,
-            LowWatermark lowWatermark,
-            FailureManager failureManager,
-            MetricManager metricManager,
-            @Named("commonScheduler") ScheduledExecutorService commonScheduler
-    ) {
-        return new TxManagerImpl(
-                nodeIdentity.nodeName(),
-                txConfig,
-                systemDistributedConfiguration,
-                messagingService,
-                topologyService,
-                replicaService,
-                lockManager,
-                txStateVolatileStorage,
-                clockService,
-                transactionIdGenerator,
-                placementDriver,
-                () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
-                indexNodeFinishedRwTransactionsChecker,
-                partitionOperationsExecutor,
-                resourcesRegistry,
-                transactionInflights,
-                lowWatermark,
-                commonScheduler,
-                failureManager,
-                metricManager
-        );
-    }
-
 }
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
index 0bd927e95ccb..c7376e39b56e 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
@@ -57,9 +57,16 @@
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.SystemPropertyView;
 import org.apache.ignite.internal.event.EventListener;
@@ -83,6 +90,7 @@
 import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.placementdriver.event.PrimaryReplicaEvent;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.placementdriver.event.PrimaryReplicaEventParameters;
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.replicator.ReplicatorRecoverableExceptions;
@@ -128,6 +136,9 @@
  *
  * <p>Uses 2PC for atomic commitment and 2PL for concurrency control.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(1700)
 public class TxManagerImpl implements TxManager, NetworkMessageHandler, SystemViewProvider {
     private static final String ABANDONED_CHECK_TS_PROP = "txnAbandonedCheckTs";
 
@@ -239,6 +250,56 @@ public class TxManagerImpl implements TxManager, NetworkMessageHandler, SystemVi
 
     private final ConcurrentLinkedQueue<CompletableFuture<?>> stopFuts = new ConcurrentLinkedQueue<>();
 
+    /**
+     * Constructor for dependency injection.
+     */
+    @Inject
+    public TxManagerImpl(
+            NodeIdentity nodeIdentity,
+            TransactionConfiguration txConfig,
+            SystemDistributedConfiguration systemCfg,
+            @Named("storageOperations") MessagingService messagingService,
+            TopologyService topologyService,
+            ReplicaService replicaService,
+            LockManager lockManager,
+            VolatileTxStateMetaStorage txStateVolatileStorage,
+            ClockService clockService,
+            TransactionIdGenerator transactionIdGenerator,
+            PlacementDriver placementDriver,
+            ReplicationConfiguration replicationConfiguration,
+            LocalRwTxCounter localRwTxCounter,
+            @Named("partitionOperationsExecutor") ExecutorService partitionOperationsExecutor,
+            RemotelyTriggeredResourceRegistry resourcesRegistry,
+            TransactionInflights transactionInflights,
+            LowWatermark lowWatermark,
+            @Named("commonScheduler") ScheduledExecutorService commonScheduler,
+            FailureProcessor failureProcessor,
+            MetricManager metricManager
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                txConfig,
+                systemCfg,
+                messagingService,
+                topologyService,
+                replicaService,
+                lockManager,
+                txStateVolatileStorage,
+                clockService,
+                transactionIdGenerator,
+                placementDriver,
+                () -> replicationConfiguration.idleSafeTimePropagationDurationMillis().value(),
+                localRwTxCounter,
+                partitionOperationsExecutor,
+                resourcesRegistry,
+                transactionInflights,
+                lowWatermark,
+                commonScheduler,
+                failureProcessor,
+                metricManager
+        );
+    }
+
     /**
      * Test-only constructor.
      *

From 95edd8a6f36c222e72ab020418fe3f3201d4b171 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Tue, 10 Mar 2026 20:51:18 +0400
Subject: [PATCH 72/79] Migrate `ConfigurationRegistry` to use
 `ConfigurationRegistryImpl`; remove redundant methods and classes.

---
 .../config/Ignite3ConfigurationUtils.java     |  4 +-
 .../org/apache/ignite/client/TestServer.java  |  3 +-
 .../configuration/ConfigurationRegistry.java  | 86 +++++++++++++++++++
 .../tree/ConfigurationSource.java             |  0
 .../tree/ConstructableTreeNode.java           |  0
 .../presentation/HoconPresentation.java       |  7 +-
 .../presentation/HoconPresentationTest.java   |  3 +-
 ...ry.java => ConfigurationRegistryImpl.java} | 22 +++--
 .../ConfigurationRegistryTest.java            | 18 ++--
 .../InjectedValueConfigurationTest.java       |  4 +-
 .../RenamedConfigurationTest.java             |  2 +-
 .../direct/DirectPropertiesTest.java          |  3 +-
 .../hocon/HoconConverterTest.java             |  9 +-
 .../ConfigurationAnyListenerTest.java         |  3 +-
 .../ConfigurationListenerTest.java            |  3 +-
 .../configuration/sample/UsageTest.java       |  5 +-
 .../configuration/tree/InternalIdTest.java    |  3 +-
 ...istributionZoneManagerNodeRestartTest.java |  6 +-
 .../rebalance/ItRebalanceDistributedTest.java |  5 +-
 .../DistributionZoneManager.java              |  6 +-
 .../utils/ClusterServiceTestUtils.java        |  3 +-
 .../partition/replicator/fixtures/Node.java   |  5 +-
 .../internal/rest/RestComponentTest.java      |  3 +-
 .../rest/configuration/TestFactory.java       |  3 +-
 ...istributedConfigurationPropertiesTest.java |  2 +-
 .../runner/app/ItIgniteNodeRestartTest.java   |  6 +-
 .../ignite/internal/app/IgniteImpl.java       |  4 +-
 .../app/di/IgniteConfigurationFactory.java    |  3 +-
 .../internal/app/di/MetaStorageFactory.java   |  3 +-
 .../internal/tx/impl/TxManagerImpl.java       | 10 +--
 30 files changed, 174 insertions(+), 60 deletions(-)
 create mode 100644 modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java
 rename modules/{configuration => configuration-api}/src/main/java/org/apache/ignite/internal/configuration/tree/ConfigurationSource.java (100%)
 rename modules/{configuration => configuration-api}/src/main/java/org/apache/ignite/internal/configuration/tree/ConstructableTreeNode.java (100%)
 rename modules/configuration/src/main/java/org/apache/ignite/internal/configuration/{ConfigurationRegistry.java => ConfigurationRegistryImpl.java} (96%)

diff --git a/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java b/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java
index b3335174700c..130c8c71b0fd 100644
--- a/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java
+++ b/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java
@@ -29,6 +29,7 @@
 import org.apache.ignite3.configuration.validation.Validator;
 import org.apache.ignite3.internal.configuration.ConfigurationModules;
 import org.apache.ignite3.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite3.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite3.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite3.internal.configuration.storage.LocalFileConfigurationStorage;
 import org.apache.ignite3.internal.configuration.validation.ConfigurationValidator;
@@ -114,7 +115,8 @@ private static ConfigurationRegistry loadConfigurations(Path cfgPath, Configurat
         ConfigurationValidator localConfigurationValidator =
                 ConfigurationValidatorImpl.withDefaultValidators(localConfigurationGenerator, myValidators);
 
-        var nodeConfigRegistry = new ConfigurationRegistry(module.rootKeys(), localFileConfigurationStorage, localConfigurationGenerator,
+        var nodeConfigRegistry = new ConfigurationRegistryImpl(
+                module.rootKeys(), localFileConfigurationStorage, localConfigurationGenerator,
                 localConfigurationValidator, c -> {}, s -> false);
 
         nodeConfigRegistry.startAsync(new ComponentContext()).join();
diff --git a/modules/client/src/test/java/org/apache/ignite/client/TestServer.java b/modules/client/src/test/java/org/apache/ignite/client/TestServer.java
index e42878465f61..4fdfc8978f21 100644
--- a/modules/client/src/test/java/org/apache/ignite/client/TestServer.java
+++ b/modules/client/src/test/java/org/apache/ignite/client/TestServer.java
@@ -54,6 +54,7 @@
 import org.apache.ignite.internal.cluster.management.network.messages.CmgMessagesFactory;
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
@@ -189,7 +190,7 @@ public TestServer(
                 List.of(ClientConnectorExtensionConfigurationSchema.class, NetworkExtensionConfigurationSchema.class),
                 List.of(StaticNodeFinderConfigurationSchema.class, MulticastNodeFinderConfigurationSchema.class)
         );
-        cfg = new ConfigurationRegistry(
+        cfg = new ConfigurationRegistryImpl(
                 List.of(NodeConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java
new file mode 100644
index 000000000000..7431d406c20a
--- /dev/null
+++ b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Consumer;
+import org.apache.ignite.configuration.ConfigurationTree;
+import org.apache.ignite.configuration.KeyIgnorer;
+import org.apache.ignite.configuration.RootKey;
+import org.apache.ignite.configuration.SuperRootChange;
+import org.apache.ignite.internal.configuration.tree.ConfigurationSource;
+import org.apache.ignite.internal.manager.IgniteComponent;
+
+/**
+ * Configuration registry interface.
+ */
+public interface ConfigurationRegistry extends IgniteComponent {
+    /**
+     * Gets the public configuration tree.
+     *
+     * @param rootKey Root key.
+     * @param <V> View type.
+     * @param <C> Change type.
+     * @param <T> Configuration tree type.
+     * @return Public configuration tree.
+     */
+    <V, C extends V, T extends ConfigurationTree<? super V, ? super C>> T getConfiguration(RootKey<T, V, C> rootKey);
+
+    /**
+     * Returns a future that resolves after the defaults are persisted to the storage.
+     */
+    CompletableFuture<Void> onDefaultsPersisted();
+
+    /**
+     * Change configuration. Gives the possibility to atomically update several root trees.
+     *
+     * @param change Closure that would consume a mutable super root instance.
+     * @return Future that is completed on change completion.
+     */
+    CompletableFuture<Void> change(Consumer<SuperRootChange> change);
+
+    /**
+     * Change configuration.
+     *
+     * @param changesSrc Configuration source to create patch from it.
+     * @return Future that is completed on change completion.
+     */
+    CompletableFuture<Void> change(ConfigurationSource changesSrc);
+
+    /**
+     * Initializes the configuration with the given source. This method should be used only for the initial setup of the configuration. The
+     * configuration is initialized with the provided source only if the storage is empty, and it is saved along with the defaults. This
+     * method must be called before {@link #startAsync}.
+     *
+     * @param configurationSource the configuration source to initialize with.
+     */
+    void initializeConfigurationWith(ConfigurationSource configurationSource);
+
+    /**
+     * Determines if key should be ignored.
+     */
+    KeyIgnorer keyIgnorer();
+
+    /**
+     * Returns the count of configuration listener notifications.
+     *
+     * <p>Monotonically increasing value that should be incremented each time an attempt is made to notify all listeners of the
+     * configuration. Allows to guarantee that new listeners will be called only on the next notification of all configuration listeners.
+     */
+    long notificationCount();
+}
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/ConfigurationSource.java b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/tree/ConfigurationSource.java
similarity index 100%
rename from modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/ConfigurationSource.java
rename to modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/tree/ConfigurationSource.java
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/ConstructableTreeNode.java b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/tree/ConstructableTreeNode.java
similarity index 100%
rename from modules/configuration/src/main/java/org/apache/ignite/internal/configuration/tree/ConstructableTreeNode.java
rename to modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/tree/ConstructableTreeNode.java
diff --git a/modules/configuration-presentation/src/main/java/org/apache/ignite/internal/configuration/presentation/HoconPresentation.java b/modules/configuration-presentation/src/main/java/org/apache/ignite/internal/configuration/presentation/HoconPresentation.java
index b0024153cb0d..478292888b81 100644
--- a/modules/configuration-presentation/src/main/java/org/apache/ignite/internal/configuration/presentation/HoconPresentation.java
+++ b/modules/configuration-presentation/src/main/java/org/apache/ignite/internal/configuration/presentation/HoconPresentation.java
@@ -26,6 +26,7 @@
 import org.apache.ignite.configuration.ConfigurationChangeException;
 import org.apache.ignite.configuration.validation.ConfigurationValidationException;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.exception.ConfigurationApplyException;
 import org.apache.ignite.internal.configuration.exception.ConfigurationParseException;
 import org.apache.ignite.internal.configuration.exception.ConfigurationValidationIgniteException;
@@ -59,8 +60,10 @@ public String represent() {
     /** {@inheritDoc} */
     @Override
     public String representByPath(@Nullable String path) {
-        return HoconConverter.represent(registry.superRoot(), path == null ? List.of() : ConfigurationUtil.split(path)).render(
-                ConfigRenderOptions.concise());
+        List<String> pathList = path == null ? List.of() : ConfigurationUtil.split(path);
+
+        return HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), pathList)
+                .render(ConfigRenderOptions.concise());
     }
 
     /** {@inheritDoc} */
diff --git a/modules/configuration-presentation/src/test/java/org/apache/ignite/internal/configuration/presentation/HoconPresentationTest.java b/modules/configuration-presentation/src/test/java/org/apache/ignite/internal/configuration/presentation/HoconPresentationTest.java
index 7a75c25562bd..3faf3364ee91 100644
--- a/modules/configuration-presentation/src/test/java/org/apache/ignite/internal/configuration/presentation/HoconPresentationTest.java
+++ b/modules/configuration-presentation/src/test/java/org/apache/ignite/internal/configuration/presentation/HoconPresentationTest.java
@@ -41,6 +41,7 @@
 import org.apache.ignite.configuration.validation.ValidationIssue;
 import org.apache.ignite.configuration.validation.Validator;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.exception.ConfigurationApplyException;
 import org.apache.ignite.internal.configuration.exception.ConfigurationParseException;
@@ -86,7 +87,7 @@ public void validate(Value annotation, ValidationContext<Object> ctx) {
 
         generator = new ConfigurationTreeGenerator(TestRootConfiguration.KEY);
 
-        cfgRegistry = new ConfigurationRegistry(
+        cfgRegistry = new ConfigurationRegistryImpl(
                 List.of(TestRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistryImpl.java
similarity index 96%
rename from modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java
rename to modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistryImpl.java
index 4da72657fdb1..ec79f6f3612f 100644
--- a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistry.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationRegistryImpl.java
@@ -45,16 +45,15 @@
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
-import org.apache.ignite.internal.manager.IgniteComponent;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 
 /**
- * Configuration registry.
+ * Configuration registry implementation.
  */
-public class ConfigurationRegistry implements IgniteComponent {
+public class ConfigurationRegistryImpl implements ConfigurationRegistry {
     /** The logger. */
-    private static final IgniteLogger LOG = Loggers.forClass(ConfigurationRegistry.class);
+    private static final IgniteLogger LOG = Loggers.forClass(ConfigurationRegistryImpl.class);
 
     /** Generated configuration implementations. Mapping: {@link RootKey#key} -> configuration implementation. */
     private final Map<String, DynamicConfiguration<?, ?>> configs = new HashMap<>();
@@ -67,7 +66,7 @@ public class ConfigurationRegistry implements IgniteComponent {
 
     /** Constructor. */
     @TestOnly
-    public ConfigurationRegistry(
+    public ConfigurationRegistryImpl(
             Collection<RootKey<?, ?, ?>> rootKeys,
             ConfigurationStorage storage,
             ConfigurationTreeGenerator generator,
@@ -79,7 +78,7 @@ public ConfigurationRegistry(
     /**
      * Constructor.
      */
-    public ConfigurationRegistry(
+    public ConfigurationRegistryImpl(
             Collection<RootKey<?, ?, ?>> rootKeys,
             ConfigurationStorage storage,
             ConfigurationTreeGenerator generator,
@@ -132,6 +131,7 @@ public CompletableFuture<Void> stopAsync(ComponentContext componentContext) {
     /**
      * Returns a future that resolves after the defaults are persisted to the storage.
      */
+    @Override
     public CompletableFuture<Void> onDefaultsPersisted() {
         return changer.onDefaultsPersisted();
     }
@@ -143,6 +143,7 @@ public CompletableFuture<Void> onDefaultsPersisted() {
      *
      * @param configurationSource the configuration source to initialize with.
      */
+    @Override
     public void initializeConfigurationWith(ConfigurationSource configurationSource) {
         changer.initializeConfigurationWith(configurationSource);
     }
@@ -156,6 +157,7 @@ public void initializeConfigurationWith(ConfigurationSource configurationSource)
      * @param <T> Configuration tree type.
      * @return Public configuration tree.
      */
+    @Override
     public <V, C extends V, T extends ConfigurationTree<? super V, ? super C>> T getConfiguration(RootKey<T, V, C> rootKey) {
         return (T) configs.get(rootKey.key());
     }
@@ -175,6 +177,7 @@ public SuperRoot superRoot() {
      * @param changesSrc Configuration source to create patch from it.
      * @return Future that is completed on change completion.
      */
+    @Override
     public CompletableFuture<Void> change(ConfigurationSource changesSrc) {
         return changer.change(changesSrc);
     }
@@ -185,6 +188,7 @@ public CompletableFuture<Void> change(ConfigurationSource changesSrc) {
      * @param change Closure that would consume a mutable super root instance.
      * @return Future that is completed on change completion.
      */
+    @Override
     public CompletableFuture<Void> change(Consumer<SuperRootChange> change) {
         return change(new ConfigurationSource() {
             @Override
@@ -252,6 +256,7 @@ private CompletableFuture<Void> combineFutures(Collection<CompletableFuture<?>>
     }
 
     /** Determines if key should be ignored. */
+    @Override
     public KeyIgnorer keyIgnorer() {
         return keyIgnorer;
     }
@@ -262,6 +267,7 @@ public KeyIgnorer keyIgnorer() {
      * <p>Monotonically increasing value that should be incremented each time an attempt is made to notify all listeners of the
      * configuration. Allows to guarantee that new listeners will be called only on the next notification of all configuration listeners.
      */
+    @Override
     public long notificationCount() {
         return changer.notificationCount();
     }
@@ -275,13 +281,13 @@ public long notificationCount() {
      * @param configurationValidator the validator ensuring the correctness of configuration updates.
      * @return a new {@code ConfigurationRegistry} instance initialized with the specified parameters.
      */
-    public static ConfigurationRegistry create(
+    public static ConfigurationRegistryImpl create(
             ConfigurationModule configurationModule,
             ConfigurationStorage storage,
             ConfigurationTreeGenerator generator,
             ConfigurationValidator configurationValidator
     ) {
-        return new ConfigurationRegistry(
+        return new ConfigurationRegistryImpl(
                 configurationModule.rootKeys(),
                 storage,
                 generator,
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/ConfigurationRegistryTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/ConfigurationRegistryTest.java
index 785946b9def6..634e3785eecb 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/ConfigurationRegistryTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/ConfigurationRegistryTest.java
@@ -57,7 +57,7 @@ public class ConfigurationRegistryTest {
     void testValidationInternalConfigurationExtensions() {
         assertThrows(
                 IllegalArgumentException.class,
-                () -> new ConfigurationRegistry(
+                () -> new ConfigurationRegistryImpl(
                         List.of(SecondRootConfiguration.KEY),
                         new TestConfigurationStorage(LOCAL),
                         new ConfigurationTreeGenerator(
@@ -70,7 +70,7 @@ void testValidationInternalConfigurationExtensions() {
         );
 
         // Check that everything is fine.
-        ConfigurationRegistry configRegistry = new ConfigurationRegistry(
+        ConfigurationRegistry configRegistry = new ConfigurationRegistryImpl(
                 List.of(FirstRootConfiguration.KEY, SecondRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(
@@ -89,7 +89,7 @@ void testValidationPolymorphicConfigurationExtensions() {
         // There is a polymorphic extension that is missing from the schema.
         assertThrows(
                 IllegalArgumentException.class,
-                () -> new ConfigurationRegistry(
+                () -> new ConfigurationRegistryImpl(
                         List.of(ThirdRootConfiguration.KEY),
                         new TestConfigurationStorage(LOCAL),
                         new ConfigurationTreeGenerator(
@@ -104,7 +104,7 @@ void testValidationPolymorphicConfigurationExtensions() {
         // There are two polymorphic extensions with the same id.
         assertThrows(
                 IllegalArgumentException.class,
-                () -> new ConfigurationRegistry(
+                () -> new ConfigurationRegistryImpl(
                         List.of(ThirdRootConfiguration.KEY),
                         new TestConfigurationStorage(LOCAL),
                         new ConfigurationTreeGenerator(
@@ -117,7 +117,7 @@ void testValidationPolymorphicConfigurationExtensions() {
         );
 
         // Check that everything is fine.
-        ConfigurationRegistry configRegistry = new ConfigurationRegistry(
+        ConfigurationRegistry configRegistry = new ConfigurationRegistryImpl(
                 List.of(ThirdRootConfiguration.KEY, FourthRootConfiguration.KEY, FifthRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(
@@ -141,7 +141,7 @@ void testValidationPolymorphicConfigurationExtensions() {
     void missingPolymorphicExtension() {
         IllegalArgumentException ex = assertThrows(
                 IllegalArgumentException.class,
-                () -> new ConfigurationRegistry(
+                () -> new ConfigurationRegistryImpl(
                         List.of(ThirdRootConfiguration.KEY),
                         new TestConfigurationStorage(LOCAL),
                         new ConfigurationTreeGenerator(ThirdRootConfiguration.KEY),
@@ -164,7 +164,7 @@ void testComplicatedPolymorphicConfig() throws Exception {
                 "sixth.poly.intVal", 1
         );
 
-        ConfigurationRegistry registry = new ConfigurationRegistry(
+        ConfigurationRegistry registry = new ConfigurationRegistryImpl(
                 List.of(SixthRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL, bootstrapConfig),
                 new ConfigurationTreeGenerator(
@@ -194,7 +194,7 @@ void testComplicatedPolymorphicConfig() throws Exception {
 
     @Test
     void testPolymorphicGet() {
-        ConfigurationRegistry registry = new ConfigurationRegistry(
+        ConfigurationRegistry registry = new ConfigurationRegistryImpl(
                 List.of(SixthRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(
@@ -228,7 +228,7 @@ void testPolymorphicGet() {
     void testChangeSuperRoot() {
         TestConfigurationStorage storage = new TestConfigurationStorage(LOCAL);
 
-        var registry = new ConfigurationRegistry(
+        var registry = new ConfigurationRegistryImpl(
                 List.of(FirstRootConfiguration.KEY, SecondRootConfiguration.KEY),
                 storage,
                 new ConfigurationTreeGenerator(FirstRootConfiguration.KEY, SecondRootConfiguration.KEY),
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/InjectedValueConfigurationTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/InjectedValueConfigurationTest.java
index 576b36acc000..61f3d83c6abc 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/InjectedValueConfigurationTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/InjectedValueConfigurationTest.java
@@ -76,7 +76,7 @@ void setUp() {
                 HoconInjectedValueRootConfiguration.KEY
         );
 
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 roots,
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(roots, List.of(), List.of()),
@@ -187,7 +187,7 @@ private void change(String hocon) {
     private String asHoconStr(List<String> basePath, String... path) {
         List<String> fullPath = Stream.concat(basePath.stream(), Arrays.stream(path)).collect(Collectors.toList());
 
-        ConfigValue hoconCfg = HoconConverter.represent(registry.superRoot(), fullPath);
+        ConfigValue hoconCfg = HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), fullPath);
 
         return hoconCfg.render(ConfigRenderOptions.concise().setJson(false));
     }
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/RenamedConfigurationTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/RenamedConfigurationTest.java
index 7de112bd150b..3c427dda1399 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/RenamedConfigurationTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/RenamedConfigurationTest.java
@@ -304,7 +304,7 @@ private static void updateConfig(ConfigurationRegistry registry, String updatedC
     }
 
     private ConfigurationRegistry startRegistry(RootKey<?, ?, ?> rootKey, ConfigurationTreeGenerator generator) {
-        var registry = new ConfigurationRegistry(Set.of(rootKey), storage, generator, new TestConfigurationValidator());
+        var registry = new ConfigurationRegistryImpl(Set.of(rootKey), storage, generator, new TestConfigurationValidator());
 
         assertThat(registry.startAsync(new ComponentContext()), willCompleteSuccessfully());
         assertThat(registry.onDefaultsPersisted(), willCompleteSuccessfully());
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/direct/DirectPropertiesTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/direct/DirectPropertiesTest.java
index c3f64e8e1e38..1089c5d5e7e9 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/direct/DirectPropertiesTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/direct/DirectPropertiesTest.java
@@ -44,6 +44,7 @@
 import org.apache.ignite.configuration.annotation.NamedConfigValue;
 import org.apache.ignite.configuration.annotation.Value;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.TestConfigurationValidator;
@@ -106,7 +107,7 @@ public static class DirectNested2ConfigurationSchema {
 
     @BeforeEach
     void setUp() {
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(DirectConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(DirectConfiguration.KEY),
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java
index 7220b5095193..47801f37812a 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/hocon/HoconConverterTest.java
@@ -50,6 +50,7 @@
 import org.apache.ignite.configuration.annotation.PublicName;
 import org.apache.ignite.configuration.annotation.Value;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.TestConfigurationValidator;
@@ -221,7 +222,7 @@ public static class HoconInjectedNameConfigurationSchema {
      */
     @BeforeAll
     public static void beforeAll() {
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(HoconRootConfiguration.KEY, HoconInjectedNameRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(
@@ -283,12 +284,12 @@ public void toHoconBasic() {
         assertEquals("[]", asHoconStr(List.of("root", "arraysList")));
 
         assertThrowsIllegalArgException(
-                () -> HoconConverter.represent(registry.superRoot(), List.of("doot")),
+                () -> HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), List.of("doot")),
                 "Configuration value 'doot' has not been found"
         );
 
         assertThrowsIllegalArgException(
-                () -> HoconConverter.represent(registry.superRoot(), List.of("root", "x")),
+                () -> HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), List.of("root", "x")),
                 "Configuration value 'root.x' has not been found"
         );
 
@@ -369,7 +370,7 @@ public void testHoconArraysSerialization() throws Exception {
     private static String asHoconStr(List<String> basePath, String... path) {
         List<String> fullPath = Stream.concat(basePath.stream(), Arrays.stream(path)).collect(Collectors.toList());
 
-        ConfigValue hoconCfg = HoconConverter.represent(registry.superRoot(), fullPath);
+        ConfigValue hoconCfg = HoconConverter.represent(((ConfigurationRegistryImpl) registry).superRoot(), fullPath);
 
         return hoconCfg.render(ConfigRenderOptions.concise().setJson(false));
     }
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationAnyListenerTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationAnyListenerTest.java
index ce4aaf811c56..ff822595779a 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationAnyListenerTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationAnyListenerTest.java
@@ -55,6 +55,7 @@
 import org.apache.ignite.configuration.notifications.ConfigurationNamedListListener;
 import org.apache.ignite.configuration.notifications.ConfigurationNotificationEvent;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.TestConfigurationValidator;
@@ -164,7 +165,7 @@ public void before() throws Exception {
                 List.of(),
                 List.of(FirstPolyAnyConfigurationSchema.class, SecondPolyAnyConfigurationSchema.class)
         );
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(RootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationListenerTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationListenerTest.java
index ac4d49704fff..b5cbb59a6df8 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationListenerTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/notifications/ConfigurationListenerTest.java
@@ -68,6 +68,7 @@
 import org.apache.ignite.configuration.notifications.ConfigurationNamedListListener;
 import org.apache.ignite.configuration.notifications.ConfigurationNotificationEvent;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.DynamicConfiguration;
 import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
@@ -184,7 +185,7 @@ public void before() {
                 List.of(InternalChildConfigurationSchema.class),
                 List.of(StringPolyConfigurationSchema.class, LongPolyConfigurationSchema.class)
         );
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(ParentConfiguration.KEY),
                 storage,
                 generator,
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/sample/UsageTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/sample/UsageTest.java
index c38c08860869..68443a735e44 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/sample/UsageTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/sample/UsageTest.java
@@ -28,6 +28,7 @@
 
 import java.util.List;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.TestConfigurationValidator;
@@ -51,7 +52,7 @@ public void after() {
      */
     @Test
     public void test() throws Exception {
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(LocalConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(LocalConfiguration.KEY),
@@ -110,7 +111,7 @@ public void multiRootConfiguration() throws Exception {
 
         long testLongValue = 30_000L;
 
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(NetworkConfiguration.KEY, LocalConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 new ConfigurationTreeGenerator(NetworkConfiguration.KEY, LocalConfiguration.KEY),
diff --git a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/InternalIdTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/InternalIdTest.java
index c038264ce5e2..ce2cac6cc8eb 100644
--- a/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/InternalIdTest.java
+++ b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/tree/InternalIdTest.java
@@ -35,6 +35,7 @@
 import org.apache.ignite.configuration.annotation.PolymorphicConfigInstance;
 import org.apache.ignite.configuration.annotation.PolymorphicId;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.direct.DirectPropertiesTest;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
@@ -90,7 +91,7 @@ void setUp() {
                 List.of(InternalIdFooConfigurationSchema.class)
         );
 
-        registry = new ConfigurationRegistry(
+        registry = new ConfigurationRegistryImpl(
                 List.of(InternalIdParentConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/distributionzones/ItIgniteDistributionZoneManagerNodeRestartTest.java b/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/distributionzones/ItIgniteDistributionZoneManagerNodeRestartTest.java
index f10bf739de2e..b16b480c5a80 100644
--- a/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/distributionzones/ItIgniteDistributionZoneManagerNodeRestartTest.java
+++ b/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/distributionzones/ItIgniteDistributionZoneManagerNodeRestartTest.java
@@ -92,7 +92,7 @@
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyServiceImpl;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalNode;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
-import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfigWriteException;
 import org.apache.ignite.internal.configuration.SystemDistributedExtensionConfiguration;
@@ -219,7 +219,7 @@ private PartialNode startPartialNode(int idx, Consumer<MetaStorageManager> metaS
                 modules.local().polymorphicSchemaExtensions()
         );
 
-        var nodeConfigRegistry = new ConfigurationRegistry(
+        var nodeConfigRegistry = new ConfigurationRegistryImpl(
                 modules.local().rootKeys(),
                 new LocalFileConfigurationStorage(configFile, localConfigurationGenerator, modules.local()),
                 localConfigurationGenerator,
@@ -298,7 +298,7 @@ private PartialNode startPartialNode(int idx, Consumer<MetaStorageManager> metaS
         Set<Validator<?, ?>> validators = new HashSet<>(modules.distributed().validators());
         validators.remove(AuthenticationProvidersValidatorImpl.INSTANCE);
 
-        var clusterConfigRegistry = new ConfigurationRegistry(
+        var clusterConfigRegistry = new ConfigurationRegistryImpl(
                 modules.distributed().rootKeys(),
                 cfgStorage,
                 distributedConfigurationGenerator,
diff --git a/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java b/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
index c9907b58303c..565729b14889 100644
--- a/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
+++ b/modules/distribution-zones/src/integrationTest/java/org/apache/ignite/internal/rebalance/ItRebalanceDistributedTest.java
@@ -121,6 +121,7 @@
 import org.apache.ignite.internal.configuration.ClusterConfiguration;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
@@ -1247,7 +1248,7 @@ private class Node {
             Path configPath = workDir.resolve(testInfo.getDisplayName());
             TestIgnitionManager.writeConfigurationFileApplyingTestDefaults(configPath);
 
-            nodeConfigRegistry = new ConfigurationRegistry(
+            nodeConfigRegistry = new ConfigurationRegistryImpl(
                     List.of(NodeConfiguration.KEY),
                     new LocalFileConfigurationStorage(configPath, nodeCfgGenerator, null),
                     nodeCfgGenerator,
@@ -1404,7 +1405,7 @@ private class Node {
                     List.of()
             );
 
-            clusterConfigRegistry = new ConfigurationRegistry(
+            clusterConfigRegistry = new ConfigurationRegistryImpl(
                     List.of(ClusterConfiguration.KEY),
                     cfgStorage,
                     clusterCfgGenerator,
diff --git a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java
index bd87dcc6f99c..a3f2d1820f68 100644
--- a/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java
+++ b/modules/distribution-zones/src/main/java/org/apache/ignite/internal/distributionzones/DistributionZoneManager.java
@@ -85,6 +85,9 @@
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyEventListener;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologySnapshot;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.SystemDistributedConfiguration;
 import org.apache.ignite.internal.configuration.utils.SystemDistributedConfigurationPropertyHolder;
 import org.apache.ignite.internal.distributionzones.events.HaZoneTopologyUpdateEvent;
@@ -117,9 +120,6 @@
 import org.apache.ignite.internal.metastorage.dsl.StatementResult;
 import org.apache.ignite.internal.metastorage.dsl.Update;
 import org.apache.ignite.internal.metrics.MetricManager;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.util.IgniteSpinBusyLock;
 import org.jetbrains.annotations.Nullable;
diff --git a/modules/network/src/testFixtures/java/org/apache/ignite/internal/network/utils/ClusterServiceTestUtils.java b/modules/network/src/testFixtures/java/org/apache/ignite/internal/network/utils/ClusterServiceTestUtils.java
index 35e1c142aaab..1cad6a856e42 100644
--- a/modules/network/src/testFixtures/java/org/apache/ignite/internal/network/utils/ClusterServiceTestUtils.java
+++ b/modules/network/src/testFixtures/java/org/apache/ignite/internal/network/utils/ClusterServiceTestUtils.java
@@ -28,6 +28,7 @@
 import java.util.stream.IntStream;
 import org.apache.ignite.configuration.annotation.ConfigurationType;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
@@ -213,7 +214,7 @@ private static ClusterService clusterService(
                 List.of(NetworkExtensionConfigurationSchema.class),
                 List.of(StaticNodeFinderConfigurationSchema.class, MulticastNodeFinderConfigurationSchema.class)
         );
-        ConfigurationRegistry nodeConfigurationRegistry = new ConfigurationRegistry(
+        ConfigurationRegistry nodeConfigurationRegistry = new ConfigurationRegistryImpl(
                 Collections.singleton(NodeConfiguration.KEY),
                 new TestConfigurationStorage(ConfigurationType.LOCAL),
                 generator,
diff --git a/modules/partition-replicator/src/integrationTest/java/org/apache/ignite/internal/partition/replicator/fixtures/Node.java b/modules/partition-replicator/src/integrationTest/java/org/apache/ignite/internal/partition/replicator/fixtures/Node.java
index e5293fd5b420..4fa6fd97bc74 100644
--- a/modules/partition-replicator/src/integrationTest/java/org/apache/ignite/internal/partition/replicator/fixtures/Node.java
+++ b/modules/partition-replicator/src/integrationTest/java/org/apache/ignite/internal/partition/replicator/fixtures/Node.java
@@ -72,6 +72,7 @@
 import org.apache.ignite.internal.configuration.ClusterConfiguration;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
@@ -370,7 +371,7 @@ public Node(
         Path configPath = dir.resolve("config");
         TestIgnitionManager.writeConfigurationFileApplyingTestDefaults(configPath);
 
-        nodeConfigRegistry = new ConfigurationRegistry(
+        nodeConfigRegistry = new ConfigurationRegistryImpl(
                 List.of(NodeConfiguration.KEY),
                 new LocalFileConfigurationStorage(configPath, nodeCfgGenerator, null),
                 nodeCfgGenerator,
@@ -577,7 +578,7 @@ public CompletableFuture<Boolean> invoke(Condition condition, Operation success,
                 List.of()
         );
 
-        clusterConfigRegistry = new ConfigurationRegistry(
+        clusterConfigRegistry = new ConfigurationRegistryImpl(
                 List.of(ClusterConfiguration.KEY),
                 cfgStorage,
                 clusterCfgGenerator,
diff --git a/modules/rest/src/test/java/org/apache/ignite/internal/rest/RestComponentTest.java b/modules/rest/src/test/java/org/apache/ignite/internal/rest/RestComponentTest.java
index 1071664048ec..305653e9f35e 100644
--- a/modules/rest/src/test/java/org/apache/ignite/internal/rest/RestComponentTest.java
+++ b/modules/rest/src/test/java/org/apache/ignite/internal/rest/RestComponentTest.java
@@ -40,6 +40,7 @@
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.ClusterState;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfiguration;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
@@ -93,7 +94,7 @@ public void setup() {
                 List.of(RestExtensionConfigurationSchema.class, NetworkExtensionConfigurationSchema.class),
                 List.of(StaticNodeFinderConfigurationSchema.class, MulticastNodeFinderConfigurationSchema.class)
         );
-        var configurationRegistry = new ConfigurationRegistry(
+        var configurationRegistry = new ConfigurationRegistryImpl(
                 List.of(NodeConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/rest/src/test/java/org/apache/ignite/internal/rest/configuration/TestFactory.java b/modules/rest/src/test/java/org/apache/ignite/internal/rest/configuration/TestFactory.java
index 7073b05e4db1..cdaded7f96ca 100644
--- a/modules/rest/src/test/java/org/apache/ignite/internal/rest/configuration/TestFactory.java
+++ b/modules/rest/src/test/java/org/apache/ignite/internal/rest/configuration/TestFactory.java
@@ -32,6 +32,7 @@
 import org.apache.ignite.configuration.validation.ValidationIssue;
 import org.apache.ignite.configuration.validation.Validator;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.TestConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
@@ -60,7 +61,7 @@ public void validate(Value annotation, ValidationContext<Object> ctx) {
 
         var generator = new ConfigurationTreeGenerator(TestRootConfiguration.KEY);
 
-        var configurationRegistry = new ConfigurationRegistry(
+        var configurationRegistry = new ConfigurationRegistryImpl(
                 List.of(TestRootConfiguration.KEY),
                 new TestConfigurationStorage(LOCAL),
                 generator,
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/configuration/ItDistributedConfigurationPropertiesTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/configuration/ItDistributedConfigurationPropertiesTest.java
index e52804085a95..37fbb50aa219 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/configuration/ItDistributedConfigurationPropertiesTest.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/configuration/ItDistributedConfigurationPropertiesTest.java
@@ -275,7 +275,7 @@ public synchronized void registerConfigurationListener(ConfigurationStorageListe
             };
 
             generator = new ConfigurationTreeGenerator(DistributedConfiguration.KEY);
-            distributedConfigRegistry = new ConfigurationRegistry(
+            distributedConfigRegistry = new ConfigurationRegistryImpl(
                     List.of(DistributedConfiguration.KEY),
                     distributedCfgStorage,
                     generator,
diff --git a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/ItIgniteNodeRestartTest.java b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/ItIgniteNodeRestartTest.java
index 765c25f61ac5..f77fb3f11fb7 100644
--- a/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/ItIgniteNodeRestartTest.java
+++ b/modules/runner/src/integrationTest/java/org/apache/ignite/internal/runner/app/ItIgniteNodeRestartTest.java
@@ -110,7 +110,7 @@
 import org.apache.ignite.internal.components.LogSyncer;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
-import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.NodeConfigWriteException;
 import org.apache.ignite.internal.configuration.RaftGroupOptionsConfigHelper;
@@ -373,7 +373,7 @@ private PartialNode startPartialNode(
                 modules.local().polymorphicSchemaExtensions()
         );
 
-        var nodeConfigRegistry = new ConfigurationRegistry(
+        var nodeConfigRegistry = new ConfigurationRegistryImpl(
                 modules.local().rootKeys(),
                 new LocalFileConfigurationStorage(configFile, localConfigurationGenerator, modules.local()),
                 localConfigurationGenerator,
@@ -549,7 +549,7 @@ public CompletableFuture<Boolean> invoke(Condition condition, List<Operation> su
                 modules.distributed().polymorphicSchemaExtensions()
         );
 
-        var clusterConfigRegistry = new ConfigurationRegistry(
+        var clusterConfigRegistry = new ConfigurationRegistryImpl(
                 modules.distributed().rootKeys(),
                 cfgStorage,
                 distributedConfigurationGenerator,
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 33838b6a70ca..b2a5ab84d793 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -74,6 +74,7 @@
 import org.apache.ignite.internal.compute.IgniteComputeInternal;
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.JdbcPortProviderImpl;
 import org.apache.ignite.internal.configuration.hocon.HoconConverter;
 import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
@@ -1232,6 +1233,7 @@ public void dumpClusterState() {
      * "ignite{clientConnector{connectTimeoutMillis=5000,idleTimeoutMillis=0}}".
      */
     private static String convertToHoconString(ConfigurationRegistry configRegistry) {
-        return HoconConverter.represent(configRegistry.superRoot(), List.of()).render(ConfigRenderOptions.concise().setJson(false));
+        return HoconConverter.represent(((ConfigurationRegistryImpl) configRegistry).superRoot(), List.of())
+                .render(ConfigRenderOptions.concise().setJson(false));
     }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
index c0e7d79e7a2e..eca41d999f34 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteConfigurationFactory.java
@@ -23,6 +23,7 @@
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.LocalFileConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
@@ -88,6 +89,6 @@ public ConfigurationRegistry nodeConfigRegistry(
             @Named("local") ConfigurationTreeGenerator generator,
             @Named("local") ConfigurationValidator validator
     ) {
-        return ConfigurationRegistry.create(modules.local(), storage, generator, validator);
+        return ConfigurationRegistryImpl.create(modules.local(), storage, generator, validator);
     }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
index 6b8efa233c8f..ba58bc43a407 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/MetaStorageFactory.java
@@ -24,6 +24,7 @@
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationExtensionConfiguration;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
+import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
@@ -48,7 +49,7 @@ public ConfigurationRegistry clusterConfigRegistry(
             @Named("distributed") ConfigurationTreeGenerator generator,
             @Named("distributed") ConfigurationValidator validator
     ) {
-        return ConfigurationRegistry.create(modules.distributed(), cfgStorage, generator, validator);
+        return ConfigurationRegistryImpl.create(modules.distributed(), cfgStorage, generator, validator);
     }
 
     /** Creates the schema synchronization configuration from the cluster config registry. */
diff --git a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
index c7376e39b56e..7bc27d2920ad 100644
--- a/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
+++ b/modules/transactions/src/main/java/org/apache/ignite/internal/tx/impl/TxManagerImpl.java
@@ -41,6 +41,10 @@
 import static org.apache.ignite.internal.util.CompletableFutures.nullCompletedFuture;
 import static org.apache.ignite.internal.util.IgniteUtils.shutdownAndAwaitTermination;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -57,10 +61,6 @@
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
-import io.micronaut.core.annotation.Order;
-import jakarta.inject.Inject;
-import jakarta.inject.Named;
-import jakarta.inject.Singleton;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
@@ -90,11 +90,11 @@
 import org.apache.ignite.internal.network.TopologyService;
 import org.apache.ignite.internal.placementdriver.PlacementDriver;
 import org.apache.ignite.internal.placementdriver.event.PrimaryReplicaEvent;
-import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.placementdriver.event.PrimaryReplicaEventParameters;
 import org.apache.ignite.internal.replicator.ReplicaService;
 import org.apache.ignite.internal.replicator.ReplicatorRecoverableExceptions;
 import org.apache.ignite.internal.replicator.ZonePartitionId;
+import org.apache.ignite.internal.replicator.configuration.ReplicationConfiguration;
 import org.apache.ignite.internal.replicator.message.ErrorReplicaResponse;
 import org.apache.ignite.internal.replicator.message.ReplicaMessageGroup;
 import org.apache.ignite.internal.replicator.message.ReplicaResponse;

From 4f377b025a39479fafd95c21f2c461c27d9c4612 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Wed, 11 Mar 2026 08:48:37 +0400
Subject: [PATCH 73/79] Add summary steps for Checkstyle, PMD, SpotBugs, and
 test results in GitHub Actions workflows to improve visibility of failures.

---
 .github/actions/test-summary/action.yml | 83 +++++++++++++++++++++++
 .github/workflows/checks.yml            | 88 +++++++++++++++++++++++++
 .github/workflows/integration-tests.yml | 60 +++++++++++++++++
 .github/workflows/unit-tests.yml        | 66 +++++++++++++++++++
 4 files changed, 297 insertions(+)
 create mode 100644 .github/actions/test-summary/action.yml

diff --git a/.github/actions/test-summary/action.yml b/.github/actions/test-summary/action.yml
new file mode 100644
index 000000000000..3bd67ec62c5b
--- /dev/null
+++ b/.github/actions/test-summary/action.yml
@@ -0,0 +1,83 @@
+name: 'Test Summary'
+description: 'Parse JUnit XML reports and write a failure summary to GITHUB_STEP_SUMMARY'
+
+inputs:
+  report-type:
+    description: 'Type of test report directory (test or integrationTest)'
+    required: true
+    default: 'test'
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Generate test summary
+      if: always()
+      shell: bash
+      run: |
+        shopt -s globstar nullglob
+
+        report_type="${{ inputs.report-type }}"
+        files=(**/build/test-results/${report_type}/TEST-*.xml)
+
+        if [ ${#files[@]} -eq 0 ]; then
+          echo "No test result files found."
+          exit 0
+        fi
+
+        total=0
+        failed=0
+        errored=0
+        skipped=0
+        failure_details=""
+
+        for f in "${files[@]}"; do
+          # Extract testsuite attributes
+          suite_line=$(head -5 "$f" | grep '<testsuite ')
+          if [ -z "$suite_line" ]; then continue; fi
+
+          t=$(echo "$suite_line" | grep -oP 'tests="\K[0-9]+' || echo 0)
+          fl=$(echo "$suite_line" | grep -oP 'failures="\K[0-9]+' || echo 0)
+          e=$(echo "$suite_line" | grep -oP 'errors="\K[0-9]+' || echo 0)
+          s=$(echo "$suite_line" | grep -oP 'skipped="\K[0-9]+' || echo 0)
+
+          total=$((total + t))
+          failed=$((failed + fl))
+          errored=$((errored + e))
+          skipped=$((skipped + s))
+
+          # Collect failure details
+          if [ "$fl" -gt 0 ] || [ "$e" -gt 0 ]; then
+            # Use python for reliable XML parsing of failure messages
+            details=$(python3 -c "
+        import xml.etree.ElementTree as ET, sys
+        try:
+            tree = ET.parse('$f')
+            for tc in tree.findall('.//testcase'):
+                fail = tc.find('failure')
+                err = tc.find('error')
+                elem = fail if fail is not None else err
+                if elem is not None:
+                    cls = tc.get('classname', '')
+                    name = tc.get('name', '')
+                    msg = elem.get('message', '')[:200].replace('|', '/').replace('\n', ' ')
+                    print(f'| \`{cls}\` | \`{name}\` | {msg} |')
+        except Exception:
+            pass
+        " 2>/dev/null || true)
+            if [ -n "$details" ]; then
+              failure_details="${failure_details}${details}"$'\n'
+            fi
+          fi
+        done
+
+        passed=$((total - failed - errored - skipped))
+
+        if [ "$failed" -eq 0 ] && [ "$errored" -eq 0 ]; then
+          echo "### :white_check_mark: Tests passed: $passed, skipped: $skipped" >> "$GITHUB_STEP_SUMMARY"
+        else
+          echo "### :x: Tests: $passed passed, $((failed + errored)) failed, $skipped skipped (total: $total)" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Class | Test | Message |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|-------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
+          echo "$failure_details" >> "$GITHUB_STEP_SUMMARY"
+        fi
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index 1b3967878735..eb67493f7cc7 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -25,6 +25,30 @@ jobs:
       - name: Run Checkstyle
         run: ./gradlew --continue checkstyleMain checkstyleTest checkstyleIntegrationTest checkstyleTestFixtures
 
+      - name: Summarize Checkstyle violations
+        if: always()
+        shell: bash
+        run: |
+          shopt -s globstar nullglob
+          files=(**/build/reports/checkstyle/*.xml)
+          if [ ${#files[@]} -eq 0 ]; then exit 0; fi
+          violations=$(grep -h '<error ' "${files[@]}" 2>/dev/null || true)
+          if [ -z "$violations" ]; then
+            echo "### :white_check_mark: Checkstyle: No violations" >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+          echo "### :x: Checkstyle Violations" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| File | Line | Message |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
+          for f in "${files[@]}"; do
+            grep '<error ' "$f" 2>/dev/null | sed -E 's/.*line="([0-9]+)".*message="([^"]+)".*/\1|\2/' | while IFS='|' read -r line msg; do
+              src=$(grep -oP 'name="\K[^"]+' "$f" | head -1)
+              short=$(echo "$src" | sed 's|.*/src/||')
+              echo "| \`$short\` | $line | $msg |" >> "$GITHUB_STEP_SUMMARY"
+            done
+          done
+
   pmd:
     name: PMD
     runs-on: ubuntu-latest
@@ -46,6 +70,37 @@ jobs:
       - name: Run PMD
         run: ./gradlew --continue pmdMain pmdTest pmdIntegrationTest pmdTestFixtures
 
+      - name: Summarize PMD violations
+        if: always()
+        shell: bash
+        run: |
+          shopt -s globstar nullglob
+          files=(**/build/reports/pmd/*.xml)
+          if [ ${#files[@]} -eq 0 ]; then exit 0; fi
+          violations=$(grep -h '<violation ' "${files[@]}" 2>/dev/null || true)
+          if [ -z "$violations" ]; then
+            echo "### :white_check_mark: PMD: No violations" >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+          echo "### :x: PMD Violations" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| File | Line | Rule | Message |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|------|------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
+          for f in "${files[@]}"; do
+            current_file=""
+            while IFS= read -r line; do
+              if echo "$line" | grep -qP '<file name="'; then
+                current_file=$(echo "$line" | grep -oP 'name="\K[^"]+' | sed 's|.*/src/||')
+              fi
+              if echo "$line" | grep -qP '<violation '; then
+                lineno=$(echo "$line" | grep -oP 'beginline="\K[0-9]+')
+                rule=$(echo "$line" | grep -oP 'rule="\K[^"]+')
+                msg=$(echo "$line" | sed -E 's/.*>([^<]+)<\/violation>.*/\1/' | xargs)
+                echo "| \`$current_file\` | $lineno | $rule | $msg |" >> "$GITHUB_STEP_SUMMARY"
+              fi
+            done < "$f"
+          done
+
   spotbugs:
     name: SpotBugs
     runs-on: ubuntu-latest
@@ -66,3 +121,36 @@ jobs:
 
       - name: Run SpotBugs
         run: ./gradlew --continue spotbugsMain spotbugsTest spotbugsIntegrationTest spotbugsTestFixtures
+
+      - name: Summarize SpotBugs violations
+        if: always()
+        shell: bash
+        run: |
+          shopt -s globstar nullglob
+          files=(**/build/reports/spotbugs/*.xml)
+          if [ ${#files[@]} -eq 0 ]; then exit 0; fi
+          bugs=$(grep -h '<BugInstance ' "${files[@]}" 2>/dev/null || true)
+          if [ -z "$bugs" ]; then
+            echo "### :white_check_mark: SpotBugs: No bugs found" >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+          echo "### :x: SpotBugs Issues" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Type | Category | Class | Line | Message |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|------|----------|-------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
+          for f in "${files[@]}"; do
+            python3 -c "
+          import xml.etree.ElementTree as ET
+          tree = ET.parse('$f')
+          for bug in tree.findall('.//BugInstance'):
+              typ = bug.get('type', '')
+              cat = bug.get('category', '')
+              msg_el = bug.find('ShortMessage')
+              msg = msg_el.text if msg_el is not None else ''
+              cls_el = bug.find('Class')
+              cls = cls_el.get('classname', '') if cls_el is not None else ''
+              src_el = bug.find('.//SourceLine[@start]')
+              line = src_el.get('start', '') if src_el is not None else ''
+              print(f'| \`{typ}\` | {cat} | \`{cls}\` | {line} | {msg} |')
+          " >> "$GITHUB_STEP_SUMMARY" 2>/dev/null || true
+          done
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index 18456e499da8..ea4439128d84 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -32,6 +32,12 @@ jobs:
           :ignite-configuration-annotation-processor:integrationTest
           :ignite-file-transfer:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -64,6 +70,12 @@ jobs:
           ./gradlew --continue
           :ignite-network:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -96,6 +108,12 @@ jobs:
           ./gradlew --continue
           :ignite-page-memory:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -133,6 +151,12 @@ jobs:
           :ignite-jdbc:integrationTest
           :ignite-schema-sync:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -168,6 +192,12 @@ jobs:
           :ignite-partition-replicator:integrationTest
           :ignite-metastorage:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -202,6 +232,12 @@ jobs:
           :ignite-index:integrationTest
           :ignite-distribution-zones:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -235,6 +271,12 @@ jobs:
           :ignite-compute:integrationTest
           :ignite-code-deployment:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -269,6 +311,12 @@ jobs:
           :ignite-rest:integrationTest
           :ignite-cli:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -306,6 +354,12 @@ jobs:
           :ignite-transactions:integrationTest
           :ignite-system-disaster-recovery:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -368,6 +422,12 @@ jobs:
           -x :ignite-transactions:integrationTest
           -x :ignite-system-disaster-recovery:integrationTest
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: integrationTest
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index 160bc9a07619..0a093fea3f0f 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -39,6 +39,12 @@ jobs:
           :ignite-vault:test
           :ignite-eventlog:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -75,6 +81,12 @@ jobs:
           :ignite-configuration-storage:test
           :ignite-configuration-system:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -110,6 +122,12 @@ jobs:
           :ignite-network-api:test
           :ignite-file-transfer:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -146,6 +164,12 @@ jobs:
           :ignite-page-memory:test
           :ignite-rocksdb-common:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -183,6 +207,12 @@ jobs:
           :ignite-jdbc:test
           :ignite-schema:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -222,6 +252,12 @@ jobs:
           :ignite-metastorage-cache:test
           :ignite-low-watermark:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -259,6 +295,12 @@ jobs:
           :ignite-system-view:test
           :ignite-system-view-api:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -293,6 +335,12 @@ jobs:
           :ignite-code-deployment:test
           :ignite-code-deployment-classloader:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -330,6 +378,12 @@ jobs:
           :ignite-rest-api:test
           :ignite-cli:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -369,6 +423,12 @@ jobs:
           :ignite-system-disaster-recovery:test
           :ignite-system-disaster-recovery-api:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4
@@ -463,6 +523,12 @@ jobs:
           -x :ignite-system-disaster-recovery:test
           -x :ignite-system-disaster-recovery-api:test
 
+      - name: Summarize test failures
+        if: always()
+        uses: ./.github/actions/test-summary
+        with:
+          report-type: test
+
       - name: Upload test reports
         if: always()
         uses: actions/upload-artifact@v4

From f66c3dfb342abc740dae2049c3fc02d6dd671a8b Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Wed, 11 Mar 2026 10:11:13 +0400
Subject: [PATCH 74/79] ignite-di-claude Improve error reporting in GitHub
 Actions by adding `::error::` annotations for Checkstyle, PMD, SpotBugs, and
 test results. Remove `continue-on-error` from workflows for stricter failure
 handling.

---
 .github/actions/test-summary/action.yml | 10 ++++++++--
 .github/workflows/checks.yml            | 17 ++++++++++++++---
 .github/workflows/integration-tests.yml | 20 --------------------
 .github/workflows/unit-tests.yml        | 22 ----------------------
 4 files changed, 22 insertions(+), 47 deletions(-)

diff --git a/.github/actions/test-summary/action.yml b/.github/actions/test-summary/action.yml
index 3bd67ec62c5b..344bb472fb37 100644
--- a/.github/actions/test-summary/action.yml
+++ b/.github/actions/test-summary/action.yml
@@ -73,9 +73,15 @@ runs:
         passed=$((total - failed - errored - skipped))
 
         if [ "$failed" -eq 0 ] && [ "$errored" -eq 0 ]; then
-          echo "### :white_check_mark: Tests passed: $passed, skipped: $skipped" >> "$GITHUB_STEP_SUMMARY"
+          summary="Tests passed: $passed, skipped: $skipped"
+          echo "$summary"
+          echo "### :white_check_mark: $summary" >> "$GITHUB_STEP_SUMMARY"
         else
-          echo "### :x: Tests: $passed passed, $((failed + errored)) failed, $skipped skipped (total: $total)" >> "$GITHUB_STEP_SUMMARY"
+          summary="Tests: $passed passed, $((failed + errored)) failed, $skipped skipped (total: $total)"
+          echo "::error::$summary"
+          echo ""
+          echo "$failure_details"
+          echo "### :x: $summary" >> "$GITHUB_STEP_SUMMARY"
           echo "" >> "$GITHUB_STEP_SUMMARY"
           echo "| Class | Test | Message |" >> "$GITHUB_STEP_SUMMARY"
           echo "|-------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index eb67493f7cc7..49ec8d5a864c 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -34,9 +34,11 @@ jobs:
           if [ ${#files[@]} -eq 0 ]; then exit 0; fi
           violations=$(grep -h '<error ' "${files[@]}" 2>/dev/null || true)
           if [ -z "$violations" ]; then
+            echo "Checkstyle: No violations"
             echo "### :white_check_mark: Checkstyle: No violations" >> "$GITHUB_STEP_SUMMARY"
             exit 0
           fi
+          echo "::error::Checkstyle violations found"
           echo "### :x: Checkstyle Violations" >> "$GITHUB_STEP_SUMMARY"
           echo "" >> "$GITHUB_STEP_SUMMARY"
           echo "| File | Line | Message |" >> "$GITHUB_STEP_SUMMARY"
@@ -45,6 +47,7 @@ jobs:
             grep '<error ' "$f" 2>/dev/null | sed -E 's/.*line="([0-9]+)".*message="([^"]+)".*/\1|\2/' | while IFS='|' read -r line msg; do
               src=$(grep -oP 'name="\K[^"]+' "$f" | head -1)
               short=$(echo "$src" | sed 's|.*/src/||')
+              echo "::error file=$short,line=$line::$msg"
               echo "| \`$short\` | $line | $msg |" >> "$GITHUB_STEP_SUMMARY"
             done
           done
@@ -79,9 +82,11 @@ jobs:
           if [ ${#files[@]} -eq 0 ]; then exit 0; fi
           violations=$(grep -h '<violation ' "${files[@]}" 2>/dev/null || true)
           if [ -z "$violations" ]; then
+            echo "PMD: No violations"
             echo "### :white_check_mark: PMD: No violations" >> "$GITHUB_STEP_SUMMARY"
             exit 0
           fi
+          echo "::error::PMD violations found"
           echo "### :x: PMD Violations" >> "$GITHUB_STEP_SUMMARY"
           echo "" >> "$GITHUB_STEP_SUMMARY"
           echo "| File | Line | Rule | Message |" >> "$GITHUB_STEP_SUMMARY"
@@ -96,6 +101,7 @@ jobs:
                 lineno=$(echo "$line" | grep -oP 'beginline="\K[0-9]+')
                 rule=$(echo "$line" | grep -oP 'rule="\K[^"]+')
                 msg=$(echo "$line" | sed -E 's/.*>([^<]+)<\/violation>.*/\1/' | xargs)
+                echo "::error file=$current_file,line=$lineno::[$rule] $msg"
                 echo "| \`$current_file\` | $lineno | $rule | $msg |" >> "$GITHUB_STEP_SUMMARY"
               fi
             done < "$f"
@@ -131,17 +137,20 @@ jobs:
           if [ ${#files[@]} -eq 0 ]; then exit 0; fi
           bugs=$(grep -h '<BugInstance ' "${files[@]}" 2>/dev/null || true)
           if [ -z "$bugs" ]; then
+            echo "SpotBugs: No bugs found"
             echo "### :white_check_mark: SpotBugs: No bugs found" >> "$GITHUB_STEP_SUMMARY"
             exit 0
           fi
+          echo "::error::SpotBugs issues found"
           echo "### :x: SpotBugs Issues" >> "$GITHUB_STEP_SUMMARY"
           echo "" >> "$GITHUB_STEP_SUMMARY"
           echo "| Type | Category | Class | Line | Message |" >> "$GITHUB_STEP_SUMMARY"
           echo "|------|----------|-------|------|---------|" >> "$GITHUB_STEP_SUMMARY"
           for f in "${files[@]}"; do
             python3 -c "
-          import xml.etree.ElementTree as ET
+          import xml.etree.ElementTree as ET, os
           tree = ET.parse('$f')
+          summary = open(os.environ['GITHUB_STEP_SUMMARY'], 'a')
           for bug in tree.findall('.//BugInstance'):
               typ = bug.get('type', '')
               cat = bug.get('category', '')
@@ -151,6 +160,8 @@ jobs:
               cls = cls_el.get('classname', '') if cls_el is not None else ''
               src_el = bug.find('.//SourceLine[@start]')
               line = src_el.get('start', '') if src_el is not None else ''
-              print(f'| \`{typ}\` | {cat} | \`{cls}\` | {line} | {msg} |')
-          " >> "$GITHUB_STEP_SUMMARY" 2>/dev/null || true
+              print(f'::error::[{typ}] {cls}:{line} - {msg}')
+              summary.write(f'| \`{typ}\` | {cat} | \`{cls}\` | {line} | {msg} |\n')
+          summary.close()
+          " 2>/dev/null || true
           done
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
index ea4439128d84..52c2fb19f33b 100644
--- a/.github/workflows/integration-tests.yml
+++ b/.github/workflows/integration-tests.yml
@@ -7,8 +7,6 @@ jobs:
   core:
     name: Core
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -49,8 +47,6 @@ jobs:
   network:
     name: Network
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -87,8 +83,6 @@ jobs:
   storage:
     name: Storage
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -125,8 +119,6 @@ jobs:
   sql:
     name: SQL
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -168,8 +160,6 @@ jobs:
   raft-replication:
     name: Raft & Replication
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -209,8 +199,6 @@ jobs:
   table-index:
     name: Table & Index
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -249,8 +237,6 @@ jobs:
   compute-deployment:
     name: Compute & Deployment
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -288,8 +274,6 @@ jobs:
   client:
     name: Client
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -328,8 +312,6 @@ jobs:
   runner:
     name: Runner
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -371,8 +353,6 @@ jobs:
   misc:
     name: Misc
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index 0a093fea3f0f..5ead382e6b1c 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -7,8 +7,6 @@ jobs:
   core:
     name: Core
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -56,8 +54,6 @@ jobs:
   configuration:
     name: Configuration
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -98,8 +94,6 @@ jobs:
   network:
     name: Network
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -139,8 +133,6 @@ jobs:
   storage:
     name: Storage
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -181,8 +173,6 @@ jobs:
   sql:
     name: SQL
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -224,8 +214,6 @@ jobs:
   raft-replication:
     name: Raft & Replication
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -269,8 +257,6 @@ jobs:
   table-index:
     name: Table & Index
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -312,8 +298,6 @@ jobs:
   compute-deployment:
     name: Compute & Deployment
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -352,8 +336,6 @@ jobs:
   client:
     name: Client
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -395,8 +377,6 @@ jobs:
   runner:
     name: Runner
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 
@@ -440,8 +420,6 @@ jobs:
   misc:
     name: Misc
     runs-on: ubuntu-latest
-    continue-on-error: true
-
     steps:
       - uses: actions/checkout@v4
 

From 86bb9be3e4d6981bb26cd605e48a47f28da51dc1 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Wed, 11 Mar 2026 14:27:49 +0400
Subject: [PATCH 75/79] Migrate remaining components to use Micronaut
 dependency injection; remove redundant factory methods and classes.

---
 modules/failure-handler/build.gradle          |  2 ++
 .../internal/failure/FailureManager.java      | 22 +++++++++++++++++++
 .../configuration/PresentationsFactory.java   |  5 ++++-
 .../rest/node/NodeManagementRestFactory.java  | 12 +---------
 .../ignite/internal/app/IgniteImpl.java       |  4 +---
 .../app/di/ClusterManagementFactory.java      |  2 +-
 .../app/di/NetworkComponentsFactory.java      | 18 ++++-----------
 .../configuration/JdbcPortProviderImpl.java   |  5 ++++-
 8 files changed, 39 insertions(+), 31 deletions(-)

diff --git a/modules/failure-handler/build.gradle b/modules/failure-handler/build.gradle
index aa1198168eb5..6482d10c998c 100644
--- a/modules/failure-handler/build.gradle
+++ b/modules/failure-handler/build.gradle
@@ -24,11 +24,13 @@ apply from: "$rootDir/buildscripts/java-test-fixtures.gradle"
 dependencies {
     annotationProcessor libs.auto.service
     annotationProcessor project(":ignite-configuration-annotation-processor")
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-api')
     implementation project(':ignite-core')
     implementation project(':ignite-configuration-api')
     implementation project(':ignite-configuration-root')
+    implementation libs.micronaut.inject
     implementation libs.jetbrains.annotations
     implementation libs.auto.service.annotations
 
diff --git a/modules/failure-handler/src/main/java/org/apache/ignite/internal/failure/FailureManager.java b/modules/failure-handler/src/main/java/org/apache/ignite/internal/failure/FailureManager.java
index a9e9f0741a46..a231f3ac32ed 100644
--- a/modules/failure-handler/src/main/java/org/apache/ignite/internal/failure/FailureManager.java
+++ b/modules/failure-handler/src/main/java/org/apache/ignite/internal/failure/FailureManager.java
@@ -22,6 +22,9 @@
 import static org.apache.ignite.internal.util.ExceptionUtils.hasCauseOrSuppressed;
 import static org.apache.ignite.lang.ErrorGroups.Common.COMPONENT_NOT_STARTED_ERR;
 
+import io.micronaut.core.annotation.Order;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.EnumMap;
 import java.util.EnumSet;
 import java.util.Map;
@@ -29,6 +32,9 @@
 import java.util.concurrent.CompletableFuture;
 import org.apache.ignite.configuration.notifications.ConfigurationListener;
 import org.apache.ignite.configuration.notifications.ConfigurationNotificationEvent;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorView;
 import org.apache.ignite.internal.failure.handlers.AbstractFailureHandler;
@@ -53,6 +59,9 @@
 /**
  * General failure processing implementation.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(600)
 public class FailureManager implements FailureProcessor, IgniteComponent {
     /** Logger. */
     private static final IgniteLogger LOG = Loggers.forClass(FailureManager.class);
@@ -118,12 +127,25 @@ public FailureManager(FailureHandler handler) {
      * @param nodeStopper Node stopper.
      * @param configuration Failure processor configuration.
      */
+    @TestOnly
     public FailureManager(String nodeName, NodeStopper nodeStopper, FailureProcessorConfiguration configuration) {
         this.nodeName = nodeName;
         this.nodeStopper = nodeStopper;
         this.configuration = configuration;
     }
 
+    /**
+     * Creates a new instance of a failure processor.
+     *
+     * @param nodeIdentity Node identity.
+     * @param nodeStopper Node stopper.
+     * @param configuration Failure processor configuration.
+     */
+    @Inject
+    public FailureManager(NodeIdentity nodeIdentity, NodeStopper nodeStopper, FailureProcessorConfiguration configuration) {
+        this(nodeIdentity.nodeName(), nodeStopper, configuration);
+    }
+
     @Override
     public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
         initFailureHandler();
diff --git a/modules/rest/src/main/java/org/apache/ignite/internal/rest/configuration/PresentationsFactory.java b/modules/rest/src/main/java/org/apache/ignite/internal/rest/configuration/PresentationsFactory.java
index dff54efbd92e..ab9d751e75b8 100644
--- a/modules/rest/src/main/java/org/apache/ignite/internal/rest/configuration/PresentationsFactory.java
+++ b/modules/rest/src/main/java/org/apache/ignite/internal/rest/configuration/PresentationsFactory.java
@@ -34,7 +34,10 @@ public class PresentationsFactory implements RestFactory {
     private ConfigurationPresentation<String> nodeCfgPresentation;
     private ConfigurationPresentation<String> clusterCfgPresentation;
 
-    public PresentationsFactory(ConfigurationRegistry nodeConfigRegistry, ConfigurationRegistry clusterConfigRegistry) {
+    public PresentationsFactory(
+            @Named("nodeConfig") ConfigurationRegistry nodeConfigRegistry,
+            @Named("clusterConfig") ConfigurationRegistry clusterConfigRegistry
+    ) {
         this.nodeCfgPresentation = new HoconPresentation(nodeConfigRegistry);
         this.clusterCfgPresentation = new HoconPresentation(clusterConfigRegistry);
     }
diff --git a/modules/rest/src/main/java/org/apache/ignite/internal/rest/node/NodeManagementRestFactory.java b/modules/rest/src/main/java/org/apache/ignite/internal/rest/node/NodeManagementRestFactory.java
index 636a5deb7a26..0b3ddfa66539 100644
--- a/modules/rest/src/main/java/org/apache/ignite/internal/rest/node/NodeManagementRestFactory.java
+++ b/modules/rest/src/main/java/org/apache/ignite/internal/rest/node/NodeManagementRestFactory.java
@@ -31,15 +31,12 @@ public class NodeManagementRestFactory implements RestFactory {
 
     private NameProvider nameProvider;
 
-    private JdbcPortProvider jdbcPortProvider;
-
     /**
      * Constructs node management rest factory.
      */
-    public NodeManagementRestFactory(StateProvider stateProvider, NameProvider nameProvider, JdbcPortProvider jdbcPortProvider) {
+    public NodeManagementRestFactory(StateProvider stateProvider, NameProvider nameProvider) {
         this.stateProvider = stateProvider;
         this.nameProvider = nameProvider;
-        this.jdbcPortProvider = jdbcPortProvider;
     }
 
     @Singleton
@@ -54,16 +51,9 @@ public NameProvider nameProvider() {
         return nameProvider;
     }
 
-    @Singleton
-    @Bean
-    public JdbcPortProvider jdbcPortProvider() {
-        return jdbcPortProvider;
-    }
-
     @Override
     public void cleanResources() {
         stateProvider = null;
         nameProvider = null;
-        jdbcPortProvider = null;
     }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index b2a5ab84d793..8b952607e399 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -75,7 +75,6 @@
 import org.apache.ignite.internal.configuration.ComponentWorkingDir;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationRegistryImpl;
-import org.apache.ignite.internal.configuration.JdbcPortProviderImpl;
 import org.apache.ignite.internal.configuration.hocon.HoconConverter;
 import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
@@ -497,8 +496,7 @@ private RestComponent createRestComponent(String name) {
                 cmgMgr,
                 () -> joinFuture
         );
-        Supplier<RestFactory> nodeManagementRestFactory = () -> new NodeManagementRestFactory(lifecycleManager, () -> name,
-                new JdbcPortProviderImpl(nodeConfigRegistry));
+        Supplier<RestFactory> nodeManagementRestFactory = () -> new NodeManagementRestFactory(lifecycleManager, () -> name);
         Supplier<RestFactory> metricRestFactory = () -> new MetricRestFactory(metricManager, metricMessaging);
         Supplier<RestFactory> authProviderFactory = () -> new AuthenticationProviderFactory(authenticationManager);
         Supplier<RestFactory> deploymentCodeRestFactory =
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index fa1c7eabacfa..23c30cdd23a6 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -21,12 +21,12 @@
 import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
-import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesConfiguration;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesExtensionConfiguration;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
+import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
 import org.apache.ignite.internal.configuration.ConfigurationDynamicDefaultsPatcherImpl;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
index 8186e25307c7..f0961477b677 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/NetworkComponentsFactory.java
@@ -18,17 +18,13 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
-import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.IgniteServer;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.SystemLocalConfiguration;
 import org.apache.ignite.internal.configuration.SystemLocalExtensionConfiguration;
-import org.apache.ignite.internal.failure.FailureManager;
+import org.apache.ignite.internal.failure.NodeStopper;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorConfiguration;
 import org.apache.ignite.internal.failure.configuration.FailureProcessorExtensionConfiguration;
 import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
@@ -66,16 +62,10 @@ public CriticalWorkersConfiguration criticalWorkersConfiguration(SystemLocalConf
         return systemConfiguration.criticalWorkers();
     }
 
-    /** Creates the failure manager. */
+    /** Creates the node stopper. */
     @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(600)
-    public FailureManager failureManager(
-            NodeIdentity nodeIdentity,
-            IgniteServer igniteServer,
-            FailureProcessorConfiguration failureProcessorConfiguration
-    ) {
-        return new FailureManager(nodeIdentity.nodeName(), igniteServer::shutdown, failureProcessorConfiguration);
+    public NodeStopper nodeStopper(IgniteServer igniteServer) {
+        return igniteServer::shutdown;
     }
 
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/JdbcPortProviderImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/configuration/JdbcPortProviderImpl.java
index f9d33cec2d33..780bbea0ec57 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/JdbcPortProviderImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/configuration/JdbcPortProviderImpl.java
@@ -17,17 +17,20 @@
 
 package org.apache.ignite.internal.configuration;
 
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import org.apache.ignite.client.handler.configuration.ClientConnectorExtensionConfiguration;
 import org.apache.ignite.internal.rest.node.JdbcPortProvider;
 
 /**
  * Provider of client port from node configuration.
  */
+@Singleton
 public class JdbcPortProviderImpl implements JdbcPortProvider {
 
     private final ConfigurationRegistry configurationRegistry;
 
-    public JdbcPortProviderImpl(ConfigurationRegistry configurationRegistry) {
+    public JdbcPortProviderImpl(@Named("nodeConfig") ConfigurationRegistry configurationRegistry) {
         this.configurationRegistry = configurationRegistry;
     }
 

From b5e4a6420071c49f95c820842a6e1c9fac960789 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Wed, 11 Mar 2026 14:59:42 +0400
Subject: [PATCH 76/79] Migrate `ConfigurationModules` to
 `ConfigurationModulesImpl` with Micronaut dependency injection; remove
 redundant classes and tests.

---
 .../config/Ignite3ConfigurationUtils.java     |  6 +--
 .../configuration/ConfigurationModules.java   | 43 +++++++++++++++++++
 modules/configuration/build.gradle            |  3 ++
 .../configuration/CompoundModule.java         |  0
 ...nfigurationDynamicDefaultsPatcherImpl.java | 12 ++++++
 .../ConfigurationModulesImpl.java}            | 25 ++++-------
 .../configuration/CompoundModuleTest.java     |  0
 .../generator/DefaultsGenerator.java          |  3 +-
 .../app/di/ClusterManagementFactory.java      | 11 -----
 .../app/di/IgniteNodeSeedFactory.java         |  3 +-
 .../ConfigurationModulesTest.java             |  6 +--
 .../ConfigurationCompatibilityTest.java       |  3 +-
 .../internal/BaseIgniteRestartTest.java       |  3 +-
 13 files changed, 80 insertions(+), 38 deletions(-)
 create mode 100644 modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java
 rename modules/{runner => configuration}/src/main/java/org/apache/ignite/internal/configuration/CompoundModule.java (100%)
 rename modules/{runner/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java => configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java} (76%)
 rename modules/{runner => configuration}/src/test/java/org/apache/ignite/internal/configuration/CompoundModuleTest.java (100%)

diff --git a/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java b/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java
index 130c8c71b0fd..7cef1958589d 100644
--- a/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java
+++ b/migration-tools/modules/migration-tools-commons/src/main/java/org/apache/ignite/migrationtools/config/Ignite3ConfigurationUtils.java
@@ -27,7 +27,7 @@
 import org.apache.ignite3.configuration.RootKey;
 import org.apache.ignite3.configuration.annotation.ConfigurationType;
 import org.apache.ignite3.configuration.validation.Validator;
-import org.apache.ignite3.internal.configuration.ConfigurationModules;
+import org.apache.ignite3.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite3.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite3.internal.configuration.ConfigurationRegistryImpl;
 import org.apache.ignite3.internal.configuration.ConfigurationTreeGenerator;
@@ -66,7 +66,7 @@ public static CombinedConfigRegistry loadCombinedRegistry(Path nodeCfgPath, Path
      * @param includeDefaults Include defaults.
      */
     public static ConfigurationRegistry loadNodeConfiguration(Path cfgPath, boolean includeDefaults) {
-        return loadConfigurations(cfgPath, ConfigurationModules.create(null).local(), includeDefaults);
+        return loadConfigurations(cfgPath, ConfigurationModulesImpl.create(null).local(), includeDefaults);
     }
 
     /**
@@ -78,7 +78,7 @@ public static ConfigurationRegistry loadNodeConfiguration(Path cfgPath, boolean
     public static ConfigurationRegistry loadClusterConfiguration(Path cfgPath, boolean includeDefaults) {
         // Hack so that it passes the validation
         // TODO: This is another hack that needs to be cleaned. We don't really need the ConfigurationRegistry.
-        var distributedModule = ConfigurationModules.create(null).distributed();
+        var distributedModule = ConfigurationModulesImpl.create(null).distributed();
         for (RootKey<?, ?, ?> key : distributedModule.rootKeys()) {
             try {
                 FieldUtils.writeDeclaredField(key, "storageType", ConfigurationType.LOCAL, true);
diff --git a/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java
new file mode 100644
index 000000000000..1a7b5fc2e98b
--- /dev/null
+++ b/modules/configuration-api/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.configuration;
+
+import org.apache.ignite.configuration.ConfigurationModule;
+import org.apache.ignite.configuration.annotation.ConfigurationType;
+
+/**
+ * An ensemble of {@link ConfigurationModule}s used to easily pick node-local and cluster-wide configuration
+ * and merge modules for convenience.
+ */
+public interface ConfigurationModules {
+    /**
+     * Return a module representing the result of merge of modules of type
+     * {@link ConfigurationType#LOCAL}.
+     *
+     * @return node-local configuration merge result
+     */
+    ConfigurationModule local();
+
+    /**
+     * Return a module representing the result of merge of modules of type
+     * {@link ConfigurationType#DISTRIBUTED}.
+     *
+     * @return cluster-wide configuration merge result
+     */
+    ConfigurationModule distributed();
+}
diff --git a/modules/configuration/build.gradle b/modules/configuration/build.gradle
index f0f77c6676cb..9fe05c4798ae 100644
--- a/modules/configuration/build.gradle
+++ b/modules/configuration/build.gradle
@@ -29,8 +29,11 @@ dependencies {
     implementation project(':ignite-bytecode')
     implementation project(':ignite-core')
     implementation libs.jetbrains.annotations
+    implementation libs.micronaut.inject
     implementation libs.typesafe.config
 
+    annotationProcessor libs.micronaut.inject.annotation.processor
+
     testAnnotationProcessor project(':ignite-configuration-annotation-processor')
     testImplementation project(':ignite-core')
     testImplementation testFixtures(project(':ignite-core'))
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/CompoundModule.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/CompoundModule.java
similarity index 100%
rename from modules/runner/src/main/java/org/apache/ignite/internal/configuration/CompoundModule.java
rename to modules/configuration/src/main/java/org/apache/ignite/internal/configuration/CompoundModule.java
diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationDynamicDefaultsPatcherImpl.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationDynamicDefaultsPatcherImpl.java
index ab6cb4e4f54f..ed26c0227e69 100644
--- a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationDynamicDefaultsPatcherImpl.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationDynamicDefaultsPatcherImpl.java
@@ -20,6 +20,9 @@
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
 import com.typesafe.config.ConfigRenderOptions;
+import jakarta.inject.Inject;
+import jakarta.inject.Named;
+import jakarta.inject.Singleton;
 import java.util.List;
 import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
 import org.apache.ignite.configuration.ConfigurationModule;
@@ -33,6 +36,7 @@
 /**
  * Implementation of {@link ConfigurationDynamicDefaultsPatcher}.
  */
+@Singleton
 public class ConfigurationDynamicDefaultsPatcherImpl implements ConfigurationDynamicDefaultsPatcher {
     /**
      * Configuration module.
@@ -52,6 +56,14 @@ public ConfigurationDynamicDefaultsPatcherImpl(
         this.generator = generator;
     }
 
+    @Inject
+    public ConfigurationDynamicDefaultsPatcherImpl(
+            ConfigurationModules modules,
+            @Named("distributed") ConfigurationTreeGenerator generator
+    ) {
+        this(modules.distributed(), generator);
+    }
+
     @Override
     public String patchWithDynamicDefaults(String hocon) {
         SuperRoot superRoot = convertToSuperRoot(hocon);
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java
similarity index 76%
rename from modules/runner/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java
rename to modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java
index 9b1132b8aac0..b279c3fd9bd4 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModules.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java
@@ -28,37 +28,28 @@
 import org.jetbrains.annotations.Nullable;
 
 /**
- * An ensemble of {@link ConfigurationModule}s used to easily pick node-local and cluster-wide configuration
- * and merge modules for convenience.
+ * Implementation of {@link ConfigurationModules} that loads and merges {@link ConfigurationModule}s.
  */
-public class ConfigurationModules {
+public class ConfigurationModulesImpl implements ConfigurationModules {
     private final CompoundModule localCompound;
     private final CompoundModule distributedCompound;
 
     /**
-     * Creates a new instance of {@link ConfigurationModules} wrapping modules passed to it.
+     * Creates a new instance wrapping modules passed to it.
      *
      * @param modules modules to wrap; they may be of different types
      */
-    public ConfigurationModules(List<ConfigurationModule> modules) {
+    public ConfigurationModulesImpl(List<ConfigurationModule> modules) {
         localCompound = compoundOfType(ConfigurationType.LOCAL, modules);
         distributedCompound = compoundOfType(ConfigurationType.DISTRIBUTED, modules);
     }
 
-    /**
-     * Return a module representing the result of merge of modules of type {@link ConfigurationType#LOCAL}.
-     *
-     * @return node-local configuration merge result
-     */
+    @Override
     public ConfigurationModule local() {
         return localCompound;
     }
 
-    /**
-     * Return a module representing the result of merge of modules of type {@link ConfigurationType#DISTRIBUTED}.
-     *
-     * @return cluster-wide configuration merge result
-     */
+    @Override
     public ConfigurationModule distributed() {
         return distributedCompound;
     }
@@ -76,7 +67,7 @@ private static CompoundModule compoundOfType(ConfigurationType type, Collection<
      * @param classLoader the class loader to use.
      * @return Configuration modules.
      */
-    public static ConfigurationModules create(@Nullable ClassLoader classLoader) {
+    public static ConfigurationModulesImpl create(@Nullable ClassLoader classLoader) {
         List<ConfigurationModule> modules = ServiceLoader.load(ConfigurationModule.class, classLoader).stream()
                 .map(Provider::get)
                 .collect(toUnmodifiableList());
@@ -86,6 +77,6 @@ public static ConfigurationModules create(@Nullable ClassLoader classLoader) {
                     + "Please make sure that the classloader for loading services is correct.");
         }
 
-        return new ConfigurationModules(modules);
+        return new ConfigurationModulesImpl(modules);
     }
 }
diff --git a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/CompoundModuleTest.java b/modules/configuration/src/test/java/org/apache/ignite/internal/configuration/CompoundModuleTest.java
similarity index 100%
rename from modules/runner/src/test/java/org/apache/ignite/internal/configuration/CompoundModuleTest.java
rename to modules/configuration/src/test/java/org/apache/ignite/internal/configuration/CompoundModuleTest.java
diff --git a/modules/runner/src/defaultsGenerator/java/org/apache/ignite/internal/configuration/generator/DefaultsGenerator.java b/modules/runner/src/defaultsGenerator/java/org/apache/ignite/internal/configuration/generator/DefaultsGenerator.java
index b3de927cc96e..b31e77268cad 100644
--- a/modules/runner/src/defaultsGenerator/java/org/apache/ignite/internal/configuration/generator/DefaultsGenerator.java
+++ b/modules/runner/src/defaultsGenerator/java/org/apache/ignite/internal/configuration/generator/DefaultsGenerator.java
@@ -28,6 +28,7 @@
 import org.apache.ignite.internal.configuration.ConfigurationChanger;
 import org.apache.ignite.internal.configuration.ConfigurationChanger.ConfigurationUpdateListener;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.ConfigurationStorage;
 import org.apache.ignite.internal.configuration.storage.LocalFileConfigurationStorage;
@@ -75,7 +76,7 @@ public static void main(String[] args) {
      * This uses fragments of cluster initialization from {@code IgniteImpl} class to set up local configuration framework.
      */
     private static ConfigurationChanger createConfigurationChanger(Path configPath) {
-        ConfigurationModules modules = ConfigurationModules.create(DefaultsGenerator.class.getClassLoader());
+        ConfigurationModules modules = ConfigurationModulesImpl.create(DefaultsGenerator.class.getClassLoader());
 
         ConfigurationTreeGenerator localConfigurationGenerator = new ConfigurationTreeGenerator(
                 modules.local().rootKeys(),
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 23c30cdd23a6..56cefdf66b5b 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -26,8 +26,6 @@
 import org.apache.ignite.internal.components.IgniteStartupPhase;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.components.StartupPhase;
-import org.apache.ignite.configuration.ConfigurationDynamicDefaultsPatcher;
-import org.apache.ignite.internal.configuration.ConfigurationDynamicDefaultsPatcherImpl;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
@@ -143,13 +141,4 @@ public ConfigurationValidator distributedConfigurationValidator(
         return ConfigurationValidatorImpl.withDefaultValidators(generator, modules.distributed().validators());
     }
 
-    /** Creates the configuration dynamic defaults patcher. */
-    @Singleton
-    public ConfigurationDynamicDefaultsPatcher configurationDynamicDefaultsPatcher(
-            ConfigurationModules modules,
-            @Named("distributed") ConfigurationTreeGenerator generator
-    ) {
-        return new ConfigurationDynamicDefaultsPatcherImpl(modules.distributed(), generator);
-    }
-
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
index ff12e5e3a414..c2e93a3e0a86 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
@@ -23,6 +23,7 @@
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite.internal.vault.VaultService;
 import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
 
@@ -40,6 +41,6 @@ public VaultService vaultService(NodeIdentity nodeIdentity) {
     /** Discovers configuration modules from the service provider class loader. */
     @Singleton
     public ConfigurationModules configurationModules(NodeIdentity nodeIdentity) {
-        return ConfigurationModules.create(nodeIdentity.serviceProviderClassLoader());
+        return ConfigurationModulesImpl.create(nodeIdentity.serviceProviderClassLoader());
     }
 }
diff --git a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/ConfigurationModulesTest.java b/modules/runner/src/test/java/org/apache/ignite/internal/configuration/ConfigurationModulesTest.java
index 43a3467d139e..02aa37546fd1 100644
--- a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/ConfigurationModulesTest.java
+++ b/modules/runner/src/test/java/org/apache/ignite/internal/configuration/ConfigurationModulesTest.java
@@ -68,7 +68,7 @@ void mergesLocalModules() {
         when(moduleA.rootKeys()).thenReturn(Set.of(rootKeyA));
         when(moduleB.rootKeys()).thenReturn(Set.of(rootKeyB));
 
-        var modules = new ConfigurationModules(List.of(moduleA, moduleB, moduleC, moduleD));
+        var modules = new ConfigurationModulesImpl(List.of(moduleA, moduleB, moduleC, moduleD));
 
         assertThat(modules.local().rootKeys(), containsInAnyOrder(rootKeyA, rootKeyB));
     }
@@ -82,7 +82,7 @@ void mergesDistributedModules() {
         when(moduleC.rootKeys()).thenReturn(Set.of(rootKeyC));
         when(moduleD.rootKeys()).thenReturn(Set.of(rootKeyD));
 
-        var modules = new ConfigurationModules(List.of(moduleA, moduleB, moduleC, moduleD));
+        var modules = new ConfigurationModulesImpl(List.of(moduleA, moduleB, moduleC, moduleD));
 
         assertThat(modules.distributed().rootKeys(), containsInAnyOrder(rootKeyC, rootKeyD));
     }
@@ -90,7 +90,7 @@ void mergesDistributedModules() {
     @ParameterizedTest
     @MethodSource("classLoaderSource")
     void createdUsingClassLoader(ClassLoader classLoader) {
-        ConfigurationModules modules = ConfigurationModules.create(classLoader);
+        ConfigurationModules modules = ConfigurationModulesImpl.create(classLoader);
 
         assertThat(modules.local().schemaExtensions().size(), is(greaterThan(0)));
         assertThat(modules.distributed().schemaExtensions().size(), is(greaterThan(0)));
diff --git a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/compatibility/ConfigurationCompatibilityTest.java b/modules/runner/src/test/java/org/apache/ignite/internal/configuration/compatibility/ConfigurationCompatibilityTest.java
index 19a3d698304a..c02d32c706ba 100644
--- a/modules/runner/src/test/java/org/apache/ignite/internal/configuration/compatibility/ConfigurationCompatibilityTest.java
+++ b/modules/runner/src/test/java/org/apache/ignite/internal/configuration/compatibility/ConfigurationCompatibilityTest.java
@@ -38,6 +38,7 @@
 import org.apache.ignite.configuration.ConfigurationModule;
 import org.apache.ignite.configuration.RootKey;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite.internal.configuration.compatibility.framework.ConfigNode;
 import org.apache.ignite.internal.configuration.compatibility.framework.ConfigNodeSerializer;
 import org.apache.ignite.internal.configuration.compatibility.framework.ConfigurationSnapshotManager;
@@ -122,7 +123,7 @@ void testConfigurationCompatibility(String fileName) throws IOException {
     }
 
     static List<ConfigNode> loadCurrentConfiguration() {
-        ConfigurationModules modules = ConfigurationModules.create(ConfigurationCompatibilityTest.class.getClassLoader());
+        ConfigurationModules modules = ConfigurationModulesImpl.create(ConfigurationCompatibilityTest.class.getClassLoader());
 
         ConfigurationModule local = modules.local();
         ConfigurationModule distributed = modules.distributed();
diff --git a/modules/runner/src/testFixtures/java/org/apache/ignite/internal/BaseIgniteRestartTest.java b/modules/runner/src/testFixtures/java/org/apache/ignite/internal/BaseIgniteRestartTest.java
index 6d1e128b3d0b..3143c9c27418 100644
--- a/modules/runner/src/testFixtures/java/org/apache/ignite/internal/BaseIgniteRestartTest.java
+++ b/modules/runner/src/testFixtures/java/org/apache/ignite/internal/BaseIgniteRestartTest.java
@@ -52,6 +52,7 @@
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopology;
 import org.apache.ignite.internal.cluster.management.topology.LogicalTopologyImpl;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
+import org.apache.ignite.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.storage.DistributedConfigurationStorage;
@@ -232,7 +233,7 @@ private static Set<String> cmgMsNodes(ClusterManagementGroupManager cmgManager)
      * @return Configuration modules.
      */
     public static ConfigurationModules loadConfigurationModules(IgniteLogger log, ClassLoader classLoader) {
-        ConfigurationModules configModules = ConfigurationModules.create(classLoader);
+        ConfigurationModules configModules = ConfigurationModulesImpl.create(classLoader);
 
         if (log.isInfoEnabled()) {
             log.info("Local root keys: {}", configModules.local().rootKeys());

From c9a634d4d2d51d9b8b5a649c83ce76b42b671851 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Wed, 11 Mar 2026 18:42:35 +0400
Subject: [PATCH 77/79] Migrate configuration and network-related classes to
 Micronaut dependency injection; remove redundant factory methods and
 constructors.

---
 .../ConfigurationModulesImpl.java             | 20 ++++++++++++++++++-
 .../MessageSerializationRegistryImpl.java     | 16 +++++++++++++++
 .../app/di/ClusterManagementFactory.java      | 11 ----------
 .../app/di/IgniteNodeSeedFactory.java         |  8 --------
 4 files changed, 35 insertions(+), 20 deletions(-)

diff --git a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java
index b279c3fd9bd4..74f2d8a642ba 100644
--- a/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java
+++ b/modules/configuration/src/main/java/org/apache/ignite/internal/configuration/ConfigurationModulesImpl.java
@@ -19,17 +19,21 @@
 
 import static java.util.stream.Collectors.toUnmodifiableList;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.Collection;
 import java.util.List;
 import java.util.ServiceLoader;
 import java.util.ServiceLoader.Provider;
 import org.apache.ignite.configuration.ConfigurationModule;
 import org.apache.ignite.configuration.annotation.ConfigurationType;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.jetbrains.annotations.Nullable;
 
 /**
  * Implementation of {@link ConfigurationModules} that loads and merges {@link ConfigurationModule}s.
  */
+@Singleton
 public class ConfigurationModulesImpl implements ConfigurationModules {
     private final CompoundModule localCompound;
     private final CompoundModule distributedCompound;
@@ -44,6 +48,16 @@ public ConfigurationModulesImpl(List<ConfigurationModule> modules) {
         distributedCompound = compoundOfType(ConfigurationType.DISTRIBUTED, modules);
     }
 
+    /**
+     * DI constructor that discovers configuration modules using the service provider class loader from {@link NodeIdentity}.
+     *
+     * @param nodeIdentity Node identity providing the service provider class loader.
+     */
+    @Inject
+    public ConfigurationModulesImpl(NodeIdentity nodeIdentity) {
+        this(loadModules(nodeIdentity.serviceProviderClassLoader()));
+    }
+
     @Override
     public ConfigurationModule local() {
         return localCompound;
@@ -68,6 +82,10 @@ private static CompoundModule compoundOfType(ConfigurationType type, Collection<
      * @return Configuration modules.
      */
     public static ConfigurationModulesImpl create(@Nullable ClassLoader classLoader) {
+        return new ConfigurationModulesImpl(loadModules(classLoader));
+    }
+
+    private static List<ConfigurationModule> loadModules(@Nullable ClassLoader classLoader) {
         List<ConfigurationModule> modules = ServiceLoader.load(ConfigurationModule.class, classLoader).stream()
                 .map(Provider::get)
                 .collect(toUnmodifiableList());
@@ -77,6 +95,6 @@ public static ConfigurationModulesImpl create(@Nullable ClassLoader classLoader)
                     + "Please make sure that the classloader for loading services is correct.");
         }
 
-        return new ConfigurationModulesImpl(modules);
+        return modules;
     }
 }
diff --git a/modules/network/src/main/java/org/apache/ignite/internal/network/MessageSerializationRegistryImpl.java b/modules/network/src/main/java/org/apache/ignite/internal/network/MessageSerializationRegistryImpl.java
index 158ca8af95fe..5a0edff17e7b 100644
--- a/modules/network/src/main/java/org/apache/ignite/internal/network/MessageSerializationRegistryImpl.java
+++ b/modules/network/src/main/java/org/apache/ignite/internal/network/MessageSerializationRegistryImpl.java
@@ -17,19 +17,35 @@
 
 package org.apache.ignite.internal.network;
 
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+import org.apache.ignite.internal.components.NodeIdentity;
 import org.apache.ignite.internal.network.serialization.MessageDeserializer;
 import org.apache.ignite.internal.network.serialization.MessageSerializationFactory;
 import org.apache.ignite.internal.network.serialization.MessageSerializationRegistry;
 import org.apache.ignite.internal.network.serialization.MessageSerializer;
+import org.apache.ignite.internal.network.serialization.SerializationRegistryServiceLoader;
 
 /**
  * Default implementation of a {@link MessageSerializationRegistry}.
  */
+@Singleton
 public class MessageSerializationRegistryImpl implements MessageSerializationRegistry {
     /** group type → message type → MessageSerializerProvider instance. */
     private final MessageSerializationFactory<?>[][] factories =
             new MessageSerializationFactory<?>[Short.MAX_VALUE + 1][];
 
+    /** Default constructor for direct use in tests. */
+    public MessageSerializationRegistryImpl() {
+    }
+
+    /** DI constructor that loads and registers all serialization factories from the classpath. */
+    @Inject
+    public MessageSerializationRegistryImpl(NodeIdentity nodeIdentity) {
+        var serviceLoader = new SerializationRegistryServiceLoader(nodeIdentity.serviceProviderClassLoader());
+        serviceLoader.registerSerializationFactories(this);
+    }
+
     @Override
     public MessageSerializationRegistry registerFactory(
             short groupType, short messageType, MessageSerializationFactory<?> factory
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 56cefdf66b5b..5ae71f855ed1 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -36,7 +36,6 @@
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ChannelTypeRegistryProvider;
 import org.apache.ignite.internal.network.ClusterService;
-import org.apache.ignite.internal.network.MessageSerializationRegistryImpl;
 import org.apache.ignite.internal.network.MessagingService;
 import org.apache.ignite.internal.network.NettyBootstrapFactory;
 import org.apache.ignite.internal.network.TopologyService;
@@ -44,7 +43,6 @@
 import org.apache.ignite.internal.network.recovery.InMemoryStaleIds;
 import org.apache.ignite.internal.network.scalecube.ScaleCubeClusterService;
 import org.apache.ignite.internal.network.serialization.MessageSerializationRegistry;
-import org.apache.ignite.internal.network.serialization.SerializationRegistryServiceLoader;
 import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
 import org.apache.ignite.internal.storage.configurations.StorageExtensionConfiguration;
 import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
@@ -55,15 +53,6 @@
  */
 @Factory
 public class ClusterManagementFactory {
-    /** Creates the message serialization registry, loading all serializers from the classpath. */
-    @Singleton
-    public MessageSerializationRegistry messageSerializationRegistry(NodeIdentity nodeIdentity) {
-        var serviceLoader = new SerializationRegistryServiceLoader(nodeIdentity.serviceProviderClassLoader());
-        var registry = new MessageSerializationRegistryImpl();
-        serviceLoader.registerSerializationFactories(registry);
-        return registry;
-    }
-
     /** Creates the cluster service. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_1)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
index c2e93a3e0a86..ba9fac4d4431 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/IgniteNodeSeedFactory.java
@@ -22,8 +22,6 @@
 import io.micronaut.context.annotation.Factory;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.configuration.ConfigurationModules;
-import org.apache.ignite.internal.configuration.ConfigurationModulesImpl;
 import org.apache.ignite.internal.vault.VaultService;
 import org.apache.ignite.internal.vault.persistence.PersistentVaultService;
 
@@ -37,10 +35,4 @@ public class IgniteNodeSeedFactory {
     public VaultService vaultService(NodeIdentity nodeIdentity) {
         return new PersistentVaultService(vaultPath(nodeIdentity.workDir()));
     }
-
-    /** Discovers configuration modules from the service provider class loader. */
-    @Singleton
-    public ConfigurationModules configurationModules(NodeIdentity nodeIdentity) {
-        return ConfigurationModulesImpl.create(nodeIdentity.serviceProviderClassLoader());
-    }
 }

From d1da845970490c2bce095e6ae3a42c47ff013459 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Fri, 13 Mar 2026 08:59:07 +0400
Subject: [PATCH 78/79] Migrate `JdbcPortProvider` to Micronaut dependency
 injection; update `NodeManagementRestFactory` constructor and related usages.

---
 .../rest/node/NodeManagementRestFactory.java         | 12 +++++++++++-
 .../org/apache/ignite/internal/app/IgniteImpl.java   |  4 +++-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/modules/rest/src/main/java/org/apache/ignite/internal/rest/node/NodeManagementRestFactory.java b/modules/rest/src/main/java/org/apache/ignite/internal/rest/node/NodeManagementRestFactory.java
index 0b3ddfa66539..636a5deb7a26 100644
--- a/modules/rest/src/main/java/org/apache/ignite/internal/rest/node/NodeManagementRestFactory.java
+++ b/modules/rest/src/main/java/org/apache/ignite/internal/rest/node/NodeManagementRestFactory.java
@@ -31,12 +31,15 @@ public class NodeManagementRestFactory implements RestFactory {
 
     private NameProvider nameProvider;
 
+    private JdbcPortProvider jdbcPortProvider;
+
     /**
      * Constructs node management rest factory.
      */
-    public NodeManagementRestFactory(StateProvider stateProvider, NameProvider nameProvider) {
+    public NodeManagementRestFactory(StateProvider stateProvider, NameProvider nameProvider, JdbcPortProvider jdbcPortProvider) {
         this.stateProvider = stateProvider;
         this.nameProvider = nameProvider;
+        this.jdbcPortProvider = jdbcPortProvider;
     }
 
     @Singleton
@@ -51,9 +54,16 @@ public NameProvider nameProvider() {
         return nameProvider;
     }
 
+    @Singleton
+    @Bean
+    public JdbcPortProvider jdbcPortProvider() {
+        return jdbcPortProvider;
+    }
+
     @Override
     public void cleanResources() {
         stateProvider = null;
         nameProvider = null;
+        jdbcPortProvider = null;
     }
 }
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 8b952607e399..2f281303637c 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -134,6 +134,7 @@
 import org.apache.ignite.internal.rest.deployment.CodeDeploymentRestFactory;
 import org.apache.ignite.internal.rest.events.RestEventsFactory;
 import org.apache.ignite.internal.rest.metrics.MetricRestFactory;
+import org.apache.ignite.internal.rest.node.JdbcPortProvider;
 import org.apache.ignite.internal.rest.node.NodeManagementRestFactory;
 import org.apache.ignite.internal.rest.node.NodePropertiesFactory;
 import org.apache.ignite.internal.rest.recovery.DisasterRecoveryFactory;
@@ -496,7 +497,8 @@ private RestComponent createRestComponent(String name) {
                 cmgMgr,
                 () -> joinFuture
         );
-        Supplier<RestFactory> nodeManagementRestFactory = () -> new NodeManagementRestFactory(lifecycleManager, () -> name);
+        JdbcPortProvider jdbcPortProvider = diContext.getBean(JdbcPortProvider.class);
+        Supplier<RestFactory> nodeManagementRestFactory = () -> new NodeManagementRestFactory(lifecycleManager, () -> name, jdbcPortProvider);
         Supplier<RestFactory> metricRestFactory = () -> new MetricRestFactory(metricManager, metricMessaging);
         Supplier<RestFactory> authProviderFactory = () -> new AuthenticationProviderFactory(authenticationManager);
         Supplier<RestFactory> deploymentCodeRestFactory =

From 766334d0e78883aca440a8d1670dd72b71aa3738 Mon Sep 17 00:00:00 2001
From: Ivan Zlenko <241953+ivanzlenko@users.noreply.github.com>
Date: Fri, 13 Mar 2026 11:05:04 +0400
Subject: [PATCH 79/79] Migrate remaining classes and components to Micronaut
 dependency injection; update constructors, add new annotations, and remove
 redundant factory methods and classes.

---
 modules/catalog/build.gradle                  |  2 +
 .../internal/catalog/CatalogManagerImpl.java  | 29 ++++++++++++
 modules/network/build.gradle                  |  1 +
 .../scalecube/ScaleCubeClusterService.java    | 39 ++++++++++++++++
 .../ignite/internal/rest/RestComponent.java   | 19 +++++++-
 .../ignite/internal/app/IgniteImpl.java       | 11 ++++-
 .../internal/app/di/CatalogFactory.java       | 25 -----------
 .../app/di/ClusterManagementFactory.java      | 44 -------------------
 8 files changed, 97 insertions(+), 73 deletions(-)

diff --git a/modules/catalog/build.gradle b/modules/catalog/build.gradle
index c759e0870c77..48f53becedfa 100644
--- a/modules/catalog/build.gradle
+++ b/modules/catalog/build.gradle
@@ -24,9 +24,11 @@ apply from: "$rootDir/buildscripts/java-integration-test.gradle"
 dependencies {
     annotationProcessor project(':ignite-configuration-annotation-processor')
     annotationProcessor libs.auto.service
+    annotationProcessor libs.micronaut.inject.annotation.processor
 
     implementation project(':ignite-api')
     implementation project(':ignite-core')
+    implementation libs.micronaut.inject
     implementation project(':ignite-configuration')
     implementation project(':ignite-configuration-root')
     implementation project(':ignite-metastorage-api')
diff --git a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
index 827d4b82d6e5..864651a8211a 100644
--- a/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
+++ b/modules/catalog/src/main/java/org/apache/ignite/internal/catalog/CatalogManagerImpl.java
@@ -28,8 +28,11 @@
 import static org.apache.ignite.internal.util.IgniteUtils.inBusyLockAsync;
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 
+import io.micronaut.core.annotation.Order;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.List;
@@ -37,6 +40,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.LongSupplier;
 import org.apache.ignite.internal.catalog.commands.CreateSchemaCommand;
+import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
 import org.apache.ignite.internal.catalog.descriptors.CatalogIndexDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogSchemaDescriptor;
 import org.apache.ignite.internal.catalog.descriptors.CatalogTableDescriptor;
@@ -48,7 +52,10 @@
 import org.apache.ignite.internal.catalog.storage.UpdateLog;
 import org.apache.ignite.internal.catalog.storage.UpdateLog.OnUpdateHandler;
 import org.apache.ignite.internal.catalog.storage.UpdateLogEvent;
+import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
 import org.apache.ignite.internal.catalog.storage.VersionedUpdate;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.event.AbstractEventProducer;
 import org.apache.ignite.internal.failure.FailureContext;
 import org.apache.ignite.internal.failure.FailureProcessor;
@@ -59,6 +66,7 @@
 import org.apache.ignite.internal.logger.IgniteLogger;
 import org.apache.ignite.internal.logger.Loggers;
 import org.apache.ignite.internal.manager.ComponentContext;
+import org.apache.ignite.internal.metastorage.MetaStorageManager;
 import org.apache.ignite.internal.sql.SqlCommon;
 import org.apache.ignite.internal.systemview.api.SystemView;
 import org.apache.ignite.internal.systemview.api.SystemViewProvider;
@@ -69,6 +77,9 @@
 /**
  * Catalog service implementation.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_2)
+@Order(100)
 public class CatalogManagerImpl extends AbstractEventProducer<CatalogEvent, CatalogEventParameters>
         implements CatalogManager, SystemViewProvider {
     private static final int MAX_RETRY_COUNT = 10;
@@ -118,6 +129,24 @@ public class CatalogManagerImpl extends AbstractEventProducer<CatalogEvent, Cata
      */
     private final PartitionCountCalculator partitionCountCalculator;
 
+    /** DI constructor that creates UpdateLogImpl internally and adapts configuration to suppliers. */
+    @Inject
+    public CatalogManagerImpl(
+            MetaStorageManager metaStorageManager,
+            ClockService clockService,
+            FailureProcessor failureProcessor,
+            SchemaSynchronizationConfiguration schemaSyncConfig,
+            PartitionCountCalculator partitionCountCalculator
+    ) {
+        this(
+                new UpdateLogImpl(metaStorageManager, failureProcessor),
+                clockService,
+                failureProcessor,
+                () -> schemaSyncConfig.delayDurationMillis().value(),
+                partitionCountCalculator
+        );
+    }
+
     /**
      * Constructor.
      */
diff --git a/modules/network/build.gradle b/modules/network/build.gradle
index d86747934f40..ee392540e9df 100644
--- a/modules/network/build.gradle
+++ b/modules/network/build.gradle
@@ -74,6 +74,7 @@ dependencies {
     testImplementation libs.bouncycastle.bcpkix.jdk18on;
 
     testFixturesAnnotationProcessor project(':ignite-network-annotation-processor')
+    testFixturesImplementation libs.micronaut.inject
     testFixturesImplementation project(':ignite-configuration')
     testFixturesImplementation project(':ignite-configuration-root')
     testFixturesImplementation project(':ignite-failure-handler')
diff --git a/modules/network/src/main/java/org/apache/ignite/internal/network/scalecube/ScaleCubeClusterService.java b/modules/network/src/main/java/org/apache/ignite/internal/network/scalecube/ScaleCubeClusterService.java
index 62a4fb881f7f..0ba2bf51b20c 100644
--- a/modules/network/src/main/java/org/apache/ignite/internal/network/scalecube/ScaleCubeClusterService.java
+++ b/modules/network/src/main/java/org/apache/ignite/internal/network/scalecube/ScaleCubeClusterService.java
@@ -22,12 +22,15 @@
 import static org.apache.ignite.lang.ErrorGroups.Common.INTERNAL_ERR;
 import static org.apache.ignite.lang.ErrorGroups.Network.ADDRESS_UNRESOLVED_ERR;
 
+import io.micronaut.core.annotation.Order;
 import io.scalecube.cluster.ClusterConfig;
 import io.scalecube.cluster.ClusterImpl;
 import io.scalecube.cluster.ClusterMessageHandler;
 import io.scalecube.cluster.membership.MembershipEvent;
 import io.scalecube.cluster.metadata.MetadataCodec;
 import io.scalecube.net.Address;
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.UnknownHostException;
@@ -41,6 +44,9 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
+import org.apache.ignite.internal.components.IgniteStartupPhase;
+import org.apache.ignite.internal.components.NodeIdentity;
+import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.failure.FailureProcessor;
 import org.apache.ignite.internal.lang.IgniteInternalException;
 import org.apache.ignite.internal.logger.IgniteLogger;
@@ -48,6 +54,7 @@
 import org.apache.ignite.internal.manager.ComponentContext;
 import org.apache.ignite.internal.metrics.MetricManager;
 import org.apache.ignite.internal.network.ChannelTypeRegistry;
+import org.apache.ignite.internal.network.ChannelTypeRegistryProvider;
 import org.apache.ignite.internal.network.ClusterIdSupplier;
 import org.apache.ignite.internal.network.ClusterNodeImpl;
 import org.apache.ignite.internal.network.ClusterService;
@@ -65,6 +72,7 @@
 import org.apache.ignite.internal.network.configuration.NetworkView;
 import org.apache.ignite.internal.network.configuration.ScaleCubeView;
 import org.apache.ignite.internal.network.netty.ConnectionManager;
+import org.apache.ignite.internal.network.recovery.InMemoryStaleIds;
 import org.apache.ignite.internal.network.recovery.StaleIds;
 import org.apache.ignite.internal.network.serialization.ClassDescriptorFactory;
 import org.apache.ignite.internal.network.serialization.ClassDescriptorRegistry;
@@ -73,6 +81,7 @@
 import org.apache.ignite.internal.network.serialization.UserObjectSerializationContext;
 import org.apache.ignite.internal.network.serialization.marshal.DefaultUserObjectMarshaller;
 import org.apache.ignite.internal.util.IgniteUtils;
+import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
 import org.apache.ignite.internal.version.IgniteProductVersionSource;
 import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
 import org.apache.ignite.lang.IgniteException;
@@ -83,6 +92,9 @@
 /**
  * ScaleCube-based implementation of {@link ClusterService}.
  */
+@Singleton
+@IgniteStartupPhase(StartupPhase.PHASE_1)
+@Order(1300)
 public class ScaleCubeClusterService implements ClusterService {
     private static final IgniteLogger LOG = Loggers.forClass(ScaleCubeClusterService.class);
 
@@ -109,6 +121,33 @@ public class ScaleCubeClusterService implements ClusterService {
     @Nullable
     private volatile ClusterImpl cluster;
 
+    /** DI constructor that resolves NodeIdentity and creates inline dependencies. */
+    @Inject
+    public ScaleCubeClusterService(
+            NodeIdentity nodeIdentity,
+            NetworkConfiguration networkConfiguration,
+            NettyBootstrapFactory nettyBootstrapFactory,
+            MessageSerializationRegistry serializationRegistry,
+            ClusterIdSupplier clusterIdSupplier,
+            CriticalWorkerRegistry criticalWorkerRegistry,
+            FailureProcessor failureProcessor,
+            MetricManager metricManager
+    ) {
+        this(
+                nodeIdentity.nodeName(),
+                networkConfiguration,
+                nettyBootstrapFactory,
+                serializationRegistry,
+                new InMemoryStaleIds(),
+                clusterIdSupplier,
+                criticalWorkerRegistry,
+                failureProcessor,
+                ChannelTypeRegistryProvider.loadByServiceLoader(nodeIdentity.serviceProviderClassLoader()),
+                new DefaultIgniteProductVersionSource(),
+                metricManager
+        );
+    }
+
     /** Constructor. */
     public ScaleCubeClusterService(
             String consistentId,
diff --git a/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java b/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
index 7ad6d8832283..db06726d2e04 100644
--- a/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
+++ b/modules/rest/src/main/java/org/apache/ignite/internal/rest/RestComponent.java
@@ -117,8 +117,23 @@ public CompletableFuture<Void> startAsync(ComponentContext componentContext) {
         boolean sslEnabled = sslConfigurationView.enabled();
         boolean dualProtocol = restConfiguration.dualProtocol().value();
 
-        if (startServer(restConfigurationView.port(), sslConfigurationView.port(), sslEnabled, dualProtocol)) {
-            return nullCompletedFuture();
+        int maxRetries = 5;
+        for (int attempt = 0; attempt <= maxRetries; attempt++) {
+            if (startServer(restConfigurationView.port(), sslConfigurationView.port(), sslEnabled, dualProtocol)) {
+                return nullCompletedFuture();
+            }
+
+            if (attempt < maxRetries) {
+                LOG.info("REST port not yet available, retrying in 200ms"
+                        + " [HTTP port=" + httpPort + "], [HTTPS port=" + httpsPort + "]"
+                        + " [attempt=" + (attempt + 1) + "/" + maxRetries + "]");
+                try {
+                    Thread.sleep(200);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    break;
+                }
+            }
         }
 
         String msg = "Cannot start REST endpoint."
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
index 2f281303637c..5c181caf482e 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/IgniteImpl.java
@@ -498,7 +498,8 @@ private RestComponent createRestComponent(String name) {
                 () -> joinFuture
         );
         JdbcPortProvider jdbcPortProvider = diContext.getBean(JdbcPortProvider.class);
-        Supplier<RestFactory> nodeManagementRestFactory = () -> new NodeManagementRestFactory(lifecycleManager, () -> name, jdbcPortProvider);
+        Supplier<RestFactory> nodeManagementRestFactory =
+                () -> new NodeManagementRestFactory(lifecycleManager, () -> name, jdbcPortProvider);
         Supplier<RestFactory> metricRestFactory = () -> new MetricRestFactory(metricManager, metricMessaging);
         Supplier<RestFactory> authProviderFactory = () -> new AuthenticationProviderFactory(authenticationManager);
         Supplier<RestFactory> deploymentCodeRestFactory =
@@ -802,7 +803,13 @@ public CompletableFuture<Void> stopAsync() {
         // Stop ALL components in reverse start order. The componentLifecycleManager tracks both
         // DI-managed and manually-started components (via markAsStarted) in the correct order.
         componentLifecycleManager.stopAll(componentContext)
-                .thenRunAsync(diContext::close)
+                .whenCompleteAsync((res, ex) -> {
+                    try {
+                        diContext.close();
+                    } catch (Exception e) {
+                        LOG.warn("Failed to close DI context", e);
+                    }
+                })
                 // Moving to the common pool on purpose to close the stop pool and proceed user's code in the common pool.
                 .whenCompleteAsync((res, ex) -> lifecycleExecutor.shutdownNow())
                 .whenCompleteAsync(copyStateTo(stopFuture));
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
index cdb48b2c8790..c34cb3d49099 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/CatalogFactory.java
@@ -24,10 +24,7 @@
 import jakarta.inject.Singleton;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
-import org.apache.ignite.internal.catalog.CatalogManagerImpl;
-import org.apache.ignite.internal.catalog.PartitionCountCalculatorWrapper;
 import org.apache.ignite.internal.catalog.configuration.SchemaSynchronizationConfiguration;
-import org.apache.ignite.internal.catalog.storage.UpdateLogImpl;
 import org.apache.ignite.internal.cluster.management.ClusterManagementGroupManager;
 import org.apache.ignite.internal.cluster.management.topology.api.LogicalTopologyService;
 import org.apache.ignite.internal.components.IgniteStartupPhase;
@@ -101,28 +98,6 @@ public IdempotentCacheVacuumizer idempotentCacheVacuumizer(
         );
     }
 
-    /** Creates the catalog manager. UpdateLogImpl is created inline because its lifecycle is managed by CatalogManagerImpl. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_2)
-    @Order(100)
-    public CatalogManagerImpl catalogManager(
-            MetaStorageManager metaStorageManager,
-            ClockService clockService,
-            FailureManager failureManager,
-            SchemaSynchronizationConfiguration schemaSyncConfig,
-            PartitionCountCalculatorWrapper partitionCountCalculatorWrapper
-    ) {
-        UpdateLogImpl updateLog = new UpdateLogImpl(metaStorageManager, failureManager);
-
-        return new CatalogManagerImpl(
-                updateLog,
-                clockService,
-                failureManager,
-                () -> schemaSyncConfig.delayDurationMillis().value(),
-                partitionCountCalculatorWrapper
-        );
-    }
-
     /** Creates the placement driver manager. */
     @Singleton
     @IgniteStartupPhase(StartupPhase.PHASE_2)
diff --git a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
index 5ae71f855ed1..1d998d4f8111 100644
--- a/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
+++ b/modules/runner/src/main/java/org/apache/ignite/internal/app/di/ClusterManagementFactory.java
@@ -18,70 +18,26 @@
 package org.apache.ignite.internal.app.di;
 
 import io.micronaut.context.annotation.Factory;
-import io.micronaut.core.annotation.Order;
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesConfiguration;
 import org.apache.ignite.internal.cluster.management.configuration.NodeAttributesExtensionConfiguration;
-import org.apache.ignite.internal.components.IgniteStartupPhase;
-import org.apache.ignite.internal.components.NodeIdentity;
-import org.apache.ignite.internal.components.StartupPhase;
 import org.apache.ignite.internal.configuration.ConfigurationModules;
 import org.apache.ignite.internal.configuration.ConfigurationRegistry;
 import org.apache.ignite.internal.configuration.ConfigurationTreeGenerator;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidator;
 import org.apache.ignite.internal.configuration.validation.ConfigurationValidatorImpl;
-import org.apache.ignite.internal.disaster.system.ClusterIdService;
-import org.apache.ignite.internal.failure.FailureManager;
-import org.apache.ignite.internal.metrics.MetricManager;
-import org.apache.ignite.internal.network.ChannelTypeRegistryProvider;
 import org.apache.ignite.internal.network.ClusterService;
 import org.apache.ignite.internal.network.MessagingService;
-import org.apache.ignite.internal.network.NettyBootstrapFactory;
 import org.apache.ignite.internal.network.TopologyService;
-import org.apache.ignite.internal.network.configuration.NetworkConfiguration;
-import org.apache.ignite.internal.network.recovery.InMemoryStaleIds;
-import org.apache.ignite.internal.network.scalecube.ScaleCubeClusterService;
-import org.apache.ignite.internal.network.serialization.MessageSerializationRegistry;
 import org.apache.ignite.internal.storage.configurations.StorageConfiguration;
 import org.apache.ignite.internal.storage.configurations.StorageExtensionConfiguration;
-import org.apache.ignite.internal.version.DefaultIgniteProductVersionSource;
-import org.apache.ignite.internal.worker.CriticalWorkerRegistry;
 
 /**
  * Micronaut factory for cluster management components.
  */
 @Factory
 public class ClusterManagementFactory {
-    /** Creates the cluster service. */
-    @Singleton
-    @IgniteStartupPhase(StartupPhase.PHASE_1)
-    @Order(1300)
-    public ClusterService clusterService(
-            NodeIdentity nodeIdentity,
-            NetworkConfiguration networkConfiguration,
-            NettyBootstrapFactory nettyBootstrapFactory,
-            MessageSerializationRegistry serializationRegistry,
-            ClusterIdService clusterIdService,
-            CriticalWorkerRegistry criticalWorkerRegistry,
-            FailureManager failureManager,
-            MetricManager metricManager
-    ) {
-        return new ScaleCubeClusterService(
-                nodeIdentity.nodeName(),
-                networkConfiguration,
-                nettyBootstrapFactory,
-                serializationRegistry,
-                new InMemoryStaleIds(),
-                clusterIdService,
-                criticalWorkerRegistry,
-                failureManager,
-                ChannelTypeRegistryProvider.loadByServiceLoader(nodeIdentity.serviceProviderClassLoader()),
-                new DefaultIgniteProductVersionSource(),
-                metricManager
-        );
-    }
-
     /** Exposes the cluster messaging service as a named bean. */
     @Singleton
     @Named("clusterMessaging")