Subversion Repositories DevTools

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 org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.erggroup.buildtool.ripple.ReleaseManager.BuildReason;

import com.erggroup.buildtool.smtp.CreateUrls;

import com.erggroup.buildtool.smtp.Smtpsend;

import com.erggroup.buildtool.utilities.MutableInt;

import com.erggroup.buildtool.utilities.XmlBuilder;

import com.erggroup.buildtool.utilities.utilities;

public class Package

{

    /**

     * name of package, must not contain spaces

     * 

     * @attribute

     */

    String mName = new String();

    /**

     * package scope

     * 

     * @attribute

     */

    String mExtension = new String();

    /**

     * 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();

    /**

     * unique identifier 

     *      daemon builds = mName + mExtension

     *      escrow builds = mName + mVersion + mExtension

     * 

     * @attribute

     */

    public String mAlias = new String();

    /**

     * Version Control System Tag

     * 

     * @attribute

     */

    String mVcsTag = new String();

    /**

     * build standards

     * 

     * @attribute

     */

    public Vector<BuildStandard> mBuildStandardCollection = new Vector<BuildStandard>();

    /**

     * GBE_MACHTYPE used to build generic packages for this baseline only has

     * meaning in the daemon build, not the escrow build accessed by

     * BuildStandard::getPlatform, getBuildStandard

     * 

     * @attribute

     */

    public static String mGenericMachtype = System.getenv("GBE_MACHTYPE");

    /**

     * build dependencies by package alias

     * 

     * @attribute

     */

    public Vector<String> mDependencyCollection = new Vector<String>();

    /**

     * primary package version key pv_id in database

     * 

     * @attribute

     */

    public int mId;

    /**

     * indication of the nature of change

     * 

     * @attribute

     */

    Package.VersionNumberingStandard mChangeType = new VersionNumberingStandard();

    /**

     * determines what field is rippled on a package version whose dependencies

     * have changed

     * 

     * @attribute

     */

    Package.VersionNumberingStandard mRippleField = new VersionNumberingStandard();

    /**

     * interested owners

     * 

     * @attribute

     */

    private Vector<String> mBuildFailureEmailCollection = new Vector<String>();

    /**

     * when true will trigger unit tests as part of the package build phase in

     * daemon mode

     * 

     * @attribute

     */

    public boolean mHasAutomatedUnitTests = false;

    /**

     * when true, do not ripple this package through packages which are

     * dependent upon it in daemon mode

     * 

     * @attribute

     */

    public boolean mAdvisoryRipple = false;

    /**

     * Pegged packages will:

     *   - Not be rippled

     *   - Not be test buildable

     *   - Dependencies will not be considered

     *   Daemon Mode:

     *      Are not built in this release

     *      Are imported with out consideration as to their dependencies

     *      Must exist in dpkg_archive - will not be built if not present

     *   Escrow Mode:

     *      Have no special consideration

     *      The package and its dependencies will be built

     *

     * Packages imported into the release from an SDK will be treated as if they were

     * pegged by the built system.

     * 

     */

    public boolean mIsPegged = false;

    public boolean mIsSdk = false;

    /**

     * Unbuildable packages will not be candidates for a ripple or a rebuild

     * If they do not exist in dpkg_archive, then then will cause an error

     */

    public boolean mIsBuildable = true;

    /**

     * determines the build file the package is built in, or not

     * <br>   1 Post Plan: build file - Result of planning

     * <br>   2 Post Plan: Future build requirement

     * <br>   3 Post Plan: Package has no build requirement

     * <br>   0 not yet processed (initial value) 

     * <br>  -1 not reproducible

     * <br>  -2 escrow: not reproducible on the build platforms configured for this release

     * <br>  -3 daemon: do not ripple

     * <br>  -4 directly dependent on package versions not in the baseline

     * <br>  -5 indirectly dependent on package versions which are not reproducible due to detected fault

     * <br>  -6 circular dependency

     * <br>  -7 Pegged or SDK Imported package not in dpkg_archive

     * <br>  -8 Pegged or SDK Imported package

     * <br>  -9 Rejected Daemon Instruction

     * <br>  -10 UnBuildable Package not in dpkg_archive

     * <br>  -11 Marked as RippleStop

     * 

     */

    int mBuildFile = 0;

    /** Retained reason the package will not be built

     *  Save negative values as mBuildFile

     * @attribute

     */

    int mNoBuildReason = 0;

    /**

     * build dependencies by package

     * Calculated from information in mDependencyCollection

     * 

     * @attribute

     */

    Vector<Package> mPackageDependencyCollection = new Vector<Package>();

    /**

     * used for escrow build purposes set true when a package has been processed

     * 

     * @attribute

     */

    boolean mProcessed = false;

    /**

     * Reason that a package is being built

     */

    public BuildReason mBuildReason = null;

    /**

     * set true for WIP package versions only used in daemon mode

     * 

     * @attribute

     */

    public boolean mDirectlyPlanned = false;

    /**

     * set true when it is determined to be ripple built

     * 

     * @attribute

     */

    boolean mIndirectlyPlanned = false;

    /**

     * non zero instruction number when it is determined to be ripple built by force

     * 

     * @attribute

     */

    public int mForcedRippleInstruction = 0;

    /**

     * test build - non zero instruction number when it is determined to be test built

     * 

     * @attribute

     */

    public int mTestBuildInstruction = 0;

    /**

     * build dependencies by pv_id (-1 or not used for planned dependencies)

     * 

     * @attribute

     */

    public Vector<Integer> mDependencyIDCollection = new Vector<Integer>();

    /**

     * unique pkg_id in the database used for querying package version existence

     * in the database in daemon mode

     * 

     * @attribute

     */

    public int mPid;

    /**

     * maximum major number supported for determining ripple number

     * 

     * @attribute

     */

    int mMajorLimit;

    /**

     * maximum minor number supported for determining ripple number

     * 

     * @attribute

     */

    int mMinorLimit;

    /**

     * maximum patch number supported for determining ripple number

     * 

     * @attribute

     */

    int mPatchLimit;

    /**

     * maximum build number number supported for determining ripple number

     * 

     * @attribute

     */

    int mBuildLimit;

    /**

     * Logger

     * 

     * @attribute

     */

    private static final Logger mLogger = LoggerFactory.getLogger(Package.class);

    /**

     * dpkg archive location - The writable dpkg_archive

     * 

     * @attribute

     */

    public static String mGbeDpkg = System.getenv("GBE_DPKG");

    /**

     *  A physically close replica of dpkg_archive

     *  Is not writable 

     */

    public static final String mGbeDpkgReplica = System.getenv("GBE_DPKG_REPLICA");

    /**

     * Exception message used upon detection an archive does not exist Seems

     * this is a rare but transient and recoverable scenario

     * 

     * @attribute

     */

    public static final String mRecoverable = "dpkg_archive does not exist, recovery will be attempted";

    /**

     * true if the package exists in the package archive (dpkg_archive)

     * 

     * @attribute

     */

    private boolean mArchivalExistence = true;

    /**

     * when true will trigger source control interaction eg labelling

     * 

     * @attribute

     */

    public boolean mRequiresSourceControlInteraction = true;

    /**

     * when true has been checked for circular dependency

     * 

     * @attribute

     */

    boolean mCheckedCircularDependency = false;

    /**

     * when true has circular dependency, or in the process of detecting a circular dependency

     * 

     * @attribute

     */

    boolean mHasCircularDependency = false;

    /**

     * Bread crumb used to detect circular dependencies

     * 0 - Normal state

     * 1 - Crumb has been set

     * 2 - Crumb is a part of a circular dependency

     * 3 - Crumb is the start/end of the loop

     */

    int mBreadCrumb = 0;

    /**

     * 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)

     *  Only valid for the duration of the comparison sorts

     */

    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 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;

    /** 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;

    /** Used by some algorithms for various indications

     * 

     */

    public boolean mIsProcessed = false;

    /**

     * Constructor

     * Used to create planned packages (WIP). In these packages the change_type is significant

     * 

     * @param pkg_id	   Package Name Identifier

     * @param pv_id        Package Version Id

     * @param pkg_name     Package Name

     * @param pkg_version  Package Version

     * @param v_ext        Package Suffix

     * @param alias        Package Alias

     * @param pkg_vcs_tag  Vcs Tag

     * @param ripple_field Ripple Field

     * @param change_type  Change Type

     */

    public Package(int pkg_id, int pv_id, String pkg_name, String pkg_version, String v_ext, String alias, String pkg_vcs_tag, char ripple_field, char change_type)

    {

        mLogger.error("Package 1: pv_id {} pkg_name {} v_ext {} alias {} pkg_vcs_tag {} change_type {}", pv_id, pkg_name,v_ext,alias, pkg_vcs_tag, change_type);

        mId = pv_id;

        mName = pkg_name;

        mPid = pkg_id;

        mVersion = "0.0.0000";

        mExtension = v_ext;

        mAlias = alias;

        mVcsTag = pkg_vcs_tag;

        // Remove the package suffix from package_version to create the fixed version number

        mFixedVersion = pkg_version;

        mFixedVersion = mFixedVersion.substring(0, mFixedVersion.length() - mExtension.length());

        // a ripple_field of 'L' indicates this package has limited version numbering

        if (change_type == 'M') {

            mChangeType.setMajor(ripple_field == 'L' ? true : false);

        } else if (change_type == 'N') {

            mChangeType.setMinor(ripple_field == 'L' ? true : false);

        } else if (change_type == 'P') {

            mChangeType.setPatch(ripple_field == 'L' ? true : false);

        } else if (change_type == 'F') {

            mChangeType.setFixed();

        } else {

            mChangeType.setUnknown();

        }

    }

    /**

     * Constructor

     * Used to create existing packages, in these packages the ripple_field is significant

     * 

     * @param pkg_id	   Package Name Identifier

     * @param pv_id        Package Version Id

     * @param pkg_name     Package Name

     * @param pkg_version  Package Version

     * @param v_ext        Package Suffix

     * @param alias        Package Alias

     * @param pkg_vcs_tag  Vcs Tag

     * @param ripple_field Ripple Field

     */

    public Package(int pkg_id,int pv_id, String pkg_name, String pkg_version, String v_ext, String alias, String pkg_vcs_tag, char ripple_field)

    {

        mLogger.debug("Package 2: pv_id " + pv_id + " pkg_name " + pkg_name + " pkg_version " + pkg_version + " v_ext "

                + v_ext + " alias " + alias + " pkg_vcs_tag " + pkg_vcs_tag + " ripple_field " + ripple_field);

        mId = pv_id;

        mName = pkg_name;

        mPid = pkg_id;

        mVersion = pkg_version;

        int endindex = mVersion.length() - v_ext.length();

        if (endindex > 0)

        {

            mVersion = mVersion.substring(0, endindex);

        }

        mExtension = v_ext;

        mAlias = alias;

        mVcsTag = pkg_vcs_tag;

        // setBuild is the default

        if (ripple_field == 'M') {

            mRippleField.setMajor();

        } else if (ripple_field == 'm') {

            mRippleField.setMinor();

        } else if (ripple_field == 'p') {

            mRippleField.setPatch();

        } else if (ripple_field == 'L') {

            mRippleField.setLimit();

        }

    }

    /**

     * constructor

     */

    Package()

    {

        mLogger.debug("Package 3");

        mId = 0;

        mName = "null";

        mExtension = "null";

        mAlias = "null";

        mVcsTag = "null";

    }

    /**

     * Constructor for unit test purposes

     *  Will invoke applyPV and save the results for the UTF framework

     */

    public Package(ReleaseManager rm, String version, int majorLimit, int minorLimit, int patchLimit, int buildNumberLimit)

    {

        mId = -1;

        mRippleField.setLimit();

        mVersion = version;

        mMajorLimit = majorLimit;

        mMinorLimit = minorLimit;

        mPatchLimit = patchLimit;

        mBuildLimit = buildNumberLimit;

        if (version.endsWith(".cots"))

        {

            mExtension = ".cots";

            mVersion = version.substring(0, version.length() - 5);

            mChangeType.setMajor(false);

            mChangeType.setMinor(false);

            mChangeType.setPatch(true);

            mRippleField.setBuild();

        }

        try

        {

            mId = applyPV(rm);

        } catch (Exception e)

        {

        }

    }

    /**

     * Constructor for unit test purposes

     * Performs a partial copy of a package - sufficient for test purposes

     * @param base      - Base package  

     * @param newPvId   - New pvid of the package

     */

    public Package(int newPvId, Package base) {

        mId = newPvId;

        mPid = base.mPid;

        mName = base.mName;

        mExtension = base.mExtension;

        mVersion = base.mVersion;

        mAlias = base.mAlias;

        mVcsTag = base.mVcsTag;

        mFixedVersion = base.mFixedVersion;

        mChangeType = base.mChangeType;

        mRippleField = base.mRippleField;

        mBuildTime = base.mBuildTime;

        mHasAutomatedUnitTests = base.mHasAutomatedUnitTests;

        mSeqId = base.mSeqId;

        mBuildFailureEmailCollection = new Vector<String>(base.mBuildFailureEmailCollection);

        mPackageDependencyCollection = new Vector<Package>(base.mPackageDependencyCollection);

        mDependencyIDCollection = new Vector<Integer>(base.mDependencyIDCollection);

        mDependencyCollection = new Vector<String>(base.mDependencyCollection);

        mBuildStandardCollection = new Vector<BuildStandard>( base.mBuildStandardCollection);

    }

    /** Generate a nice text string useful for debugging

     * 

     */

    public String toString()

    {

        return mId + ":" + mAlias;

    }

    /**

     * accessor for unit test purposes

     */

    public int getId()

    {

        return mId;

    }

    /**

     * accessor for unit test purposes

     */

    public String getVersion()

    {

        return mVersion;

    }

    /**

     * accessor for unit test purposes

     */

    public String getNextVersion()

    {

        return mNextVersion;

    }

    /**

     * returns true if mBuildStandardCollection is not empty

     */

    boolean isReproducible()

    {

        mLogger.debug("isReproducible on Package {}", mName);

        boolean retVal = ! mBuildStandardCollection.isEmpty();

        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);

        boolean retVal = false;

        for (Iterator<BuildStandard> it = mBuildStandardCollection.iterator(); it.hasNext();)

        {

            BuildStandard buildStandard = it.next();

            if (buildStandard.isGeneric())

            {

                retVal = true;

                break;

            }

        }

        mLogger.info("isGeneric returned {}", retVal);

        return retVal;

    }

    /**

     * Returns true if at least one of the packages build standards can be 

     * built in the named machine class. 

     *  

     * Used to determine if the package can be built with the current buildset 

     * by iteration over all machine classes in the buildset. 

     */

    boolean canBeBuildby(String machineClass)

    {

        mLogger.debug("canBeBuildby on Package " + mName);

        boolean retVal = false;

        for (Iterator<BuildStandard> it = mBuildStandardCollection.iterator(); it.hasNext();)

        {

            BuildStandard buildStandard = it.next();

            if (buildStandard.isGeneric())

            {

                retVal = true;

                break;

            }

            if (buildStandard.mMachClass.equals(machineClass))

            {

                retVal = true;

                break;

            }

        }

        mLogger.info("canBeBuildby returned " + retVal);

        return retVal;

    }

    /**

     * Compare the build standards of two packages 

     * Used only in escrow mode 

     * Used to compare a package and its dependents (one by one) 

     *  

     * Returns true if the parent (this) package  can be built in the same escrow 

     * build iteration as the dependent package. 

     *  

     * This is a complex decision and has a few built in assumptions. 

     *  

     * If the dependent package is 'generic' then the parent package can be built 

     *  

     * If the parent package is generic then is can only be built if the dependent is 

     * also generic. Otherwise we must assume that the parent package is an agregator 

     * package and requires artifacts from the dependent package built by all of its 

     * required build machines. 

     *  

     * If both packages are not generic, then if the build standards of the parent and the 

     * dependent are identical then 

     *  

     *      If we have one build standard, we can build the parent in this iteration as

     *      the dependent package has been completely built.

     *  

     *      If we have more than one build standard ( but they are identical ) then we

     *      ASSUME that we can build the parent in this iteration. The assumption is that

     *      there is no mixing between build machines. ie: Windows consumer users Windows

     *      artifacts and the Linux consumer uses Linux artifacts ...

     *  

     * If both packages are not generic and the build standards are not identical, then 

     * things get hard. The safest solution is to assume the parent cannot be built in this 

     * iteration. This is not a bad assumption. 

     *  

     */

    boolean haveSameBuildStandards(Package d)

    {

        HashMap<String, Boolean> standardSet = new HashMap<String, Boolean>();

        boolean isGeneric = false;

        boolean isGeneric_d = false;

        boolean isIdentical = true;

        // Scan the build standards of the parent package and create a hash map for each machine

        // class required by the parent. Also determine if the parent is generic.

        for (Iterator<BuildStandard> it = mBuildStandardCollection.iterator(); it.hasNext();)

        {

            BuildStandard bs = it.next();

            standardSet.put(bs.mMachClass, false);

            if (bs.isGeneric())

            {

                isGeneric = true;

                break;

            }

        }

        // Scan the build standards in the dependent package and remove items from the map

        // If it was not in the map then the dependent package builds for platforms that the

        // parent package does not - thus the build standards cannot be identical

        // Also determine if the dependent is generic.

        for (Iterator<BuildStandard> it = d.mBuildStandardCollection.iterator(); it.hasNext();)

        {

            BuildStandard bs = it.next();

             if (bs.isGeneric())

             {

             isGeneric_d = true;

             break;

             }

            Boolean value = standardSet.remove(bs.mMachClass);

            if (value == null)

            {

                isIdentical = false;

                break;

            }

        }

        //

        // If there are any items left in the map then the parent package builds on machines

        // that the dependent does not. The two are not identical.

        if (!standardSet.isEmpty())

        {

            isIdentical = false;

        }

        // If dependent is generic, then it will be build on the first platform in this iteration

        // All is good

        if( isGeneric_d)

            return true;

        //  If I am generic and the dependent is generic, then I can be built at this time

        // 

        //  Will not reach here as we have already said that if dependenbt is generic, then all is good

        //  if (isGeneric_d && isGeneric)

        //  {

        //      return true;

        //  }

        //  If I am generic then I must wait for ALL dependent to be built on all platforms

        //  Thus I can't be built this round

        //

        if (isGeneric)

            return false;

        //

        //  If the two sets of build standards don't have generic, BUT are identical

        //  the we can assume that there is no cross breading. and that windows bits build from windows bits

        //  and solaris bits build from solaris

        //

        if (isIdentical)

            return true;

        //  The two sets of build standards are not an exact match

        //  Cheap solution: Assume that I can't be built this round

        //  Possible solution: If I am a subset of the dependent - then I can be built

        //                     If I am a superset of the dependent - then ???

        return false;

    }

    /**

     * Applies the required version number change. Will calculate mNextVersion

     * while not changing mVersion.

     * 

     * @param releaseManager    Release Manager instance to work against

     * 

     * @return 0 : success

     *         1 : cannot work with non standard versioning

     *         2 : ripple field limitations prevent a ripple build

     *         3 : Invalid Change Type

     * @exception Exception

     */

    int applyPV(ReleaseManager releaseManager) throws Exception

    {

        String logInfo = "applyPV," + mName;

        mLogger.error("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

        // Package version is out of date: false true true don't care applyPV

        // Forced ripple: false true don't care > 0 applyPV

        // Package version does not exist: false true false = 0 do not 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.error("applyPV. Rebuild Package {}", mName);

            mLogger.info("applyPv returned 0");

            return 0;

        }

        // override - no longer doing a rebuild - version number change from this point on

        if (mTestBuildInstruction == 0)

        {

            mRequiresSourceControlInteraction = true;

        }

        //	Force test builds to use a sensible version number

        if (mTestBuildInstruction > 0 )

        {

        	mChangeType.resetData();		// Resolve conflict via build numbers

        	mRippleField.setBuild();

        	mVersion = "99.99.98999";		// Such that rippling build number will goto 99.99.99000

        }

        //

        // Detect invalid change type

        // Flagged when package instance is created

        //

        if (mChangeType.mUnknown)

        {

            mLogger.error("Package Version unknown on Package {} 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

            mNextVersion = mFixedVersion;

            mLogger.error("Package Version specified on Package {} New Version: {}", mName,  mNextVersion);

            mLogger.info("applyPv returned 0");

            return 0;

        }

        // We need to calculate the new version number

        //

        MutableInt major = new MutableInt(0);

        MutableInt minor = new MutableInt(0);

        MutableInt patch = new MutableInt(1000);

        // Planned packages have a previous version number to be used as the bases for the

        // calculation. Ripples won't.

        //

        if (mPrevVersion != null)

        {

        	mVersion = mPrevVersion;

        }

        String[] field = mVersion.split("\\D");

        String nonStandardCotsVersion = "";

        logInfo += ", Prev:" + mVersion;

        if (field.length == 3)

        {

            major.value = Integer.parseInt(field[0]);

            minor.value = Integer.parseInt(field[1]);

            patch.value = Integer.parseInt(field[2]);

        } 

        else

        {

            //

            // 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 && field.length > 0)

            {

                // 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();

                // check patchStr is the last (at least 4) digits

                if (patchLen > 3

                        && mVersion.substring(mVersion.length() - patchLen, mVersion.length()).compareTo(patchStr) == 0)

                {

                    patch.value = Integer.parseInt(patchStr);

                    nonStandardCotsVersion = mVersion.substring(0, mVersion.length() - patchLen);

                }

            }

            if (nonStandardCotsVersion.length() == 0)

            {

                // cannot work with non standard versioning

                mLogger.error("applyPV cannot work with non standard versioning");

                mLogger.info("applyPv returned 1");

                return 1;

            }

        }

        if (nonStandardCotsVersion.length() == 0 && patch.value < 1000 && field[2].substring(0, 1).compareTo("0") != 0)

        {

            mLogger.info("applyPV accomodate old style Version of the form 1.0.1");

            patch.value = patch.value * 1000;

        }

        // mChangeType overrides mRippleField

        do

        {

            if (mChangeType.mMajor)

            {

                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);

                    minor.value = 0;

                    patch.value = 0;

                } else if (mRippleField.mMinor)

                {

                    logInfo += ",R Minor";

                    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);

                } else if (mRippleField.mBuild)

                {

                    logInfo += ", R Build";

                    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;

                    }

                }

            }

            if (nonStandardCotsVersion.length() == 0)

            {

                mVersion = String.valueOf(major.value) + "." + String.valueOf(minor.value) + ".";