Class AbstractCargoMojo

    • Field Detail

      • CONTEXT_KEY_CONTAINER

        public static final String CONTEXT_KEY_CONTAINER
        The key under which the container instance is stored in the plugin context. We store it so that it's possible to get back the same container instance even if this mojo is called in a different Maven execution context. This is required for stopping embedded containers for example as we need to use the same instance that was started in order to stop them.
      • CONTEXT_KEY_CLASSLOADER

        public static final String CONTEXT_KEY_CLASSLOADER
        The key suffix under which the classloader of the container instance is stored in the plugin context. We store it so that it's possible to get back the same classloader even if this mojo is called in a different Maven execution context. This is required for starting and stopping multiple containers as each container initialization requires different classloader.
        See Also:
        Constant Field Values
    • Constructor Detail

      • AbstractCargoMojo

        public AbstractCargoMojo()
    • Method Detail

      • calculateContainerArtifactId

        public static String calculateContainerArtifactId​(String containerId)
        Calculates the container artifact ID for a given container ID. Note that all containers identifier are in the form containerArtifactId + the version number + x; for example jboss42x is from container artifact ID cargo-core-container-jboss.
        Parameters:
        containerId - Container ID, for example jboss42x.
        Returns:
        Container artifact ID, for example cargo-core-container-jboss.
      • getFileHandler

        protected FileHandler getFileHandler()
        Returns:
        the Cargo file utility class
      • setFileHandler

        protected void setFileHandler​(FileHandler fileHandler)
        Parameters:
        fileHandler - the Cargo file utility class to use. This method is useful for unit testing with Mock objects as it can be passed a test file handler that doesn't perform any real file action.
      • setDeployerElement

        protected void setDeployerElement​(Deployer deployerElement)
        Parameters:
        deployerElement - the Deployer configuration defined by the user
        See Also:
        getDeployerElement()
      • getDaemon

        protected Daemon getDaemon()
        Returns:
        The daemon configuration
      • setContainerElement

        protected void setContainerElement​(Container containerElement)
        Parameters:
        containerElement - the Container configuration defined by the user
        See Also:
        getContainerElement()
      • setCargoProject

        protected void setCargoProject​(CargoProject cargoProject)
        Parameters:
        cargoProject - Cargo project
      • getCargoProject

        protected CargoProject getCargoProject()
        Returns:
        Cargo project
      • isIgnoreFailures

        public boolean isIgnoreFailures()
        Returns:
        the ignoreFailures
      • setIgnoreFailures

        public void setIgnoreFailures​(boolean ignoreFailures)
        Parameters:
        ignoreFailures - the ignoreFailures to set
      • execute

        public final void execute()
                           throws org.apache.maven.plugin.MojoExecutionException

        Note: This method is final so that extending classes cannot extend it. Instead they should implement the doExecute() method.

        Throws:
        org.apache.maven.plugin.MojoExecutionException
      • doExecute

        protected abstract void doExecute()
                                   throws org.apache.maven.plugin.MojoExecutionException
        Executes the plugin.

        This method must be implemented by all Mojos extending this class. The reason for this pattern is because we want the execute() method to always be called so that necessary plugin initialization can be performed. Without this pattern Mojos extending this class could "forget" to call super.execute() thus leading to unpredictible results.

        Throws:
        org.apache.maven.plugin.MojoExecutionException - in case of error
      • createConfiguration

        protected Configuration createConfiguration()
                                             throws org.apache.maven.plugin.MojoExecutionException
        Creates a Configuration instance. If the user has not specified a configuration element in the POM file then automatically create a standalone configuration if the container's type is local or otherwise create a runtime configuration.
        Returns:
        a valid Configuration instance
        Throws:
        org.apache.maven.plugin.MojoExecutionException - in case of error
      • createContainer

        protected Container createContainer()
                                     throws org.apache.maven.plugin.MojoExecutionException
        Returns:
        a Container instance if no container object was stored in the Maven Plugin Context or returns the saved instance otherwise. If a new container instance is created it's also saved in the Maven Plugin Context for later retrieval.
        Throws:
        org.apache.maven.plugin.MojoExecutionException - in case of error
      • createNewContainer

        protected Container createNewContainer()
                                        throws org.apache.maven.plugin.MojoExecutionException
        Creates a brand new Container instance. If the user has not specified a container element in the POM file or if the user has not specified the container id then automatically create a default container (as defined in createDefaultContainerElementIfNecessary()) if the project calling this plugin has a WAR packaging. If the packaging is different then an exception is raised.
        Returns:
        a valid Container instance
        Throws:
        org.apache.maven.plugin.MojoExecutionException - in case of error or if a default container could not be created
      • createDefaultContainerElementIfNecessary

        protected void createDefaultContainerElementIfNecessary()
                                                         throws org.apache.maven.plugin.MojoExecutionException
        Creates a container element if required.
        Throws:
        org.apache.maven.plugin.MojoExecutionException - in case of error or if a default container could not be created
      • createDefaultInstallerElementIfNecessary

        protected void createDefaultInstallerElementIfNecessary()
                                                         throws IOException
        Creates a installer element if required.
        Throws:
        IOException - If the properties file cannot be loaded.
      • createAutoDeployDeployable

        protected Deployable createAutoDeployDeployable​(Container container)
                                                 throws org.apache.maven.plugin.MojoExecutionException
        Create the autodeploy deployable (if the current project is a Java EE deployable)
        Parameters:
        container - Container.
        Returns:
        The autodeploy deployable.
        Throws:
        org.apache.maven.plugin.MojoExecutionException - If deployable creation fails.
      • createLogger

        protected Logger createLogger()
        Create a logger. If a <log> configuration element has been specified by the user then use it. If none is specified then log to the Maven 2 logging subsystem.
        Returns:
        the logger to use for logging this plugin's activity
      • waitDeployableMonitor

        protected void waitDeployableMonitor​(Container container,
                                             boolean starting)
        Waits until all deployables with a deployable monitor are deployed / undeployed.
        Parameters:
        container - Container where is deployable deployed.
        starting - true if container is starting (i.e., wait for deployment), false otherwise.