Revert "fix: Remove kafka"

This reverts commit 0082305a5a.

.drone.yml

@@ -118,10 +118,13 @@ steps:
       - ssh-keyscan -H git.2martens.de > $HOME/.ssh/known_hosts 2>/dev/null
       - git clone ssh://giteajim@git.2martens.de:22/2martens/cloud-configuration.git .
       - git checkout main
-  - name: modify deployed image
+  - name: update image version
     image: alpine
     commands:
-      - sed -i -r "s/(wahlrecht_image_version:).*/\1\ ${DRONE_SEMVER}/" ansible/inventories/host_vars/api-server/public.yaml
+      - mkdir $HOME/bin
+      - wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_arm64 -O $HOME/bin/yq && chmod +x $HOME/bin/yq
+      - sed -i -r "s/(tag:).*/\1\ \"${DRONE_SEMVER}\"/" argocd/wahlrecht/${DRONE_DEPLOY_TO}/overwrite_values.yaml
+      - cd argocd/wahlrecht/${DRONE_DEPLOY_TO} && $HOME/bin/yq '. *= load("overwrite_values.yaml")' default_values.yaml > values.yaml
   - name: save modified variable file
     image: alpine/git
     environment:
@@ -134,32 +137,13 @@ steps:
       - touch $HOME/.ssh/known_hosts
       - chmod 600 $HOME/.ssh/known_hosts
       - ssh-keyscan -H git.2martens.de > $HOME/.ssh/known_hosts 2>/dev/null
-      - git add ansible/inventories/host_vars/api-server/public.yaml
+      - git add argocd/wahlrecht/${DRONE_DEPLOY_TO}/*
       - git diff-index --quiet HEAD || git commit -m "[Drone] Changed wahlrecht_image_version to ${DRONE_SEMVER}"
       - git push origin main
-  - name: deploy image
-    image: plugins/ansible:latest
-    volumes:
-      - name: cache
-        path: /root/.ansible
-    settings:
-      playbook: ansible/deploy_spring.yaml
-      inventory: ansible/inventories/production
-      galaxy: ansible/requirements.yaml
-      galaxy_force: false
-      private_key:
-        from_secret: private_ssh_key
-      vault_password:
-        from_secret: vault_password
-
-volumes:
-  - name: cache
-    host:
-      path: /var/lib/drone/cache/.ansible
 
 trigger:
   target:
-    - production
+    - test
   event:
     include:
       - promote

gradle/libs.versions.toml

@@ -1,21 +1,21 @@
 [versions]
-spring-boot = "3.1.2"
+spring-boot = "3.2.3"
-spring-doc = "2.1.0"
+spring-doc = "2.3.0"
-spring-cloud = "2022.0.4"
+spring-cloud = "2023.0.0"
 spring-grpc = "2.14.0.RELEASE"
 grpc = "1.57.0"
 tomcat-annotations = "6.0.53"
-httpclient = "5.2.1"
+httpclient = "5.3.1"
-slf4j = "2.0.7"
+slf4j = "2.0.12"
-log4j = "2.20.0"
+log4j = "2.23.0"
-log4j-ecs = "1.5.0"
+log4j-ecs = "1.6.0"
 mapstruct = "1.5.5.Final"
-junit = "5.10.0"
+junit = "5.10.2"
-assertj = "3.24.2"
+assertj = "3.25.3"
-mockito = "5.4.0"
+mockito = "5.11.0"
-keycloak = "22.0.1"
+keycloak = "24.0.1"
 kotlin-logging = "3.0.5"
-kotlin-reflect = "1.9.0"
+kotlin-reflect = "1.9.22"
 kotlin-lombok = "1.9.0"
 plugin-nebula-release = "17.2.2"
 plugin-lombok = "8.0.1"

module-server/src/main/kotlin/de/twomartens/wahlrecht/configuration/KafkaConfiguration.kt

@@ -1,20 +0,0 @@
-package de.twomartens.wahlrecht.configuration
-
-import org.apache.kafka.clients.admin.AdminClientConfig
-import org.springframework.beans.factory.annotation.Value
-import org.springframework.context.annotation.Bean
-import org.springframework.context.annotation.Configuration
-import org.springframework.kafka.core.KafkaAdmin
-
-@Configuration
-open class KafkaConfiguration {
-  @Value(value = "\${spring.kafka.bootstrap-servers[0]}")
-  private val bootstrapServers: List<String> = mutableListOf()
-
-  @Bean
-  open fun kafkaAdmin(): KafkaAdmin {
-    val configs: MutableMap<String, Any?> = HashMap()
-    configs[AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG] = bootstrapServers.first()
-    return KafkaAdmin(configs)
-  }
-}

module-server/src/main/kotlin/de/twomartens/wahlrecht/security/SpringPolicyEnforcer.kt

@@ -13,53 +13,54 @@ import org.keycloak.representations.idm.authorization.Permission
 class SpringPolicyEnforcer(private val policyEnforcer: PolicyEnforcer,
                            private val policyEnforcerConfig: PolicyEnforcerConfig) {
 
-    fun enforce(request: HttpRequest, response: HttpResponse): AuthorizationContext {
+  fun enforce(request: HttpRequest, response: HttpResponse): AuthorizationContext {
-        if (log.isDebugEnabled) {
+    if (log.isDebugEnabled) {
-            log.debug("Policy enforcement is enabled. Enforcing policy decisions for path [{}].", request.uri)
+      log.debug("Policy enforcement is enabled. Enforcing policy decisions for path [{}].", request.uri)
-        }
-        val context = authorize(request, response)
-        if (log.isDebugEnabled) {
-            log.debug("Policy enforcement result for path [{}] is : {}", request.uri, if (context.isGranted) "GRANTED" else "DENIED")
-            log.debug("Returning authorization context with permissions:")
-            for (permission in context.permissions) {
-                log.debug(permission.toString())
-            }
-        }
-        return context
     }
-
+    val context = authorize(request, response)
-    private fun authorize(request: HttpRequest, response: HttpResponse): AuthorizationContext {
+    if (log.isDebugEnabled) {
-        val enforcementMode = policyEnforcerConfig.enforcementMode
+      log.debug("Policy enforcement result for path [{}] is : {}", request.uri, if (context.isGranted) "GRANTED" else "DENIED")
-        return if (EnforcementMode.DISABLED == enforcementMode) {
+      log.debug("Returning authorization context with permissions:")
-            createAuthorizedContext()
+      for (permission in context.permissions) {
-        } else policyEnforcer.enforce(request, response)
+        log.debug(permission.toString())
+      }
     }
+    return context
+  }
 
-    private fun createAuthorizedContext(): AuthorizationContext {
+  private fun authorize(request: HttpRequest, response: HttpResponse): AuthorizationContext {
-        return object : ClientAuthorizationContext(policyEnforcer.authzClient) {
+    val enforcementMode = policyEnforcerConfig.enforcementMode
-            override fun hasPermission(resourceName: String, scopeName: String): Boolean {
+    log.debug("Authorize with enforcement mode: [{}]", enforcementMode)
-                return true
+    return if (EnforcementMode.DISABLED == enforcementMode) {
-            }
+      createAuthorizedContext()
+    } else policyEnforcer.enforce(request, response)
+  }
 
-            override fun hasResourcePermission(resourceName: String): Boolean {
+  private fun createAuthorizedContext(): AuthorizationContext {
-                return true
+    return object : ClientAuthorizationContext(policyEnforcer.authzClient) {
-            }
+      override fun hasPermission(resourceName: String, scopeName: String): Boolean {
+        return true
+      }
 
-            override fun hasScopePermission(scopeName: String): Boolean {
+      override fun hasResourcePermission(resourceName: String): Boolean {
-                return true
+        return true
-            }
+      }
 
-            override fun getPermissions(): List<Permission> {
+      override fun hasScopePermission(scopeName: String): Boolean {
-                return emptyList()
+        return true
-            }
+      }
 
-            override fun isGranted(): Boolean {
+      override fun getPermissions(): List<Permission> {
-                return true
+        return emptyList()
-            }
+      }
-        }
+
+      override fun isGranted(): Boolean {
+        return true
+      }
     }
+  }
 
-    companion object {
+  companion object {
-        private val log = KotlinLogging.logger {}
+    private val log = KotlinLogging.logger {}
-    }
+  }
 }

module-server/src/main/kotlin/de/twomartens/wahlrecht/security/SpringPolicyEnforcerFilter.kt

@@ -12,18 +12,15 @@ import org.keycloak.adapters.authorization.spi.ConfigurationResolver
 import org.keycloak.adapters.authorization.spi.HttpRequest
 import org.keycloak.representations.adapters.config.PolicyEnforcerConfig
 import java.io.IOException
-import java.util.concurrent.ConcurrentHashMap
 
 
 class SpringPolicyEnforcerFilter(private val configResolver: ConfigurationResolver) : Filter {
-    private val policyEnforcer: MutableMap<PolicyEnforcerConfig, SpringPolicyEnforcer> = ConcurrentHashMap()
-
     @Throws(IOException::class, ServletException::class)
     override fun doFilter(servletRequest: ServletRequest, servletResponse: ServletResponse?, filterChain: FilterChain) {
         val request = servletRequest as HttpServletRequest
         val response = servletResponse as HttpServletResponse?
         val httpRequest = ServletHttpRequest(request) { extractBearerToken(request) }
-        val policyEnforcer = getOrCreatePolicyEnforcer(httpRequest)
+        val policyEnforcer = createPolicyEnforcer(httpRequest)
         val authzContext = policyEnforcer.enforce(httpRequest, ServletHttpResponse(response))
         request.setAttribute(AuthorizationContext::class.java.name, authzContext)
         if (authzContext.isGranted) {
@@ -53,8 +50,8 @@ class SpringPolicyEnforcerFilter(private val configResolver: ConfigurationResolv
         return null
     }
 
-    private fun getOrCreatePolicyEnforcer(request: HttpRequest): SpringPolicyEnforcer {
+    private fun createPolicyEnforcer(request: HttpRequest): SpringPolicyEnforcer {
-        return policyEnforcer.computeIfAbsent(configResolver.resolve(request)) { createPolicyEnforcer(it) }
+        return createPolicyEnforcer(configResolver.resolve(request))
     }
 
     private fun createPolicyEnforcer(enforcerConfig: PolicyEnforcerConfig): SpringPolicyEnforcer {

module-server/src/main/resources/application-dev.yaml

@@ -1,7 +1,3 @@
-server.port: 12000
-management.server.port: 12001
-
-
 spring:
   config:
     import:

module-server/src/main/resources/application-prod.yaml

@@ -4,4 +4,4 @@ spring:
       - "configserver:${CONFIGSERVER_SCHEME:http}://${CONFIGSERVER_HOST:configserver}:${CONFIGSERVER_PORT:8888}${CONFIGSERVER_PREFIX:/config}"
   kafka:
     bootstrap-servers:
-      - ${KAFKA_HOST:kafka}:${KAFKA_PORT:9092}
+      - "${KAFKA_HOST:kafka}:${KAFKA_PORT:9092}"

module-server/src/main/resources/application.yaml

@@ -1,12 +1,12 @@
 server:
-  port: 12000
+  port: ${PORT:12000}
   shutdown: graceful
   forward-headers-strategy: framework
 
 ### technical configurations ###
 management:
   # for security, don't use same port as application
-  server.port: 12001
+  server.port: ${ACTUATOR_PORT:12001}
   health:
     livenessState.enabled: true
     readinessState.enabled: true