WebSVN – DevTools – Diff – /buildtool/branches/planMetrics/src/main/java/com/erggroup/buildtool/ripple/Package.java

 package com.erggroup.buildtool.ripple;
 import java.io.File;
 import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.Vector;
-import java.util.Comparator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import com.erggroup.buildtool.ripple.ReleaseManager.BuildReason;
      * instance identifier
+     *
      * @attribute
      */
     public String mVersion = new String();
+    /**
+     * If this package is a candidate for building, then this value will be calculated
+     * and will  be used if the package is selected for building
+     */
+    public String mNextVersion = null;
     /**
      * Version string as specified by the user. Used with a ripple type of 'F'
      */
     String mFixedVersion = new String();
      */
     public boolean mIsBuildable = true;
     /**
      * determines the build file the package is built in, or not
-     * @param   1 Post Plan: build file - Result of planning
+     * <br>   1 Post Plan: build file - Result of planning
-     * @param   2 Post Plan: Future build requirement
+     * <br>   2 Post Plan: Future build requirement
-     * @param   3 Post Plan: Package has no build requirement
+     * <br>   3 Post Plan: Package has no build requirement
-     * @param   0 not yet processed (initial value)
+     * <br>   0 not yet processed (initial value)
-     * @param  -1 not reproducible
+     * <br>  -1 not reproducible
-     * @param  -2 escrow: not reproducible on the build platforms configured for this release
+     * <br>  -2 escrow: not reproducible on the build platforms configured for this release
-     * @param  -3 daemon: do not ripple
+     * <br>  -3 daemon: do not ripple
-     * @param  -4 directly dependent on package versions not in the baseline
+     * <br>  -4 directly dependent on package versions not in the baseline
-     * @param  -5 indirectly dependent on package versions which are not reproducible due to detected fault
+     * <br>  -5 indirectly dependent on package versions which are not reproducible due to detected fault
-     * @param  -6 circular dependency
+     * <br>  -6 circular dependency
-     * @param  -7 Pegged or SDK Imported package not in dpkg_archive
+     * <br>  -7 Pegged or SDK Imported package not in dpkg_archive
-     * @param  -8 Pegged or SDK Imported package
+     * <br>  -8 Pegged or SDK Imported package
-     * @param  -9 Rejected Daemon Instruction
+     * <br>  -9 Rejected Daemon Instruction
-     * @param  -10 UnBuildable Package not in dpkg_archive
+     * <br>  -10 UnBuildable Package not in dpkg_archive
-     * @param  -11 Marked as RippleStop
+     * <br>  -11 Marked as RippleStop
+     *
      */
     int mBuildFile = 0;
     /** Retained reason the package will not be built
     /**
      * non zero instruction number when it is determined to be ripple built by force
+     *
      * @attribute
      */
-    int mForcedRippleInstruction = 0;
+    public int mForcedRippleInstruction = 0;
     /**
      * test build - non zero instruction number when it is determined to be test built
+     *
      * @attribute
      */
-    int mTestBuildInstruction = 0;
+    public int mTestBuildInstruction = 0;
-    /**
-     * test build - Package PVID
-     *
-     * @attribute
-     */
-    int mTestBuildPvId = -1;
-    /**
-     * test build email destination
-     * Used by all daemon instructions to retain instigator of the instruction
-     *
-     * @attribute
-     */
-    String mTestBuildEmail;
-    /**
-     * test build - Version Control System Tag
-     *
-     * @attribute
-     */
-    String mTestBuildVcsTag = new String();
-    /**
-     * test build - build standards
-     *
-     * @attribute
-     */
-    Vector<BuildStandard> mTestBuildStandardCollection = new Vector<BuildStandard>();
-    /**
-     * test build - build dependencies by package alias
-     *
-     * @attribute
-     */
-    Vector<String> mTestBuildDependencyCollection = new Vector<String>();
-    /**
-     * test build - package has build dependencies
-     */
-	public boolean mTestBuildHasAutomatedUnitTests;
     /**
      * build dependencies by pv_id (-1 or not used for planned dependencies)
+     *
      * @attribute
      * Planned packages (WIPS) need calculate a new version number
      * This should be based on the Version of the package that the WIP was based upon
      */
 	public String mPrevVersion;
-	/** Used to preserve the basic ordering of the package list(s)
+    /** Used to preserve the basic ordering of the package list(s)
-	 *  Only valid for the duration of the comparison sorts
+     *  Only valid for the duration of the comparison sorts
-	 */
+     */
-	int mSeqId;
+    int mSeqId;
 	/** Indicates that the package not be ripple built at this time
 	 *  Sequence is:
 	 *     User sets to 's'
 	 *     This buildtool will set to 'w' when a ripple has been detected
 	 *     User resets to NULL when the ripple can be resumed. This is stored as an 'n'
+	 *
 	 */
     public char mRippleStop;
+    /**
+     *  The calculated ripple build plan for this package
+     *  Will not be calculated for all packages, just those of interest
+     *  All packages that can (not must) be built when this package is built
+     *  The list will not include packages that cannot be built at the moment
+     *
+     *  Does not include this package
+     */
+    public ArrayList<Package> mRipplePlan = null;
+    /** The duration (seconds) of the last build of this package
+     *  Used to estimate the cost of building the package
+     *  A WIP packages gets the buildTime of the package its based upon
+     */
+    public int mBuildTime;
+    /** Calculated time ( seconds) that is may take to build this package and then ripple packages that depend on it
+     *  both directly and indirectly. Based on mRipplePlan.
+     */
+    public int mRippleTime = 0;
+    /** Set to indicate that the package is NOT a part of the full release set
+     *  The package is a WIP, TestBuild or a ForcedRipple
+     *
+     *   Used to simplify detection of such packages and to limit processing of these packages
+     *   May be cleared if the package is added to the full set
+     */
+    public boolean mIsNotReleased = false;
     /**
      * Constructor
      * Used to create planned packages. In these packages the change_type is significant
+     *
         mAlias = "null";
         mVcsTag = "null";
+    }
     /**
-     * Constructor for test build purposes
-     * Used when a test build package does not exist in the current package set
-     *
-     */
-    Package(int pkg_id, int pv_id, String pkg_name, String v_ext, String alias, String pkg_vcs_tag, int testBuildInstruction, String email)
-    {
-        mLogger.debug("Package 4: pkg_name " + pkg_name + " v_ext " + v_ext + " alias " + alias + " pkg_vcs_tag "
-                + pkg_vcs_tag);
-        // don't need pv_id
-        mId = -1;
-        mName = pkg_name;
-        mPid = pkg_id;
-        // avoid interaction with real versions
-        mVersion = "0.0.0000";
-        mExtension = v_ext;
-        mAlias = alias;
-        mTestBuildInstruction = testBuildInstruction;
-        mTestBuildEmail = email;
-        mTestBuildVcsTag = pkg_vcs_tag;
-        mTestBuildPvId = pv_id;
-        mTestBuildHasAutomatedUnitTests = false;
-    }
-    /**
      * constructor for unit test purposes
      */
     public Package(ReleaseManager rm, String version, int majorLimit, int minorLimit, int patchLimit, int buildNumberLimit)
+    {
         mId = -1;
     public String getVersion()
+    {
         return mVersion;
+    }
-    /** Set the sequence of all packages in the list
-     *  Used so that the UnitTestComparator function can preserve the
-     *  basic ordering of the list
-     */
-    public static void setSequence(ArrayList<Package> al)
-    {
-        int seq = 1;
-        for (Iterator<Package> it = al.iterator(); it.hasNext(); )
-        {
-            Package p = it.next();
-            p.mSeqId = seq++;
-        }
-    }
-    /** Comparator for sorting unit tests
-     *      Used to sort a list of packages such that the package with the lowest mTestBuildInstruction
-     *      is at the head of the list.
-     *
-     *      Packages without a unit test are sorted by mSeqId to preserve the basic
-     *      ordering of the list.
-     */
-    public static final Comparator<Package> UnitTestComparator = new Comparator<Package>() {
-        /**
-         * Returns -ve: p1 is less than p2
-         *           0: p1 = p2
-         *         +ve: p1 > p2
-         */
-        public int compare (Package p1, Package p2) {
-            // Both are test builds
-            if (p1.mTestBuildInstruction > 0 && p2.mTestBuildInstruction > 0)
-                return p1.mTestBuildInstruction - p2.mTestBuildInstruction;
-            // Neither is a test build
-            if (p1.mTestBuildInstruction == 0 && p2.mTestBuildInstruction == 0)
-                return p1.mSeqId - p2.mSeqId;
-            // Only one is a test build
-            if (p1.mTestBuildInstruction > 0)
-                return -1;
-            return 1;
-        }
-    };
     /**
      * returns true if mBuildStandardCollection is not empty
      */
     boolean isReproducible()
+    {
-        mLogger.debug("isReproducible on Package " + mName);
+        mLogger.debug("isReproducible on Package {}", mName);
         boolean retVal = ! mBuildStandardCollection.isEmpty();
-        mLogger.info("isReproducible returned " + retVal);
+        mLogger.info("isReproducible returned {}", retVal);
         return retVal;
+    }
     /**
      * returns true if at least one of its BuildStandards has mGeneric true
      */
     boolean isGeneric()
+    {
-        mLogger.debug("isGeneric on Package " + mName);
+        mLogger.debug("isGeneric on Package {}", mName);
         boolean retVal = false;
         for (Iterator<BuildStandard> it = mBuildStandardCollection.iterator(); it.hasNext();)
+        {
             BuildStandard buildStandard = it.next();
                 retVal = true;
                 break;
+            }
+        }
-        mLogger.info("isGeneric returned " + retVal);
+        mLogger.info("isGeneric returned {}", retVal);
         return retVal;
+    }
     /**
      * Returns true if at least one of the packages build standards can be
         return false;
+    }
     /**
-     * Applies the required version number change
+     * Applies the required version number change. Will calculate mNextVersion
+     *
      * @param releaseManager    Release Manager instance to work against
      * @param rtag_id           Release Identifier
+     *
-     * @return 0 on success
+     * @return 0 : success
-     *         1 on cannot work with non standard versioning
+     *         1 : cannot work with non standard versioning
-     *         2 on ripple field limitations prevent a ripple build
+     *         2 : ripple field limitations prevent a ripple build
-     *         3 on Invalid Change Type
+     *         3 : Invalid Change Type
      * @exception Exception
      */
     int applyPV(ReleaseManager releaseManager, int rtag_id) throws Exception
+    {
         String logInfo = "applyPV," + mName;
         mLogger.debug("applyPV on Package " + mName);
+        //
+        //  This method used to actually perform the version change
+        //  Now it just calculates the potential value
+        //  Must not alter mVersion as it will be used if the package is not selected to be built,
+        //  but some of the code assumes that it can be.
+        //
+        String originalVersion = mVersion;
         //
         // Four scenarios, only applyPV for 3 of them
         // mDirectlyPlanned mIndirectlyPlanned mArchivalExistence mForcedRipple
         // Action
         // WIP/test build exists: true true don't care don't care applyPV
         if (!mDirectlyPlanned && mIndirectlyPlanned && !mArchivalExistence && mForcedRippleInstruction == 0)
+        {
             // the package has an mIndirectlyPlanned flag set true in daemon
             // mode because the package does not exist in an archive
             // do not apply a different package version
-            mLogger.info("applyPV. Rebuild Package " + mName);
+            mLogger.info("applyPV. Rebuild Package {}", mName);
-            releaseManager.claimVersion(mPid, mVersion + mExtension, rtag_id);
             mLogger.info("applyPv returned 0");
             return 0;
+        }
         // override - no longer doing a rebuild - version number change from this point on
         // Detect invalid change type
         // Flagged when package instance is created
         //
         if (mChangeType.mUnknown)
+        {
-            mLogger.info("Package Version specified on Package " + mName + "New Version:" + mVersion);
+            mLogger.info("Package Version specified on Package {} New Version: {}", mName, mVersion);
             mLogger.info("applyPv returned 3");
             return 3;
+        }
         // If we are not calculating the new package version because the user
         // has fixed the version of the package. We are given the new package version.
         if (mChangeType.mFixed)
+        {
             // mVersion is already setup
-            mVersion = mFixedVersion;
+            mNextVersion = mFixedVersion;
-            mLogger.info("Package Version specified on Package " + mName + "New Version:" + mVersion);
+            mLogger.info("Package Version specified on Package {} New Version: {}", mName,  mVersion);
-            releaseManager.claimVersion(mPid, mVersion + mExtension, rtag_id);
             mLogger.info("applyPv returned 0");
             return 0;
+        }
         // We need to calculate the new version number
             // Can ripple a .cots package under very controlled conditions
             // Its ends with a .patchBuild field
             // Package is marked as ripple via build number
             // Change type of Major and Minor are not allowed
             //
-            if (!mChangeType.mMajor && !mChangeType.mMinor && mRippleField.mBuild && mExtension.compareTo(".cots") == 0
+            if (!mChangeType.mMajor && !mChangeType.mMinor && mRippleField.mBuild && mExtension.compareTo(".cots") == 0 && field.length > 0)
-                    && field.length > 0)
+            {
-                // DEVI 52782
                 // allow and work with (ripple build) versions a.b.c.d....xxxx
                 // where xxxx.length > 3
                 String patchStr = field[field.length - 1];
                 int patchLen = patchStr.length();
+            }
+        }
         if (nonStandardCotsVersion.length() == 0 && patch.value < 1000 && field[2].substring(0, 1).compareTo("0") != 0)
+        {
-            mLogger.info("applyPV accomodate old style mVersion of the form 1.0.1");
+            mLogger.info("applyPV accomodate old style Version of the form 1.0.1");
             patch.value = patch.value * 1000;
+        }
         // mChangeType overrides mRippleField
         do
+            {
                 logInfo += ",CT Major";
                 if (!incrementFieldsAccordingToLimits(4, major, minor, patch))
+                {
                     mLogger.info("applyPv returned 2");
+                    mVersion = originalVersion;
                     return 2;
+                }
             } else if (mChangeType.mMinor)
+            {
                 logInfo += ",CT Minor";
                 if (!incrementFieldsAccordingToLimits(3, major, minor, patch))
+                {
                     mLogger.info("applyPv returned 2");
+                    mVersion = originalVersion;
                     return 2;
+                }
             } else if (mChangeType.mPatch)
+            {
                 logInfo += ",CT Patch";
                 if (!incrementFieldsAccordingToLimits(2, major, minor, patch))
+                {
                     mLogger.info("applyPv returned 2");
+                    mVersion = originalVersion;
                     return 2;
+                }
             } else
+            {
                 if (mRippleField.mMajor)
+                {
                     logInfo += ",R Major";
                     major.value++;
-                    mLogger.info("applyPV mRippleField.mMajor " + major.value);
+                    mLogger.info("applyPV mRippleField.mMajor {}", major.value);
                     minor.value = 0;
                     patch.value = 0;
                 } else if (mRippleField.mMinor)
+                {
                     logInfo += ",R Minor";
                     minor.value++;
-                    mLogger.info("applyPV mRippleField.mMinor " + minor.value);
+                    mLogger.info("applyPV mRippleField.mMinor {}", minor.value);
                     patch.value = 0;
                 } else if (mRippleField.mPatch)
+                {
                     logInfo += ",R Patch";
                     patch.value = ((patch.value / 1000) + 1) * 1000;
-                    mLogger.info("applyPV mRippleField.mPatch " + patch.value);
+                    mLogger.info("applyPV mRippleField.mPatch {}", patch.value);
                 } else if (mRippleField.mBuild)
+                {
                     logInfo += ", R Build";
                     patch.value++;
-                    mLogger.info("applyPV mRippleField.mBuild " + patch.value);
+                    mLogger.info("applyPV mRippleField.mBuild {}", patch.value);
                 } else
+                {
                     if (!incrementFieldsAccordingToLimits(1, major, minor, patch))
+                    {
                         mLogger.info("applyPv returned 2");
+                        mVersion = originalVersion;
                         return 2;
+                    }
+                }
+            }
+            }
             mVersion += String.valueOf(patch.value);
         } while (exists(releaseManager, rtag_id));
-        logInfo += ", Claim:" + mVersion;
+        logInfo += ", Next Version:" + mVersion;
-        releaseManager.claimVersion(mPid, mVersion + mExtension, rtag_id);
         mLogger.error(logInfo);
         mLogger.info("applyPv returned 0");
+        mNextVersion = mVersion;
+        mVersion = originalVersion;
         return 0;
+    }
     /**
      * increments fields according to mRippleField.mLimit if necessary will
         return retVal;
+    }
     /**
-     * Check if a Package Version exists in dpkg_archive or the Release Manager Database
+     * Check if a specified Version of the package exists in dpkg_archive or the Release Manager Database
+     *
      * @param releaseManager Release Manager Instance
      * @param rtag_id        Release Tag Identifier
+     *
      * @return True if the Package Version exists within the Release Manager Database
     private boolean exists(ReleaseManager releaseManager, int rtag_id) throws Exception
+    {
         mLogger.debug("exists on Package " + mName + " version " + mVersion + " extension " + mExtension);
         boolean retVal = false;
-        if (!ReleaseManager.mUseDatabase)
+        if (!releaseManager.mUseDatabase)
+        {
             mLogger.info("exists !releaseManager.mUseDatabase");
+        }
         else
+        {
+    }
     /**
      * Adds email to mBuildFailureEmailCollection.
      * Do not worry about multiple entries. These will be handled when the data is extracted
-     * @param   email   - Email address
+     * @param   email   - Email address. Null is allowed and will not be added
      */
     public void addEmail(String email)
+    {
-        mBuildFailureEmailCollection.add(email);
-    }
-    /**
-     * Transfer the Test Build Email information to the packages email list
-     */
-    void setTestEmail()
-    {
-        mBuildFailureEmailCollection.clear();
-        addEmail(mTestBuildEmail);
+        if (email != null)
-    }
-    /**
-     * Transfer the Test Build Dependency information to the packages dependency collection
-     */
-    void setTestDependencyCollection()
-    {
-        // does not worry about mPackageDendencyCollection by design
-        mDependencyCollection.clear();
-        for (Iterator<String> it = mTestBuildDependencyCollection.iterator(); it.hasNext();)
+        {
-            String dependency = it.next();
-            mDependencyCollection.add(dependency);
-        }
-    }
-    /**
-     * Transfer the Test Build Build Standard information to the packages build standard collection
-     */
-    void setTestBuildStandardCollection()
-    {
-        mBuildStandardCollection.clear();
-        for (Iterator<BuildStandard> it = mTestBuildStandardCollection.iterator(); it.hasNext();)
-        {
-            BuildStandard buildStandard = it.next();
-            mBuildStandardCollection.add(buildStandard);
+            mBuildFailureEmailCollection.add(email);
+        }
+    }
     /**
      * End of Processing for a Test Build
      * If the package depends on a package with a circular dependency then the function
      * will return false.
      */
     public boolean hasCircularDependency(RippleEngine ripEng)
+    {
-        mLogger.debug("hasCircularDependency: " + mAlias);
+        mLogger.debug("hasCircularDependency: {}", mAlias);
         boolean retVal = detectCircularDependency(mAlias, ripEng, null);
-        mLogger.info("hasCircularDependency returned " + retVal);
+        mLogger.info("hasCircularDependency returned {} ", retVal);
         return retVal;
+    }
     /**
      * Returns true is a part of a circular dependency
             mCheckedCircularDependency = true;
+        }
         // return the persisted circular dependency outcome
         retVal = mHasCircularDependency;
-        mLogger.info("detectCircularDependency 2 returned " + retVal);
+        mLogger.info("detectCircularDependency 2 returned {}", retVal);
         return retVal;
+    }
+    /** Set the sequence of all packages in the list
+     *  Used so that the Unit Tests function can preserve the basic ordering of the list
+     */
+    public static void setSequence(ArrayList<Package> al)
+    {
+        int seq = 1;
+        for (Iterator<Package> it = al.iterator(); it.hasNext(); )
+        {
+            Package p = it.next();
+            p.mSeqId = seq++;
+        }
+    }
+    /** Comparator for sorting package collections by mSeqId
+     *  Used to preserve order for unit testing
+     */
+    public static final Comparator<Package> SeqComparator = new Comparator<Package>() {
+        /**
+         * Returns -ve: p1 is less than p2
+         *           0: p1 = p2
+         *         +ve: p1 > p2
+         */
+        public int compare (Package p1, Package p2) {
+                return p1.mSeqId - p2.mSeqId;
+        }
+    };
     /**
      * entity class supporting the ERG version numbering standard:
      * <major>.<minor>.<patch/build> patch/build is at least a 4 digit number
      * whose last 3 digits represent the build

Subversion Repositories DevTools

(root)/buildtool/branches/planMetrics/src/main/java/com/erggroup/buildtool/ripple/Package.java – Rev 7047 → 7048