pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
    Copyright (c) 2016 Contributors to the Eclipse Foundation
   
    See the NOTICE file(s) distributed with this work for additional
    information regarding copyright ownership.
   
    This program and the accompanying materials are made available under the
    terms of the Eclipse Public License 2.0 which is available at
    http://www.eclipse.org/legal/epl-2.0
   
    SPDX-License-Identifier: EPL-2.0
 -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <parent>
    <groupId>org.eclipse.hono</groupId>
    <artifactId>hono-bom</artifactId>
    <version>2.7.0-SNAPSHOT</version>
    <relativePath>../bom</relativePath>
  </parent>
  <modelVersion>4.0.0</modelVersion>

  <artifactId>hono-tests</artifactId>

  <name>Hono Integration Tests</name>
  <description>
    Integration tests verifying Hono's APIs. Test cases are run against Docker images of Hono server
    + (Apache Qpid Dispatch Router and ActiveMQ Artemis broker).
  </description>
  <url>https://www.eclipse.org/hono</url>

  <properties>
    <maven.javadoc.skip>true</maven.javadoc.skip>
    <maven.source.skip>true</maven.source.skip>
    <maven.install.skip>true</maven.install.skip>
    <gpg.skip>true</gpg.skip>

    <custom.network.name>hono-test</custom.network.name>

    <!--
      Hono service names
    -->
    <hono.amqp-network.host>hono-dispatch-router</hono.amqp-network.host>
    <hono.amqp-broker.host>hono-artemis</hono.amqp-broker.host>
    <hono.commandrouter.host>hono-service-command-router</hono.commandrouter.host>
    <hono.registration.host>hono-service-device-registry</hono.registration.host>
    <hono.auth.host>hono-service-auth</hono.auth.host>

    <!-- duration before vert.x complains about blocking the event loop -->
    <max.event-loop.execute-time>PT5S</max.event-loop.execute-time>

    <!-- logging profile used by all Hono components: prod, dev or trace -->
    <logging.profile>prod</logging.profile>
    <!-- maximum time (milliseconds) to wait for successful startup of a single service component -->
    <service.startup.timeout>120000</service.startup.timeout>
    <!-- color used by components of the AMQP Messaging Network for logging -->
    <log.color.amqp-network>magenta</log.color.amqp-network>
    <log.color.kafka>magenta</log.color.kafka>
    <!-- color used by components of the device registry for logging -->
    <log.color.hono-device-registry>green</log.color.hono-device-registry>
    <!-- color used by protocol adapters for logging -->
    <log.color.hono-protocol-adapters>red</log.color.hono-protocol-adapters>
    <!-- color used by remaining Hono services for logging -->
    <log.color.hono-services>yellow</log.color.hono-services>
    <!-- color used by extra (non-Hono) services for logging -->
    <log.color.extra-services>cyan</log.color.extra-services>

    <!--
      Properties shared by all protocol adapters
    -->
    <link.establishment.timeout>5000</link.establishment.timeout>
    <flow.latency>1000</flow.latency>
    <request.timeout>500</request.timeout>
    <adapter.sendMessageToDeviceTimeout>1000</adapter.sendMessageToDeviceTimeout>
    <!-- use minimum cost factor in order to speed up test execution -->
    <max.bcrypt.costFactor>4</max.bcrypt.costFactor>

    <default.java-options>
      -XX:MinRAMPercentage=80
      -XX:MaxRAMPercentage=90
    </default.java-options>

    <!--
     Command Router related properties.
     -->
    <hono.command-router.config-src>clustered-cache</hono.command-router.config-src>
    <hono.command-router.image>hono-service-command-router-infinispan</hono.command-router.image>
    <hono.command-router.max-mem>300000000</hono.command-router.max-mem>
    <hono.command-router.java-options>${default.java-options}</hono.command-router.java-options>
    <hono.command-router.native-image-args></hono.command-router.native-image-args>

    <hono.service-auth.disabled>false</hono.service-auth.disabled>

    <hono.infinispan.disabled>false</hono.infinispan.disabled>

    <!--
      Messaging related properties - Kafka is used as the default one.
    -->
    <hono.messaging-infra.type>kafka</hono.messaging-infra.type>
    <hono.amqp-messaging.disabled>true</hono.amqp-messaging.disabled>
    <hono.kafka-messaging.disabled>false</hono.kafka-messaging.disabled>
    <hono.kafka.log-level>WARN</hono.kafka.log-level>
    <hono.kafka.bootstrap.servers>kafka:9092</hono.kafka.bootstrap.servers>

    <hono.command-router.disabled>false</hono.command-router.disabled>

    <!--
      Device Registry related properties - The MongoDB based device registry is used as the default one.
    -->
    <hono.deviceregistry.type>mongodb</hono.deviceregistry.type>

    <hono.deviceregistry.mongodb.disabled>false</hono.deviceregistry.mongodb.disabled>
    <hono.deviceregistry.mongodb.image>hono-service-device-registry-mongodb</hono.deviceregistry.mongodb.image>
    <hono.deviceregistry.mongodb.max-mem>400000000</hono.deviceregistry.mongodb.max-mem>
    <hono.deviceregistry.mongodb.java-options>${default.java-options}</hono.deviceregistry.mongodb.java-options>
    <hono.deviceregistry.mongodb.native-image-args></hono.deviceregistry.mongodb.native-image-args>

    <hono.deviceregistry.jdbc.disabled>true</hono.deviceregistry.jdbc.disabled>
    <hono.deviceregistry.jdbc.image>hono-service-device-registry-jdbc</hono.deviceregistry.jdbc.image>
    <hono.deviceregistry.jdbc.max-mem>400000000</hono.deviceregistry.jdbc.max-mem>
    <hono.deviceregistry.jdbc.java-options>
      ${default.java-options}
      -Dorg.eclipse.hono.service.base.jdbc.store.skipDumpingStatementConfiguration=true
    </hono.deviceregistry.jdbc.java-options>
    <hono.deviceregistry.jdbc.native-image-args></hono.deviceregistry.jdbc.native-image-args>

    <!--  accept requests with a body size of up to 2000 bytes -->
    <hono.deviceregistry.maxPayloadSize>2000</hono.deviceregistry.maxPayloadSize>
    <!-- the credentials required for accessing the (Mongo DB) registry's HTTP endpoint -->
    <hono.deviceregistry.http.authConfig.username>test-client</hono.deviceregistry.http.authConfig.username>
    <hono.deviceregistry.http.authConfig.salt>secret</hono.deviceregistry.http.authConfig.salt>
    <hono.deviceregistry.http.authConfig.password>sauce</hono.deviceregistry.http.authConfig.password>
    <!--
      password hash is the (uppercase) Hex representation of the PBKDF2 SHA-512 digest of "secretsauce" (salt + password)
      created using https://stuff.birkenstab.de/pbkdf2/
    -->
    <hono.deviceregistry.http.authConfig.passwordHash>
      5905BFCF36F5852A0E75B9D0727F3E26FD9701FD3C6A182F360EBD1FBFD321A8E1D7E392AEA7D8AF84B445186C86532E22D99892DE5EE95C86C0783198AA9840
    </hono.deviceregistry.http.authConfig.passwordHash>

    <hono.mongodb.disabled>false</hono.mongodb.disabled>

    <hono.mongodb.host>hono-mongodb</hono.mongodb.host>
    <hono.mongodb.port>27017</hono.mongodb.port>
    <hono.mongodb.username>device-registry</hono.mongodb.username>
    <hono.mongodb.password>device-registry-secret</hono.mongodb.password>
    <hono.mongodb.database.name>hono-it-tests</hono.mongodb.database.name>

    <hono.postgres.disabled>true</hono.postgres.disabled>

    <hono.amqp-adapter.host>hono-adapter-amqp</hono.amqp-adapter.host>
    <hono.amqp-adapter.image>hono-adapter-amqp</hono.amqp-adapter.image>
    <hono.amqp-adapter.max-mem>314572800</hono.amqp-adapter.max-mem>
    <hono.amqp-adapter.java-options>${default.java-options}</hono.amqp-adapter.java-options>
    <hono.amqp-adapter.native-image-args></hono.amqp-adapter.native-image-args>
    <hono.amqp-adapter.disabled>false</hono.amqp-adapter.disabled>

    <hono.coap-adapter.host>hono-adapter-coap</hono.coap-adapter.host>
    <hono.coap-adapter.image>hono-adapter-coap</hono.coap-adapter.image>
    <hono.coap-adapter.max-mem>314572800</hono.coap-adapter.max-mem>
    <hono.coap-adapter.java-options>${default.java-options}</hono.coap-adapter.java-options>
    <hono.coap-adapter.native-image-args></hono.coap-adapter.native-image-args>
    <hono.coap-adapter.disabled>false</hono.coap-adapter.disabled>

    <hono.http-adapter.host>hono-adapter-http</hono.http-adapter.host>
    <hono.http-adapter.image>hono-adapter-http</hono.http-adapter.image>
    <hono.http-adapter.max-mem>314572800</hono.http-adapter.max-mem>
    <hono.http-adapter.nativeTlsRequired>true</hono.http-adapter.nativeTlsRequired>
    <hono.http-adapter.java-options>${default.java-options}</hono.http-adapter.java-options>
    <hono.http-adapter.native-image-args></hono.http-adapter.native-image-args>
    <hono.http-adapter.disabled>false</hono.http-adapter.disabled>

    <hono.lora-adapter.host>hono-adapter-lora</hono.lora-adapter.host>
    <hono.lora-adapter.image>hono-adapter-lora</hono.lora-adapter.image>
    <hono.lora-adapter.max-mem>314572800</hono.lora-adapter.max-mem>
    <hono.lora-adapter.nativeTlsRequired>false</hono.lora-adapter.nativeTlsRequired>
    <hono.lora-adapter.java-options>${default.java-options}</hono.lora-adapter.java-options>
    <hono.lora-adapter.native-image-args></hono.lora-adapter.native-image-args>
    <hono.lora-adapter.disabled>false</hono.lora-adapter.disabled>

    <hono.mqtt-adapter.host>hono-adapter-mqtt</hono.mqtt-adapter.host>
    <hono.mqtt-adapter.image>hono-adapter-mqtt</hono.mqtt-adapter.image>
    <hono.mqtt-adapter.max-mem>314572800</hono.mqtt-adapter.max-mem>
    <hono.mqtt-adapter.java-options>${default.java-options}</hono.mqtt-adapter.java-options>
    <hono.mqtt-adapter.native-image-args></hono.mqtt-adapter.native-image-args>
    <hono.mqtt-adapter.disabled>false</hono.mqtt-adapter.disabled>

    <hono.auth-server.image>hono-service-auth</hono.auth-server.image>
    <hono.auth-server.max-mem>205520896</hono.auth-server.max-mem>
    <hono.auth-server.java-options>${default.java-options}</hono.auth-server.java-options>
    <hono.auth-server.native-image-args></hono.auth-server.native-image-args>
    <hono.auth-server.nativeTlsRequired>true</hono.auth-server.nativeTlsRequired>

    <trace.frames>0</trace.frames>

    <jaeger.disabled>true</jaeger.disabled>
    <jaeger.host>hono-jaeger</jaeger.host>
    <jaeger.otel-collector.port>4317</jaeger.otel-collector.port>

    <otel-collector.endpoint>http://localhost</otel-collector.endpoint>
    <otel-traces-sampler>always_off</otel-traces-sampler>

    <!-- prevents circular dependency -->
    <quarkus.application-dev.properties>n/a</quarkus.application-dev.properties>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-demo-certs</artifactId>
    </dependency>
    <dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty-tcnative-boringssl-static</artifactId>
    </dependency>
    <dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty-tcnative-classes</artifactId>
    </dependency>
    <dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty-transport-native-epoll</artifactId>
      <classifier>linux-x86_64</classifier>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty-transport-native-kqueue</artifactId>
      <classifier>osx-x86_64</classifier>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-engine</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter-params</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-junit5</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-core</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-service-device-registry-base</artifactId>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.jboss.slf4j</groupId>
          <artifactId>slf4j-jboss-logmanager</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-service-command-router-base</artifactId>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.jboss.slf4j</groupId>
          <artifactId>slf4j-jboss-logmanager</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-adapter-coap</artifactId>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.jboss.slf4j</groupId>
          <artifactId>slf4j-jboss-logmanager</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>core-test-utils</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-core</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-proton</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>jcl-over-slf4j</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.apache.qpid</groupId>
      <artifactId>qpid-jms-client</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-mqtt</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.hivemq</groupId>
      <artifactId>hivemq-mqtt-client</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.californium</groupId>
      <artifactId>californium-core</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.californium</groupId>
      <artifactId>scandium</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.assertj</groupId>
      <artifactId>assertj-core</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.google.truth</groupId>
      <artifactId>truth</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-client-command-amqp</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-client-registry-amqp</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-client-application-amqp</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-client-application-kafka</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-client-notification-amqp</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.eclipse.hono</groupId>
      <artifactId>hono-client-telemetry-kafka</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.opentelemetry</groupId>
      <artifactId>opentelemetry-opentracing-shim</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.opentelemetry</groupId>
      <artifactId>opentelemetry-sdk</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.bouncycastle</groupId>
      <artifactId>bcpkix-jdk18on</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <resources>
      <resource>
        <directory>${project.basedir}/src/test/resources</directory>
        <filtering>true</filtering>
        <targetPath>${project.build.directory}/resources</targetPath>
      </resource>
    </resources>
    <pluginManagement>
      <plugins>
        <plugin>
          <groupId>org.codehaus.mojo</groupId>
          <artifactId>build-helper-maven-plugin</artifactId>
          <version>3.0.0</version>
        </plugin>
      </plugins>
    </pluginManagement>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-checkstyle-plugin</artifactId>
      </plugin>
    </plugins>
    <extensions>
      <extension>
        <groupId>kr.motd.maven</groupId>
        <artifactId>os-maven-plugin</artifactId>
        <version>1.7.0</version>
      </extension>
    </extensions>
  </build>

  <profiles>
    <profile>
      <id>ci_environment</id>
      <activation>
        <property>
          <name>CI</name>
        </property>
      </activation>
      <!-- 
        relax timeouts when running on CI environment in order to account for (very) limited
        CPU resources.
       -->
      <properties>
        <adapter.sendMessageToDeviceTimeout>3000</adapter.sendMessageToDeviceTimeout>
        <max.event-loop.execute-time>20000</max.event-loop.execute-time>
        <request.timeout>3000</request.timeout>
        <service.startup.timeout>240000</service.startup.timeout>
      </properties>
    </profile>

    <profile>
      <id>jaeger</id>
      <properties>
        <jaeger.disabled>false</jaeger.disabled>
        <otel-collector.endpoint>http://${jaeger.host}:${jaeger.otel-collector.port}</otel-collector.endpoint>
        <otel-traces-sampler>jaeger_remote</otel-traces-sampler>
      </properties>
    </profile>

    <profile>
      <id>embedded_cache</id>
      <activation>
        <property>
          <name>hono.commandrouting.cache</name>
          <value>embedded</value>
        </property>
      </activation>
      <properties>
        <hono.infinispan.disabled>true</hono.infinispan.disabled>
        <hono.command-router.config-src>embedded-cache</hono.command-router.config-src>
        <hono.command-router.max-mem>350000000</hono.command-router.max-mem>
      </properties>
    </profile>
    <profile>
      <id>amqp</id>
      <activation>
        <property>
          <name>hono.messaging-infra.type</name>
          <value>amqp</value>
        </property>
      </activation>
      <properties>
        <hono.amqp-messaging.disabled>false</hono.amqp-messaging.disabled>
        <hono.kafka-messaging.disabled>true</hono.kafka-messaging.disabled>
      </properties>
    </profile>
    <profile>
      <id>kafka</id>
      <activation>
        <property>
          <name>hono.messaging-infra.type</name>
          <value>!amqp</value>
        </property>
      </activation>
      <properties>
        <hono.amqp-messaging.disabled>true</hono.amqp-messaging.disabled>
        <hono.kafka-messaging.disabled>false</hono.kafka-messaging.disabled>
        <request.timeout>4000</request.timeout>
        <!--The max memory command router is increased to 500 MB-->
        <hono.command-router.max-mem>524288000</hono.command-router.max-mem>
      </properties>
      <build>
        <plugins>
          <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>build-helper-maven-plugin</artifactId>
            <executions>
              <execution>
                <id>reserve-network-port</id>
                <goals>
                  <goal>reserve-network-port</goal>
                </goals>
                <phase>initialize</phase>
                <configuration>
                  <randomPort>true</randomPort>
                  <portNames>
                    <!--
                      The port on which Kafka's advertised listener for the Docker-external clients is set up
                      must be the same on which Docker exposes the container port to the "outside".
                      The docker-maven-plugin cannot be used since the advertised listener is defined as an
                      environment variable of the container and the plugin chooses the random port after the definition
                      of the container is made.
                    -->
                    <portName>kafka.port</portName>
                  </portNames>
                </configuration>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <!--
              The standard Maven plugin for writing properties cannot be used as it is only capable of writing
              all project properties to file but not specific ones only.
            -->
            <groupId>com.internetitem</groupId>
            <artifactId>write-properties-file-maven-plugin</artifactId>
            <executions>
              <execution>
                <phase>post-integration-test</phase>
                <goals>
                  <goal>write-properties-file</goal>
                </goals>
                <configuration>
                  <filename>kafka.port.properties</filename>
                  <outputDirectory>${project.build.directory}/docker</outputDirectory>
                  <properties>
                    <property>
                      <name>kafka.port</name>
                      <value>${kafka.port}</value>
                    </property>
                    <property>
                      <name>docker.host.address</name>
                      <value>${docker.host.address}</value>
                    </property>
                  </properties>
                </configuration>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <configuration>
              <systemPropertyVariables>
                <downstream.bootstrap.servers>${docker.host.address}:${kafka.port}</downstream.bootstrap.servers>
              </systemPropertyVariables>
            </configuration>
          </plugin>
        </plugins>
      </build>
    </profile>
    <profile>
      <id>device-registry-jdbc</id>
      <activation>
        <property>
          <name>hono.deviceregistry.type</name>
          <value>jdbc</value>
        </property>
      </activation>
      <properties>
        <hono.mongodb.disabled>true</hono.mongodb.disabled>
        <hono.deviceregistry.mongodb.disabled>true</hono.deviceregistry.mongodb.disabled>
        <hono.postgres.disabled>false</hono.postgres.disabled>
        <hono.deviceregistry.type>jdbc</hono.deviceregistry.type>
        <hono.deviceregistry.jdbc.disabled>false</hono.deviceregistry.jdbc.disabled>
        <hono.deviceregistry.jdbc.resources.folder>deviceregistry-jdbc-postgres</hono.deviceregistry.jdbc.resources.folder>
        <hono.jdbc.db.url>jdbc:postgresql://hono-jdbc-db:5432/</hono.jdbc.db.url>
        <hono.jdbc.db.admin.username>postgres</hono.jdbc.db.admin.username>
        <hono.jdbc.db.admin.password>change-me</hono.jdbc.db.admin.password>
        <hono.jdbc.db.registry.username>${hono.jdbc.db.admin.username}</hono.jdbc.db.registry.username>
        <hono.jdbc.db.registry.password>${hono.jdbc.db.admin.password}</hono.jdbc.db.registry.password>
      </properties>
    </profile>
    <profile>
      <id>device-registry-file</id>
      <activation>
        <property>
          <name>hono.deviceregistry.type</name>
          <value>file</value>
        </property>
      </activation>
      <properties>
        <hono.mongodb.disabled>true</hono.mongodb.disabled>
        <hono.deviceregistry.mongodb.disabled>true</hono.deviceregistry.mongodb.disabled>
        <hono.postgres.disabled>true</hono.postgres.disabled>
        <hono.deviceregistry.type>file</hono.deviceregistry.type>
        <hono.deviceregistry.jdbc.disabled>false</hono.deviceregistry.jdbc.disabled>
        <hono.deviceregistry.jdbc.resources.folder>deviceregistry-jdbc-h2</hono.deviceregistry.jdbc.resources.folder>
        <!-- increase memory limit of the device registry container in order to accommodate for H2 DB -->
        <hono.deviceregistry.jdbc.max-mem>450000000</hono.deviceregistry.jdbc.max-mem>
        <hono.jdbc.db.url>jdbc:h2:file://var/tmp/hono</hono.jdbc.db.url>
      </properties>
    </profile>
    <profile>
      <id>components-quarkus-native</id>
      <activation>
        <property>
          <name>hono.components.type</name>
          <value>quarkus-native</value>
        </property>
      </activation>
      <properties>
        <hono.amqp-adapter.image>hono-adapter-amqp-native</hono.amqp-adapter.image>
        <hono.amqp-adapter.max-mem>70000000</hono.amqp-adapter.max-mem>

        <hono.coap-adapter.image>hono-adapter-coap-native</hono.coap-adapter.image>
        <hono.coap-adapter.max-mem>120000000</hono.coap-adapter.max-mem>

        <hono.http-adapter.image>hono-adapter-http-native</hono.http-adapter.image>
        <hono.http-adapter.max-mem>70000000</hono.http-adapter.max-mem>
        <hono.http-adapter.nativeTlsRequired>false</hono.http-adapter.nativeTlsRequired>

        <hono.lora-adapter.image>hono-adapter-lora-native</hono.lora-adapter.image>
        <hono.lora-adapter.max-mem>70000000</hono.lora-adapter.max-mem>

        <hono.mqtt-adapter.image>hono-adapter-mqtt-native</hono.mqtt-adapter.image>
        <hono.mqtt-adapter.max-mem>70000000</hono.mqtt-adapter.max-mem>

        <hono.auth-server.image>hono-service-auth-native</hono.auth-server.image>
        <hono.auth-server.max-mem>60000000</hono.auth-server.max-mem>
        <hono.auth-server.nativeTlsRequired>false</hono.auth-server.nativeTlsRequired>
        <hono.command-router.image>hono-service-command-router-infinispan-native</hono.command-router.image>
        <hono.command-router.max-mem>100000000</hono.command-router.max-mem>
        <hono.deviceregistry.mongodb.image>hono-service-device-registry-mongodb-native</hono.deviceregistry.mongodb.image>
        <hono.deviceregistry.mongodb.max-mem>150000000</hono.deviceregistry.mongodb.max-mem>
        <hono.deviceregistry.jdbc.image>hono-service-device-registry-jdbc-native</hono.deviceregistry.jdbc.image>
        <hono.deviceregistry.jdbc.max-mem>150000000</hono.deviceregistry.jdbc.max-mem>
      </properties>
    </profile>
    <profile>
      <id>no-services</id>
      <activation>
        <property>
          <name>no-services</name>
        </property>
      </activation>
      <properties>
        <hono.service-auth.disabled>true</hono.service-auth.disabled>
        <hono.deviceregistry.mongodb.disabled>true</hono.deviceregistry.mongodb.disabled>
        <hono.deviceregistry.jdbc.disabled>true</hono.deviceregistry.jdbc.disabled>
        <hono.command-router.disabled>true</hono.command-router.disabled>
      </properties>
    </profile>
    <profile>
      <id>auth-only</id>
      <activation>
        <property>
          <name>auth-only</name>
        </property>
      </activation>
      <properties>
        <hono.deviceregistry.mongodb.disabled>true</hono.deviceregistry.mongodb.disabled>
        <hono.deviceregistry.jdbc.disabled>true</hono.deviceregistry.jdbc.disabled>
        <hono.command-router.disabled>true</hono.command-router.disabled>
      </properties>
    </profile>
    <profile>
      <id>no-adapters</id>
      <activation>
        <property>
          <name>no-adapters</name>
        </property>
      </activation>
      <properties>
        <hono.amqp-adapter.disabled>true</hono.amqp-adapter.disabled>
        <hono.coap-adapter.disabled>true</hono.coap-adapter.disabled>
        <hono.http-adapter.disabled>true</hono.http-adapter.disabled>
        <hono.lora-adapter.disabled>true</hono.lora-adapter.disabled>
        <hono.mqtt-adapter.disabled>true</hono.mqtt-adapter.disabled>
      </properties>
    </profile>
    <profile>
      <id>amqp-only</id>
      <properties>
        <hono.amqp-adapter.disabled>false</hono.amqp-adapter.disabled>
        <hono.coap-adapter.disabled>true</hono.coap-adapter.disabled>
        <hono.http-adapter.disabled>true</hono.http-adapter.disabled>
        <hono.lora-adapter.disabled>true</hono.lora-adapter.disabled>
        <hono.mqtt-adapter.disabled>true</hono.mqtt-adapter.disabled>
      </properties>
    </profile>
    <profile>
      <id>coap-only</id>
      <properties>
        <hono.amqp-adapter.disabled>true</hono.amqp-adapter.disabled>
        <hono.coap-adapter.disabled>false</hono.coap-adapter.disabled>
        <hono.http-adapter.disabled>true</hono.http-adapter.disabled>
        <hono.lora-adapter.disabled>true</hono.lora-adapter.disabled>
        <hono.mqtt-adapter.disabled>true</hono.mqtt-adapter.disabled>
      </properties>
    </profile>
    <profile>
      <id>http-only</id>
      <properties>
        <hono.amqp-adapter.disabled>true</hono.amqp-adapter.disabled>
        <hono.coap-adapter.disabled>true</hono.coap-adapter.disabled>
        <hono.http-adapter.disabled>false</hono.http-adapter.disabled>
        <hono.lora-adapter.disabled>true</hono.lora-adapter.disabled>
        <hono.mqtt-adapter.disabled>true</hono.mqtt-adapter.disabled>
      </properties>
    </profile>
    <profile>
      <id>lora-only</id>
      <properties>
        <hono.amqp-adapter.disabled>true</hono.amqp-adapter.disabled>
        <hono.coap-adapter.disabled>true</hono.coap-adapter.disabled>
        <hono.http-adapter.disabled>true</hono.http-adapter.disabled>
        <hono.lora-adapter.disabled>false</hono.lora-adapter.disabled>
        <hono.mqtt-adapter.disabled>true</hono.mqtt-adapter.disabled>
      </properties>
    </profile>
    <profile>
      <id>mqtt-only</id>
      <properties>
        <hono.amqp-adapter.disabled>true</hono.amqp-adapter.disabled>
        <hono.coap-adapter.disabled>true</hono.coap-adapter.disabled>
        <hono.http-adapter.disabled>true</hono.http-adapter.disabled>
        <hono.lora-adapter.disabled>true</hono.lora-adapter.disabled>
        <hono.mqtt-adapter.disabled>false</hono.mqtt-adapter.disabled>
      </properties>
    </profile>
    
    <profile>
      <id>local</id>
      <activation>
        <property>
          <name>local</name>
        </property>
      </activation>
      <properties>
        <docker.host.address>localhost</docker.host.address>
        <auth.ip>localhost</auth.ip>
        <deviceregistry.ip>localhost</deviceregistry.ip>
        <amqp.ip>localhost</amqp.ip>
        <coap.ip>localhost</coap.ip>
        <http.ip>localhost</http.ip>
        <lora.ip>localhost</lora.ip>
        <mqtt.ip>localhost</mqtt.ip>
      </properties>
    </profile>

    <profile>
      <id>fix-ports</id>
      <activation>
        <property>
          <name>start</name>
        </property>
      </activation>
      <properties>
        <mongodb.port>27017</mongodb.port>
        <kafka.port>9094</kafka.port>
        <qpid.amqps.port>15671</qpid.amqps.port>
        <qpid.amqp.port>15672</qpid.amqp.port>

        <auth.amqps.port>${fixed.auth.amqps.port}</auth.amqps.port>
        <deviceregistry.amqp.port>${fixed.deviceregistry.amqp.port}</deviceregistry.amqp.port>
        <deviceregistry.http.port>${fixed.deviceregistry.http.port}</deviceregistry.http.port>
        <commandrouter.amqp.port>${fixed.commandrouter.amqp.port}</commandrouter.amqp.port>

        <amqp.port>${fixed.amqp.adapter.port}</amqp.port>
        <amqps.port>${fixed.amqps.adapter.port}</amqps.port>
        <coap.port>${fixed.coap.adapter.port}</coap.port>
        <coaps.port>${fixed.coaps.adapter.port}</coaps.port>
        <http.port>${fixed.http.adapter.port}</http.port>
        <https.port>${fixed.https.adapter.port}</https.port>
        <lora.port>${fixed.lora.adapter.port}</lora.port>
        <lora.secure-port>${fixed.loras.adapter.port}</lora.secure-port>
        <mqtt.port>${fixed.mqtt.adapter.port}</mqtt.port>
        <mqtts.port>${fixed.mqtts.adapter.port}</mqtts.port>
      </properties>
      <build>
        <plugins>
          <!-- Skips random kafka port -->
          <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>build-helper-maven-plugin</artifactId>
            <executions>
              <execution>
                <id>reserve-network-port</id>
                <goals>
                  <goal>reserve-network-port</goal>
                </goals>
                <phase>none</phase>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>

    <profile>
      <id>run-tests</id>
      <activation>
        <property>
          <name>start</name>
        </property>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
              <execution>
                <!--
                  Execution and configuration for copying certificates and config files
                  from related modules "target/config" folder so that we can include them in the image.
                 -->
                <id>copy_demo_certs</id>
                <phase>generate-test-resources</phase>
                <goals>
                  <goal>unpack-dependencies</goal>
                </goals>
                <configuration>
                  <includeArtifactIds>hono-demo-certs</includeArtifactIds>
                  <outputDirectory>${project.build.directory}/certs</outputDirectory>
                  <includes>
                    *.pem,
                    *.p12,
                    *.jks,
                    *-password
                  </includes>
                  <useSubDirectoryPerArtifact>false</useSubDirectoryPerArtifact>
                  <stripClassifier>true</stripClassifier>
                  <stripVersion>true</stripVersion>
                  <excludeTransitive>true</excludeTransitive>
                </configuration>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <groupId>io.fabric8</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <configuration>
              <verbose>true</verbose>
              <autoCreateCustomNetworks>true</autoCreateCustomNetworks>
              <startParallel>false</startParallel>
              <images>
                <!-- ##### Infinispan server for Command Router ##### -->
                <image>
                  <name>${docker.repository}/hono-infinispan-test:${project.version}</name>
                  <build>
                    <skip>${hono.infinispan.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${infinispan-image.name}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSet>
                          <directory>${project.build.directory}/resources/infinispan</directory>
                          <outputDirectory>opt/infinispan/server/conf</outputDirectory>
                          <includes>
                            <include>*</include>
                          </includes>
                        </fileSet>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.infinispan.disabled}</skip>
                    <entrypoint>
                      <arg>/opt/infinispan/bin/server.sh</arg>
                    </entrypoint>
                    <cmd>
                      <arg>-c</arg>
                      <arg>hono-data-grid.xml</arg>
                      <arg>-Dquarkus.log.category."org.infinispan.AUDIT".level=WARN</arg>
                      <arg>-Dquarkus.log.category."org.infinispan.CONFIG".level=INFO</arg>
                      <arg>-Dquarkus.log.category."org.infinispan.CONTAINER".level=INFO</arg>
                      <arg>-Dquarkus.log.category."org.infinispan.SECURITY".level=INFO</arg>
                      <arg>-Dquarkus.log.category."org.infinispan.SERVER".level=INFO</arg>
                    </cmd>
                    <ports>
                      <!--
                        We need to map the port in order to be able to access the data grid
                        from a Command Router process that is not running in Docker.
                      -->
                      <port>hono.infinispan.port:${hono.infinispan.port}</port>
                    </ports>
                    <env>
                      <!-- 
                        In order to support running on a rootless Docker daemon which uses cgroups v2 for
                        enforcing resource limits, and because the Infinispan native server image has been
                        created using Java 11 (which doesn't support cgroups v2), we need to (also) explicitly limit
                        memory using Java options here. Otherwise the VM would use a max heap space of 1/4 of the
                        host's memory which is probably much more than the 120mb we specify for the container ...
                       -->
                      <JAVA_OPTIONS>-Xms70m -Xmx80m</JAVA_OPTIONS>
                    </env>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.infinispan.host}</alias>
                    </network>
                    <memorySwap>120000000</memorySwap>
                    <memory>120000000</memory>
                    <log>
                      <prefix>INFINISPAN</prefix>
                      <color>${log.color.hono-services}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <log>.*(Infinispan Server .* started).*</log>
                    </wait>
                  </run>
                </image>
                <!-- ##### Jaeger tracing component ##### -->
                <image>
                  <name>${docker.repository}/hono-jaeger-test:${project.version}</name>
                  <build>
                    <skip>${jaeger.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${jaeger.image.name}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSet>
                          <directory>${project.build.directory}/resources/jaeger</directory>
                          <outputDirectory>etc/hono</outputDirectory>
                          <includes>
                            <include>*</include>
                          </includes>
                        </fileSet>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${jaeger.disabled}</skip>
                    <ports>
                      <port>jaeger.health.port:14269</port><!-- admin-http -->
                      <port>18080:16686</port><!-- query-http -->
                      <port>jaeger.otel-collector.port:4317</port><!-- OTEL collector -->
                    </ports>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${jaeger.host}</alias>
                    </network>
                    <!--
                      Setting the swap property to the same value as the memory property effectively
                      prevents the container from swapping at all.
                      This way we can force the same behavior for running the integration
                      tests on both a local machine (which usually has swap space available) as
                      well as on CI infrastructure where there usually is no swap space available.
                      We can thus detect OOM problems when running locally as opposed to only
                      later on CI infrastructure.
                     -->
                    <memorySwap>314572800</memorySwap>
                    <memory>314572800</memory>
                    <env>
                      <LOG_LEVEL>info</LOG_LEVEL>
                      <MEMORY_MAX_TRACES>2000</MEMORY_MAX_TRACES>
                      <COLLECTOR_OTLP_ENABLED>true</COLLECTOR_OTLP_ENABLED>
                      <SAMPLING_STRATEGIES_FILE>/etc/hono/default-sampling-strategies.json</SAMPLING_STRATEGIES_FILE>
                    </env>
                    <log>
                      <prefix>JAEGER</prefix>
                      <color>${log.color.extra-services}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${docker.host.address}:${jaeger.health.port}/health</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
                <!-- ##### Authentication service ##### -->
                <image>
                  <name>${docker.repository}/hono-service-auth-test:${project.version}</name>
                  <build>
                    <skip>${hono.service-auth.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${docker.repository}/${hono.auth-server.image}:${project.version}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <dependencySets>
                          <dependencySet>
                            <includes>
                              <!--  use openSSL in Auth server -->
                              <include>io.netty:netty-tcnative-boringssl-static:jar:linux-${os.detected.arch}</include>
                              <include>io.netty:netty-tcnative-classes</include>
                            </includes>
                            <outputDirectory>opt/hono/extensions</outputDirectory>
                          </dependencySet>
                        </dependencySets>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/auth</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>opt/hono/config/certs</outputDirectory>
                            <includes>
                              <include>auth-server-*.pem</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.service-auth.disabled}</skip>
                    <ports>
                      <port>+auth.ip:auth.amqps.port:5671</port>
                      <port>+auth.ip:auth.health.port:${health.check.port}</port>
                    </ports>
                    <portPropertyFile>${project.build.directory}/docker/auth.port.properties</portPropertyFile>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.auth.host}</alias>
                    </network>
                    <!--
                      Setting the swap property to the same value as the memory property effectively
                      prevents the container from swapping at all.
                      This way we can force the same behavior for running the integration
                      tests on both a local machine (which usually has swap space available) as
                      well as on CI infrastructure where there usually is no swap space available.
                      We can thus detect OOM problems when running locally as opposed to only
                      later on CI infrastructure.
                     -->
                    <memorySwap>${hono.auth-server.max-mem}</memorySwap>
                    <memory>${hono.auth-server.max-mem}</memory>
                    <cmd>
                      <exec>
                        <arg>${hono.auth-server.native-image-args}</arg>
                      </exec>
                    </cmd>
                    <env>
                      <QUARKUS_CONFIG_LOCATIONS>
                        /opt/hono/config/logging-quarkus-${logging.profile}.yml
                      </QUARKUS_CONFIG_LOCATIONS>
                      <JDK_JAVA_OPTIONS>${hono.auth-server.java-options}</JDK_JAVA_OPTIONS>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                      <OTEL_SERVICE_NAME>${hono.auth.host}</OTEL_SERVICE_NAME>
                      <OTEL_TRACES_SAMPLER>${otel-traces-sampler}</OTEL_TRACES_SAMPLER>
                      <OTEL_TRACES_SAMPLER_ARG>endpoint=http://${jaeger.host}:14250</OTEL_TRACES_SAMPLER_ARG>
                    </env>
                    <log>
                      <prefix>AUTH</prefix>
                      <color>${log.color.hono-services}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${auth.ip}:${auth.health.port}${health.check.root-path}${health.check.readiness-path}</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
                <!-- ##### ActiveMQ Artemis message broker ##### -->
                <image>
                  <name>${docker.repository}/hono-artemis-test:${project.version}</name>
                  <build>
                    <skip>${hono.amqp-messaging.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${artemis.image.name}</from>
                    <ports>
                      <port>5671</port>
                    </ports>
                    <entryPoint>
                      <arg>/bin/bash</arg>
                      <arg>/opt/amq/conf/launch.sh</arg>
                    </entryPoint>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/opt/amq/conf</basedir>
                      <inline>
                        <id>config</id>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/artemis</directory>
                            <outputDirectory>.</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>.</outputDirectory>
                            <includes>
                              <include>artemisKeyStore.p12</include>
                              <include>trustStore.jks</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.amqp-messaging.disabled}</skip>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.amqp-broker.host}</alias>
                    </network>
                    <memorySwap>419430400</memorySwap>
                    <memory>419430400</memory>
                    <env>
                      <AMQ_NAME>custom</AMQ_NAME>
                      <AMQ_USER>admin</AMQ_USER>
                      <AMQ_PASSWORD>admin</AMQ_PASSWORD>
                      <HOME>/home/jboss</HOME>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                    </env>
                    <log>
                      <prefix>ARTEMIS</prefix>
                      <color>${log.color.amqp-network}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <log>.*(Server is now live)$</log>
                    </wait>
                  </run>
                </image>
                <!-- ##### Qpid Dispatch Router ##### -->
                <image>
                  <name>${docker.repository}/hono-dispatch-router-test:${project.version}</name>
                  <build>
                    <skip>${hono.amqp-messaging.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${dispatch-router.image.name}</from>
                    <ports>
                      <port>5671</port>
                      <port>5672</port>
                      <port>5673</port>
                    </ports>
                    <cmd>
                      <exec>
                        <arg>/sbin/qdrouterd</arg>
                        <arg>-c</arg>
                        <arg>/etc/hono/qdrouterd-with-broker.json</arg>
                      </exec>
                    </cmd>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/etc/hono</basedir>
                      <inline>
                        <id>config</id>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/qpid</directory>
                            <outputDirectory>.</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>.</outputDirectory>
                            <includes>
                              <include>qdrouter-*.pem</include>
                              <include>trusted-certs.pem</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.amqp-messaging.disabled}</skip>
                    <ports>
                      <port>+qpid.ip:qpid.amqps.port:5671</port>
                      <port>+qpid.ip:qpid.amqp.port:5672</port>
                    </ports>
                    <portPropertyFile>${project.build.directory}/docker/qpid.port.properties</portPropertyFile>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.amqp-network.host}</alias>
                    </network>
                    <memorySwap>268435456</memorySwap>
                    <memory>268435456</memory>
                    <log>
                      <prefix>QPID</prefix>
                      <color>${log.color.amqp-network}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <log>.*(Listening on 0.0.0.0:5673)$</log>
                    </wait>
                    <env>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                    </env>
                  </run>
                </image>
                <!-- ##### Kafka ##### -->
                <image>
                  <name>${kafka.image.name}</name>
                  <alias>hono-kafka-test</alias>
                  <run>
                    <skip>${hono.kafka-messaging.disabled}</skip>
                    <ports>
                      <port>kafka.port:9094</port>
                    </ports>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>kafka</alias>
                    </network>
                    <memorySwap>1500000000</memorySwap>
                    <memory>1500000000</memory>
                    <log>
                      <prefix>Kafka</prefix>
                      <color>${log.color.kafka}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <log>.*(Kafka startTimeMs:).*</log>
                    </wait>
                    <env>
                      <CLUSTER_ID>q1Sh-9_ISia_zwGINzRvyQ</CLUSTER_ID>
                      <KAFKA_ADVERTISED_LISTENERS>DOCKER_INTERNAL://kafka:9092,DOCKER_EXTERNAL://${docker.host.address}:${kafka.port}</KAFKA_ADVERTISED_LISTENERS>
                      <KAFKA_CONTROLLER_LISTENER_NAMES>CONTROLLER</KAFKA_CONTROLLER_LISTENER_NAMES>
                      <KAFKA_CONTROLLER_QUORUM_VOTERS>1@127.0.0.1:9093</KAFKA_CONTROLLER_QUORUM_VOTERS>
                      <KAFKA_NODE_ID>1</KAFKA_NODE_ID>
                      <KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS>0</KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS>
                      <KAFKA_INTER_BROKER_LISTENER_NAME>DOCKER_INTERNAL</KAFKA_INTER_BROKER_LISTENER_NAME>
                      <KAFKA_LISTENERS>DOCKER_INTERNAL://0.0.0.0:9092,CONTROLLER://0.0.0.0:9093,DOCKER_EXTERNAL://0.0.0.0:9094</KAFKA_LISTENERS>
                      <KAFKA_LISTENER_SECURITY_PROTOCOL_MAP>CONTROLLER:PLAINTEXT,DOCKER_INTERNAL:PLAINTEXT,DOCKER_EXTERNAL:PLAINTEXT</KAFKA_LISTENER_SECURITY_PROTOCOL_MAP>
                      <!-- increase log cleaner check frequency (default is 5min) for test where records shall be removed -->
                      <KAFKA_LOG_RETENTION_CHECK_INTERVAL_MS>1000</KAFKA_LOG_RETENTION_CHECK_INTERVAL_MS>
                      <KAFKA_LOG_SEGMENT_DELETE_DELAY_MS>0</KAFKA_LOG_SEGMENT_DELETE_DELAY_MS>
                      <!-- log level for AppInfoParser needs to be pinned to INFO so that docker-maven-plugin can wait for container startup -->
                      <KAFKA_LOG4J_LOGGERS>kafka=${hono.kafka.log-level},org.apache.kafka=${hono.kafka.log-level},state.change.logger=${hono.kafka.log-level},org.apache.kafka.common.utils.AppInfoParser=INFO</KAFKA_LOG4J_LOGGERS>
                      <KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR>1</KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR>
                      <KAFKA_PROCESS_ROLES>broker,controller</KAFKA_PROCESS_ROLES>
                      <KAFKA_REST_BOOTSTRAP_SERVERS>127.0.0.1:9092</KAFKA_REST_BOOTSTRAP_SERVERS>
                      <KAFKA_TRANSACTION_STATE_LOG_MIN_ISR>1</KAFKA_TRANSACTION_STATE_LOG_MIN_ISR>
                      <KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR>1</KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR>
                    </env>
                  </run>
                </image>
                <!-- ##### Mongo DB instance for the device registry ##### -->
                <image>
                  <name>${docker.repository}/hono-mongodb-test:${project.version}</name>
                  <build>
                    <skip>${hono.mongodb.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${mongodb-image.name}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSet>
                          <directory>${project.build.directory}/resources/mongodb/init_db</directory>
                          <outputDirectory>docker-entrypoint-initdb.d/</outputDirectory>
                          <includes>
                            <include>*</include>
                          </includes>
                        </fileSet>
                        <file>
                          <source>${project.build.directory}/resources/mongodb/mongod.conf</source>
                          <outputDirectory>etc/mongo/</outputDirectory>
                        </file>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.mongodb.disabled}</skip>
                    <cmd>
                      <arg>--config</arg>
                      <arg>/etc/mongo/mongod.conf</arg>
                    </cmd>
                    <ports>
                      <port>mongodb.port:${hono.mongodb.port}</port>
                    </ports>
                    <env>
                      <MONGO_INITDB_DATABASE>${hono.mongodb.database.name}</MONGO_INITDB_DATABASE>
                    </env>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.mongodb.host}</alias>
                    </network>
                    <memorySwap>524288000</memorySwap>
                    <memory>524288000</memory>
                    <log>
                      <prefix>MONGODB</prefix>
                      <color>${log.color.hono-device-registry}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <log>.*("Listening on").*("0.0.0.0").*</log>
                    </wait>
                  </run>
                </image>
                <!-- ##### MongoDB based Device Registration service ##### -->
                <image>
                  <name>${docker.repository}/hono-service-device-registry-test:${project.version}</name>
                  <build>
                    <skip>${hono.deviceregistry.mongodb.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${docker.repository}/${hono.deviceregistry.mongodb.image}:${project.version}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/deviceregistry-mongodb</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>opt/hono/config/certs</outputDirectory>
                            <includes>
                              <include>device-registry-*.pem</include>
                              <include>auth-server-cert.pem</include>
                              <include>trusted-certs.pem</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.deviceregistry.mongodb.disabled}</skip>
                    <ports>
                      <port>+deviceregistry.ip:deviceregistry.amqp.port:5672</port>
                      <port>+deviceregistry.ip:deviceregistry.http.port:8080</port>
                      <port>+deviceregistry.ip:deviceregistry.health.port:${health.check.port}</port>
                    </ports>
                    <portPropertyFile>${project.build.directory}/docker/deviceregistry.port.properties</portPropertyFile>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.registration.host}</alias>
                    </network>
                    <cmd>
                      <exec>
                        <arg>${hono.deviceregistry.mongodb.native-image-args}</arg>
                      </exec>
                    </cmd>
                    <memorySwap>${hono.deviceregistry.mongodb.max-mem}</memorySwap>
                    <memory>${hono.deviceregistry.mongodb.max-mem}</memory>
                    <env>
                      <QUARKUS_CONFIG_LOCATIONS>
                        /opt/hono/config/logging-quarkus-${logging.profile}.yml
                      </QUARKUS_CONFIG_LOCATIONS>
                      <JDK_JAVA_OPTIONS>${hono.deviceregistry.mongodb.java-options}</JDK_JAVA_OPTIONS>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                      <OTEL_SERVICE_NAME>${hono.registration.host}</OTEL_SERVICE_NAME>
                      <OTEL_TRACES_SAMPLER>${otel-traces-sampler}</OTEL_TRACES_SAMPLER>
                      <OTEL_TRACES_SAMPLER_ARG>endpoint=http://${jaeger.host}:14250</OTEL_TRACES_SAMPLER_ARG>
                    </env>
                    <log>
                      <prefix>REGISTRY</prefix>
                      <color>${log.color.hono-device-registry}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${deviceregistry.ip}:${deviceregistry.health.port}${health.check.root-path}${health.check.readiness-path}</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
                <!-- ##### PostgreSQL instance for the JDBC based device registry ##### -->
                <image>
                  <name>${postgresql-image.name}</name>
                  <run>
                    <skip>${hono.postgres.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <ports>
                      <port>5432:5432</port>
                    </ports>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>hono-jdbc-db</alias>
                    </network>
                    <memorySwap>134217728</memorySwap>
                    <memory>134217728</memory>
                    <env>
                      <POSTGRES_PASSWORD>${hono.jdbc.db.admin.password}</POSTGRES_PASSWORD>
                    </env>
                    <log>
                      <prefix>POSTGRES</prefix>
                      <color>${log.color.hono-device-registry}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <log>.*(listening on IPv4 address).*</log>
                    </wait>
                  </run>
                </image>
                <!-- ##### JDBC based Device Registration service ##### -->
                <image>
                  <name>${docker.repository}/hono-service-device-registry-test:${project.version}</name>
                  <build>
                    <skip>${hono.deviceregistry.jdbc.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${docker.repository}/${hono.deviceregistry.jdbc.image}:${project.version}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/${hono.deviceregistry.jdbc.resources.folder}</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>opt/hono/config/certs</outputDirectory>
                            <includes>
                              <include>device-registry-*.pem</include>
                              <include>auth-server-cert.pem</include>
                              <include>trusted-certs.pem</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.deviceregistry.jdbc.disabled}</skip>
                    <ports>
                      <port>+deviceregistry.ip:deviceregistry.amqp.port:5672</port>
                      <port>+deviceregistry.ip:deviceregistry.http.port:8080</port>
                      <port>+deviceregistry.ip:deviceregistry.health.port:${health.check.port}</port>
                    </ports>
                    <portPropertyFile>${project.build.directory}/docker/deviceregistry.port.properties</portPropertyFile>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.registration.host}</alias>
                    </network>
                    <cmd>
                      <exec>
                        <arg>${hono.deviceregistry.jdbc.native-image-args}</arg>
                      </exec>
                    </cmd>
                    <memorySwap>${hono.deviceregistry.jdbc.max-mem}</memorySwap>
                    <memory>${hono.deviceregistry.jdbc.max-mem}</memory>
                    <env>
                      <QUARKUS_CONFIG_LOCATIONS>
                        /opt/hono/config/logging-quarkus-${logging.profile}.yml
                      </QUARKUS_CONFIG_LOCATIONS>
                      <JDK_JAVA_OPTIONS>${hono.deviceregistry.jdbc.java-options}</JDK_JAVA_OPTIONS>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                      <OTEL_SERVICE_NAME>${hono.registration.host}</OTEL_SERVICE_NAME>
                      <OTEL_TRACES_SAMPLER>${otel-traces-sampler}</OTEL_TRACES_SAMPLER>
                      <OTEL_TRACES_SAMPLER_ARG>endpoint=http://${jaeger.host}:14250</OTEL_TRACES_SAMPLER_ARG>
                    </env>
                    <log>
                      <prefix>REGISTRY</prefix>
                      <color>${log.color.hono-device-registry}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${deviceregistry.ip}:${deviceregistry.health.port}${health.check.root-path}${health.check.readiness-path}</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
                <!-- ##### Command Router service ##### -->
                <image>
                  <name>${docker.repository}/hono-service-command-router-test:${project.version}</name>
                  <build>
                    <skip>${hono.command-router.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${docker.repository}/${hono.command-router.image}:${project.version}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/commandrouter</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/resources/commandrouter/${hono.command-router.config-src}</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>opt/hono/config/certs</outputDirectory>
                            <includes>
                              <include>command-router-*.pem</include>
                              <include>trusted-certs.pem</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.command-router.disabled}</skip>
                    <ports>
                      <port>commandrouter.amqp.port:5672</port>
                      <port>commandrouter.health.port:${health.check.port}</port>
                    </ports>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.commandrouter.host}</alias>
                    </network>
                    <memorySwap>${hono.command-router.max-mem}</memorySwap>
                    <memory>${hono.command-router.max-mem}</memory>
                    <cmd>
                      <exec>
                        <arg>${hono.command-router.native-image-args}</arg>
                      </exec>
                    </cmd>
                    <env>
                      <QUARKUS_CONFIG_LOCATIONS>
                        /opt/hono/config/logging-quarkus-${logging.profile}.yml
                      </QUARKUS_CONFIG_LOCATIONS>
                      <JDK_JAVA_OPTIONS>${hono.command-router.java-options}</JDK_JAVA_OPTIONS>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                      <OTEL_SERVICE_NAME>${hono.commandrouter.host}</OTEL_SERVICE_NAME>
                      <OTEL_TRACES_SAMPLER>${otel-traces-sampler}</OTEL_TRACES_SAMPLER>
                      <OTEL_TRACES_SAMPLER_ARG>endpoint=http://${jaeger.host}:14250</OTEL_TRACES_SAMPLER_ARG>
                    </env>
                    <log>
                      <prefix>CMDROUTER</prefix>
                      <color>${log.color.hono-services}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${docker.host.address}:${commandrouter.health.port}${health.check.root-path}${health.check.readiness-path}</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
                <!-- ##### HTTP adapter ##### -->
                <image>
                  <name>${docker.repository}/hono-adapter-http-test:${project.version}</name>
                  <build>
                    <skip>${hono.http-adapter.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${docker.repository}/${hono.http-adapter.image}:${project.version}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <dependencySets>
                          <dependencySet>
                            <includes>
                              <!--  use openSSL in HTTP adapter -->
                              <include>io.netty:netty-tcnative-boringssl-static:jar:linux-${os.detected.arch}</include>
                              <include>io.netty:netty-tcnative-classes</include>
                            </includes>
                            <outputDirectory>opt/hono/extensions</outputDirectory>
                          </dependencySet>
                        </dependencySets>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/http</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>opt/hono/config/certs</outputDirectory>
                            <includes>
                              <include>http-adapter-*.pem</include>
                              <include>trustStore.jks</include>
                              <include>trust-store-password</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.http-adapter.disabled}</skip>
                    <ports>
                      <port>+http.ip:http.port:8080</port>
                      <port>https.port:8443</port>
                      <port>+http.ip:http.health.port:${health.check.port}</port>
                    </ports>
                    <portPropertyFile>${project.build.directory}/docker/adapter.http.port.properties</portPropertyFile>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.http-adapter.host}</alias>
                    </network>
                    <memorySwap>${hono.http-adapter.max-mem}</memorySwap>
                    <memory>${hono.http-adapter.max-mem}</memory>
                    <cmd>
                      <exec>
                        <arg>${hono.http-adapter.native-image-args}</arg>
                      </exec>
                    </cmd>
                    <env>
                      <QUARKUS_CONFIG_LOCATIONS>
                        /opt/hono/config/logging-quarkus-${logging.profile}.yml
                      </QUARKUS_CONFIG_LOCATIONS>
                      <JDK_JAVA_OPTIONS>${hono.http-adapter.java-options}</JDK_JAVA_OPTIONS>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                      <OTEL_SERVICE_NAME>${hono.http-adapter.host}</OTEL_SERVICE_NAME>
                      <OTEL_TRACES_SAMPLER>${otel-traces-sampler}</OTEL_TRACES_SAMPLER>
                      <OTEL_TRACES_SAMPLER_ARG>endpoint=http://${jaeger.host}:14250</OTEL_TRACES_SAMPLER_ARG>
                    </env>
                    <log>
                      <prefix>HTTP</prefix>
                      <color>${log.color.hono-protocol-adapters}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${http.ip}:${http.health.port}${health.check.root-path}${health.check.readiness-path}</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
                <!-- ##### MQTT adapter ##### -->
                <image>
                  <name>${docker.repository}/hono-adapter-mqtt-test:${project.version}</name>
                  <build>
                    <skip>${hono.mqtt-adapter.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${docker.repository}/${hono.mqtt-adapter.image}:${project.version}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/mqtt</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>opt/hono/config/certs</outputDirectory>
                            <includes>
                              <include>mqtt-adapter-*.pem</include>
                              <include>trusted-certs.pem</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.mqtt-adapter.disabled}</skip>
                    <ports>
                      <port>+mqtt.ip:mqtt.port:1883</port>
                      <port>mqtts.port:8883</port>
                      <port>+mqtt.ip:mqtt.health.port:${health.check.port}</port>
                    </ports>
                    <portPropertyFile>${project.build.directory}/docker/adapter.mqtt.port.properties</portPropertyFile>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.mqtt-adapter.host}</alias>
                    </network>
                    <memorySwap>${hono.mqtt-adapter.max-mem}</memorySwap>
                    <memory>${hono.mqtt-adapter.max-mem}</memory>
                    <cmd>
                      <exec>
                        <arg>${hono.mqtt-adapter.native-image-args}</arg>
                      </exec>
                    </cmd>
                    <env>
                      <QUARKUS_CONFIG_LOCATIONS>
                        /opt/hono/config/logging-quarkus-${logging.profile}.yml
                      </QUARKUS_CONFIG_LOCATIONS>
                      <JDK_JAVA_OPTIONS>${hono.mqtt-adapter.java-options}</JDK_JAVA_OPTIONS>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                      <OTEL_SERVICE_NAME>${hono.mqtt-adapter.host}</OTEL_SERVICE_NAME>
                      <OTEL_TRACES_SAMPLER>${otel-traces-sampler}</OTEL_TRACES_SAMPLER>
                      <OTEL_TRACES_SAMPLER_ARG>endpoint=http://${jaeger.host}:14250</OTEL_TRACES_SAMPLER_ARG>
                    </env>
                    <log>
                      <prefix>MQTT</prefix>
                      <color>${log.color.hono-protocol-adapters}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${mqtt.ip}:${mqtt.health.port}${health.check.root-path}${health.check.readiness-path}</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
                <!-- ##### AMQP adapter ##### -->
                <image>
                  <name>${docker.repository}/hono-adapter-amqp-test:${project.version}</name>
                  <build>
                    <skip>${hono.amqp-adapter.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${docker.repository}/${hono.amqp-adapter.image}:${project.version}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/amqp</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>opt/hono/config/certs</outputDirectory>
                            <includes>
                              <include>amqp-adapter-*.pem</include>
                              <include>trusted-certs.pem</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.amqp-adapter.disabled}</skip>
                    <ports>
                      <!-- <port>5005</port> -->
                      <port>+amqp.ip:amqp.port:5672</port>
                      <port>+amqps.ip:amqps.port:5671</port>
                      <port>+amqp.ip:adapter.amqp.health.port:${health.check.port}</port>
                    </ports>
                    <portPropertyFile>${project.build.directory}/docker/adapter.amqp.port.properties</portPropertyFile>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.amqp-adapter.host}</alias>
                    </network>
                    <memorySwap>${hono.amqp-adapter.max-mem}</memorySwap>
                    <memory>${hono.amqp-adapter.max-mem}</memory>
                    <cmd>
                      <exec>
                        <arg>${hono.amqp-adapter.native-image-args}</arg>
                      </exec>
                    </cmd>
                    <env>
                      <QUARKUS_CONFIG_LOCATIONS>
                        /opt/hono/config/logging-quarkus-${logging.profile}.yml
                      </QUARKUS_CONFIG_LOCATIONS>
                      <JDK_JAVA_OPTIONS>${hono.amqp-adapter.java-options}</JDK_JAVA_OPTIONS>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                      <OTEL_SERVICE_NAME>${hono.amqp-adapter.host}</OTEL_SERVICE_NAME>
                      <OTEL_TRACES_SAMPLER>${otel-traces-sampler}</OTEL_TRACES_SAMPLER>
                      <OTEL_TRACES_SAMPLER_ARG>endpoint=http://${jaeger.host}:14250</OTEL_TRACES_SAMPLER_ARG>
                    </env>
                    <log>
                      <prefix>AMQP</prefix>
                      <color>${log.color.hono-protocol-adapters}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${amqp.ip}:${adapter.amqp.health.port}${health.check.root-path}${health.check.readiness-path}</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
                <!-- ##### CoAP adapter ##### -->
                <image>
                  <name>${docker.repository}/hono-adapter-coap-test:${project.version}</name>
                  <build>
                    <skip>${hono.coap-adapter.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${docker.repository}/${hono.coap-adapter.image}:${project.version}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/coap</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>opt/hono/config/certs</outputDirectory>
                            <includes>
                              <include>coap-adapter-*.pem</include>
                              <include>trusted-certs.pem</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.coap-adapter.disabled}</skip>
                    <ports>
                      <port>+coap.ip:coap.port:5683/udp</port>
                      <port>coaps.port:5684/udp</port>
                      <port>+coap.ip:coap.health.port:${health.check.port}</port>
                    </ports>
                    <portPropertyFile>${project.build.directory}/docker/adapter.coap.port.properties</portPropertyFile>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.coap-adapter.host}</alias>
                    </network>
                    <memorySwap>${hono.coap-adapter.max-mem}</memorySwap>
                    <memory>${hono.coap-adapter.max-mem}</memory>
                    <cmd>
                      <exec>
                        <arg>${hono.coap-adapter.native-image-args}</arg>
                      </exec>
                    </cmd>
                    <env>
                      <QUARKUS_CONFIG_LOCATIONS>
                        /opt/hono/config/logging-quarkus-${logging.profile}.yml
                      </QUARKUS_CONFIG_LOCATIONS>
                      <JDK_JAVA_OPTIONS>${hono.coap-adapter.java-options}</JDK_JAVA_OPTIONS>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                      <OTEL_SERVICE_NAME>${hono.coap-adapter.host}</OTEL_SERVICE_NAME>
                      <OTEL_TRACES_SAMPLER>${otel-traces-sampler}</OTEL_TRACES_SAMPLER>
                      <OTEL_TRACES_SAMPLER_ARG>endpoint=http://${jaeger.host}:14250</OTEL_TRACES_SAMPLER_ARG>
                    </env>
                    <log>
                      <prefix>COAP</prefix>
                      <color>${log.color.hono-protocol-adapters}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${coap.ip}:${coap.health.port}${health.check.root-path}${health.check.readiness-path}</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
                <!-- ##### Lora adapter ##### -->
                <image>
                  <name>${docker.repository}/hono-adapter-lora-test:${project.version}</name>
                  <build>
                    <skip>${hono.lora-adapter.disabled}</skip>
                    <imagePullPolicy>IfNotPresent</imagePullPolicy>
                    <from>${docker.repository}/${hono.lora-adapter.image}:${project.version}</from>
                    <assembly>
                      <mode>dir</mode>
                      <basedir>/</basedir>
                      <inline>
                        <id>config</id>
                        <fileSets>
                          <fileSet>
                            <directory>${project.build.directory}/resources/lora</directory>
                            <outputDirectory>opt/hono/config</outputDirectory>
                            <includes>
                              <include>*</include>
                            </includes>
                          </fileSet>
                          <fileSet>
                            <directory>${project.build.directory}/certs</directory>
                            <outputDirectory>opt/hono/config/certs</outputDirectory>
                            <includes>
                              <include>lora-adapter-*.pem</include>
                              <include>trusted-certs.pem</include>
                            </includes>
                          </fileSet>
                        </fileSets>
                      </inline>
                    </assembly>
                  </build>
                  <run>
                    <skip>${hono.lora-adapter.disabled}</skip>
                    <ports>
                      <port>+lora.ip:lora.port:8080</port>
                      <port>lora.secure-port:8443</port>
                      <port>+lora.ip:lora.health.port:${health.check.port}</port>
                    </ports>
                    <portPropertyFile>${project.build.directory}/docker/adapter.lora.port.properties</portPropertyFile>
                    <network>
                      <mode>custom</mode>
                      <name>${custom.network.name}</name>
                      <alias>${hono.lora-adapter.host}</alias>
                    </network>
                    <memorySwap>${hono.lora-adapter.max-mem}</memorySwap>
                    <memory>${hono.lora-adapter.max-mem}</memory>
                    <cmd>
                      <exec>
                        <arg>${hono.lora-adapter.native-image-args}</arg>
                      </exec>
                    </cmd>
                    <env>
                      <SMALLRYE_CONFIG_LOCATIONS>
                        /opt/hono/config/logging-quarkus-${logging.profile}.yml
                      </SMALLRYE_CONFIG_LOCATIONS>
                      <JDK_JAVA_OPTIONS>${hono.lora-adapter.java-options}</JDK_JAVA_OPTIONS>
                      <PN_TRACE_FRM>0</PN_TRACE_FRM>
                      <OTEL_SERVICE_NAME>${hono.lora-adapter.host}</OTEL_SERVICE_NAME>
                      <OTEL_TRACES_SAMPLER>${otel-traces-sampler}</OTEL_TRACES_SAMPLER>
                      <OTEL_TRACES_SAMPLER_ARG>endpoint=http://${jaeger.host}:14250</OTEL_TRACES_SAMPLER_ARG>
                    </env>
                    <log>
                      <prefix>LORA</prefix>
                      <color>${log.color.hono-protocol-adapters}</color>
                    </log>
                    <wait>
                      <time>${service.startup.timeout}</time>
                      <http>
                        <method>GET</method>
                        <url>http://${lora.ip}:${lora.health.port}${health.check.root-path}${health.check.readiness-path}</url>
                        <status>200..299</status>
                      </http>
                    </wait>
                  </run>
                </image>
              </images>
            </configuration>
            <executions>
              <execution>
                <id>build_images</id>
                <phase>package</phase>
                <goals>
                  <goal>build</goal>
                </goals>
              </execution>
              <execution>
                <id>start-docker</id>
                <phase>pre-integration-test</phase>
                <goals>
                  <goal>start</goal>
                </goals>
              </execution>
              <execution>
                <id>stop-and-remove-docker</id>
                <phase>post-integration-test</phase>
                <goals>
                  <goal>stop</goal>
                  <goal>remove</goal>
                </goals>
                <configuration>
                  <removeVolumes>true</removeVolumes>
                  <removeNamePattern>**/hono-*-test:*</removeNamePattern>
                </configuration>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-surefire-plugin</artifactId>
            <configuration>
              <skip>true</skip>
            </configuration>
          </plugin>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <configuration>
              <classpathDependencyExcludes>
                <classpathDependencyExclude>org.jboss.slf4j:slf4j-jboss-logmanager</classpathDependencyExclude>
              </classpathDependencyExcludes>
              <environmentVariables>
                <PN_TRACE_FRM>${trace.frames}</PN_TRACE_FRM>
              </environmentVariables>
              <systemPropertyVariables>
                <auth.host>${auth.ip}</auth.host>
                <auth.amqps.port>${auth.amqps.port}</auth.amqps.port>
                <auth.http.port>${auth.health.port}</auth.http.port>
                <downstream.host>${qpid.ip}</downstream.host>
                <downstream.amqp.port>${qpid.amqp.port}</downstream.amqp.port>
                <downstream.amqps.port>${qpid.amqps.port}</downstream.amqps.port>
                <deviceregistry.type>${hono.deviceregistry.type}</deviceregistry.type>
                <deviceregistry.host>${deviceregistry.ip}</deviceregistry.host>
                <deviceregistry.amqp.port>${deviceregistry.amqp.port}</deviceregistry.amqp.port>
                <deviceregistry.http.port>${deviceregistry.http.port}</deviceregistry.http.port>
                <adapter.http.disabled>${hono.http-adapter.disabled}</adapter.http.disabled>
                <adapter.http.host>${http.ip}</adapter.http.host>
                <adapter.http.port>${http.port}</adapter.http.port>
                <adapter.https.port>${https.port}</adapter.https.port>
                <adapter.mqtt.disabled>${hono.mqtt-adapter.disabled}</adapter.mqtt.disabled>
                <adapter.mqtt.host>${mqtt.ip}</adapter.mqtt.host>
                <adapter.mqtt.port>${mqtt.port}</adapter.mqtt.port>
                <adapter.mqtts.port>${mqtts.port}</adapter.mqtts.port>
                <adapter.amqp.disabled>${hono.amqp-adapter.disabled}</adapter.amqp.disabled>
                <adapter.amqp.host>${amqp.ip}</adapter.amqp.host>
                <adapter.amqp.port>${amqp.port}</adapter.amqp.port>
                <adapter.amqps.port>${amqps.port}</adapter.amqps.port>
                <adapter.coap.disabled>${hono.coap-adapter.disabled}</adapter.coap.disabled>
                <adapter.coap.host>${coap.ip}</adapter.coap.host>
                <adapter.coap.port>${coap.port}</adapter.coap.port>
                <adapter.coaps.port>${coaps.port}</adapter.coaps.port>
                <adapter.lora.disabled>${hono.lora-adapter.disabled}</adapter.lora.disabled>
                <adapter.lora.host>${lora.ip}</adapter.lora.host>
                <adapter.lora.port>${lora.port}</adapter.lora.port>
                <adapter.lora.secure-port>${lora.secure-port}</adapter.lora.secure-port>

                <hono.username>hono-client</hono.username>
                <hono.password>secret</hono.password>
                <tenant.admin.username>http-adapter@HONO</tenant.admin.username>
                <tenant.admin.password>http-secret</tenant.admin.password>
                <downstream.username>consumer@HONO</downstream.username>
                <downstream.password>verysecret</downstream.password>
                <deviceregistry.http.authConfig.username>${hono.deviceregistry.http.authConfig.username}</deviceregistry.http.authConfig.username>
                <deviceregistry.http.authConfig.password>${hono.deviceregistry.http.authConfig.password}</deviceregistry.http.authConfig.password>
                <adapter.sendMessageToDeviceTimeout>${adapter.sendMessageToDeviceTimeout}</adapter.sendMessageToDeviceTimeout>
                <trust-store.path>${project.build.directory}/certs/trusted-certs.pem</trust-store.path>
                <test.env>${test.env}</test.env>
                <logging.profile>${logging.profile}</logging.profile>
                <max.bcrypt.costFactor>${max.bcrypt.costFactor}</max.bcrypt.costFactor>
                <vertx.logger-delegate-factory-class-name>io.vertx.core.logging.SLF4JLogDelegateFactory</vertx.logger-delegate-factory-class-name>
<!--                 <javax.net.debug>ssl:handshake</javax.net.debug> -->
                <javax.net.ssl.trustStore>${project.build.directory}/certs/trustStore.jks</javax.net.ssl.trustStore>
                <javax.net.ssl.trustStorePassword>honotrust</javax.net.ssl.trustStorePassword>
              </systemPropertyVariables>
              <failIfNoSpecifiedTests>false</failIfNoSpecifiedTests>
            </configuration>
            <executions>
              <execution>
                <goals>
                  <goal>integration-test</goal>
                  <goal>verify</goal>
                </goals>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>

    <profile>
      <id>useRunningContainers</id>
      <activation>
        <property>
          <name>use-running</name>
        </property>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>properties-maven-plugin</artifactId>
            <executions>
              <execution>
                <phase>initialize</phase>
                <goals>
                  <goal>read-project-properties</goal>
                </goals>
                <configuration>
                  <quiet>true</quiet>
                  <files>
                    <file>${project.build.directory}/docker/auth.port.properties</file>
                    <file>${project.build.directory}/docker/deviceregistry.port.properties</file>
                    <file>${project.build.directory}/docker/qpid.port.properties</file>
                    <file>${project.build.directory}/docker/kafka.port.properties</file>
                    <file>${project.build.directory}/docker/adapter.http.port.properties</file>
                    <file>${project.build.directory}/docker/adapter.lora.port.properties</file>
                    <file>${project.build.directory}/docker/adapter.mqtt.port.properties</file>
                    <file>${project.build.directory}/docker/adapter.amqp.port.properties</file>
                    <file>${project.build.directory}/docker/adapter.coap.port.properties</file>
                  </files>
                </configuration>
              </execution>
            </executions>
          </plugin>
          <!-- disable kafka.port auto generation -->
          <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>build-helper-maven-plugin</artifactId>
            <executions>
              <execution>
                <id>reserve-network-port</id>
                <goals>
                  <goal>reserve-network-port</goal>
                </goals>
                <phase>none</phase>
              </execution>
            </executions>
          </plugin>
          <plugin>
            <groupId>io.fabric8</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <executions>
              <!-- disable 'build', 'start' and 'stop-and-remove' executions -->
              <execution>
                <id>build_images</id>
                <phase>none</phase>
              </execution>
              <execution>
                <id>start-docker</id>
                <phase>none</phase>
              </execution>
              <execution>
                <id>stop-and-remove-docker</id>
                <phase>none</phase>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>

    <profile>
      <id>start</id>
      <activation>
        <property>
          <name>start</name>
        </property>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <configuration>
              <skipITs>true</skipITs>
            </configuration>
          </plugin>
          <plugin>
            <groupId>io.fabric8</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <configuration>
              <verbose>true</verbose>
            </configuration>
            <executions>
              <!-- disable 'stop-and-remove' executions -->
              <execution>
                <id>stop-and-remove-docker</id>
                <phase>none</phase>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>

    <profile>
      <id>stopContainers</id>
      <activation>
        <property>
          <name>stop</name>
        </property>
      </activation>
      <build>
        <plugins>
          <plugin>
            <groupId>io.fabric8</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <configuration>
              <verbose>true</verbose>
            </configuration>
            <executions>
              <!-- disable 'build' and 'start' executions -->
              <execution>
                <id>build_images</id>
                <phase>none</phase>
              </execution>
              <execution>
                <id>start-docker</id>
                <phase>none</phase>
              </execution>
              <execution>
                <id>stop-and-remove-docker</id>
                <phase>post-integration-test</phase>
                <goals>
                  <goal>stop</goal>
                  <goal>remove</goal>
                </goals>
                <configuration>
                  <removeVolumes>true</removeVolumes>
                  <removeNamePattern>**/hono-*-test:*</removeNamePattern>
                  <stopNamePattern>hono-*-test-*,all-in-one-*,cp-*,postgres-*</stopNamePattern>
                </configuration>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
</project>