//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

=== Using the karaf-maven-plugin

The Karaf Maven plugin allows you:

* to work with Karaf features: verify and validate a features descriptor, add features bundle into a repository, create a KAR archive from a features descriptor, etc.
* to create Karaf commands help: it generates help from Karaf commands
* to modify Karaf instances and create distributions

See [examples/karaf-maven-example] for details.

==== Packaging

The most generally useful features of the karaf-maven-plugin are exposed as packagings.  To use the packagings the pom or an ancestor must configure the karaf-maven-plugin with extensions:

----
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.karaf.tooling</groupId>
                    <artifactId>karaf-maven-plugin</artifactId>
                    <version>${project.version}</version>
                    <extensions>true</extensions>
                </plugin>
            </plugins>
        </pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.apache.karaf.tooling</groupId>
                <artifactId>karaf-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
----

Then specify the packaging in your project as usual, e.g.

----
    <packaging>kar</packaging>
----

|===
|Packaging |Description

|feature
|The feature packaging verifies a features.xml descriptor using the `karaf:verify` goal.

|kar
|The kar packaging generates a features.xml descriptor using the `karaf:features-generate-descriptor` and then packages a kar using the `karaf:features-create-kar` goal.

|karaf-assembly
|Assembles a Karaf server based on the features descriptors and kar files listed as Maven dependencies.
|===

==== Commands goals

The `karaf-maven-plugin` is able to generate documentation for Karaf commands

===== `karaf:commands-generate-help`

The `karaf:commands-generate-help` goal generates documentation containing Karaf commands help.

It looks for Karaf commands in the current project class loader and generates the help as displayed with the `--help`
option in the Karaf shell console.

====== Example

The example below generates help for the commands in the current project:

----
<project>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.karaf.tooling</groupId>
        <artifactId>karaf-maven-plugin</artifactId>
        <version>${project.version}</version>

        <executions>
          <execution>
            <id>document-commands</id>
            <phase>generate-resources</phase>
            <goals>
              <goal>commands-generate-help</goal>
            </goals>
            <configuration>
              <targetFolder>${project.build.directory}/docbook/sources</targetFolder>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>
----

====== Parameters

|===
|Name |Type |Description

|`targetFolder`
|`File`
|The directory where the documentation output files are to be generated. Default value: ${project.build.directory}/docbkx/sources

|`format`
|`String`
|The output format (docbx, asciidoc, or conf) of the commands documentation. Default value: docbx

|`classLoader`
|`String`
|The class loader to use in loading the commands. Default value: ${project}
|===

==== Features and kar goals

[NOTE]
====
You should use the features or kar packaging instead of these individual goals.
====

The `karaf-maven-plugin` provides several goals to help you create and verify features XML descriptors as well as leverage your features to create a custom Karaf distribution.

===== `karaf:features-generate-descriptor`

The `karaf:features-generate-descriptor` goal generates a features XML file based on the Maven dependencies.
By default, it will follow Maven transitive dependencies, stopping when it encounters bundles already present in features that are Maven dependencies.

A record of the dependency tree search can be found in target/history/treeListing.txt.

You can track dependency changes and warn or fail on change.

====== Configuration

Specify the packaging as a top level element

----
<packaging>feature</packaging>
----

You can supply a feature descriptor to extend in `src/main/feature/feature.xml`.

|===
|Parameter Name |Type |Description

|aggregateFeatures
|boolean (false)
|Specifies processing of feature repositories that are (transitive) Maven dependencies.
If false, all features in these repositories become dependencies of the generated feature.
If true, all features in these repositories are copied into the generated feature repository.

|startLevel
|int
|The start level for the bundles determined from Maven dependencies.
This can be overridden by specifying the bundle in the source feature.xml with the desired startlevel.

|includeTransitiveDependency
|boolean (true)
|Whether to follow Maven transitive dependencies.

|checkDependencyChange
|boolean (false)
|Whether to record dependencies in `src/main/history/dependencies.xml` for change tracking.

|warnOnDependencyChange
|boolean (false)
|whether to fail on changed dependencies (false, default) or warn in the build output (true).

|logDependencyChanges
|boolean (false)
|If true, added and removed dependencies are shown in `target/history`.

|overwriteChangedDependencies
|boolean (false)
|If true, the `src/main/history/dependencies.xml` file will be overwritten if it has changed.
|===

====== Example

----
<project>
...
  <packaging>feature</packaging>
  <dependencies>
    <dependency>
      <groupId>org.apache</groupId>
      <artifactId>bundle1</artifactId>
      <version>1.0</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.karaf.tooling</groupId>
        <artifactId>karaf-maven-plugin</artifactId>
        <version>${project.version}</version>
        <extensions>true</extensions>
        <configuration>
          <enableGeneration>true</enableGeneration>
        </configuration>
        <executions>
          <execution>
            <id>generate-features-file</id>
            <phase>generate-resources</phase>
            <goals>
              <goal>features-generate-descriptor</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>
----

===== `karaf:verify`

Except in unusual circumstances, use the `<packaging>feature</packaging>` to run this goal.

The `karaf:verify` goal verifies and validates a features XML descriptor by checking if all the required imports
for the bundles defined in the features can be matched to a provided export.

By default, the plugin tries to add the Karaf core features (standard and enterprise) in the repositories set.
It means that it's not required to explicitly define the Karaf features descriptor in the repository section of
your features descriptor.

====== Example

The example below validates the features defined in the `target/features.xml` by checking all the imports and exports.
It reads the definition for the packages that are exported by the system bundle from the `src/main/resources/config.properties` file.

----
<project>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.karaf.tooling</groupId>
        <artifactId>karaf-maven-plugin</artifactId>
        <configuration>
        </configuration>
        <executions>
          <execution>
            <id>verify</id>
            <phase>process-resources</phase>
            <goals>
              <goal>verify</goal>
            </goals>
            <configuration>
              <descriptors>
                <descriptor>mvn:org.apache.karaf.features/framework/4.0.4/xml/features</descriptor>
                <descriptor>file:${project.build.directory}/feature/feature.xml</descriptor>
              </descriptors>
              <distribution>org.apache.karaf.features:framework</distribution>
              <javase>1.8</javase>
              <framework>
                <feature>framework</feature>
              </framework>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>
----

====== Parameters

|===
|Name |Type |Description

|`descriptors`
|`String[]`
|The list of features XML repositories to use for the verify

|`features`
|`String[]`
|The list of features to verify. If not specified, all features in the descriptors will be verified.

|`framework`
|`String[]`
|The features providing the Karaf framework (optional)

|`javase`
|`String`
|The Java version to use for the verify

|===

===== `karaf:features-add-to-repository`

Consider using the karaf-assembly packaging which makes it easy to assemble a custom distribution in one step instead
of this individual goal.

The `karaf:features-add-to-repository` goal adds all the required bundles for a given set of features into directory.
You can use this goal to create a `/system` directory for building your own Karaf-based distribution.

By default, the Karaf core features descriptors (standard and enterprise) are automatically included in the descriptors set.

====== Example

The example below copies the bundles for the `spring` and `war` features defined in the Karaf features XML descriptor
into the `target/features-repo` directory.

----
<project>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.karaf.tooling</groupId>
        <artifactId>karaf-maven-plugin</artifactId>
        <version>${project.version}</version>

        <executions>
          <execution>
            <id>features-add-to-repo</id>
            <phase>generate-resources</phase>
            <goals>
              <goal>features-add-to-repository</goal>
            </goals>
            <configuration>
              <descriptors>
                <descriptor>mvn:org.apache.karaf.features/standard/4.0.0/xml/features</descriptor>
                <descriptor>mvn:my.groupid/my.artifactid/1.0.0/xml/features</descriptor>
              </descriptors>
              <features>
                <feature>spring</feature>
                <feature>war</feature>
                <feature>my</feature>
              </features>
              <repository>target/features-repo</repository>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>
----

====== Parameters

|===
|Name |Type |Description

|`descriptors`
|`String[]`
|List of features XML descriptors where the features are defined

|`features`
|`String[]`
|List of features that bundles should be copied to the repository directory

|`repository`
|`File`
|The directory where the bundles will be copied by the plugin goal

|`timestampedSnapshot`
|`boolean`
|For SNAPSHOT artifacts, if false we use the base version (foo-1.0-SNAPSHOT), else we use the timestamped version (foo-1.0-2019xxxx). Default value: false
|===

===== `karaf:create-kar`

[NOTE]
====
Except in unusual circumstances, use the `<packaging>kar</packaging>` to run this goal.
====

The `karaf:kar` goal assembles a KAR archive from a features XML descriptor file, normally generated in the same project
with the `karaf:features-generate-descriptor` goal.

There are two important directories in a kar:

* `repository/`  contains a Maven structured repository of artifacts to be copied into the Karaf repository.
The features descriptor and all the bundles mentioned in it are installed in this directory.
* `resources/` contains other resources to be copied over the Karaf installation.

Everything in `target/classes` is copied into the kar.
Therefore resources you want installed into Karaf need to be in e.g. `src/main/resources/resources`.
This choice is so other resources such as legal files from the maven-remote-resources-plugin can be included under
META-INF in the kar, without getting installed into Karaf.

====== Example

----
<project>
...
  <packaging>kar</packaging>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.karaf.tooling</groupId>
        <artifactId>karaf-maven-plugin</artifactId>
        <version>${project.version}</version>
        <extensions>true</extensions>
        <!-- There is no useful configuration for the kar mojo. The features-generate-descriptor mojo configuration may be useful -->
      </plugin>
    </plugins>
  </build>
</project>
----

===== `karaf:install-kar`

==== Instances and distributions goals

The `karaf-maven-plugin` helps you to build custom Karaf distributions or archives existing Karaf instances:

===== `karaf:assembly`

[NOTE]
====
This goal is run as part of the karaf-assembly packaging.
====

The `karaf:assembly` goal creates a Karaf instance (assembly) filesystem using the Maven dependencies and a provided configuration.

====== Example

----
    ...
    <packaging>karaf-assembly</packaging>
    ...
    <dependencies>
        <dependency>
            <groupId>org.apache.karaf.features</groupId>
            <artifactId>framework</artifactId>
            <type>kar</type>
        </dependency>
        <dependency>
            <groupId>org.apache.karaf.features</groupId>
            <artifactId>standard</artifactId>
            <classifier>features</classifier>
            <type>xml</type>
            <scope>runtime</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.karaf.tooling</groupId>
                <artifactId>karaf-maven-plugin</artifactId>
                <extensions>true</extensions>
                <configuration>
                    <finalName>${project.artifactId}</finalName>
                    <installedBundles>
                        <installedBundle>${additional.bundle}</installedBundle>
                    </installedBundles>
                    <bootFeatures>
                        <feature>bundle</feature>
                        <feature>config</feature>
                        <feature>diagnostic</feature>
                        <feature>feature</feature>
                        <feature>jaas</feature>
                        <feature>shell</feature>
                        <feature>log</feature>
                        <feature>management</feature>
                        <feature>package</feature>
                        <feature>shell-compat</feature>
                        <feature>ssh</feature>
                        <feature>system</feature>
                        <feature>wrap</feature>
                    </bootFeatures>
                </configuration>
            </plugin>
        </plugins>
    </build>
----

By default, the generate Karaf instance is a dynamic distribution (it's started with default set of resources and then you can deploy new applications in this instance).

It's also possible to generate a Karaf instance as a static distribution (kind of immutable):

----
    <dependencies>
        <dependency>
            <groupId>org.apache.karaf.features</groupId>
            <artifactId>static</artifactId>
            <type>kar</type>
        </dependency>
        <dependency>
            <groupId>org.apache.karaf.features</groupId>
            <artifactId>standard</artifactId>
            <classifier>features</classifier>
            <type>xml</type>
        </dependency>
        <dependency>
            <groupId>org.apache.karaf.services</groupId>
            <artifactId>org.apache.karaf.services.staticcm</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.karaf.tooling</groupId>
                <artifactId>karaf-maven-plugin</artifactId>
                <extensions>true</extensions>
                <configuration>
                    <startupFeatures>
                        <startupFeature>static-framework</startupFeature>
                        <startupFeature>scr</startupFeature>
                        <startupFeature>http-whiteboard</startupFeature>
                    </startupFeatures>
                    <framework>static</framework>
                    <useReferenceUrls>true</useReferenceUrls>
                    <environment>static</environment>
                </configuration>
            </plugin>
        </plugins>
    </build>
----

====== Parameters

|===
|Name |Type |Description

|`sourceDirectory`
|`File`
| Base directory used to overwrite resources in generated assembly after the build (resource directory). Default value: ${project.basedir}/src/main/resources/assembly

|`workDirectory`
|`File`
|Base directory used to copy the resources during the build (working directory). Default value: ${project.build.directory}/assembly

|`featuresProcessing`
|`File`
|Optional location for custom features processing XML configuration (`etc/org.apache.karaf.features.cfg`). Default value: null

|`installAllFeaturesByDefault`
|`Boolean`
|For given stage (startup, boot, install) if there are no stage-specific features and profiles, all features from stage-specific repositories will be used. Default value: true

|`environment`
|`String`
|An environment identifier that may be used to select different variant of PID configuration file, e.g., `org.ops4j.pax.url.mvn.cfg#docker`. Default value: null

|`defaultStartLevel`
|`int`
|Default start level for bundles in features that don't specify it. Default value: 30

|`startupRepositories`
|`List<String>`
|List of compile-scope features XML files to be used in startup stage (etc/startup.properties).

|`bootRepositories`
|`List<String>`
|List of runtime-scope features XML files to be used in boot stage (etc/org.apache.karaf.features.cfg)

|`installedRepositories`
|`List<String>`
|List of provided-scope features XML files to be used in install stage

|`blacklistedRepositories`
|`List<String>`
|List of blacklisted repository URIs. Blacklisted URI may use globs and version ranges.

|`startupFeatures`
|`List<String>`
|List of features from compile-scope features XML files and KARs to be installed into system repo and listed in etc/startup.properties.

|`bootFeatures`
|`List<String>`
|List of features from runtime-scope features XML files and KARs to be installed into system repo and listed in featuresBoot property in etc/org.apache.karaf.features.cfg

|`installedFeatures`
|`List<String>`
|List of features from provided-scope features XML files and KARs to be installed into system repo and not mentioned elsewhere.

|`blacklistedFeatures`
|`List<String>`
|List of feature blacklisting clauses. Each clause is in one of the formats (feature-name, feature-name;range=version-or-range, feature-name/version-or-range

|`startupBundles`
|`List<String>`
|List of compile-scope bundles added to etc/startup.properties

|`bootBundles`
|`List<String>`
|List of runtime-scope bundles wrapped in special feature added to featuresBoot property in etc/org.apache.karaf.features.cfg

|`installedBundles`
|`List<String>`
|List of provided-scope bundles added to system repo

|`blacklistedBundles`
|`List<String>`
|List of blacklisted bundle URIs. Blacklisted URI may use globs and version ranges.

|`profilesUris`
|`List<String>`
|List of profile URIs to use

|`startupProfiles`
|`List<String>`
|List of profiles names to load from configured `profilesUris` and use as startup profiles.

|`bootProfiles`
|`List<String>`
|List of profiles names to load from configured `profilesUris` and use as boot profiles.

|`installedProfiles`
|`List<String>`
|List of profiles names to load from configured `profilesUris` and use as installed profiles.

|`blacklistedProfiles`
|`List<String>`
|List of blacklisted profile names (possibly using `*` glob).

|`writeProfiles`
|`boolean`
|When assembly custom distribution, we can include generated and added profiles in the distribution itself, in `${karaf.etc}/profiles` directory. Default value: false

|`generateConsistencyReport`
|`String`
|When assembly custom distribution, we can also generate an XML/XSLT report with the summary of bundles. This parameter specifies target directory, to which `bundle-report.xml` and `bundle-report-full.xml` (along with XSLT stylesheet) will be written.

|`consistencyReportProjectName`
|`String`
|When generating consistency report, we can specify project name. Default value: Apache Karaf

|`consistencyReportProjectVersion`
|`String`
|When generating consistency report, we can specify project version. Default value: ${project.version}
|===

===== `karaf:archive`

[NOTE]
====
This goal is run as part of the karaf-assembly packaging.
====

The `karaf:archive` goal packages a Karaf instance archive from a given assembled instance.

Both tar.gz and zip formats are generated in the destination folder.

====== Example

The example below create archives for the given Karaf instance:

----
<project>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.karaf.tooling</groupId>
        <artifactId>karaf-maven-plugin</artifactId>
        <version>${project.version}</version>
          <executions>
            <execution>
              <id>generate</id>
              <phase>package</phase>
              <goals>
                <goal>archive</goal>
              </goals>
              <configuration>
                <destDir>${project.build.directory}</destDir>
                <targetServerDirectory>${project.build.directory}/assembly</targetServerDirectory>
                <targetFile>${project.file}</targetFile>
              </configuration>
            </execution>
          </executions>
        </plugin>
    </plugins>
  </build>
</project>
----

====== Parameters

|===
|Name |Type |Description

|`destDir`
|`File`
| The target directory of the project. Default value: ${project.build.directory}

|`targetServerDirectory`
|`File`
|The location of the server repository. Default value: ${project.build.directory}/assembly

|`pathPrefix`
|`String`
|Path prefix of files in the created archive. Default value: ${project.artifactId}-${project.version}

|`usePathPrefix`
|`boolean`
|Use a path prefix of files in the created archive. Default value: false

|`targetFile`
|`File`
|The target file to set as the project's artifact. Default value: ${project.artifactId}-${project.version}

|`archiveZip`
|`Boolean`
|Switches creation of *.zip artifact on or off. Default value: true

|`archiveTarGz`
|`Boolean`
|Switches creation of *.tar.gz artifact on or off. Default value: true

|`attach`
|`boolean`
|Whether to attach the resulting assembly to the project as an artifact. Default value: true

|`classifier`
|`String`
|If supplied, the classifier for the artifact when attached.

|`useSymLinks`
|`boolean`
|Use symbolic links in tar.gz or zip archives. Symbolic links are not very well supported by windows Platform. At least, is does not work on WinXP + NTFS, so do not include them for now. Default value: false
|===

==== Run, client, deploy goals

These goals allows you to run Karaf via Maven or interact with a running instance.

===== `karaf:run`

`karaf:run` goal runs a Karaf instance from Maven.

It can use the current project if it's a bundle to directly deploy the project artifact in the running Karaf instance.

====== Example

----
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.karaf.tooling</groupId>
                <artifactId>karaf-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>run</id>
                        <goals>
                            <goal>run</goal>
                        </goals>
                        <configuration>
                            <karafDistribution>mvn:org.apache.karaf/apache-karaf/4.2.4/zip</karafDistribution>
                            <keepRunning>false</keepRunning>
                            <deployProjectArtifact>false</deployProjectArtifact>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
----

====== Parameters

|===
|Name |Type |Description

|`karafDirectory`
|`File`
|Directory containing Karaf container base directory. Default value: ${project.build.directory}/karaf

|`karafDistribution`
|`File`
|Location where to download the Karaf distribution. Default value: mvn:org.apache.karaf/apache-karaf/LATEST/zip

|`deployProjectArtifact`
|`boolean`
|Define if the project artifact should be deployed in the started container or not. Default value: true

|`featureRepositories`
|`String[]`
|A list of URLs referencing feature repositories that will be added to the karaf instance started by this goal.

|`featuresToInstall`
|`String`
|Comma-separated list of features to install.

|`keepRunning`
|`boolean`
|Define if the Karaf container keep running or stop just after the goal execution. Default value: true

|`startSsh`
|`boolean`
|Define if the Karaf embedded sshd should be started or not. Default value: false
|===

===== `karaf:client`

The `karaf:client` interacts with a running Karaf instance directly from Maven via SSH.

====== Example

----
<execution>
    <id>client</id>
    <goals>
        <goal>client</goal>
    <goals>
    <configuration>
        <commands>
            <command>
                <rank>1</rank>
                <command>feature:install foo</command>
            </command>
        </commands>
    </configuration>
</execution>
----

====== Parameters

|===
|Name |Type |Description

|`port`
|`int`
|SSH port of the running Karaf instance. Default value: 8101

|`host`
|`String`
|Hostname or IP address of the running Karaf instance. Default value: localhost

|`user`
|`String`
|The username to connect to the running Karaf instance. Default value: karaf

|`password`
|`String`
|The password to connect to the running Karaf instance. Default value: karaf

|`keyFile`
|`File`
|The key file to use to connecto to the running Karaf instance.

|`attempts`
|`int`
|The number of tentative to connect to the running Karaf instance. Default value: 0

|`delay`
|`int`
|The delay (in second) to wait before trying to connect to the Karaf instance. Default value: 2

|`commands`
|`List<CommandDescriptor>`
|The list of the commands to execute on the running Karaf instance.

|`scripts`
|`List<ScriptDescriptor>`
|The list of the scripts to execute on the running Karaf instance.

|`skip`
|`boolean`
|Skip or not the execution of the client goal execution. Default value: false
|===

===== `karaf:deploy`

The `karaf:deploy` goal allows you to deploy bundles on a running Karaf instance (via SSH or JMX).

===== Example

----
<execution>
    <id>deploy</id>
    <goals>
        <goal>deploy</goal>
    <goals>
    <configuration>
        <useProjectArtifact>true</useProjectArtifact>
    </configuration>
</execution>
----

===== Parameters

|===
|Name |Type |Description

|`port`
|`int`
|SSH port of the running Karaf instance. Default value: 8101

|`host`
|`String`
|Hostname or IP address of the running Karaf instance. Default value: localhost

|`user`
|`String`
|The username to connect to the running Karaf instance. Default value: karaf

|`password`
|`String`
|The password to connect to the running Karaf instance. Default value: karaf

|`keyFile`
|`File`
|The key file to use to connecto to the running Karaf instance.

|`attempts`
|`int`
|The number of tentative to connect to the running Karaf instance. Default value: 0

|`delay`
|`int`
|The delay (in second) to wait before trying to connect to the Karaf instance. Default value: 2

|`instance`
|`String`
|Name of the Karaf instance. Default value: karaf-root

|`useSsh`
|`boolean`
| Define if the deployment is done via SSH or via JMX. Default value: false

|`useProjectArtifact`
|`boolean`
|Define if deploy uses the current Maven project artifact (in the case of the project is a bundle project). Default value: true

|`artifactLocations`
|`List<String>`
|The list of bundle locations (mvn, http, file, ... URLs) to deploy.
|===

==== Dockerfile, Docker

The Karaf Maven plugin is also able to generate Dockerfile and eventually interact with a local Docker daemon.

===== Dockerfile

The `karaf:dockerfile` goal creates a ready to use Dockerfile for a given Karaf distribution/assembly.

====== Example

----
<execution>
    <id>dockerfile</id>
    <goals>
        <goal>dockerfile</goal>
    </goals>
</execution>
----

====== Parameters

|===
|Name |Type |Description

|`destDir`
|`File`
|The directory where the Dockerfile is generated. Default value: ${project.build.directory}

|`assembly`
|`File`
|The directory containing the Karaf assembly (as generated by `karaf:assembly`). Default value: ${project.build.directory}/assembly
|===

===== Docker

The `karaf:docker` goal interacts directly with a local Docker daemon (via the command line) to directly create a Docker image with your Karaf assembly.

[NOTE]
====
This goal requires a local Docker daemon and runs only on Unix. The `docker` command has to be in the `PATH`.
====

====== Example

----
<execution>
    <id>docker</id>
    <goals>
        <goal>docker</docker>
    </goals>
</execution>
----

====== Parameters

|===
|Name |Type |Description

|`location`
|`File`
|The directory containing the Dockerfile (can be generated by `karaf:dockerfile`). Default value: ${project.build.directory}

|`imageName`
|`String`
|The name of the generated Docker image. Default value: karaf
|===