chore(MP-23): network DI client, frontend architecture guards, detekt & ktlint setup, docs, ping DI factory (#21)

* chore(MP-21): snapshot pre-refactor state (Epic 1) * chore(MP-22): scaffold new repo structure, relocate Docker Compose, move frontend/backend modules, update Makefile; add docs mapping and env template * MP-22 Epic 2: Erfolgreich umgesetzt und verifiziert * MP-23 Epic 3: Gradle/Build Governance zentralisieren
2025-11-30 23:14:00 +01:00
parent 89bbd42245
commit 034892e890
101 changed files with 857 additions and 407 deletions
@@ -0,0 +1,40 @@
+package at.mocode.ping.service
+
+import at.mocode.ping.api.EnhancedPingResponse
+import at.mocode.ping.api.HealthResponse
+import at.mocode.ping.api.PingApi
+import at.mocode.ping.api.PingResponse
+import org.springframework.web.bind.annotation.*
+import java.time.OffsetDateTime
+import java.time.format.DateTimeFormatter
+
+@RestController
+@CrossOrigin(
+    origins = ["http://localhost:8080", "http://localhost:8083", "http://localhost:4000"],
+    methods = [RequestMethod.GET, RequestMethod.POST, RequestMethod.PUT, RequestMethod.DELETE, RequestMethod.OPTIONS],
+    allowedHeaders = ["*"],
+    allowCredentials = "true"
+)
+class PingController(
+    private val pingService: PingServiceCircuitBreaker
+) : PingApi {
+
+    // Contract endpoints
+    @GetMapping("/ping/simple")
+    override suspend fun simplePing(): PingResponse {
+        val now = OffsetDateTime.now().format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)
+        return PingResponse(
+            status = "pong",
+            timestamp = now,
+            service = "ping-service"
+        )
+    }
+
+    @GetMapping("/ping/enhanced")
+    override suspend fun enhancedPing(
+        @RequestParam(required = false, defaultValue = "false") simulate: Boolean
+    ): EnhancedPingResponse = pingService.ping(simulate)
+
+    @GetMapping("/ping/health")
+    override suspend fun healthCheck(): HealthResponse = pingService.healthCheck()
+}
@@ -0,0 +1,35 @@
+package at.mocode.ping.service
+
+import org.springframework.boot.autoconfigure.SpringBootApplication
+import org.springframework.boot.runApplication
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.EnableAspectJAutoProxy
+import org.springframework.web.servlet.config.annotation.CorsRegistry
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
+
+@SpringBootApplication
+@EnableAspectJAutoProxy
+class PingServiceApplication {
+
+    @Bean
+    fun corsConfigurer(): WebMvcConfigurer {
+        return object : WebMvcConfigurer {
+            override fun addCorsMappings(registry: CorsRegistry) {
+                registry.addMapping("/**")
+                    .allowedOriginPatterns("http://localhost:*")
+                    .allowedOrigins("http://localhost:8080",
+                        "http://localhost:8083",
+                        "http://localhost:4000"
+                    )
+                    .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
+                    .allowedHeaders("*")
+                    .allowCredentials(true)
+                    .maxAge(3600)
+            }
+        }
+    }
+}
+
+fun main(args: Array<String>) {
+    runApplication<PingServiceApplication>(*args)
+}
@@ -0,0 +1,109 @@
+package at.mocode.ping.service
+
+import at.mocode.ping.api.EnhancedPingResponse
+import at.mocode.ping.api.HealthResponse
+import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import kotlin.random.Random
+
+/**
+ * Service demonstrating a Circuit Breaker pattern with Resilience
+ *
+ * This service simulates potential failures and uses circuit breaker
+ * to handle service degradation gracefully with fallback responses.
+ */
+@Service
+class PingServiceCircuitBreaker {
+
+    private val logger = LoggerFactory.getLogger(PingServiceCircuitBreaker::class.java)
+
+    companion object {
+        const val PING_CIRCUIT_BREAKER = "pingCircuitBreaker"
+        private val formatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME //.ofPattern("yyyy-MM-dd HH:mm:ss")
+    }
+
+    /**
+     * Primary ping method with circuit breaker protection returning DTO directly
+     *
+     * @param simulateFailure - if true, randomly throws exceptions to test circuit breaker
+     */
+    @CircuitBreaker(name = PING_CIRCUIT_BREAKER, fallbackMethod = "fallbackPing")
+    fun ping(simulateFailure: Boolean = false): EnhancedPingResponse {
+        val start = System.nanoTime()
+        logger.info("Executing ping service call...")
+
+        if (simulateFailure && Random.nextDouble() < 0.6) {
+            logger.warn("Simulating service failure for circuit breaker testing")
+            throw RuntimeException("Simulated service failure")
+        }
+
+        val currentTime = LocalDateTime.now().atOffset(java.time.ZoneOffset.UTC).format(formatter)
+        val elapsedMs = (System.nanoTime() - start) / 1_000_000
+        logger.info("Ping service call successful")
+
+        return EnhancedPingResponse(
+            status = "pong",
+            timestamp = currentTime,
+            service = "ping-service",
+            circuitBreakerState = "CLOSED",
+            responseTime = elapsedMs
+        )
+    }
+
+    /**
+     * Fallback method called when circuit breaker is OPEN
+     *
+     * @param simulateFailure - original parameter (ignored in fallback)
+     * @param exception - the exception that triggered the fallback
+     */
+    fun fallbackPing(simulateFailure: Boolean = false, exception: Exception): EnhancedPingResponse {
+        val start = System.nanoTime()
+        // Die volle Exception nur loggen, nicht an den Client weitergeben.
+        logger.warn("Circuit breaker fallback triggered due to: {}", exception.toString())
+
+        val currentTime = LocalDateTime.now().atOffset(java.time.ZoneOffset.UTC).format(formatter)
+        val elapsedMs = (System.nanoTime() - start) / 1_000_000
+
+        return EnhancedPingResponse(
+            status = "fallback",
+            timestamp = currentTime,
+            service = "ping-service-fallback",
+            circuitBreakerState = "OPEN",
+            responseTime = elapsedMs
+        )
+    }
+
+    /**
+     * Health check method with circuit breaker protection returning DTO directly
+     */
+    @CircuitBreaker(name = PING_CIRCUIT_BREAKER, fallbackMethod = "fallbackHealth")
+    fun healthCheck(): HealthResponse {
+        logger.info("Executing health check...")
+
+        val currentTime = LocalDateTime.now().atOffset(java.time.ZoneOffset.UTC).format(formatter)
+        return HealthResponse(
+            status = "pong",
+            timestamp = currentTime,
+            service = "ping-service",
+            healthy = true
+        )
+    }
+
+    /**
+     * Fallback for health check returning DTO
+     */
+    fun fallbackHealth(exception: Exception): HealthResponse {
+        logger.warn("Health check fallback triggered: {}", exception.message)
+
+        val currentTime = LocalDateTime.now().atOffset(java.time.ZoneOffset.UTC).format(formatter)
+        return HealthResponse(
+            status = "down",
+            timestamp = currentTime,
+            service = "ping-service",
+            healthy = false
+        )
+    }
+}
@@ -0,0 +1,36 @@
+package at.mocode.ping.service.config
+
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity
+import org.springframework.security.config.annotation.web.builders.HttpSecurity
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity
+import org.springframework.security.config.http.SessionCreationPolicy
+import org.springframework.security.web.SecurityFilterChain
+
+/**
+ * Security configuration for the Ping Service.
+ * Enables method-level security for fine-grained authorization control.
+ */
+@Configuration
+@EnableWebSecurity
+@EnableMethodSecurity(prePostEnabled = true)
+class SecurityConfiguration {
+
+    @Bean
+    fun securityFilterChain(http: HttpSecurity): SecurityFilterChain {
+        return http
+            .csrf { it.disable() }
+            .sessionManagement { it.sessionCreationPolicy(SessionCreationPolicy.STATELESS) }
+            .authorizeHttpRequests { auth ->
+                auth
+                    // Allow health check endpoints
+                    .requestMatchers("/actuator/**", "/health/**").permitAll()
+                    // Allow ping endpoints for monitoring (these are typically public)
+                    .requestMatchers("/ping/**").permitAll()
+                    // All other endpoints require authentication (handled by method-level security)
+                    .anyRequest().authenticated()
+            }
+            .build()
+    }
+}
@@ -0,0 +1,73 @@
+spring:
+  application:
+    name: ping-service
+  cloud:
+    consul:
+      host: ${CONSUL_HOST:localhost}
+      port: ${CONSUL_PORT:8500}
+      discovery:
+        enabled: true
+        register: true
+        health-check-path: /actuator/health
+        health-check-interval: 10s
+
+server:
+  port: ${SERVER_PORT:${PING_SERVICE_PORT:8082}}
+
+management:
+  endpoints:
+    web:
+      exposure:
+        include: health,info,metrics,prometheus,circuitbreakers
+  endpoint:
+    health:
+      show-details: always
+      probes:
+        enabled: true
+  tracing:
+    # Disable tracing by default to avoid Zipkin connection errors
+    enabled: ${TRACING_ENABLED:false}
+    sampling:
+      probability: ${TRACING_SAMPLING_PROBABILITY:0.1}
+  zipkin:
+    tracing:
+      # Only configure endpoint if tracing is explicitly enabled
+      endpoint: ${ZIPKIN_TRACING_ENDPOINT:http://localhost:9411/api/v2/spans}
+      # Configure timeout and connection settings to handle missing Zipkin gracefully
+      connect-timeout: 1s
+      read-timeout: 5s
+
+# Resilience4j Circuit Breaker Configuration
+resilience4j:
+  circuitbreaker:
+    configs:
+      default:
+        # Circuit breaker opens when the failure rate exceeds 50%
+        failure-rate-threshold: 50
+        # Minimum number of calls to calculate the failure rate
+        minimum-number-of-calls: 5
+        # Time to wait before transitioning from OPEN to HALF_OPEN
+        wait-duration-in-open-state: 10s
+        # Number of calls in HALF_OPEN state before deciding to close/open
+        permitted-number-of-calls-in-half-open-state: 3
+        # Sliding window size for calculating failure rate
+        sliding-window-size: 10
+        # Type of sliding window (COUNT_BASED or TIME_BASED)
+        sliding-window-type: COUNT_BASED
+        # Record exceptions that should be considered as failures
+        record-exceptions:
+          - java.lang.Exception
+        # Ignore certain exceptions (don't count as failures)
+        ignore-exceptions:
+          - java.lang.IllegalArgumentException
+    instances:
+      pingCircuitBreaker:
+        # Use default configuration
+        base-config: default
+        # Override specific settings for this instance if needed
+        failure-rate-threshold: 60
+        minimum-number-of-calls: 4
+        wait-duration-in-open-state: 5s
+
+  # Metrics configuration removed to avoid property resolution warnings
+  # Use micrometer and actuator endpoints for metrics instead
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <property name="LOG_PATTERN" value="%d{ISO8601} %-5level [%X{traceId:-}:%X{spanId:-}] %logger{36} - %msg%n"/>
+
+    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>${LOG_PATTERN}</pattern>
+        </encoder>
+    </appender>
+
+    <logger name="org.springframework" level="INFO"/>
+    <logger name="org.springframework.web" level="INFO"/>
+    <logger name="org.springframework.boot.actuate" level="INFO"/>
+    <logger name="reactor.netty" level="WARN"/>
+
+    <root level="INFO">
+        <appender-ref ref="CONSOLE"/>
+    </root>
+</configuration>