Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package org.codehaus.mojo.rpm;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import java.io.File;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
Abstract base class for building RPMs.

Author(s):
Carlos
Brett Okken, Cerner Corp.
  
  abstract class AbstractRPMMojo
      extends AbstractMojo
      implements RPMVersionableMojo
  {
    
Maintains a mapping of macro keys to their values (either evaluated or set via defineStatements.

Since:
2.1-alpha-1
  
      private final Map<StringStringmacroKeyToValue = new HashMap<StringString>();

    
The key of the map is the directory where the files should be linked to. The value is the List of SoftlinkSources to be linked to.

Since:
2.0-beta-3
  
      private final Map<StringList<SoftlinkSource>> linkTargetToSources =
          new LinkedHashMap<StringList<SoftlinkSource>>();

    
The name portion of the output file name.
  
      @Parameter( required = true, property = "rpm.name", defaultValue = "${project.artifactId}" )
      private String name;

    
The version portion of the RPM file name.
  
      @Parameter( required = true, alias = "version", property = "rpm.version", defaultValue = "${project.version}" )
      private String projversion;

    
The release portion of the RPM file name.

Beginning with 2.0-beta-2, this is an optional parameter. By default, the release will be generated from the modifier portion of the project version using the following rules:

  • If no modifier exists, the release will be 1.
  • If the modifier ends with SNAPSHOT, the timestamp (in UTC) of the build will be appended to end.
  • All instances of '-' in the modifier will be replaced with '_'.
  • If a modifier exists and does not end with SNAPSHOT, "_1" will be appended to end.
 
     @Parameter( property = "rpm.release" )
     private String release;

    
The target architecture for the rpm. The default value is noarch.

For passivity purposes, a value of true or false will indicate whether the architecture of the build machine will be used. Any other value (such as x86_64) will set the architecture of the rpm to x86_64.

This can also be used in conjunction with Source targetArchitecture to flex the contents of the rpm based on the architecture.

 
     @Parameter
     private String needarch;

    
The actual targeted architecture. This will be based on evaluation of needarch.
 
     private String targetArch;

    
The target os for building the RPM. By default, this will be populated to Os.OS_NAME.

This can be used in conjunction with Source targetOSName to flex the contents of the rpm based on operating system.

Since:
2.0-beta-3
 
     @Parameter
     private String targetOS;

    
The target vendor for building the RPM. By default, this will be populated to the result of rpm -E %{_host_vendor}.

Since:
2.0-beta-3
 
     @Parameter
     private String targetVendor;

    
Set to a key name to sign the package using GPG. If keyPassphrase is not also provided, this will require the input of the passphrase at the terminal.
 
     @Parameter( property = "gpg.keyname" )
     private String keyname;

    
The directory from which gpg will load keyrings. If not specified, gpg will use the value configured for its installation, e.g. ~/.gnupg or %APPDATA%/gnupg.

Since:
2.1.2
 
     @Parameter( property = "gpg.homedir" )
     private File keypath;

    
The passphrase for the keyname to sign the rpm. This utilizes expect and requires that expect be on the PATH.

Note that the data type used is NOT String.

 <configuration>
     ...
     <keyPassphrase>
         <passphrase>password</passphrase>
     </keyPassphrase>
 
If not given, look up the value under Maven settings using server id at 'keyPassphraseServerId' configuration.

Since:
2.0-beta-4
 
     @Parameter
     private Passphrase keyPassphrase;

    
Server id to lookup the gpg passphrase under Maven settings. The default value intentionally selected to match with maven-gpg-plugin.

Since:
2.1.2
 
     @Parameter( property = "gpg.passphraseServerId", defaultValue = "gpg.passphrase" )
     private String passphraseServerId;

    
The long description of the package.
 
     @Parameter( property = "rpm.description", defaultValue = "${project.description}" )
     private String description;

    
The one-line description of the package.
 
     @Parameter( property = "rpm.summary", defaultValue = "${project.name}" )
     private String summary;

    
The one-line license information.

Since:
2.1-alpha-4
 
     @Parameter
     private String license;

    
The distribution containing this package.
 
     @Parameter
     private String distribution;

    
An icon for the package.
 
     @Parameter
     private File icon;

    
The vendor supplying the package.
 
     @Parameter( property = "rpm.vendor", defaultValue = "${project.organization.name}" )
     private String vendor;

    
A URL for the vendor.
 
     @Parameter( property = "rpm.url", defaultValue = "${project.organization.url}" )
     private String url;

    
The package group for the package.
 
     @Parameter( required = true )
     private String group;

    
The name of the person or group creating the package.
 
     @Parameter( property = "rpm.packager", defaultValue = "${project.organization.name}" )
     private String packager;

    
Automatically add provided shared libraries.

Since:
2.0-beta-4
 
     @Parameter( defaultValue = "true" )
     private boolean autoProvides;

    
Automatically add requirements deduced from included shared libraries.

Since:
2.0-beta-4
 
     @Parameter( defaultValue = "true" )
     private boolean autoRequires;

    
The list of virtual packages provided by this package.
 
     @Parameter
     private LinkedHashSet<Stringprovides;

    
The list of requirements for this package.
 
     @Parameter
     private LinkedHashSet<Stringrequires;

    
The list of prerequisites for this package.

Since:
2.0-beta-3
 
     @Parameter
     private LinkedHashSet<Stringprereqs;

    
The list of obsoletes for this package.

Since:
2.0-beta-3
 
     @Parameter
     private LinkedHashSet<Stringobsoletes;

    
The list of conflicts for this package.
 
     @Parameter
     private LinkedHashSet<Stringconflicts;

    
The relocation prefix for this package.
 
     @Parameter
     private String prefix;

    
Additional relocation prefixes if needed.

Since:
2.1-alpha-4
 
     @Parameter
     private List<Stringprefixes;

    
The area for RPM to use for building the package.
NOTE: The absolute path to the workarea MUST NOT have a space in any of the directory names.

Beginning with release 2.0-beta-3, sub-directories will be created within the workarea for each execution of the plugin within a life cycle.
The pattern will be workarea/name[-classifier].
The classifier portion is only applicable for the attached-rpm goal.

 
     @Parameter( defaultValue = "${project.build.directory}/rpm" )
     private File workarea;

    
The list of file mappings.
 
     @Parameter
     private List<Mappingmappings = Collections.emptyList();

    
The prepare scriptlet;

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet prepareScriptlet;

    
The pre-installation scriptlet.

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet preinstallScriptlet;

    
The post install scriptlet.

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet postinstallScriptlet;

    
The installation scriptlet.

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet installScriptlet;

    
The pre-removal scriptlet.

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet preremoveScriptlet;

    
The post-removal scriptlet.

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet postremoveScriptlet;

    
The verify scriptlet.

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet verifyScriptlet;

    
The clean scriptlet.

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet cleanScriptlet;

    
The pretrans scriptlet.

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet pretransScriptlet;

    
The posttrans script.

Since:
2.0-beta-4
 
     @Parameter
     private Scriptlet posttransScriptlet;

    
The list of triggers to take place on installation of other packages.
  <triggers>
      <installTrigger>
          <subpackage>optional</subpackage>
          <program>program to execute (if not shell) optional</program>
          <script>actual contents of script - optional</script>
          <scriptFile>location of file containing script - optional</script>
          <fileEncoding>character encoding for script file - recommended</fileEncoding>
          <triggers>
              <trigger>package/version to trigger on (i.e. jre > 1.5)</trigger>
              ...
          </triggers>
      </installTrigger>
      <removeTrigger>
          ...
      </removeTrigger>
      <postRemoveTrigger>
          ...
      </postRemoveTrigger>
      ...
  </triggers>
 

Since:
2.0-beta-4
See also:
BaseTrigger
 
     @Parameter
     private List<BaseTriggertriggers;

    
Filters (property files) to include during the interpolation of the pom.xml.

Since:
2.0
 
     @Parameter
     private List<Stringfilters;

    
Expression preceded with the String won't be interpolated \${foo} will be replaced with ${foo}

Since:
2.0
 
     @Parameter( property = "maven.rpm.escapeString" )
     private String escapeString;

    

Since:
2.0
 
     @Parameter( defaultValue = "${session}", readonly = true, required = true )
     private MavenSession session;

    

Since:
2.1-alpha-4
 
     @Parameter( required = true, readonly = true, property = "project.build.sourceEncoding" )
     private String sourceEncoding;

    

Since:
2.0
 
     @Component( role = org.apache.maven.shared.filtering.MavenFileFilter.class, hint = "default" )
     private MavenFileFilter mavenFileFilter;

    
The filter wrappers to use for file filtering.

Since:
2.0
See also:
mavenFileFilter
 
     private List<FilterWrapperdefaultFilterWrappers;

    
The primary project artifact.
 
     @Parameter( required = true, readonly = true, property = "project.artifact" )
     private Artifact artifact;

    
Auxillary project artifacts.
 
     @Parameter( required = true, readonly = true, property = "project.attachedArtifacts" )
     private List<ArtifactattachedArtifacts;
 
     @Parameter( defaultValue = "${project}", readonly = true, required = true )
     protected MavenProject project;

    
Should brp-repack-jars be used in the RPM build. Defaults to false. If it is false brp-repack-jars will be disabled by:
%define __jar_repack 0 This will have no effect on RHEL5 or earlier release.

Since:
2.1-alpha-4
 
     @Parameter
     private boolean repackJars = false;

    
A list of %define arguments
 
     @Parameter
     private List<StringdefineStatements;

    
The default file mode (octal string) to assign to files when installed.
Only applicable to a Mapping if filemode, username, AND groupname are NOT populated.

Since:
2.0-beta-2
 
     @Parameter
     private String defaultFilemode;

    
The default directory mode (octal string) to assign to directories when installed.
Only applicable to a Mapping if filemode, username, AND groupname are NOT populated.

Since:
2.0-beta-2
 
     @Parameter
     private String defaultDirmode;

    
The default user name for files when installed.
Only applicable to a Mapping if filemode, username, AND groupname are NOT populated.

Since:
2.0-beta-2
 
     @Parameter
     private String defaultUsername;

    
The default group name for files when installed.
Only applicable to a Mapping if filemode, username, AND groupname are NOT populated.

Since:
2.0-beta-2
 
     @Parameter
     private String defaultGroupname;

    
Indicates if the execution should be disabled. If true, nothing will occur during execution.

Since:
2.0
 
     @Parameter
     private boolean disabled;

    
The root of the build area prior to calling rpmbuild.
 
     private File buildroot;

    
The root of the build area as used by rpmbuild.
 
     private File rpmBuildroot;

    
The changelog string.
 
     private String changelog;

    
The changelog file. If the file does not exist, it is ignored.

Since:
2.0-beta-3
 
     @Parameter
     private File changelogFile;

    
This is not set until is called.

Since:
2.1-alpha-1
 
     private RPMHelper helper;

    
The system property to read the calculated version from, normally set by the version mojo.

Since:
2.1-alpha-2
 
     @Parameter( required = true, defaultValue = "rpm.version" )
     private String versionProperty;

    
The system property to read the calculated release from, normally set by the version mojo.

Since:
2.1-alpha-2
 
     @Parameter( required = true, defaultValue = "rpm.release" )
     private String releaseProperty;

    
Maven Security Dispatcher

Since:
2.1.2
 
     @Component( hint = "mng-4384" )
     private SecDispatcher securityDispatcher;

    
Current user system settings for use in Maven.

Since:
2.1.2
 
     @Parameter( defaultValue = "${settings}", readonly = true )
     private Settings settings;
 
     // // // Mojo methods
 
    
 
     public final void execute()
     {
         if (  )
         {
             getLog().info"MOJO is disabled. Doing nothing." );
 
             // FIXME, is it a correct way getting install/deploy to ignore the original primary 'rpm' artifact?
             if ( "rpm".equalsthis..getPackaging() ) )
             {
                 this..setPackaging"pom" );
             }
 
             return;
         }
 
         if ( this. != null )
         {
             if ( this. == null )
             {
                 this. = new ArrayList<String>();
             }
             this..add();
         }
 
          = new RPMHelperthis );
 
         checkParams );
 
         final String classifier = getClassifier();
 
         if ( classifier != null )
         {
              = new File + '-' + classifier );
         }
         else
         {
              = new File );
         }
 
         buildWorkArea();
 
         // set up the maven file filter and FilteringDirectoryArchiver
         setDefaultWrappers();
         final FilteringDirectoryArchiver copier = new FilteringDirectoryArchiver();
         copier.setMavenFileFilter );
         new FileHelperthiscopier ).installFiles();
 
         writeSpecFile();
 
         this.loadGpgPassphrase();
 
         .buildPackage();
 
         afterExecution();
     }

    
Will be called on completion of execute(). Provides subclasses an opportunity to perform any post execution logic (such as attaching an artifact).

 
     protected void afterExecution()
     {
 
     }

    
Provides an opportunity for subclasses to provide an additional classifier for the rpm workarea.
By default this implementation returns null, which indicates that no additional classifier should be used.

Returns:
An additional classifier to use for the rpm workarea or null if no additional classifier should be used.
 
     {
         return null;
     }

    
Returns the generated rpm java.io.File.

Returns:
The generated rpm File.
 
     protected File getRPMFile()
     {
         File rpms = new File"RPMS" );
         File archDir = new Filerpms );
 
         return new FilearchDir + '-' +  + '-' +  + '.' +  + ".rpm" );
     }

    
 
     private void setDefaultWrappers()
         throws MojoExecutionException
     {
         final MavenResourcesExecution mavenResourcesExecution = new MavenResourcesExecution();
         mavenResourcesExecution.setEscapeString );
 
         try
         {
              =
                 .getDefaultFilterWrappersfalsethis.,
                                                           mavenResourcesExecution );
         }
         catch ( MavenFilteringException e )
         {
             getLog().error"fail to build filering wrappers " + e.getMessage() );
             throw new MojoExecutionExceptione.getMessage(), e );
         }
     }

    
Build the structure of the work area.

Throws:
org.apache.maven.plugin.MojoFailureException if a directory cannot be built
org.apache.maven.plugin.MojoExecutionException if buildroot cannot be cleared (if exists)
 
     private void buildWorkArea()
     {
         final String[] topdirs = { "BUILD""RPMS""SOURCES""SPECS""SRPMS""tmp-buildroot""buildroot" };
 
         // Build the top directory
         if ( !.exists() )
         {
             getLog().info"Creating directory " + .getAbsolutePath() );
             if ( !.mkdirs() )
             {
                 throw new MojoFailureException"Unable to create directory " + .getAbsolutePath() );
             }
         }
 
         validateWorkarea();
 
         // Build each directory in the top directory
         for ( String topdir : topdirs )
         {
             File dir = new Filetopdir );
             if ( dir.exists() )
             {
                 getLog().info"Directory " + dir.getAbsolutePath() + " already exists. Deleting all contents." );
 
                 try
                 {
                     FileUtils.cleanDirectorydir );
                 }
                 catch ( IOException e )
                 {
                     throw new MojoExecutionException"Unable to clear directory: " + dir.getName(), e );
                 }
             }
             else
             {
                 getLog().info"Creating directory " + dir.getAbsolutePath() );
                 if ( !dir.mkdir() )
                 {
                     throw new MojoFailureException"Unable to create directory " + dir.getAbsolutePath() );
                 }
             }
         }
 
         // set build root variable
          = new File"tmp-buildroot" );
          = new File"buildroot" );
     }

    
Check the parameters for validity.

Throws:
org.apache.maven.plugin.MojoFailureException if an invalid parameter is found
org.apache.maven.plugin.MojoExecutionException if an error occurs reading a script
 
     private void checkParamsRPMHelper helper )
     {
         Log log = getLog();
 
         // Retrieve any versions set by the VersionMojo
         String projversion = this..getProperties().getProperty );
         if ( projversion != null )
         {
             this. = projversion;
         }
         String release = this..getProperties().getProperty );
         if ( release != null )
         {
             this. = release;
         }
 
         // calculate versions if neccessary, check for existing maven modifier and split them accordingly
         if ( this. == null || this. == null || this..contains"-" ) )
         { // including -SNAPSHOT and 1-34
             final VersionHelper.Version version = new VersionHelperthis ).calculateVersion();
             this. = version.version;
             this. = version.release;
         }
 
         log.debug"project version = " + this. );
         log.debug"project release = " + this. );
 
         // evaluate needarch and populate targetArch
         if (  == null || .length() == 0 || "false".equalsIgnoreCase ) )
         {
              = "noarch";
         }
         else if ( "true".equalsIgnoreCase ) )
         {
              = helper.getArch();
         }
         else
         {
              = ;
         }
         log.debug"targetArch = " +  );
 
         // provide default targetOS if value not given
         if (  == null || .length() == 0 )
         {
              = .;
         }
         log.debug"targetOS = " +  );
 
         if (  == null || .length() == 0 )
         {
              = helper.getHostVendor();
         }
         log.debug"targetVendor = " +  );
 
         // Various checks in the mappings
         for ( Mapping map :  )
         {
             if ( map.getDirectory() == null )
             {
                 throw new MojoFailureException"<mapping> element must contain the destination directory" );
             }
             if ( map.getSources() != null )
             {
                 for ( Source src : map.getSources() )
                 {
                     if ( src.getLocation() == null )
                     {
                         throw new MojoFailureException"<mapping><source> tag must contain the source directory" );
                     }
                 }
             }
         }
 
         if ( (  == null ) && (  != null ) )
         {
             if ( !.exists() )
             {
                 log.debug.getAbsolutePath() + " does not exist - ignoring" );
             }
             else
             {
                 try
                 {
                     StringBuilder sb = new StringBuilder();
                     BufferedReader br = new BufferedReadernew FileReader ) );
                     while ( br.ready() )
                     {
                         String line = br.readLine();
                         sb.appendline );
                         sb.append'\n' );
                     }
                     br.close();
                      = sb.toString();
                 }
                 catch ( Throwable t )
                 {
                     throw new MojoExecutionException"Unable to read " + .getAbsolutePath(), t );
                 }
             }
         }
 
         // generate license text if not set
         if (  == null )
         {
              = generateDefaultCopyrightText();
         }
 
         // if this package obsoletes any packages, make sure those packages are added to the provides list
         if (  != null )
         {
             if (  == null )
             {
                  = ;
             }
             else
             {
                 .addAll );
             }
         }
 
         if ( ! )
         {
             if (  == null )
             {
                  = new ArrayList<String>();
             }
 
             .add"__jar_repack 0" );
         }
 
         processDefineStatements();
     }

    
Put all name/value pairs in defineStatements in macroKeyToValue.

Since:
2.1-alpha-1
 
     private void processDefineStatements()
     {
         if (  == null )
         {
             return;
         }
         for ( String define :  )
         {
             String[] parts = define.split" " );
             if ( parts.length == 2 )
             {
                 .putparts[0], parts[1] );
             }
         }
     }

    
Validate that workarea is a directory and that the java.io.File.getAbsolutePath() does not contain any spaces.

 
     private void validateWorkarea()
         throws MojoExecutionException
     {
         if ( !.isDirectory() )
         {
             throw new MojoExecutionException + " is not a directory" );
         }
 
         if ( .getAbsolutePath().trim().indexOf" " ) != -1 )
         {
             throw new MojoExecutionException + " contains a space in path" );
         }
     }

    
Determines the actual value for the macro. Will check both defineStatements and RPMHelper.evaluateMacro(java.lang.String).

Parameters:
macro The macro to evaluate.
Returns:
The literal value or name of macro if it has no value.
Throws:
org.apache.maven.plugin.MojoExecutionException
Since:
2.1-alpha-1
    String evaluateMacroString macro )
        throws MojoExecutionException
    {
        if ( .containsKeymacro ) )
        {
            return .getmacro );
        }
        final String value = .evaluateMacromacro );
        .putmacrovalue );
        return value;
    }

    
Write the SPEC file.

Throws:
org.apache.maven.plugin.MojoExecutionException if an error occurs writing the file
    private void writeSpecFile()
        throws MojoExecutionException
    {
        File f = new File"SPECS" );
        File specf = new Filef + ".spec" );
        try
        {
            getLog().info"Creating spec file " + specf.getAbsolutePath() );
            PrintWriter spec = new UnixPrintWriternew FileWriterspecf ) );
            try
            {
                new SpecWriterthisspec ).writeSpecFile();
            }
            finally
            {
                spec.close();
            }
        }
        catch ( IOException e )
        {
            throw new MojoExecutionException"Unable to write " + specf.getAbsolutePath(), e );
        }
    }

    
Generates a default copyright text from org.apache.maven.project.MavenProject.getOrganization() and org.apache.maven.project.MavenProject.getInceptionYear().

Returns:
Generated copyright text from the organization name and inception year.
    {
        String copyrightText;
        String year = .getInceptionYear();
        String organization = .getOrganization() == null ? null : .getOrganization().getName();
        if ( ( year != null ) && ( organization != null ) )
        {
            copyrightText = year + " " + organization;
        }
        else
        {
            copyrightText = year == null ? organization : year;
        }
        return "(c) " + copyrightText;
    }

    

Returns:
Returns the linkTargetToSources.
    {
        return this.;
    }

    

Returns:
Returns the name.
    final String getName()
    {
        return this.;
    }

    

Returns:
Returns the release.
    public final String getRelease()
    {
        return this.;
    }
    public Date getBuildTimestamp()
    {
        return .getStartTime();
    }

    

Returns:
Returns the description.
    final String getDescription()
    {
        return this.;
    }

    

Returns:
Returns the summary.
    final String getSummary()
    {
        return this.;
    }

    

Returns:
Returns the license.
    final String getLicense()
    {
        return this.;
    }

    

Returns:
Returns the distribution.
    final String getDistribution()
    {
        return this.;
    }

    

Returns:
Returns the icon.
    final File getIcon()
    {
        return this.;
    }

    

Returns:
Returns the vendor.
    final String getVendor()
    {
        return this.;
    }

    

Returns:
Returns the url.
    final String getUrl()
    {
        return this.;
    }

    

Returns:
Returns the group.
    final String getGroup()
    {
        return this.;
    }

    

Returns:
Returns the packager.
    final String getPackager()
    {
        return this.;
    }

    

Returns:
Returns the autoProvides.
    final boolean isAutoProvides()
    {
        return this.;
    }

    

Returns:
Returns the autoRequires.
    final boolean isAutoRequires()
    {
        return this.;
    }

    

Returns:
Returns the provides.
    {
        return this.;
    }

    

Returns:
Returns the requires.
    {
        return this.;
    }

    

Returns:
Returns the prereqs.
    {
        return this.;
    }

    

Returns:
Returns the obsoletes.
    {
        return this.;
    }

    

Returns:
Returns the conflicts.
    {
        return this.;
    }
    final List<StringgetPrefixes()
    {
        return ;
    }

    

Returns:
Returns the mappings.
    final List<MappinggetMappings()
    {
        return this.;
    }

    

Returns:
Returns the prepareScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the preinstallScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the postinstallScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the installScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the preremoveScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the postremoveScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the verifyScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the cleanScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the pretransScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the posttransScriptlet.
    {
        return this.;
    }

    

Returns:
Returns the triggers.
    final List<BaseTriggergetTriggers()
    {
        return this.;
    }

    

Returns:
Returns the defineStatements.
    {
        return this.;
    }

    

Returns:
Returns the defaultFilemode.
    final String getDefaultFilemode()
    {
        return this.;
    }

    

Returns:
Returns the defaultDirmode.
    final String getDefaultDirmode()
    {
        return this.;
    }

    

Returns:
Returns the defaultUsername.
    final String getDefaultUsername()
    {
        return this.;
    }

    

Returns:
Returns the defaultGroupname.
    {
        return this.;
    }

    

Returns:
Returns the buildroot.
    final File getBuildroot()
    {
        return this.;
    }

    

Returns:
Returns the rpmBuildroot.
    final File getRPMBuildroot()
    {
        return this.;
    }

    

InheritDoc:
    public final String getVersion()
    {
        return this.;
    }

    

Returns:
Returns the changelog.
    final String getChangelog()
    {
        return this.;
    }

    

Returns:
Returns the targetArch.
    final String getTargetArch()
    {
        return this.;
    }

    

Returns:
Returns the targetOS.
    final String getTargetOS()
    {
        return this.;
    }

    

Returns:
Returns the targetVendor.
    final String getTargetVendor()
    {
        return this.;
    }

    

Returns:
Returns the keypath.
    final File getKeypath()
    {
        return this.;
    }
    

Returns:
Returns the keyname.
    final String getKeyname()
    {
        return this.;
    }

    

Returns:
Returns the keyPassphrase.
    {
        return this.;
    }

    

Returns:
Returns the workarea.
    final File getWorkarea()
    {
        return this.;
    }

    

Returns:
Returns the artifact.
    final Artifact getArtifact()
    {
        return this.;
    }

    

Returns:
Returns the attachedArtifacts.
    {
        return this.;
    }

    
Returns the wrappers to use for filtering resources.

Returns:
Returns the FilterWrappers to use for filtering resources.
    {
        return this.;
    }

    
Load and decrypt gpg passphrase from maven settings if not given from plugin configuration

    private void loadGpgPassphrase()
        throws MojoFailureException
    {
        if ( this. == null )
        {
            Server server = this..getServer );
            if ( server != null )
            {
                if ( server.getPassphrase() != null )
                {
                    try
                    {
                        this. = new Passphrase();
                        this..setPassphrase.decryptserver.getPassphrase() ) );
                    }
                    catch ( SecDispatcherException e )
                    {
                        throw new MojoFailureException"Unable to decrypt gpg password"e );
                    }
                }
            }
        }
    }