FileDocCategorySizeDatePackage
Rpm.javaAPI DocApache Ant 1.7011450Wed Dec 13 06:16:22 GMT 2006org.apache.tools.ant.taskdefs.optional

Rpm

public class Rpm extends org.apache.tools.ant.Task
Invokes the rpm tool to build a Linux installation file.

Fields Summary
private static final String
PATH1
private static final String
PATH2
private static final String
PATH3
private static final int
PATH_LEN
private String
specFile
the spec file
private File
topDir
the rpm top dir
private String
command
the rpm command to use
private String
rpmBuildCommand
The executable to use for building the packages.
private boolean
cleanBuildDir
clean BUILD directory
private boolean
removeSpec
remove spec file
private boolean
removeSource
remove sources
private File
output
the file to direct standard output from the command
private File
error
the file to direct standard error from the command
private boolean
failOnError
Halt on error return value from rpm build.
private boolean
quiet
Don't show output of RPM build command on console. This does not affect the printing of output and error messages to files.
Constructors Summary
Methods Summary
public voidexecute()
Execute the task

throws
BuildException is there is a problem in the task execution.


                       
         

        Commandline toExecute = new Commandline();

        toExecute.setExecutable(rpmBuildCommand == null
                                ? guessRpmBuildCommand()
                                : rpmBuildCommand);
        if (topDir != null) {
            toExecute.createArgument().setValue("--define");
            toExecute.createArgument().setValue("_topdir" + topDir);
        }

        toExecute.createArgument().setLine(command);

        if (cleanBuildDir) {
            toExecute.createArgument().setValue("--clean");
        }
        if (removeSpec) {
            toExecute.createArgument().setValue("--rmspec");
        }
        if (removeSource) {
            toExecute.createArgument().setValue("--rmsource");
        }

        toExecute.createArgument().setValue("SPECS/" + specFile);

        ExecuteStreamHandler streamhandler = null;
        OutputStream outputstream = null;
        OutputStream errorstream = null;
        if (error == null && output == null) {
            if (!quiet) {
                streamhandler = new LogStreamHandler(this, Project.MSG_INFO,
                                                     Project.MSG_WARN);
            } else {
                streamhandler = new LogStreamHandler(this, Project.MSG_DEBUG,
                                                     Project.MSG_DEBUG);
            }
        } else {
            if (output != null) {
                try {
                    BufferedOutputStream bos
                        = new BufferedOutputStream(new FileOutputStream(output));
                    outputstream = new PrintStream(bos);
                } catch (IOException e) {
                    throw new BuildException(e, getLocation());
                }
            } else if (!quiet) {
                outputstream = new LogOutputStream(this, Project.MSG_INFO);
            } else {
                outputstream = new LogOutputStream(this, Project.MSG_DEBUG);
            }
            if (error != null) {
                try {
                    BufferedOutputStream bos
                        = new BufferedOutputStream(new FileOutputStream(error));
                    errorstream = new PrintStream(bos);
                }  catch (IOException e) {
                    throw new BuildException(e, getLocation());
                }
            } else if (!quiet) {
                errorstream = new LogOutputStream(this, Project.MSG_WARN);
            } else {
                errorstream = new LogOutputStream(this, Project.MSG_DEBUG);
            }
            streamhandler = new PumpStreamHandler(outputstream, errorstream);
        }

        Execute exe = getExecute(toExecute, streamhandler);
        try {
            log("Building the RPM based on the " + specFile + " file");
            int returncode = exe.execute();
            if (Execute.isFailure(returncode)) {
                String msg = "'" + toExecute.getExecutable()
                    + "' failed with exit code " + returncode;
                if (failOnError) {
                    throw new BuildException(msg);
                } else {
                    log(msg, Project.MSG_ERR);
                }
            }
        } catch (IOException e) {
            throw new BuildException(e, getLocation());
        } finally {
            FileUtils.close(outputstream);
            FileUtils.close(errorstream);
        }
protected org.apache.tools.ant.taskdefs.ExecutegetExecute(org.apache.tools.ant.types.Commandline toExecute, org.apache.tools.ant.taskdefs.ExecuteStreamHandler streamhandler)
Get the execute object.

param
toExecute the command line to use.
param
streamhandler the stream handler to use.
return
the execute object.
since
Ant 1.6.3

        Execute exe = new Execute(streamhandler, null);

        exe.setAntRun(getProject());
        if (topDir == null) {
            topDir = getProject().getBaseDir();
        }
        exe.setWorkingDirectory(topDir);

        exe.setCommandline(toExecute.getCommandline());
        return exe;
protected java.lang.StringguessRpmBuildCommand()
Checks whether rpmbuild is on the PATH and returns the absolute path to it - falls back to rpm otherwise.

return
the command used to build RPM's
since
1.6

        Vector env = Execute.getProcEnvironment();
        String path = null;
        for (Enumeration e = env.elements(); e.hasMoreElements();) {
            String var = (String) e.nextElement();
            if (var.startsWith(PATH1) || var.startsWith(PATH2) || var.startsWith(PATH3)) {
                path = var.substring(PATH_LEN);
                break;
            }
        }

        if (path != null) {
            Path p = new Path(getProject(), path);
            String[] pElements = p.list();
            for (int i = 0; i < pElements.length; i++) {
                File f = new File(pElements[i],
                                  "rpmbuild"
                                  + (Os.isFamily("dos") ? ".exe" : ""));
                if (f.canRead()) {
                    return f.getAbsolutePath();
                }
            }
        }

        return "rpm";
public voidsetCleanBuildDir(boolean cbd)
Flag (optional, default=false) to remove the generated files in the BUILD directory

param
cbd a boolean value.

        cleanBuildDir = cbd;
public voidsetCommand(java.lang.String c)
What command to issue to the rpm build tool; optional. The default is "-bb"

param
c the command to use.

        this.command = c;
public voidsetError(java.io.File error)
Optional file to save stderr to

param
error the file to save error output to.

        this.error = error;
public voidsetFailOnError(boolean value)
If true, stop the build process when the rpmbuild command exits with an error status.

param
value true if it should halt, otherwise false. The default is false.
since
Ant 1.6.3

        failOnError = value;
public voidsetOutput(java.io.File output)
Optional file to save stdout to.

param
output the file to save stdout to.

        this.output = output;
public voidsetQuiet(boolean value)
If true, output from the RPM build command will only be logged to DEBUG.

param
value false if output should be logged, otherwise true. The default is false.
since
Ant 1.6.3

        quiet = value;
public voidsetRemoveSource(boolean rs)
Flag (optional, default=false) to remove the sources after the build. See the --rmsource option of rpmbuild.

param
rs a boolean value.

        removeSource = rs;
public voidsetRemoveSpec(boolean rs)
Flag (optional, default=false) to remove the spec file from SPECS

param
rs a boolean value.

        removeSpec = rs;
public voidsetRpmBuildCommand(java.lang.String c)
The executable to run when building; optional. The default is rpmbuild.

since
Ant 1.6
param
c the rpm build executable

        this.rpmBuildCommand = c;
public voidsetSpecFile(java.lang.String sf)
The name of the spec File to use; required.

param
sf the spec file name to use.

        if ((sf == null) || (sf.trim().equals(""))) {
            throw new BuildException("You must specify a spec file", getLocation());
        }
        this.specFile = sf;
public voidsetTopDir(java.io.File td)
The directory which will have the expected subdirectories, SPECS, SOURCES, BUILD, SRPMS ; optional. If this isn't specified, the baseDir value is used

param
td the directory containing the normal RPM directories.

        this.topDir = td;