Subversion Repositories DevTools

package com.erggroup.mass.ant;

import java.io.File;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Copy;
import org.apache.tools.ant.taskdefs.Echo;
import org.apache.tools.ant.taskdefs.Mkdir;
import org.apache.tools.ant.types.FileSet;

public class ReleaseElement implements JatsElement
{
        public static final String TASK_NAME = "release";

        private Project project;

        /**
         * The version, used if type='force'
         */
        private String version;

        /**
         * Specifies the type of release (default=force; all other types are deprecated).
         */
        private String type = "force";
        
        /**
         * Specifies the label used when building this release (optional)
         */
    private String label;

        /**
         * 
         */
        private PackageVersion releaseVersion = null;


        private Jats parent;

        public ReleaseElement()
        {
        }

        public String getElementType()
        {
                return TASK_NAME;
        }

        public void setType(String type)
        {
                this.type = type;
        }

        public void setVersion(String value)
        {
                this.version = value;
        }
        
        public void setLabel( String value )
        {
                this.label = value;
        }

        public void execute(Jats parent)
        {
                this.parent  = parent;
                this.project = parent.getProject();

                if ( "force".equalsIgnoreCase(type) )
                {
                        if ( version == null ) 
                        {
                                throw new BuildException("Release 'version' attribute is mandatory."); 
                        }
                        releaseVersion = new PackageVersion(version);
                }
                else
                {
                        throw new BuildException("Release type can only be 'force'; all other types are deprecated.");
                }

                updateDescpkgFile();

                releasePackage();
        }

        private void updateDescpkgFile()
        {
                StringBuffer buffer = new StringBuffer();

                buffer.append("Package Name: ")
                      .append(parent.getPackage());
                buffer.append("\nVersion:      ")
                          .append(releaseVersion.toString());
                buffer.append("\nReleased By:  ")
                          .append(project.replaceProperties("${user.name}"));
                buffer.append("\nReleased On:  ")
                          .append(new Date());
                
                // Build label (if specified)                   
                if ( label != null )
                {
                        buffer.append("\nLabel:        ")
                                  .append(project.replaceProperties(label));
                }
                
                // Path to source of build (vob-relative)
                File baseDirectory = project.getBaseDir();
                String buildPath = baseDirectory.getAbsolutePath();
                int cpos = buildPath.indexOf(":");
                if ( cpos > -1 )
                {
                        buildPath = buildPath.substring(cpos+1);
                }
                buffer.append("\nPath:         ").append(buildPath);

                buffer.append("\n\nBuild Dependencies:\n");
                Collection sandbox = SandboxElement.getSandboxElements();
                for (Iterator i = sandbox.iterator() ; i.hasNext() ; )
                {
                        SandboxElement element = (SandboxElement)i.next();
                        if ( ! element.isRuntime() )
                        buffer.append("\n<sandbox name=\"")
                                  .append(element.getName())
                                  .append("\" version=\"")
                                  .append(element.getVersion())
                                  .append("\"/>");
                }

                Echo echo = new Echo();
                echo.setTaskName(TASK_NAME);
                echo.setProject(project);
                String descpkgFilename = project.replaceProperties("${basedir}") + "/pkg/descpkg";
                echo.setFile(new File(descpkgFilename));

                echo.setMessage(buffer.toString());
                echo.execute();
        }

        /**
         * Attempts to copy the 'pkg' files into dpkg_archive.
         */
        private void releasePackage()
        {
                String packageName = parent.getPackage();
                String version = releaseVersion.toString();

                // Check for the existance of the package directory in dpkg_archive, and if
                // it exists, then throw an exception.
                File dpkgArchivePackageDir = validatePackageDirectory(packageName);

                File dpkgArchiveVersionDir = validatePackageVersionDirectory(dpkgArchivePackageDir, version);

                // Copy the files from the pkg directory into
                // dpkg_archive/${jats.package.name}/${major}.${minor}.${patch}.${project}
                Copy copy = new Copy();
                copy.setProject(project);
                copy.setTaskName(this.getElementType());
                copy.setTodir(dpkgArchiveVersionDir);

                File basedir = new File(project.replaceProperties("${basedir}"));
                File pkgdir = new File(basedir, "pkg");

                FileSet fileSet = new FileSet();
                fileSet.setDir(pkgdir);
                fileSet.setIncludes("**/*");
                copy.addFileset(fileSet);
                copy.perform();
        }

        /**
         *
         * @param directoryName
         * @return
         */
        private File validatePackageDirectory(String directoryName)
        {
                File dir = new File(parent.getFromdir(), directoryName);

                if (dir.exists() == false)
                {
                        makeDirectory(dir);
                }

                if (dir.isDirectory() == false)
                {
                        throw new BuildException(dir.toString() + " is not a directory.");
                }

                return dir;
        }

        /**
         *
         * @param fromdir
         * @param directoryName
         * @return
         */
        private File validatePackageVersionDirectory(File fromdir, String directoryName)
        {
                File dir = new File(fromdir, directoryName);

                if (dir.exists() == false)
                {
                        makeDirectory(dir);
                }
                else
                {
                        String packageName = parent.getPackage();
                        throw new BuildException("Cannot release package \'"
                                                                         + packageName + "\' version \'"
                                                                         + releaseVersion + "\' as it has already been released.");
                }

                return dir;
        }

        /**
         *
         * @param dir
         */
        private void makeDirectory(File dir)
        {
                Mkdir mkdir = new Mkdir();
                mkdir.setProject(this.project);
                mkdir.setTaskName(this.getElementType());

                mkdir.setDir(dir);

                mkdir.perform();
        }
}