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



     */
    boolean isReproducible()
    {
        mLogger.debug("isReproducible on Package {}", mName);
        boolean retVal = ! mBuildStandardCollection.isEmpty();
        mLogger.debug("isReproducible returned {}", retVal);
        return retVal;
    }
 
 
    /**

                retVal = true;
                break;
            }
        }
 
        mLogger.debug("isGeneric returned {}", retVal);
        return retVal;
    }
    
    /**
     * Returns true if at least one of the packages build standards can be 

    
    int applyPV(ReleaseManager releaseManager) throws Exception
    {
        String logInfo = "applyPV," + mName;
        String changeType = "";
        mLogger.warn("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,

        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.warn("applyPV. Rebuild Package {}", mName);
            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.warn("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

        if (mChangeType.mFixed)
        {
            // mVersion is already setup
 
            mNextVersion = mFixedVersion;
            mLogger.warn("Package Version specified on Package {} New Version: {}", mName,  mNextVersion);
            mLogger.info("applyPv returned 0");
            return 0;
        }
 
        // We need to calculate the new version number

            }
 
            if (nonStandardCotsVersion.length() == 0)
            {
                // cannot work with non standard versioning
                mLogger.warn("applyPV cannot work with non standard versioning");
                mLogger.info("applyPv returned 1");
                return 1;
            }
        }
 

 
            mVersion += String.valueOf(patch.value);
        } while (exists(releaseManager));
 
        logInfo += changeType + ", Next Version:" + mVersion;
        mLogger.warn(logInfo);
        mLogger.info("applyPv returned 0");
        mNextVersion = mVersion;
        mVersion = originalVersion;
        return 0;
    }

            }
 
            if (!changeOccurred)
            {
                // unable to increment a field due to field limitations
                mLogger.warn("incrementFieldsAccordingToLimits ripple field limitations prevent a ripple build");
                mLogger.info("incrementFieldsAccordingToLimits returned false");
                retVal = false;
            }
        }
 

        if (mGbeDpkgReplica != null && mGbeDpkgReplica.length() > 0)
        {
            File dpkg = new File(mGbeDpkgReplica);
            if (!dpkg.exists())
            {
                mLogger.error("existsInDpkgArchive. mGbeDpkgReplica not accessable. {}", mRecoverable);
                throw new Exception(mRecoverable);
            }
            
            if( utilities.freshFileExists(utilities.catDir(mGbeDpkgReplica, name) ) )
            {

            //  This is a recoverable error
            
            File dpkg = new File(mGbeDpkg);
            if (!dpkg.exists())
            {
                mLogger.error("existsInDpkgArchive. mGbeDpkg not accessable. {}", mRecoverable);
                throw new Exception(mRecoverable);
            }
    
            if( utilities.freshFileExists(utilities.catDir(mGbeDpkg, name) ) )
            {

                retVal = true;
            }
        }
        
        mArchivalExistence = retVal;
        mLogger.debug("existsInDpkgArchive returned {}", retVal);
        return retVal;
    }
    
    /**
     * returns true if the required package archives (dpkg_archive) exist

                retVal = true;
                mLogger.error("recover: dpkg_archive access has been restored");
            }
        }
 
        mLogger.debug("recover returned {}", retVal);
        return retVal;
    }
 
    /**
     * Returns a data structure of unique email addresses

     */
    public boolean hasCircularDependency(ArrayList<Package> packageCollection)
    {
        mLogger.debug("hasCircularDependency: {}", mAlias);
        boolean retVal = detectCircularDependency(mAlias, packageCollection, null);
        mLogger.debug("hasCircularDependency returned {} ", retVal);
        return retVal;
    }
    
    /** Reset the circular dependency testing information
     * 

Rev 7163	Rev 7176
Line 597...	Line 597...
597	`*/`	597	`*/`
598	`boolean isReproducible()`	598	`boolean isReproducible()`
599	`{`	599	`{`
600	`mLogger.debug("isReproducible on Package {}", mName);`	600	`mLogger.debug("isReproducible on Package {}", mName);`
601	`boolean retVal = ! mBuildStandardCollection.isEmpty();`	601	`boolean retVal = ! mBuildStandardCollection.isEmpty();`
602	`mLogger.info("isReproducible returned {}", retVal);`	602	`mLogger.debug("isReproducible returned {}", retVal);`
603	`return retVal;`	603	`return retVal;`
604	`}`	604	`}`
605		605
606		606
607	`/**`	607	`/**`
Line 620...	Line 620...
620	`retVal = true;`	620	`retVal = true;`
621	`break;`	621	`break;`
622	`}`	622	`}`
623	`}`	623	`}`
624		624
625	`mLogger.info("isGeneric returned {}", retVal);`	625	`mLogger.debug("isGeneric returned {}", retVal);`
626	`return retVal;`	626	`return retVal;`
627	`}`	627	`}`
628		628
629	`/**`	629	`/**`
630	`* Returns true if at least one of the packages build standards can be`	630	`* Returns true if at least one of the packages build standards can be`
Line 794...	Line 794...
794		794
795	`int applyPV(ReleaseManager releaseManager) throws Exception`	795	`int applyPV(ReleaseManager releaseManager) throws Exception`
796	`{`	796	`{`
797	`String logInfo = "applyPV," + mName;`	797	`String logInfo = "applyPV," + mName;`
798	`String changeType = "";`	798	`String changeType = "";`
799	`mLogger.error("applyPV on Package {}", mName);`	799	`mLogger.warn("applyPV on Package {}", mName);`
800		800
801	`//`	801	`//`
802	`// This method used to actually perform the version change`	802	`// This method used to actually perform the version change`
803	`// Now it just calculates the potential value`	803	`// Now it just calculates the potential value`
804	`// Must not alter mVersion as it will be used if the package is not selected to be built,`	804	`// Must not alter mVersion as it will be used if the package is not selected to be built,`
Line 818...	Line 818...
818	`if (!mDirectlyPlanned && mIndirectlyPlanned && !mArchivalExistence && mForcedRippleInstruction == 0)`	818	`if (!mDirectlyPlanned && mIndirectlyPlanned && !mArchivalExistence && mForcedRippleInstruction == 0)`
819	`{`	819	`{`
820	`// the package has an mIndirectlyPlanned flag set true in daemon`	820	`// the package has an mIndirectlyPlanned flag set true in daemon`
821	`// mode because the package does not exist in an archive`	821	`// mode because the package does not exist in an archive`
822	`// do not apply a different package version`	822	`// do not apply a different package version`
823	`mLogger.error("applyPV. Rebuild Package {}", mName);`	823	`mLogger.warn("applyPV. Rebuild Package {}", mName);`
824	`mLogger.info("applyPv returned 0");`	824	`mLogger.info("applyPv returned 0");`
825	`return 0;`	825	`return 0;`
826	`}`	826	`}`
827		827
828	`// override - no longer doing a rebuild - version number change from this point on`	828	`// override - no longer doing a rebuild - version number change from this point on`
Line 843...	Line 843...
843	`// Detect invalid change type`	843	`// Detect invalid change type`
844	`// Flagged when package instance is created`	844	`// Flagged when package instance is created`
845	`//`	845	`//`
846	`if (mChangeType.mUnknown)`	846	`if (mChangeType.mUnknown)`
847	`{`	847	`{`
848	`mLogger.error("Package Version unknown on Package {} Version: {}", mName, mVersion);`	848	`mLogger.warn("Package Version unknown on Package {} Version: {}", mName, mVersion);`
849	`mLogger.info("applyPv returned 3");`	849	`mLogger.info("applyPv returned 3");`
850	`return 3;`	850	`return 3;`
851	`}`	851	`}`
852		852
853	`// If we are not calculating the new package version because the user`	853	`// If we are not calculating the new package version because the user`
Line 855...	Line 855...
855	`if (mChangeType.mFixed)`	855	`if (mChangeType.mFixed)`
856	`{`	856	`{`
857	`// mVersion is already setup`	857	`// mVersion is already setup`
858		858
859	`mNextVersion = mFixedVersion;`	859	`mNextVersion = mFixedVersion;`
860	`mLogger.error("Package Version specified on Package {} New Version: {}", mName, mNextVersion);`	860	`mLogger.warn("Package Version specified on Package {} New Version: {}", mName, mNextVersion);`
861	`mLogger.info("applyPv returned 0");`	861	`mLogger.info("applyPv returned 0");`
862	`return 0;`	862	`return 0;`
863	`}`	863	`}`
864		864
865	`// We need to calculate the new version number`	865	`// We need to calculate the new version number`
Line 910...	Line 910...
910	`}`	910	`}`
911		911
912	`if (nonStandardCotsVersion.length() == 0)`	912	`if (nonStandardCotsVersion.length() == 0)`
913	`{`	913	`{`
914	`// cannot work with non standard versioning`	914	`// cannot work with non standard versioning`
915	`mLogger.error("applyPV cannot work with non standard versioning");`	915	`mLogger.warn("applyPV cannot work with non standard versioning");`
916	`mLogger.info("applyPv returned 1");`	916	`mLogger.info("applyPv returned 1");`
917	`return 1;`	917	`return 1;`
918	`}`	918	`}`
919	`}`	919	`}`
920		920
Line 1011...	Line 1011...
1011		1011
1012	`mVersion += String.valueOf(patch.value);`	1012	`mVersion += String.valueOf(patch.value);`
1013	`} while (exists(releaseManager));`	1013	`} while (exists(releaseManager));`
1014		1014
1015	`logInfo += changeType + ", Next Version:" + mVersion;`	1015	`logInfo += changeType + ", Next Version:" + mVersion;`
1016	`mLogger.error(logInfo);`	1016	`mLogger.warn(logInfo);`
1017	`mLogger.info("applyPv returned 0");`	1017	`mLogger.info("applyPv returned 0");`
1018	`mNextVersion = mVersion;`	1018	`mNextVersion = mVersion;`
1019	`mVersion = originalVersion;`	1019	`mVersion = originalVersion;`
1020	`return 0;`	1020	`return 0;`
1021	`}`	1021	`}`
Line 1147...	Line 1147...
1147	`}`	1147	`}`
1148		1148
1149	`if (!changeOccurred)`	1149	`if (!changeOccurred)`
1150	`{`	1150	`{`
1151	`// unable to increment a field due to field limitations`	1151	`// unable to increment a field due to field limitations`
1152	`mLogger.error("incrementFieldsAccordingToLimits ripple field limitations prevent a ripple build");`	1152	`mLogger.warn("incrementFieldsAccordingToLimits ripple field limitations prevent a ripple build");`
1153	`mLogger.info("incrementFieldsAccordingToLimits returned false");`	1153	`mLogger.info("incrementFieldsAccordingToLimits returned false");`
1154	`retVal = false;`	1154	`retVal = false;`
1155	`}`	1155	`}`
1156	`}`	1156	`}`
1157		1157
Line 1211...	Line 1211...
1211	`if (mGbeDpkgReplica != null && mGbeDpkgReplica.length() > 0)`	1211	`if (mGbeDpkgReplica != null && mGbeDpkgReplica.length() > 0)`
1212	`{`	1212	`{`
1213	`File dpkg = new File(mGbeDpkgReplica);`	1213	`File dpkg = new File(mGbeDpkgReplica);`
1214	`if (!dpkg.exists())`	1214	`if (!dpkg.exists())`
1215	`{`	1215	`{`
1216	`mLogger.error("existsInDpkgArchive. mGbeDpkgReplica not accessable. " + mRecoverable);`	1216	`mLogger.error("existsInDpkgArchive. mGbeDpkgReplica not accessable. {}", mRecoverable);`
1217	`throw new Exception(mRecoverable);`	1217	`throw new Exception(mRecoverable);`
1218	`}`	1218	`}`
1219		1219
1220	`if( utilities.freshFileExists(utilities.catDir(mGbeDpkgReplica, name) ) )`	1220	`if( utilities.freshFileExists(utilities.catDir(mGbeDpkgReplica, name) ) )`
1221	`{`	1221	`{`
Line 1233...	Line 1233...
1233	`// This is a recoverable error`	1233	`// This is a recoverable error`
1234		1234
1235	`File dpkg = new File(mGbeDpkg);`	1235	`File dpkg = new File(mGbeDpkg);`
1236	`if (!dpkg.exists())`	1236	`if (!dpkg.exists())`
1237	`{`	1237	`{`
1238	`mLogger.error("existsInDpkgArchive. mGbeDpkg not accessable. " + mRecoverable);`	1238	`mLogger.error("existsInDpkgArchive. mGbeDpkg not accessable. {}", mRecoverable);`
1239	`throw new Exception(mRecoverable);`	1239	`throw new Exception(mRecoverable);`
1240	`}`	1240	`}`
1241		1241
1242	`if( utilities.freshFileExists(utilities.catDir(mGbeDpkg, name) ) )`	1242	`if( utilities.freshFileExists(utilities.catDir(mGbeDpkg, name) ) )`
1243	`{`	1243	`{`
Line 1245...	Line 1245...
1245	`retVal = true;`	1245	`retVal = true;`
1246	`}`	1246	`}`
1247	`}`	1247	`}`
1248		1248
1249	`mArchivalExistence = retVal;`	1249	`mArchivalExistence = retVal;`
1250	`mLogger.info("existsInDpkgArchive returned " + retVal);`	1250	`mLogger.debug("existsInDpkgArchive returned {}", retVal);`
1251	`return retVal;`	1251	`return retVal;`
1252	`}`	1252	`}`
1253		1253
1254	`/**`	1254	`/**`
1255	`* returns true if the required package archives (dpkg_archive) exist`	1255	`* returns true if the required package archives (dpkg_archive) exist`
Line 1268...	Line 1268...
1268	`retVal = true;`	1268	`retVal = true;`
1269	`mLogger.error("recover: dpkg_archive access has been restored");`	1269	`mLogger.error("recover: dpkg_archive access has been restored");`
1270	`}`	1270	`}`
1271	`}`	1271	`}`
1272		1272
1273	`mLogger.info("recover returned " + retVal);`	1273	`mLogger.debug("recover returned {}", retVal);`
1274	`return retVal;`	1274	`return retVal;`
1275	`}`	1275	`}`
1276		1276
1277	`/**`	1277	`/**`
1278	`* Returns a data structure of unique email addresses`	1278	`* Returns a data structure of unique email addresses`
Line 1377...	Line 1377...
1377	`*/`	1377	`*/`
1378	`public boolean hasCircularDependency(ArrayList<Package> packageCollection)`	1378	`public boolean hasCircularDependency(ArrayList<Package> packageCollection)`
1379	`{`	1379	`{`
1380	`mLogger.debug("hasCircularDependency: {}", mAlias);`	1380	`mLogger.debug("hasCircularDependency: {}", mAlias);`
1381	`boolean retVal = detectCircularDependency(mAlias, packageCollection, null);`	1381	`boolean retVal = detectCircularDependency(mAlias, packageCollection, null);`
1382	`mLogger.info("hasCircularDependency returned {} ", retVal);`	1382	`mLogger.debug("hasCircularDependency returned {} ", retVal);`
1383	`return retVal;`	1383	`return retVal;`
1384	`}`	1384	`}`
1385		1385
1386	`/** Reset the circular dependency testing information`	1386	`/** Reset the circular dependency testing information`
1387	`*`	1387	`*`

Subversion Repositories DevTools

(root)/buildtool/trunk/src/main/java/com/erggroup/buildtool/ripple/Package.java – Rev 7163 → 7176