feat: Add Dagger for Dependency Injection Framework

buildSrc/src/main/kotlin/com.hedera.block.jpms-modules.gradle.kts

@@ -49,6 +49,13 @@ jvmDependencyConflicts.patch {
     module("io.grpc:grpc-stub") { annotationLibraries.forEach { removeDependency(it) } }
     module("io.grpc:grpc-testing") { annotationLibraries.forEach { removeDependency(it) } }
     module("io.grpc:grpc-util") { annotationLibraries.forEach { removeDependency(it) } }
+    module("com.google.dagger:dagger-compiler") {
+        annotationLibraries.forEach { removeDependency(it) }
+    }
+    module("com.google.dagger:dagger-producers") {
+        annotationLibraries.forEach { removeDependency(it) }
+    }
+    module("com.google.dagger:dagger-spi") { annotationLibraries.forEach { removeDependency(it) } }
     module("com.google.guava:guava") {
         (annotationLibraries -
                 "com.google.code.findbugs:jsr305" -
@@ -63,6 +70,9 @@ jvmDependencyConflicts.patch {
         removeDependency("io.prometheus:simpleclient_tracer_otel")
         removeDependency("io.prometheus:simpleclient_tracer_otel_agent")
     }
+    module("org.jetbrains.kotlin:kotlin-stdlib") {
+        removeDependency("org.jetbrains.kotlin:kotlin-stdlib-common")
+    }
     module("junit:junit") { removeDependency("org.hamcrest:hamcrest-core") }
     module("org.hyperledger.besu:secp256k1") { addApiDependency("net.java.dev.jna:jna") }
 }
@@ -110,7 +120,7 @@ extraJavaModuleInfo {
     }
     module("com.google.guava:failureaccess", "com.google.common.util.concurrent.internal")
     module("com.google.api.grpc:proto-google-common-protos", "com.google.api.grpc.common")
-
+    module("com.google.dagger:dagger", "dagger")
     module("io.perfmark:perfmark-api", "io.perfmark")
     module("javax.inject:javax.inject", "javax.inject")
 
@@ -121,6 +131,7 @@ extraJavaModuleInfo {
 
     module("org.checkerframework:checker-qual", "org.checkerframework.checker.qual")
     module("net.i2p.crypto:eddsa", "net.i2p.crypto.eddsa")
+    module("org.jetbrains:annotations", "org.jetbrains.annotations")
     module("org.antlr:antlr4-runtime", "org.antlr.antlr4.runtime")
 
     // needed for metrics and logging, but also several platform classes
@@ -143,9 +154,24 @@ extraJavaModuleInfo {
     module("com.google.auto.service:auto-service-annotations", "com.google.auto.service")
     module("com.google.auto.service:auto-service", "com.google.auto.service.processor")
     module("com.google.auto:auto-common", "com.google.auto.common")
+    module("com.google.dagger:dagger-compiler", "dagger.compiler")
+    module("com.google.dagger:dagger-producers", "dagger.producers")
+    module("com.google.dagger:dagger-spi", "dagger.spi")
+    module(
+        "com.google.devtools.ksp:symbol-processing-api",
+        "com.google.devtools.ksp.symbolprocessingapi"
+    )
+    module("com.google.errorprone:javac-shaded", "com.google.errorprone.javac.shaded")
+    module("com.google.googlejavaformat:google-java-format", "com.google.googlejavaformat")
+    module("net.ltgt.gradle.incap:incap", "net.ltgt.gradle.incap")
+    module("org.jetbrains.kotlinx:kotlinx-metadata-jvm", "kotlinx.metadata.jvm")
 
     // Test clients only
     module("com.google.protobuf:protobuf-java-util", "com.google.protobuf.util")
+    module("com.squareup:javapoet", "com.squareup.javapoet") {
+        exportAllPackages()
+        requires("java.compiler")
+    }
     module("junit:junit", "junit")
     module("org.hamcrest:hamcrest", "org.hamcrest")
     module("org.json:json", "org.json")

gradle/modules.properties

@@ -32,3 +32,10 @@ org.apache.commons.compress=org.apache.commons:commons-compress
 
 java.annotation=javax.annotation:javax.annotation-api
 org.apache.logging.log4j.slf4j2.impl=org.apache.logging.log4j:log4j-slf4j2-impl
+
+grpc.protobuf=io.grpc:grpc-protobuf
+dagger=com.google.dagger:dagger
+dagger.compiler=com.google.dagger:dagger-compiler
+com.squareup.javapoet=com.squareup:javapoet
+javax.inject=javax.inject:javax.inject
+org.checkerframework.checker.qual=org.checkerframework:checker-qual

server/build.gradle.kts

@@ -25,6 +25,7 @@ application {
 }
 
 mainModuleInfo {
+    annotationProcessor("dagger.compiler")
     annotationProcessor("com.google.auto.service.processor")
     runtimeOnly("com.swirlds.config.impl")
     runtimeOnly("org.apache.logging.log4j.slf4j2.impl")

server/src/main/java/com/hedera/block/server/BlockNodeApp.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2024 Hedera Hashgraph, LLC
+ *
+ * Licensed 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 com.hedera.block.server;
+
+import static java.lang.System.Logger;
+import static java.lang.System.Logger.Level.INFO;
+
+import com.hedera.block.server.config.BlockNodeContext;
+import com.hedera.block.server.data.ObjectEvent;
+import com.hedera.block.server.health.HealthService;
+import com.hedera.block.server.mediator.LiveStreamMediatorBuilder;
+import com.hedera.block.server.mediator.StreamMediator;
+import com.hedera.block.server.persistence.storage.PersistenceStorageConfig;
+import com.hedera.block.server.persistence.storage.read.BlockAsDirReaderBuilder;
+import com.hedera.block.server.persistence.storage.read.BlockReader;
+import com.hedera.block.server.persistence.storage.write.BlockAsDirWriterBuilder;
+import com.hedera.block.server.persistence.storage.write.BlockWriter;
+import com.hedera.hapi.block.SubscribeStreamResponse;
+import com.hedera.hapi.block.stream.Block;
+import com.hedera.hapi.block.stream.BlockItem;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import io.helidon.webserver.WebServer;
+import io.helidon.webserver.grpc.GrpcRouting;
+import io.helidon.webserver.http.HttpRouting;
+import java.io.IOException;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+/**
+ * The main class for the Block Node application. This class is responsible for starting the server
+ * and initializing the context.
+ */
+@Singleton
+public class BlockNodeApp {
+
+    private static final Logger LOGGER = System.getLogger(BlockNodeApp.class.getName());
+
+    private final ServiceStatus serviceStatus;
+    private final HealthService healthService;
+    private final BlockNodeContext blockNodeContext;
+
+    /**
+     * Has all needed dependencies to start the server and initialize the context.
+     *
+     * @param serviceStatus the status of the service
+     * @param healthService the health service
+     * @param blockNodeContext the context of the block node
+     */
+    @Inject
+    public BlockNodeApp(
+            @NonNull ServiceStatus serviceStatus,
+            @NonNull HealthService healthService,
+            @NonNull BlockNodeContext blockNodeContext) {
+        this.serviceStatus = serviceStatus;
+        this.healthService = healthService;
+        this.blockNodeContext = blockNodeContext;
+    }
+
+    /**
+     * Starts the server and binds to the specified port.
+     *
+     * @throws IOException if the server cannot be started
+     */
+    public void start() throws IOException {
+
+        final BlockWriter<BlockItem> blockWriter =
+                BlockAsDirWriterBuilder.newBuilder(blockNodeContext).build();
+        final StreamMediator<BlockItem, ObjectEvent<SubscribeStreamResponse>> streamMediator =
+                LiveStreamMediatorBuilder.newBuilder(blockWriter, blockNodeContext, serviceStatus)
+                        .build();
+
+        final BlockReader<Block> blockReader =
+                BlockAsDirReaderBuilder.newBuilder(
+                                blockNodeContext
+                                        .configuration()
+                                        .getConfigData(PersistenceStorageConfig.class))
+                        .build();
+
+        final BlockStreamService blockStreamService =
+                buildBlockStreamService(
+                        streamMediator, blockReader, serviceStatus, blockNodeContext);
+
+        final GrpcRouting.Builder grpcRouting = GrpcRouting.builder().service(blockStreamService);
+
+        final HttpRouting.Builder httpRouting =
+                HttpRouting.builder().register(healthService.getHealthRootPath(), healthService);
+
+        // Build the web server
+        // TODO: make port server a configurable value.
+        final WebServer webServer =
+                WebServer.builder()
+                        .port(8080)
+                        .addRouting(grpcRouting)
+                        .addRouting(httpRouting)
+                        .build();
+
+        // Update the serviceStatus with the web server
+        serviceStatus.setWebServer(webServer);
+
+        // Start the web server
+        webServer.start();
+
+        // Log the server status
+        LOGGER.log(INFO, String.format("Block Node Server started at port: %d", webServer.port()));
+    }
+
+    @NonNull
+    private static BlockStreamService buildBlockStreamService(
+            @NonNull
+                    final StreamMediator<BlockItem, ObjectEvent<SubscribeStreamResponse>>
+                            streamMediator,
+            @NonNull final BlockReader<Block> blockReader,
+            @NonNull final ServiceStatus serviceStatus,
+            @NonNull final BlockNodeContext blockNodeContext) {
+
+        return new BlockStreamService(streamMediator, blockReader, serviceStatus, blockNodeContext);
+    }
+}

server/src/main/java/com/hedera/block/server/BlockNodeAppInjectionComponent.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2024 Hedera Hashgraph, LLC
+ *
+ * Licensed 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 com.hedera.block.server;
+
+import com.hedera.block.server.health.HealthInjectionModule;
+import dagger.Component;
+import javax.inject.Singleton;
+
+/** The infrastructure used to manage the instances and inject them using Dagger */
+@Singleton
+@Component(
+        modules = {
+            BlockNodeAppInjectionModule.class,
+            HealthInjectionModule.class,
+        })
+public interface BlockNodeAppInjectionComponent {
+    /**
+     * Get the block node app server.
+     *
+     * @return the block node app server
+     */
+    BlockNodeApp getBlockNodeApp();
+}

server/src/main/java/com/hedera/block/server/BlockNodeAppInjectionModule.java

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2024 Hedera Hashgraph, LLC
+ *
+ * Licensed 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 com.hedera.block.server;
+
+import com.hedera.block.server.config.BlockNodeContext;
+import com.hedera.block.server.config.BlockNodeContextFactory;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import java.io.IOException;
+import javax.inject.Singleton;
+
+/**
+ * A Dagger Module for interfaces that are at the BlockNodeApp Level, should be temporary and
+ * everything should be inside its own modules.
+ */
+@Module
+public interface BlockNodeAppInjectionModule {
+
+    /**
+     * Binds the service status to the service status implementation.
+     *
+     * @param serviceStatus needs a service status implementation
+     * @return the service status implementation
+     */
+    @Singleton
+    @Binds
+    ServiceStatus bindServiceStatus(ServiceStatusImpl serviceStatus);
+
+    /**
+     * Provides a block node context singleton using the factory.
+     *
+     * @return a block node context singleton
+     */
+    @Provides
+    @Singleton
+    static BlockNodeContext provideBlockNodeContext() {
+        try {
+            return BlockNodeContextFactory.create();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}