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

+{
     /**Unit test hook.
      * Prevents Oracle interaction when false.
      * @attribute
      */
-    public static boolean mUseDatabase = true;
+    public boolean mUseDatabase = true;
     /**Debug Support.
      * Set to false if EnvVar GBE_BUILDTOOL_DEBUG exists
      * Value of GBE_BUILDTOOL_DEBUG is expected to be an email if greater than
      * one character.
                 if (connection != null)
                 	connection.close();
+            }
             catch (SQLException e)
+            {
-                mLogger.error("SQL Exception closing connection:" + e.getMessage());
+                mLogger.error("SQL Exception closing connection: {}", e.getMessage());
+            }
+    	}
+    }
     /**database connection for use when not planning a build
      * @param username
      * @param password
      */
     public ReleaseManager(final String connectionString, final String username, final String password)
+    {
-        mLogger.debug("ReleaseManager " + connectionString);
+        mLogger.debug("ReleaseManager {}", connectionString);
         mConnectionString = connectionString;
         mUsername = username;
         mPassword = password;
         String gbeBtDebug = System.getenv("GBE_BUILDTOOL_DEBUG");
      *               False: Escrow Mode
      */
     public void setDaemonMode(boolean isDaemon)
+    {
         mDaemon = isDaemon;
-        mLogger.debug("DaemonMode:" + mDaemon);
+        mLogger.debug("DaemonMode:{}", mDaemon);
+    }
     /**
      * Clear mUseMutex
      * Used only in test mode to prevent the use of a mutex
      * @throws Exception
      */
     void handleSQLException(SQLException e, String instanceId ) throws SQLException, Exception
+    {
         String callingMethodName = Thread.currentThread().getStackTrace()[2].getMethodName() + instanceId ;
-        mLogger.error(callingMethodName + " sql exception:" + e.getMessage());
+        mLogger.error("{} sql exception:{}", callingMethodName, e.getMessage());
         if ( mConnection == null || !mConnection.isValid(10) )
+        {
-            mLogger.error(callingMethodName + " database access error only");
+            mLogger.error( "{} database access error only", callingMethodName);
             RmConnection.closeConnection(mConnection);
             throw new SQLException(e);
+        }
         else
+        {
-            mLogger.error(callingMethodName + " show stopper");
+            mLogger.error( "{} show stopper", callingMethodName);
             throw new Exception(callingMethodName + " show stopper");
+        }
+    }
     /** Claim the Build System Planning Lock
+            }
             catch( SQLException e )
+            {
                 // do not throw Exception
                 // this is part of Exception handling
-                mLogger.error( "indefinitePause caught SQLException " + e.getMessage() );
+                mLogger.error( "indefinitePause caught SQLException {}", e.getMessage() );
                 RmConnection.closeConnection(mConnection);
+            }
             catch( Exception e )
+            {
-                mLogger.error( "indefinitePause caught Exception " + e.getMessage() );
+                mLogger.error( "indefinitePause caught Exception {}", e.getMessage() );
+            }
             finally
+            {
                 // this block is executed regardless of what happens in the try block
                 // even if an exception is thrown
+                }
                 catch( Exception e )
+                {
                     // do not throw Exception
                     // this is part of Exception handling
-                    mLogger.error( "indefinitePause2 caught Exception " + e.getMessage() );
+                    mLogger.error( "indefinitePause2 caught Exception {}", e.getMessage() );
                     RmConnection.closeConnection(mConnection);
+                }
+            }
+        }
+    }
      * @exception SQLException
      * @exception Exception
      */
     void claimVersion(int pkgId, String pkgVersion, int rtagId) throws SQLException, Exception
+    {
-        mLogger.debug("claimVersion " + pkgId + " " + pkgVersion);
+        mLogger.debug("claimVersion {} {}", pkgId, pkgVersion);
         if ( mUseDatabase )
+        {
             CallableStatement stmt1 = null;
             try
+            {
      *  @param pkgId - Identifies the name of the package being built
      *  @param pkgPvId - Identifies the packageVersion the build is based upon
      */
     public void setCurrentPackageBeingBuilt(int rconId, int pkgId, int pkgPvId) throws SQLException, Exception
+    {
-        mLogger.error("setCurrentPackageBeingBuilt " + rconId);
+        mLogger.error("setCurrentPackageBeingBuilt {}", rconId);
         if ( mUseDatabase )
+        {
             CallableStatement stmt = null;
             try
+            {
+     *
      *  @param rconId - Identifies the Release Config table entry
      */
     public void clearCurrentPackageBeingBuilt(int rconId) throws SQLException, Exception
+    {
-        mLogger.error("clearCurrentPackageBeingBuilt " + rconId);
+        mLogger.error("clearCurrentPackageBeingBuilt {}", rconId);
         if ( mUseDatabase )
+        {
             try
+            {
                 connect();
      */
     public boolean autoMakeRelease(ReportingData mReporting) throws SQLException, Exception
+    {
         mReporting.errMsg = null;
-        mLogger.debug("autoMakeRelease " + mReporting.packageName);
+        mLogger.debug("autoMakeRelease {}", mReporting.packageName);
         if ( mUseDatabase )
+        {
             try
+            {
                 //  Create an array of dependencies
                 //  Report per-package errors directly
                 //  Exceptions are for errors that need to halt the entire system
                 //
                 if ( result <= 0 )
+                {
-                    mLogger.error("autoMakeRelease PK_RMAPI.AUTO_MAKE_VCSRELEASE failed, returned " + result);
+                    mLogger.error("autoMakeRelease PK_RMAPI.AUTO_MAKE_VCSRELEASE failed, returned {}", result);
                     if ( result == -4 ) {
                         mReporting.errMsg = "Package migrated to SVN being built from CC tag";
                     } else if ( result == -3 ) {
                         mReporting.errMsg = "Package not approved for autobuild";
                     } else if ( result == -2 ) {
      *  Handles database connection/disconnection
      */
     public void insertPackageMetrics(int mRtagId, String packageName,
             String packageExtension, String metrics) throws SQLException, Exception
+    {
-        mLogger.debug("insertPackageMetrics " + packageName);
+        mLogger.debug("insertPackageMetrics {}", packageName);
         if ( mUseDatabase )
+        {
             try
+            {
                 connect();
                 int result = stmt.getInt( 1 );
                 if ( result != 0 )
+                {
                     // flag build failure
-                    mLogger.error("insertPackageMetrics show stopper PK_RMAPI.INSERT_PACKAGE_METRICS failed, returned" + result);
+                    mLogger.error("insertPackageMetrics show stopper PK_RMAPI.INSERT_PACKAGE_METRICS failed, returned {}", result);
                     throw new Exception("insertPackageMetrics show stopper PK_RMAPI.INSERT_PACKAGE_METRICS failed, returned" + result);
+                }
                 stmt.close();
                 commit();
+            }
      */
     public int createBuildInstance(int rtagId, int pvId, BuildReason reason) throws SQLException, Exception
+    {
         int buildId = 0;
-        mLogger.debug("createBuildInstance " + rtagId + ":" + pvId);
+        mLogger.debug("createBuildInstance {}:{}", rtagId, pvId);
         if ( mUseDatabase )
+        {
             try
+            {
                 connect();
                 stmt.setLong( 3,pvId );
                 stmt.setString( 4,reason.toString() );
                 stmt.executeUpdate();
                 buildId = stmt.getInt( 1 );
-                mLogger.warn("createBuildInstance: Build Instance ID: " + buildId);
+                mLogger.warn("createBuildInstance: Build Instance ID: {}", buildId);
                 stmt.close();
                 commit();
+            }
             catch ( SQLException e )
      */
     public int updateBuildInstance(int buildID, int pvId, BuildResult result) throws SQLException, Exception
+    {
         int rv = 0;
-        mLogger.debug("updateBuildInstance " + buildID + ":" + pvId + ":" + result);
+        mLogger.debug("updateBuildInstance {}:{}:{}", buildID, pvId, result);
         if ( mUseDatabase )
+        {
             try
+            {
                 connect();
                 stmt.setLong( 3,pvId );
                 stmt.setString( 4,result.toString() );
                 stmt.executeUpdate();
                 rv = stmt.getInt( 1 );
-                mLogger.warn("updateBuildInstance: Result: " + rv);
+                mLogger.warn("updateBuildInstance: Result: {}", rv);
                 stmt.close();
                 commit();
+            }
             catch ( SQLException e )
         if ( !mUseDatabase || !btr.mResultsFound )
+        {
             return;
+        }
-        mLogger.warn("insertTestResults: " + buildId + ", Number:" + btr.mTestResults.size() );
+        mLogger.warn("insertTestResults: {}, Number:{}", buildId, btr.mTestResults.size() );
         try
+        {
             connect();
             String sql = "BEGIN ? := PK_RMAPI.insert_test_run(?, ?, ?, ?, ?, ?, ?);end;";
             CallableStatement stmt = mConnection.prepareCall(sql);
+     *
      * @return  true if an instruction exists - for use in a while loop
      */
     public boolean getDaemonInst(DaemonInstruction di ) throws SQLException, Exception
+    {
-        mLogger.debug("getDaemonInst " + di.instruction);
+        mLogger.debug("getDaemonInst {}", di.instruction);
         boolean retVal = false;
         if ( mUseDatabase )
+        {
             try
+     *
      *  @param  instruction - PVID of the daemon instruction to process
      */
     public void markDaemonInstInProgress(final int instruction) throws SQLException, Exception
+    {
-        mLogger.debug("markDaemonInstInProgress " + instruction);
+        mLogger.debug("markDaemonInstInProgress {}", instruction);
         if ( mUseDatabase )
+        {
             try
+            {
+     *
      *  @param  instruction - PVID of Daemon Instruction to process
      */
     public void markDaemonInstCompleted(final int instruction) throws SQLException, Exception
+    {
-        mLogger.debug("markDaemonInstCompletedConnect " + instruction);
+        mLogger.debug("markDaemonInstCompletedConnect {}", instruction);
         boolean connectionCreated = false;
         try
+        {
             if (! mIsConnected)
+     *
      * Overridden in ReleaseManagerUtf
      */
     public String queryBaselineName(int baseline) throws SQLException, Exception
+    {
-        mLogger.debug("queryBaselineName " + mDaemon);
+        mLogger.debug("queryBaselineName {}", mDaemon);
         StringBuilder retVal = new StringBuilder();
         String sql = "";
         if ( mDaemon )
         catch ( SQLException e )
+        {
             handleSQLException(e, "");
+        }
-        mLogger.info("queryBaselineName returned " + retVal);
+        mLogger.info("queryBaselineName returned {}", retVal);
         return retVal.toString();
+    }
     /**only used in daemon mode
      *   select config from release_manager.build_service_config where service='MAIL SERVER';
+        {
             handleSQLException(e, "");
+        }
-        mLogger.info("queryMailServer returned " + retVal);
+        mLogger.info("queryMailServer returned {}", retVal);
         return retVal;
+    }
     /**only used in daemon mode
      * returns the configured service
         catch ( SQLException e )
+        {
             handleSQLException(e, "");
+        }
-        mLogger.debug("queryMailSender returned " + retVal);
+        mLogger.debug("queryMailSender returned {}", retVal);
         return retVal;
+    }
     /**only used in daemon mode
      * returns the configured global email addresses
+        {
             handleSQLException(e, "");
+        }
-        mLogger.debug("queryGlobalAddresses returned " + retVal);
+        mLogger.debug("queryGlobalAddresses returned {}", retVal);
         return retVal;
+    }
     /**
      * Determine a list of global, project wide and release email recipients
      * @param rtag_id   - Target Release
      * @param buildFile - buildfile content to be saved
      */
     public void publishBuildFile(int rtag_id, BuildFile buildFile) throws SQLException, Exception
+    {
-        mLogger.debug("publishBuildFile publishing a build file of length " + buildFile.content.length());
+        mLogger.debug("publishBuildFile publishing a build file of length {}", buildFile.content.length());
-        mLogger.debug("publishBuildFile publishing pkgId: " + buildFile.mPkgId + " pvid: " + buildFile.mPvId);
+        mLogger.debug("publishBuildFile publishing pkgId: {} pvid: {}", buildFile.mPkgId, buildFile.mPvId);
         try
+        {
             connect();
+        }
         catch ( Exception e )
+        {
             // this catch and rethrow is historical
             // problems were found using CallableStatement when updating a CLOB column with data > 4000 bytes
-            mLogger.error("publishBuildFile caught Exception " + e.getMessage());
+            mLogger.error("publishBuildFile caught Exception {}", e.getMessage());
             throw new Exception("publishBuildFile caught Exception " + e.getMessage());
+        }
         finally
+        {
             // this block is executed regardless of what happens in the try block
+            {
                 disconnect();
+            }
+        }
-        mLogger.warn("queryReleaseSeqNum returned " + retVal);
+        mLogger.warn("queryReleaseSeqNum returned {}", retVal);
         return retVal;
+    }
     /**
      * Disable all the daemons for a specific release
      * @throws SQLException
      * @throws Exception
      */
     private void disableDaemons(final int rtag_id) throws SQLException, Exception
+    {
-        mLogger.error("disableDaemons: " + rtag_id );
+        mLogger.error("disableDaemons: {}", rtag_id );
         try
+        {
             CallableStatement stmt1 = mConnection.prepareCall( "call PK_BUILDAPI.set_daemon_states(?,2)" );
             stmt1.setInt( 1, rtag_id );
+        }
         catch ( SQLException e )
+        {
             handleSQLException(e, "");
+        }
-        mLogger.info("isRtagIdConfigured returning " + retVal);
+        mLogger.info("isRtagIdConfigured returning {}", retVal);
         return retVal;
+    }
     /**queries the RUN_LEVEL table for daemon to determine if the daemon has been paused
      * or disabled.
      * @exception SQLException
      * @exception Exception
      */
     public boolean queryDirectedRunLevel(final int rcon_id) throws SQLException, Exception
+    {
-        mLogger.debug("queryDirectedRunLevel " + rcon_id);
+        mLogger.debug("queryDirectedRunLevel {}", rcon_id);
         boolean retVal = true;
         if ( mUseDatabase )
+        {
             try
+            {
                 handleSQLException(e, "");
+            }
+        }
-        mLogger.info("queryDirectedRunLevel returning " + retVal);
+        mLogger.info("queryDirectedRunLevel returning {}", retVal);
         return retVal;
+    }
     /**
      * queries the RELEASE_CONFIG and BUILD_MACHINE_CONFIG tables using the rcon_id primary key, rtag_id, machine_hostname, daemon_mode
                 //      Handles case where daemon has just been started/restarted
                 //
                 if ( daemon_mode == 'M' &&  build_age > 0 && days_since_last_build > (build_age + 1) )
+                {
                     long upTimeSecs = (System.currentTimeMillis() - threadStartTime)/1000;
-                    mLogger.error("queryReleaseConfig 1: " + rtag_id + ", " + rcon_id + ", "+ daemon_mode + ", " + pause + ", " + build_age + ", " + days_since_last_build + ", " + upTimeSecs );
+                    mLogger.error("queryReleaseConfig 1: {},{},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build, upTimeSecs );
                     if ( upTimeSecs > mPostponeShutdown)
+                    {
                         disableDaemons(rtag_id);
                         pause = 2;
+                    }
+                    {
                         mLogger.error("queryReleaseConfig 1: Shutdown Postponed"  );
+                    }
+                }
-                mLogger.info("queryReleaseConfig 1: " + rtag_id + ", " + rcon_id + ", "+ daemon_mode + ", " + pause + ", " + build_age + ", " + days_since_last_build );
+                mLogger.info("queryReleaseConfig 1: {},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build  );
                 if ( pause <= 1 )
+                {
                     retVal = true;
+                }
         catch ( SQLException e )
+        {
             handleSQLException(e, ":1");
+        }
-        mLogger.info("queryReleaseConfig 1 returning " + retVal);
+        mLogger.info("queryReleaseConfig 1 returning {}", retVal);
         return retVal;
+    }
     /**removes all elements from the mReleaseConfigCollection
      * handles database connection and disconnection
                 int rcon_id = rset.mustGetInt("rcon_id");
                 char dm = 'S';
                 String daemon_mode = rset.getString("daemon_mode","S");
-                mLogger.info("queryReleaseConfig 2 daemon_mode " + daemon_mode + ".");
+                mLogger.info("queryReleaseConfig 2 daemon_mode '{}'", daemon_mode);
                 if ( daemon_mode.compareTo("M") == 0 )
+                {
                     dm = 'M';
+                }
+     *
      * Used by the BuildDaemon thread to determine daemons to start and stop
      */
     public void queryReleaseConfig(final String hostname) throws SQLException, Exception
+    {
-        mLogger.debug("queryReleaseConfig 3 " + hostname);
+        mLogger.debug("queryReleaseConfig 3 {}", hostname);
         mReleaseConfigCollection.resetData();
         try
+        {
             connect();
                 int rcon_id = rset.mustGetInt("rcon_id");
                 char dm = 'S';
                 String daemon_mode = rset.getString("daemon_mode", "S");
-                mLogger.info("queryReleaseConfig 3 daemon_mode " + daemon_mode + ".");
+                mLogger.info("queryReleaseConfig 3 daemon_mode '{}'", daemon_mode);
                 if ( daemon_mode.compareTo("M") == 0 )
+                {
                     dm = 'M';
+                }
      *  Used by the Master and Slave Daemons
      *  Overridden in ReleaseManagerUtf
      */
     public int queryMasterCount(final int rtag_id) throws SQLException, Exception
+    {
-        mLogger.debug("queryMasterCount rtag_id " + rtag_id);
+        mLogger.debug("queryMasterCount rtag_id {}", rtag_id);
         int masterCount = 0;
         try
+        {
             connect();
             disconnect();
+        }
         return rv;
+    }
-    /**in daemon mode
-     *  1 get planned package info
-     *     select pl.pv_id, p.pkg_id, p.pkg_name, pv.v_ext, pv.pkg_vcs_tag, pv.change_type
-     *     from release_manager.planned pl, release_manager.package_versions pv, release_manager.packages p
-     *     where pl.rtag_id=<mBaseline> and pv.build_type='A' and pv.dlocked='A'
-     *     and pv.pv_id=pl.pv_id and p.pkg_id=pv.pkg_id
-     *     order by pl.pv_id;
-     *  2 get planned package dependency info
-     *     select pl.pv_id, p.pkg_name, dpv.v_ext
-     *     from release_manager.planned pl, release_manager.package_versions pv, release_manager.package_dependencies pd, release_manager.package_versions dpv, release_manager.packages p
-     *     where pl.rtag_id=<mBaseline> and pv.build_type='A' and pv.dlocked='A'
-     *     and pv.pv_id = pl.pv_id and pd.pv_id=pl.pv_id and dpv.pv_id=pd.dpv_id and p.pkg_id=dpv.pkg_id
-     *     order by pl.pv_id;
-     *  3 get planned package build info
-     *     select pl.pv_id, bm.bm_name, bsa.bsa_name
-     *     from release_manager.planned pl, release_manager.package_versions pv, release_manager.package_build_info pbi, release_manager.build_machines bm, release_manager.build_standards_addendum bsa
-     *     where pl.rtag_id=<mBaseline> and pv.build_type='A' and pv.dlocked='A'
-     *     and pv.pv_id = pl.pv_id and pbi.pv_id=pv.pv_id and bm.bm_id=pbi.bm_id and bsa.bsa_id=pbi.bsa_id
-     *     order by pl.pv_id;
-     *  4 get planned package unit test info
-     *     select pl.pv_id, tt.test_type_name
-     *     from release_manager.planned pl, release_manager.package_versions pv, release_manager.unit_tests ut, release_manager.test_types tt
-     *     where pl.rtag_id=<mBaseline> and pv.build_type='A' and pv.dlocked='A'
-     *     and pv.pv_id = pl.pv_id and ut.pv_id=pv.pv_id and tt.test_type_id=ut.test_types_fk
-     *     order by pl.pv_id;
-     *  5 get planned package build failure info
-     *     select pl.pv_id, u.user_email
-     *     from release_manager.planned pl, release_manager.release_tags rt, release_manager.package_versions pv, release_manager.autobuild_failure af, release_manager.members_group mg, release_manager.users u
-     *     where pl.rtag_id=<mBaseline> and rt.rtag_id=pl.rtag_id and pv.build_type='A' and pv.dlocked='A'
-     *     and pv.pv_id = pl.pv_id and af.view_id=pl.view_id and mg.group_email_id=af.group_email_id and u.user_id=mg.user_id and af.proj_id=rt.proj_id
-     *     order by pl.pv_id;
-     *  6 get planned package do not ripple info
-     *     select pl.pv_id
-     *     from release_manager.planned pl, release_manager.package_versions pv, release_manager.do_not_ripple dnr
-     *     where pl.rtag_id=<mBaseline> and pv.build_type='A' and pv.dlocked='A'
-     *     and pv.pv_id = pl.pv_id and dnr.rtag_id=pl.rtag_id and dnr.pv_id=pl.pv_id
-     *     order by pl.pv_id;
-     *  7 get planned package advisory ripple info
-     *     select pl.pv_id
-     *     from release_manager.planned pl, release_manager.package_versions pv, release_manager.advisory_ripple ar
-     *     where pl.rtag_id=<mBaseline> and pv.build_type='A' and pv.dlocked='A'
-     *     and pv.pv_id = pl.pv_id and ar.rtag_id=pl.rtag_id and ar.pv_id=pl.pv_id
-     *     order by pl.pv_id;
-     *  8 get released package info
-     *     select rc.pv_id, p.pkg_id, p.pkg_name, pv.pkg_version, pv.v_ext, pv.pkg_vcs_tag, pv.ripple_field
-     *     pv.major_limit, pv.minor_limit, pv.patch_limit, pv.build_number_limit
-     *     from release_manager.release_content rc, release_manager.package_versions pv, release_manager.packages p
-     *     where rc.rtag_id=<mBaseline>
-     *     and pv.pv_id = rc.pv_id and p.pkg_id = pv.pkg_id
-     *     order by rc.pv_id;
-     *  9 get released package dependency info
-     *     select rc.pv_id, dpv.pv_id, p.pkg_name, dpv.v_ext
-     *     from release_manager.release_content rc, release_manager.package_versions pv, release_manager.package_dependencies pd, release_manager.package_versions dpv, release_manager.packages p
-     *     where rc.rtag_id=<mBaseline>
-     *     and pv.pv_id = rc.pv_id and pd.pv_id=pv.pv_id and dpv.pv_id=pd.dpv_id and p.pkg_id=dpv.pkg_id
-     *     order by rc.pv_id;
-     * 10 get released package build info
-     *     select rc.pv_id, bm.bm_name, bsa.bsa_name
-     *     from release_manager.release_content rc, release_manager.package_versions pv, release_manager.package_build_info pbi, release_manager.build_machines bm, release_manager.build_standards_addendum bsa
-     *     where rc.rtag_id=<mBaseline>
-     *     and pv.pv_id = rc.pv_id and pbi.pv_id=pv.pv_id and bm.bm_id=pbi.bm_id and bsa.bsa_id=pbi.bsa_id
-     *     order by rc.pv_id;
-     * 11 get released package unit test info
-     *     select rc.pv_id, tt.test_type_name
-     *     from release_manager.release_content rc, release_manager.package_versions pv, release_manager.unit_tests ut, release_manager.test_types tt
-     *     where rc.rtag_id=<mBaseline>
-     *     and pv.pv_id = rc.pv_id and ut.pv_id=pv.pv_id and tt.test_type_id=ut.test_types_fk
-     *     order by rc.pv_id;
-     * 12 get released package build failure email info
-     *     select rc.pv_id, u.user_email
-     *     from release_manager.release_content rc, release_manager.release_tags rt, release_manager.package_versions pv, release_manager.autobuild_failure af, release_manager.members_group mg, release_manager.users u
-     *     where rc.rtag_id=<mBaseline> and rt.rtag_id=rc.rtag_id
-     *     and pv.pv_id = rc.pv_id and af.view_id=rc.base_view_id and mg.group_email_id=af.group_email_id and u.user_id=mg.user_id and af.proj_id=rt.proj_id
-     *     order by rc.pv_id;
-     * 13 get released package do not ripple info
-     *     select rc.pv_id
-     *     from release_manager.release_content rc, release_manager.package_versions pv, release_manager.do_not_ripple dnr
-     *     where rc.rtag_id=<mBaseline>
-     *     and pv.pv_id = rc.pv_id and dnr.rtag_id=rc.rtag_id and dnr.pv_id=rc.pv_id
-     *     order by rc.pv_id;
-     * 14 get released advisory ripple info
-     *     select rc.pv_id
-     *     from release_manager.release_content rc, release_manager.package_versions pv, release_manager.advisory_ripple ar
-     *     where rc.rtag_id=<mBaseline>
-     *     and pv.pv_id = rc.pv_id and ar.rtag_id=rc.rtag_id and ar.pv_id=rc.pv_id
-     *     order by rc.pv_id;
-     *
+    /**
-     * in escrow mode
-     *  1 get released product info
-     *     select oc.prod_id, p.pkg_name, pv.pkg_version, pv.v_ext, pv.pkg_vcs_tag
+     * Extract all package-version information for released packages
-     *     from deployment_manager.bom_contents bc, deployment_manager.operating_systems os, deployment_manager.os_contents oc, release_manager.package_versions pv, release_manager.packages p
-     *     where bc.bom_id=<mBaseline> and os.node_id=bc.node_id and oc.os_id=os.os_id and pv.pv_id=oc.prod_id and p.pkg_id=pv.pkg_id
-     *     order by oc.prod_id;
+     * Used in both Escrow and non-Escrow modes
-     *    this will generate a list of pv_ids associated with products
-     *    many in the list will reference cots products outside the scope of a escrow build
-     *  2 for each <pv_id>, call traverseDependencies( packageCollection, pv_id, false ) to traverse its set of dependencies
-     *  3 for each Package, call queryBuildInfo to get released package build info
      *
-     * Supports
-     *    test_type_name="Autobuild UTF"
+     * @param   rippleEngine        - Instance to use
-     *    bm_name="Generic"|"Linux"|"Solaris"|"Win32"
+     * @param   packageCollection   - Package Collection structure to fill. Expected to be cleared
-     *    bsa_name="Debug"|"Production"|"Production and Debug"|"Java 1.4"|"Java 1.5"|"Java 1.6"
+     * @param   baseline            - RtagId of the release being processed, BomId of an Escrow being processed
+     *
      * Overridden in ReleaseManagerUtf
+     *
      */
-    protected void queryPackageVersions(
-            RippleEngine rippleEngine,
-            ArrayList<Package> packageCollection,
-            int baseline) throws SQLException, Exception
+    protected void queryPackageVersions(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
+    {
         Phase phase = new Phase("rmData");
-        mLogger.debug("queryPackageVersions " + mDaemon);
+        mLogger.debug("queryPackageVersions {}", mDaemon);
         try
+        {
             if (mDaemon)
+            {
-                // Get planned package info
-                // Support multiple WIPS on the same package and build in the order they were released
-                // These are packages that are marked as pending build
-                //
-                mLogger.debug("queryPackageVersions: stmt1");
-                phase.setPhase("getPlannedPkgs1");
-                PreparedStatement stmt1 = mConnection.prepareStatement(
-                        "select pl.pv_id, p.pkg_id, p.pkg_name, pv.pkg_version, " +
-                                " pv.v_ext, pv.change_type, pv.ripple_field," +
-                                " pv.major_limit, pv.minor_limit, pv.patch_limit, pv.build_number_limit," +
-                                " pv.modified_stamp," +
-                                " release_manager.PK_RMAPI.return_vcs_tag(pl.pv_id) AS vcsTag" +
-                                " from release_manager.planned pl," +
-                                "      release_manager.package_versions pv," +
-                                "      release_manager.packages p" +
-                                " where pl.rtag_id=" + baseline +
-                                "   and pv.build_type='A' and pv.dlocked='A'" +
-                                "   and pv.pv_id=pl.pv_id and p.pkg_id=pv.pkg_id" +
-                                " order by pv.modified_stamp"
-                        );
-                stmt1.setFetchSize(500);
-                RmResultSet rset1 = new RmResultSet(stmt1.executeQuery(), "queryPackageVersions rset1");
-                while( rset1.next() )
-                {
-                    int pv_id = rset1.mustGetKeyInt("pv_id");
-                    int pkg_id = rset1.mustGetInt("pkg_id");
-                    String pkg_name = rset1.mustGetString("pkg_name");
-                    String pkg_version = rset1.mustGetString("pkg_version");
-                    // Previous Version of this package, without the project suffix
-                    String pkg_prevVersion = getBaseVersionNumber(pv_id);
-                    if ( pkg_prevVersion == null)
-                    {
-                        mLogger.error("queryPackageVersions. No Previous version" + pv_id);
-                        // show stopper
-                        throw new Exception("queryPackageVersions. No Previous version" + pv_id);
-                    }
-                    String v_ext = rset1.getString("v_ext","");
-                    String change_type = rset1.getString("change_type", "P");
-                    char ct = 'x';
-                    if ( change_type.compareTo("M") == 0 )
-                    {
-                        ct = 'M';
-                    }
-                    else if ( change_type.compareTo("N") == 0 )
-                    {
-                        ct = 'N';
-                    }
-                    else if ( change_type.compareTo("P") == 0 )
-                    {
-                        ct = 'P';
-                    }
-                    else if ( change_type.compareTo("F") == 0 )
-                    {
-                        ct = 'F';
-                    }
-                    if ( ct != 'x' )
-                    {
-                        String ripple_field = rset1.getString("ripple_field", "b");
-                        int major_limit = rset1.getInt("major_limit", 0);
-                        int minor_limit = rset1.getInt("minor_limit",0);
-                        int patch_limit = rset1.getInt("patch_limit",0);
-                        int build_number_limit = rset1.getInt("build_number_limit",0);
-                        String vcs_tag = rset1.getString("vcsTag", "");
-                        Package p = new Package(pkg_id, pv_id, pkg_name, pkg_version, v_ext, pkg_name + v_ext, vcs_tag, ripple_field.charAt(0), ct);
-                        p.mDirectlyPlanned = true;
-                        p.mBuildReason = BuildReason.NewVersion;
-                        p.mMajorLimit = major_limit;
-                        p.mMinorLimit = minor_limit;
-                        p.mPatchLimit = patch_limit;
-                        p.mBuildLimit = build_number_limit;
-                        p.mPrevVersion = pkg_prevVersion;
-                        Package prevPlannedPackage = findPackage(p.mAlias, packageCollection);
-                        // If there are multiple packages with the same Alias, then only the first one
-                        // will be placed in the build set. The will be the oldest, the first one released
-                        // to be built
-                        if ( prevPlannedPackage == NULL_PACKAGE )
-                        {
-                            mLogger.info("queryPackageVersions rset1 no previous planned package " + pv_id);
-                            packageCollection.add(p);
-                        }
-                    }
-                }
-                rset1.close();
-                stmt1.close();
-                // get planned package dependency info
-                mLogger.debug("queryPackageVersions: stmt2");
-                phase.setPhase("getPlannedPkgs2");
-                PreparedStatement stmt2 = mConnection.prepareStatement(
-                        "select pl.pv_id, p.pkg_name, dpv.v_ext, pv.modified_stamp " +
-                                "from release_manager.planned pl,"+
-                                "     release_manager.package_versions pv,"+
-                                "     release_manager.package_dependencies pd," +
-                                "     release_manager.package_versions dpv,"+
-                                "     release_manager.packages p " +
-                                " where pl.rtag_id=" + baseline +
-                                "  and pv.build_type='A'"+
-                                "  and pv.dlocked='A' " +
-                                "  and pv.pv_id = pl.pv_id"+
-                                "  and pd.pv_id=pl.pv_id"+
-                                "  and dpv.pv_id=pd.dpv_id"+
-                                "  and p.pkg_id=dpv.pkg_id " +
-                                " order by pv.modified_stamp"
-                        );
-                stmt2.setFetchSize(500);
-                RmResultSet rset2 = new RmResultSet(stmt2.executeQuery(), "queryPackageVersions rset2");
-                while( rset2.next() )
-                {
-                    boolean ignore = false;
-                    int pv_id = rset2.mustGetKeyInt("pv_id");
-                    Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset2 package superceded by planned " + pv_id);
-                        ignore = true;
-                    }
-                    String pkg_name = rset2.mustGetString("pkg_name");
-                    String v_ext = rset2.getString("v_ext","");
-                    if ( !ignore )
-                    {
-                        p.mDependencyCollection.add(pkg_name + v_ext);
-                        p.mDependencyIDCollection.add(-1);
-                    }
-                }
-                rset2.close();
-                stmt2.close();
-                // get planned package build info
-                mLogger.debug("queryPackageVersions: stmt3");
-                phase.setPhase("getPlannedPkgs3");
-                PreparedStatement stmt3 = mConnection.prepareStatement(
-                        "select pl.pv_id, bm.bm_name, bsa.bsa_name, pv.modified_stamp " +
-                                "from release_manager.planned pl," +
-                                "     release_manager.package_versions pv," +
-                                "     release_manager.package_build_info pbi," +
-                                "     release_manager.build_machines bm," +
-                                "     release_manager.build_standards_addendum bsa " +
-                                "where pl.rtag_id=" + baseline +
-                                "     and pv.build_type='A' and pv.dlocked='A' " +
-                                "     and pv.pv_id = pl.pv_id" +
-                                "     and pbi.pv_id=pv.pv_id" +
-                                "     and bm.bm_id=pbi.bm_id" +
-                                "     and bsa.bsa_id=pbi.bsa_id " +
-                                "order by pv.modified_stamp"
-                        );
-                stmt3.setFetchSize(500);
-                RmResultSet rset3 = new RmResultSet(stmt3.executeQuery(), "queryPackageVersions rset3");
-                while( rset3.next() )
-                {
-                    boolean ignore = false;
-                    int pv_id = rset3.mustGetKeyInt("pv_id");
-                    Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset3 package superceded by planned " + pv_id);
-                        ignore = true;
-                    }
-                    String bm_name = rset3.mustGetString("bm_name");
-                    String bsa_name = rset3.mustGetString("bsa_name");
-                    if ( !ignore )
-                    {
-                        BuildStandard bs = new BuildStandard(rippleEngine, bm_name, bsa_name);
-                        if ( bs.supportedBuildStandard() )
-                        {
-                            p.mBuildStandardCollection.add(bs);
-                        }
-                    }
-                }
-                rset3.close();
-                stmt3.close();
-                // get planned package unit test info
-                mLogger.debug("queryPackageVersions: stmt4");
-                phase.setPhase("getPlannedPkgs4");
-                PreparedStatement stmt4 = mConnection.prepareStatement(
-                        "select pl.pv_id, tt.test_type_name, pv.modified_stamp" +
-                        "  from release_manager.planned pl,"+
-                        "       release_manager.package_versions pv,"+
-                        "       release_manager.unit_tests ut," +
-                        "       release_manager.test_types tt" +
-                        " where pl.rtag_id=" + baseline +
-                        "   and pv.build_type='A'" +
-                        "   and pv.dlocked='A'" +
-                        "  and pv.pv_id = pl.pv_id" +
-                        "  and ut.pv_id=pv.pv_id" +
-                        "  and tt.test_type_id=ut.test_types_fk" +
-                        " order by pv.modified_stamp"
-                        );
-                stmt4.setFetchSize(500);
-                RmResultSet rset4 = new RmResultSet(stmt4.executeQuery(), "queryPackageVersions rset4");
-                while( rset4.next() )
-                {
-                    boolean ignore = false;
-                    int pv_id = rset4.mustGetKeyInt("pv_id");
-                    Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset4 package superceded by planned " + pv_id);
-                        ignore = true;
-                    }
-                    String test_type_name = rset4.mustGetString("test_type_name");
-                    if ( !ignore )
-                    {
-                        if ( test_type_name.compareTo("Autobuild UTF") == 0 )
-                        {
-                            p.mHasAutomatedUnitTests = true;
-                        }
-                    }
-                }
-                rset4.close();
-                stmt4.close();
-                // get planned package build failure info...
-                //      view based
-                mLogger.debug("queryPackageVersions: stmt5");
-                phase.setPhase("getPlannedPkgs6");
-                PreparedStatement stmt5 = mConnection.prepareStatement(
-                        "select pl.pv_id, u.user_email, pv.modified_stamp " +
-                                " from release_manager.planned pl, " +
-                                "      release_manager.release_tags rt, " +
-                                "      release_manager.package_versions pv, " +
-                                "      release_manager.autobuild_failure af, " +
-                                "      release_manager.members_group mg, " +
-                                "      release_manager.users u " +
-                                " where pl.rtag_id=" + baseline +
-                                "      and rt.rtag_id=pl.rtag_id" +
-                                "      and pv.build_type='A' and pv.dlocked='A' " +
-                                "      and pv.pv_id = pl.pv_id " +
-                                "      and af.view_id=pl.view_id " +
-                                "      and mg.group_email_id=af.group_email_id " +
-                                "      and u.user_id=mg.user_id " +
-                                "      and af.proj_id=rt.proj_id " +
-                                " order by pv.modified_stamp"
-                        );
-                stmt5.setFetchSize(500);
-                RmResultSet rset5 = new RmResultSet(stmt5.executeQuery(), "queryPackageVersions rset5");
-                while( rset5.next() )
-                {
-                    int pv_id = rset5.mustGetKeyInt("pv_id");
-                    Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset5 package superceded by planned " + pv_id);
-                    }
-                    else
-                    {
-                        String user_email = rset5.getString("user_email", null);
-                        if ( user_email != null )
-                        {
-                            p.addEmail(user_email);
-                        }
-                    }
-                }
-                rset5.close();
-                stmt5.close();
-                // get planned package build failure info...
-                // package version
-                mLogger.debug("queryPackageVersions: stmt6");
-                phase.setPhase("getPlannedPkgs7");
-                PreparedStatement stmt6 = mConnection.prepareStatement(
-                        "select pl.pv_id, u1.user_email, u2.user_email, u3.user_email, pv.modified_stamp" +
-                        " from release_manager.planned pl," +
-                        "      release_manager.release_tags rt," +
-                        "      release_manager.package_versions pv," +
-                        "      release_manager.users u1," +
-                        "      release_manager.users u2," +
-                        "      release_manager.users u3 " +
-                        " where pl.rtag_id=" + baseline +
-                        "   and rt.rtag_id=pl.rtag_id" +
-                        "   and pv.build_type='A'" +
-                        "   and pv.dlocked='A' " +
-                        "   and pv.pv_id = pl.pv_id" +
-                        "   and u1.user_id=pv.creator_id" +
-                        "   and u2.user_id=pv.owner_id" +
-                        "   and u3.user_id=pv.modifier_id" +
-                        "   order by pv.modified_stamp"
-                        );
-                stmt6.setFetchSize(500);
-                RmResultSet rset6 = new RmResultSet(stmt6.executeQuery(), "queryPackageVersions rset6");
-                while( rset6.next() )
-                {
-                    int pv_id = rset6.mustGetKeyInt("pv_id");
-                    Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset6 package superceded by planned " + pv_id);
-                    }
-                    else
-                    {
-                        // walk the 3 columns of user_email in the resultset
-                        // columns 2, 3 and 4, all of the same name, respectively
-                        for(int column=2; column<5; column++ )
-                        {
-                            String user_email = rset6.getString(column,null);
-                            if ( user_email != null )
-                            {
-                                p.addEmail(user_email);
-                            }
-                        }
-                    }
-                }
-                rset6.close();
-                stmt6.close();
-                // get planned package advisory ripple info
-                mLogger.debug("queryPackageVersions: stmt7");
-                phase.setPhase("getPlannedPkgs8");
-                PreparedStatement stmt7 = mConnection.prepareStatement(
-                        "select pl.pv_id, pv.modified_stamp " +
-                        " from release_manager.planned pl," +
-                        "      release_manager.package_versions pv," +
-                        "      release_manager.advisory_ripple ar " +
-                        " where pl.rtag_id=" + baseline +
-                        "   and pv.build_type='A'" +
-                        "    and pv.dlocked='A' " +
-                        "    and pv.pv_id = pl.pv_id" +
-                        "    and ar.rtag_id=pl.rtag_id" +
-                        "    and ar.pv_id=pl.pv_id " +
-                        " order by pv.modified_stamp"
-                        );
-                stmt7.setFetchSize(500);
-                RmResultSet rset7 = new RmResultSet(stmt7.executeQuery(), "queryPackageVersions rset7");
-                while( rset7.next() )
-                {
-                    boolean ignore = false;
-                    int pv_id = rset7.mustGetInt("pv_id");
-                    Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset7 package superceded by planned " + pv_id);
-                        ignore = true;
-                    }
-                    if ( !ignore )
-                    {
-                        p.mAdvisoryRipple = true;
-                    }
-                }
-                rset7.close();
-                stmt7.close();
-                //  Process Scheduled Build Approvals. OpCode is 2
-                //      These are treated as requests to not-include a 'Pending' package-version in the current build set
-                //      If there is an un-expired instruction, then remove the pending package-version from the build set
-                //
-                //  Process all expired requests
-                //      These are scheduled builds were the scheduled time has been exceeded
-                //      Simply discard the instruction and let the Approved build proceed
-                //
-                DaemonInstruction di = new DaemonInstruction(baseline, 2, true);
-                phase.setPhase("removeOldSchedBuilds");
-                while ( getDaemonInst( di ) )
-                {
-                    markDaemonInstCompleted(di.instruction);
-                    mLogger.info("queryPackageVersions remove Scheduled Build Approvals " + di.pvId);
-                }
-                phase.setPhase("getSchedBuilds");
-                di = new DaemonInstruction(baseline, 2, false);
-                while ( getDaemonInst( di ) )
-                {
-                    Package p = findPackage(di.pvId, packageCollection);
-                    if ( p != NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions Scheduled Build Approvals " + di.pvId);
-                        packageCollection.remove(p);
-                    }
-                    else
-                    {
-                        // discard - the package no longer exists
-                        markDaemonInstCompleted( di.instruction );
-                        mLogger.info("queryPackageVersions remove Scheduled Build Approvals for nonexistent package " + di.pvId);
-                    }
-                }
-                // get released package info
-                //    Get package information on ALL released packages within the release of interest
+                // Get package information on ALL released packages within the release of interest
                 //
                 mLogger.debug("queryPackageVersions: stmt8");
                 phase.setPhase("getAllPkgs1");
                 PreparedStatement stmt8 = mConnection.prepareStatement(
                         "SELECT rc.pv_id," +
-                                "  p.pkg_id," +
+                                " p.pkg_id," +
-                                "  p.pkg_name," +
+                                " p.pkg_name," +
-                                "  pv.pkg_version," +
+                                " pv.pkg_version," +
-                                "  pv.v_ext," +
+                                " pv.v_ext," +
-                                "  pv.ripple_field," +
+                                " pv.ripple_field," +
-                                "  pv.major_limit," +
+                                " pv.major_limit," +
-                                "  pv.minor_limit," +
+                                " pv.minor_limit," +
-                                "  pv.patch_limit," +
+                                " pv.patch_limit," +
-                                "  pv.build_number_limit," +
+                                " pv.build_number_limit," +
-                                "  pv.build_type," +
+                                " pv.build_type," +
-                                "  rc.sdktag_id," +
+                                " rc.sdktag_id," +
-                                "  rc.ripple_stop," +
+                                " rc.ripple_stop," +
-                                "  peg.pv_id as pegged," +
+                                " peg.pv_id as pegged," +
-                                "  release_manager.PK_RMAPI.return_vcs_tag(rc.pv_id) AS vcsTag" +
+                                " release_manager.PK_RMAPI.return_vcs_tag(rc.pv_id) AS vcsTag," +
+                                " pv.build_time" +
                                 " FROM release_manager.release_content rc," +
                                 "  release_manager.package_versions pv," +
                                 "  release_manager.packages p," +
                                 "  release_manager.pegged_versions peg" +
                                 " WHERE rc.rtag_id= " + baseline +
                     String vcs_tag = rset8.getString("vcsTag","");
                     int isAnSdk = rset8.getInt("sdktag_id",0);
                     int isPegged = rset8.getInt("pegged",0);
                     String buildType = rset8.getString("build_type", null);
                     boolean isBuildable = ( buildType != null ) && (buildType.equals("A") || buildType.equals("Y") );
+                    int buildTime = rset8.getInt("build_time", 60);
                     String rippleStopData = rset8.getString("ripple_stop","n");
                     char rippleStop = rippleStopData.charAt(0);
                     Package p = new Package(pkg_id, pv_id, pkg_name, pkg_version, v_ext, pkg_name + v_ext, vcs_tag, ripple_field.charAt(0));
                     p.mBuildLimit = build_number_limit;
                     p.mIsSdk = isAnSdk > 0;
                     p.mIsPegged = isPegged > 0;
                     p.mIsBuildable = isBuildable;
                     p.mRippleStop = rippleStop;
-                    Integer ipv_id = Integer.valueOf(pv_id);
+                    p.mBuildTime = buildTime;
-                    rippleEngine.mReleasedPvIDCollection.add(ipv_id);
                     //  If this package is to be replaced by a planned package then
                     //  insert some of the current packages attributes
                     //  Otherwise, add the the package to the package collection
                     //
+//TODO Sort out this bit of logic
                     Package plannedPackage = findPackage(p.mAlias, packageCollection);
                     if ( plannedPackage == NULL_PACKAGE )
+                    {
-                        mLogger.info("queryPackageVersions rset8 no planned package " + pv_id);
+                        mLogger.info("queryPackageVersions rset8 no planned package {}", pv_id);
                         packageCollection.add(p);
+                    }
                     else
+                    {
                         //  Copy these flags from the package that will be replaced
                 RmResultSet rset9 = new RmResultSet(stmt9.executeQuery(), "queryPackageVersions rset9");
                 mLogger.debug("queryPackageVersions: stmt9 query done");
                 while( rset9.next() )
+                {
-                    boolean ignore = false;
                     int pv_id = rset9.mustGetKeyInt("pv_id");
                     int dpv_id = rset9.mustGetInt("dpv_id");
-                    Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset9 package superceded by planned " + pv_id);
-                        ignore = true;
-                    }
                     String pkg_name = rset9.mustGetString("pkg_name");
                     String v_ext = rset9.getString("v_ext","");
+                    Package p = findPackage(pv_id, packageCollection);
-                    if ( !ignore )
+                    if ( p != NULL_PACKAGE )
+                    {
                         p.mDependencyCollection.add(pkg_name + v_ext);
                         p.mDependencyIDCollection.add(dpv_id);
+                    }
+                }
                 mLogger.debug("queryPackageVersions: stmt9 processing complete");
                 rset9.close();
                 stmt9.close();
                 stmt10.setInt(1, baseline);
                 RmResultSet rset10 = new RmResultSet(stmt10.executeQuery(), "queryPackageVersions rset10");
                 while( rset10.next() )
+                {
-                    boolean ignore = false;
                     int pv_id = rset10.mustGetKeyInt("pv_id");
-                    Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset10 package superceded by planned " + pv_id);
-                        ignore = true;
-                    }
                     String bm_name = rset10.mustGetString("bm_name");
                     String bsa_name = rset10.mustGetString("bsa_name");
+                    Package p = findPackage(pv_id, packageCollection);
-                    if ( !ignore )
+                    if ( p != NULL_PACKAGE )
+                    {
                         BuildStandard bs = new BuildStandard(rippleEngine, bm_name, bsa_name);
                         if ( bs.supportedBuildStandard() )
+                        {
                             p.mBuildStandardCollection.add(bs);
+                        }
+                    }
                 stmt11.setFetchSize(1000);
                 RmResultSet rset11 = new RmResultSet(stmt11.executeQuery(), "queryPackageVersions rset11");
                 while( rset11.next() )
+                {
-                    boolean ignore = false;
                     int pv_id = rset11.mustGetKeyInt("pv_id");
-                    Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset11 package superceded by planned " + pv_id);
-                        ignore = true;
-                    }
                     String test_type_name = rset11.mustGetString("test_type_name");
+                    Package p = findPackage(pv_id, packageCollection);
-                    if ( !ignore )
+                    if ( p != NULL_PACKAGE )
+                    {
                         if ( test_type_name.compareTo("Autobuild UTF") == 0 )
+                        {
                             p.mHasAutomatedUnitTests = true;
+                        }
                 RmResultSet rset12 = new RmResultSet(stmt12.executeQuery(), "queryPackageVersions rset12");
                 while( rset12.next() )
+                {
                     int pv_id = rset12.mustGetKeyInt("pv_id");
+                    String user_email = rset12.getString("user_email",null);
                     Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
+                    if ( p != NULL_PACKAGE )
+                    {
-                        mLogger.info("queryPackageVersions rset12 package superceded by planned " + pv_id);
-                    }
-                    else
-                    {
-                        String user_email = rset12.getString("user_email",null);
-                        if ( user_email != null )
-                        {
-                            p.addEmail(user_email);
+                        p.addEmail(user_email);
-                        }
+                    }
+                }
                 rset12.close();
                 stmt12.close();
                 stmt14.setFetchSize(1000);
                 RmResultSet rset14 = new RmResultSet(stmt14.executeQuery(), "queryPackageVersions rset14");
                 while( rset14.next() )
+                {
-                    boolean ignore = false;
                     int pv_id = rset14.mustGetInt("pv_id");
                     Package p = findPackage(pv_id, packageCollection);
-                    if ( p == NULL_PACKAGE )
+                    if ( p != NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions rset14 package superceded by planned " + pv_id);
-                        ignore = true;
-                    }
-                    if ( !ignore )
+                    {
                         p.mAdvisoryRipple = true;
+                    }
+                }
                 rset14.close();
                 stmt14.close();
-                // Daemon Instruction: Force Package Ripple
-                //  An op code of 0 means force ripple
-                phase.setPhase("getDaemonInstructions1");
-                di = new DaemonInstruction( baseline, 0, true);
-                while ( getDaemonInst( di ) )
-                {
-                    Package p = findPackage(di.pvId, packageCollection);
-                    if ( p != NULL_PACKAGE )
-                    {
-                        mLogger.info("queryPackageVersions forced ripple data " + di.pvId);
-                        p.mForcedRippleInstruction = di.instruction;
-                        p.mTestBuildEmail = di.userEmail;
-                    }
-                    else
-                    {
-                        // discard
-                        markDaemonInstCompleted( di.instruction );
-                    }
-                }
-                // Daemon Instruction: Test Build Package
-                //  An op code of 1 means test build
-                //
-                // bare minimal data collection - last thing needed is more data to collect
-                // the approach...
-                // query all test build instructions for this baseline
-                // for each, query its build information
-                // store them in "mTestBuild" Package attributes as follows:
-                // - mTestBuildInstruction (default 0)
-                // - mTestBuildEmail (default "null")
-                // - mTestBuildVcsTag (default "null")
-                // - mTestBuildStandardCollection
-                // - mTestBuildDependencyCollection
-                // additionally, trust nothing - these are mostly wips that at any time may have:
-                // - no build location
-                // - no build label
-                // - an empty build standard collection
-                // proceed with defaults above if necessary (the build will subsequently fail)
-                // in all cases, build a meaningful email body to inform the user
-                // of the snapshot of build information that applied to the build and store in:
-                // - mTestBuildEmailBody
-                mLogger.debug("queryPackageVersions: stmt141");
-                phase.setPhase("getTestBuild1");
-                di = new DaemonInstruction( baseline, 1, true);
-                while ( getDaemonInst( di ) )
-                {
-                    // can only do one test build at a time - others will be discarded until future cycle
-                    mLogger.info("queryPackageVersions test build data " + di.pvId);
-                    int testBuildPvId = di.pvId;
-                    int testBuildInstruction = di.instruction;
-                    String testBuildEmail = di.userEmail;
-                    String pkg_name = "";
-                    String pkg_ext = "";
-                    String testBuildVcsTag = "null";
-                    int pkg_id = 0;
-                    // get package info for test build package
-                    mLogger.debug("queryPackageVersions: stmt15");
-                    PreparedStatement stmt15 = mConnection.prepareStatement(
-                            "select p.pkg_name, p.pkg_id, pv.v_ext, release_manager.PK_RMAPI.return_vcs_tag(pv.pv_id) AS vcsTag " +
-                                    " from release_manager.package_versions pv," +
-                                    "release_manager.packages p" +
-                                    " where pv.pv_id=" + testBuildPvId +
-                                    " and p.pkg_id=pv.pkg_id "
-                            );
-                    stmt15.setFetchSize(10);
-                    RmResultSet rset15 = new RmResultSet(stmt15.executeQuery(), "queryPackageVersions rset15");
-                    int rsetSize = 0;
-                    while( rset15.next() )
-                    {
-                        rsetSize++;
-                        pkg_name = rset15.mustGetKeyString("pkg_name");
-                        pkg_id = rset15.mustGetInt("pkg_id");
-                        pkg_ext = rset15.getString("v_ext","");
-                        testBuildVcsTag = rset15.getString("vcsTag", "null");
-                    }
-                    rset15.close();
-                    stmt15.close();
-                    mLogger.debug("queryPackageVersions: stmt16");
-                    if ( rsetSize == 0 )
-                    {
-                        mLogger.error("queryPackageVersions rset15 no data found " + di.instruction);
-                        markDaemonInstCompleted( di.instruction );
-                    }
-                    else
-                    {
-                        Package q = findPackage(pkg_name + pkg_ext, packageCollection);
-                        if ( q == NULL_PACKAGE )
-                        {
-                            // Package alias does not exist in this release (planned or released packages)
-                            q = new Package(pkg_id, testBuildPvId, pkg_name, pkg_ext, pkg_name + pkg_ext, testBuildVcsTag, testBuildInstruction, testBuildEmail);
-                            packageCollection.add(q);
-                        }
-                        else
-                        {
-                            // Avoid interaction with real versions
-                        	// Flag as not pegged - so that we test build
-                            q.mVersion = "0.0.0000";
-                            q.mTestBuildVcsTag = testBuildVcsTag;
-                            q.mTestBuildInstruction = testBuildInstruction;
-                            q.mTestBuildEmail = testBuildEmail;
-                            q.mTestBuildPvId = testBuildPvId;
-                            q.mTestBuildHasAutomatedUnitTests = false;
-                            q.mIsPegged = false;
-                        }
-                        // get test build package dependency info
-                        PreparedStatement stmt16 = mConnection.prepareStatement(
-                                "select p.pkg_name, dpv.v_ext " +
-                                        " from release_manager.package_versions pv," +
-                                        "   release_manager.package_dependencies pd,"+
-                                        "   release_manager.package_versions dpv,"+
-                                        "   release_manager.packages p" +
-                                        " where pv.pv_id=" + testBuildPvId +
-                                        "   and pd.pv_id=" + testBuildPvId +
-                                        "   and dpv.pv_id=pd.dpv_id"+
-                                        "   and p.pkg_id=dpv.pkg_id"
-                                );
-                        stmt16.setFetchSize(1000);
-                        RmResultSet rset16 = new RmResultSet(stmt16.executeQuery(), "queryPackageVersions rset16");
-                        while( rset16.next() )
-                        {
-                            String dpkg_name = rset16.mustGetString("pkg_name");
-                            String v_ext = rset16.getString("v_ext", "");
-                            q.mTestBuildDependencyCollection.add(dpkg_name + v_ext);
-                        }
-                        rset16.close();
-                        stmt16.close();
-                        // get test build package build info
-                        mLogger.debug("queryPackageVersions: stmt17");
-                        PreparedStatement stmt17 = mConnection.prepareStatement(
-                                "select bm.bm_name, bsa.bsa_name " +
-                                        "from release_manager.package_versions pv," +
-                                        "     release_manager.package_build_info pbi," +
-                                        "     release_manager.build_machines bm," +
-                                        "     release_manager.build_standards_addendum bsa " +
-                                        "where pv.pv_id=" + testBuildPvId +
-                                        "   and pbi.pv_id=pv.pv_id" +
-                                        "   and bm.bm_id=pbi.bm_id" +
-                                        "   and bsa.bsa_id=pbi.bsa_id"
-                                );
-                        RmResultSet rset17 = new RmResultSet(stmt17.executeQuery(), "queryPackageVersions rset17");
-                        while( rset17.next() )
-                        {
-                            String bm_name = rset17.mustGetKeyString("bm_name");
-                            String bsa_name = rset17.mustGetString("bsa_name");
-                            BuildStandard bs = new BuildStandard(rippleEngine, bm_name, bsa_name);
-                            if ( bs.supportedBuildStandard() )
-                            {
-                                q.mTestBuildStandardCollection.add(bs);
-                            }
-                        }
-                        rset17.close();
-                        stmt17.close();
-                        // get test build package unit test info
-                        mLogger.debug("queryPackageVersions: stmt4");
-                        PreparedStatement stmt18 = mConnection.prepareStatement(
-                                "select tt.test_type_name" +
-                                "  from release_manager.unit_tests ut," +
-                                "       release_manager.test_types tt" +
-                                " where ut.pv_id=" + testBuildPvId +
-                                "  and tt.test_type_id=ut.test_types_fk"
-                                );
-                        RmResultSet rset18 = new RmResultSet(stmt18.executeQuery(), "queryPackageVersions rset18");
-                        while( rset18.next() )
-                        {
-                            boolean ignore = false;
-                            String test_type_name = rset18.mustGetString("test_type_name");
-                            if ( !ignore )
-                            {
-                                if ( test_type_name.compareTo("Autobuild UTF") == 0 )
-                                {
-                                	q.mTestBuildHasAutomatedUnitTests = true;
-                                }
-                            }
-                        }
-                        rset18.close();
-                        stmt18.close();
-                    }
-                }
+            }
             else
+            {
                 // Escrow Mode
+                    }
+                }
                 rset.close();
                 stmt.close();
+                //  Now have all the package-versions used in the SBOM need to
+                //      determine all the dependent packages
+                //      determine the build info for all the packages
+                //  Determine all dependent packages
+                //  Note: use a ListIterator as it allows traverseDependencies to modify the packageCollection
+                for (ListIterator<Package> it = packageCollection.listIterator(); it.hasNext(); )
+                {
+                    Package p = it.next();
+                    traverseDependencies(packageCollection, p, false, it);
+                }
+                //  Add required build information
+                for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
+                {
+                    Package p = it.next();
+                    queryBuildInfo(rippleEngine, p);
+                }
+            }
+        }
         catch ( SQLException e )
+        {
             handleSQLException(e, "");
+        }
+        phase.setPhase("End");
+    }
+    /**
+     * Extract all package-version information for Planned Packages (WIPS)
+     * Not used in ESCROW
+     *
+     * @param   rippleEngine        - Instance to use
+     * @param   packageCollection   - Package Collection structure to fill. Expected to be cleared
+     * @param   baseline            - RtagId of the release being processed, BomId of an Escrow being processed
+     *
+     * Overridden in ReleaseManagerUtf
+     *
+     */
+    protected void queryWips(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
+    {
+        if (!mDaemon){
+            return;
+        }
+        Phase phase = new Phase("rmData");
+        mLogger.debug("queryWips {}", mDaemon);
-        if (!mDaemon)
+        try
+        {
+            // Get planned package info
-            // use a ListIterator as it allows traverseDependencies to modify the packageCollection
+            // Support multiple WIPS on the same package and build in the order they were released
+            // These are packages that are marked as pending build
+            //
+            mLogger.debug("queryPackageVersions: stmt1");
+            phase.setPhase("getPlannedPkgs1");
-            for (ListIterator<Package> it = packageCollection.listIterator(); it.hasNext(); )
+            PreparedStatement stmt1 = mConnection.prepareStatement(
+                    "select pl.pv_id, pv.modified_stamp," +
+                            " from release_manager.planned pl," +
+                            "      release_manager.package_versions pv," +
+                            "      release_manager.packages p" +
+                            " where pl.rtag_id=" + baseline +
+                            "   and pv.build_type='A' and pv.dlocked='A'" +
+                            "   and pv.pv_id=pl.pv_id and p.pkg_id=pv.pkg_id" +
+                            " order by pv.modified_stamp"
+                    );
+            stmt1.setFetchSize(500);
+            RmResultSet rset1 = new RmResultSet(stmt1.executeQuery(), "queryPackageVersions rset1");
+            while( rset1.next() )
+            {
+                int pvId = rset1.mustGetKeyInt("pv_id");
+                Package p = getPackageInfo(pvId, rippleEngine);
-                Package p = it.next();
+                if ( p != NULL_PACKAGE)
+                {
+                    p.mIsNotReleased = true;
+                    p.mDirectlyPlanned = true;
+                    p.mBuildReason = BuildReason.NewVersion;
+                    // If there are multiple packages with the same Alias, then only the first one
+                    // will be placed in the build set. The will be the oldest, the first one released
+                    // to be built
+                    Package prevPlannedPackage = findPackage(p.mAlias, packageCollection);
+                    if ( prevPlannedPackage == NULL_PACKAGE )
+                    {
+                        mLogger.info("queryWips rset1 no previous WIP package {}", pvId);
-                traverseDependencies(packageCollection, p, false, it);
+                        packageCollection.add(p);
+                    }
+                }
+            }
+            rset1.close();
+            stmt1.close();
+            //  Process Scheduled Build Approvals. OpCode is 2
+            //      These are treated as requests to not-include a 'Pending' package-version in the current build set
+            //      If there is an un-expired instruction, then remove the pending package-version from the build set
+            //
+            //  Process all expired requests
+            //      These are scheduled builds were the scheduled time has been exceeded
+            //      Simply discard the instruction and let the Approved build proceed
+            //
-            for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
+            DaemonInstruction di = new DaemonInstruction(baseline, 2, true);
+            phase.setPhase("removeOldSchedBuilds");
+            while ( getDaemonInst( di ) )
+            {
+                markDaemonInstCompleted(di.instruction);
+                mLogger.info("queryPackageVersions remove Scheduled Build Approvals {}", di.pvId);
+            }
+            phase.setPhase("getSchedBuilds");
+            di = new DaemonInstruction(baseline, 2, false);
+            while ( getDaemonInst( di ) )
+            {
+                Package p = findPackage(di.pvId, packageCollection);
+                if ( p != NULL_PACKAGE )
+                {
+                    mLogger.info("queryPackageVersions Scheduled Build Approvals {}", di.pvId);
+                    packageCollection.remove(p);
+                }
+                else
+                {
+                    // discard - the package no longer exists
+                    markDaemonInstCompleted( di.instruction );
+                    mLogger.info("queryPackageVersions remove Scheduled Build Approvals for nonexistent package {}", di.pvId);
+                }
+            }
+        }
+        catch ( SQLException e )
+        {
+            handleSQLException(e, "");
+        }
+        phase.setPhase("End");
+    }
+    /**
+     * Extract all TEST package-version information
+     * Only active in Daemon Mode
+     *
+     * @param   rippleEngine        - Instance to use
+     * @param   packageCollection   - Package Collection structure to fill. Expected to be cleared
+     * @param   baseline            - RtagId of the release being processed, BomId of an Escrow being processed
+     *
+     * Overridden in ReleaseManagerUtf
+     *
+     */
+    protected void queryTest(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
+    {
+        if (!mDaemon){
+            return;
+        }
+        Phase phase = new Phase("rmData");
+        mLogger.debug("queryTest {}", mDaemon);
+        try
+        {
+            // Daemon Instruction: Test Build Package
+            //  An op code of 1 means test build
+            //
+            // Trust nothing - these are mostly wips that at any time may have:
+            // - no build location
+            // - no build label
+            // - an empty build standard collection
+            // proceed with defaults above if necessary (the build will subsequently fail)
+            // in all cases, build a meaningful email body to inform the user
+            // of the snapshot of build information that applied to the build and store in:
+            // - mTestBuildEmailBody
+            mLogger.debug("queryTest: stmt141");
+            phase.setPhase("getTestBuild1");
+            DaemonInstruction di = new DaemonInstruction( baseline, 1, true);
+            while ( getDaemonInst( di ) )
+            {
+                mLogger.info("queryPackageVersions test build data {}", di.pvId);
+                Package p = getPackageInfo(di.pvId, rippleEngine);
+                if ( p == NULL_PACKAGE )
+                {
+                    mLogger.error("queryTest rset15 no data found {}", di.instruction);
+                    markDaemonInstCompleted( di.instruction );
+                }
+                else
+                {
-                Package p = it.next();
+                    packageCollection.add(p);
+                    //  Set some Test information
+                    //  Avoid interaction with real versions
+                    //  Flag as not pegged - so that we test build
+                    p.mVersion = "0.0.0000";
+                    p.mTestBuildInstruction = di.instruction;
-                queryBuildInfo(rippleEngine, p);
+                    p.addEmail(di.userEmail);
+                    p.mBuildReason = BuildReason.Test;
+                    p.mIsPegged = false;
+                    p.mIsNotReleased = true;
+                }
+            }
+        }
+        catch ( SQLException e )
+        {
+            handleSQLException(e, "");
+        }
         phase.setPhase("End");
+    }
+    /**
+     * Extract all Ripple Request package-version information
+     * The returned list is in daemon instruction id order - ie the first request will be first
+     * Only active in Daemon Mode
+     *
+     * @param   rippleEngine        - Instance to use
+     * @param   packageCollection   - Package Collection structure to fill. Expected to be cleared
+     * @param   baseline            - RtagId of the release being processed, BomId of an Escrow being processed
+     *
+     * Overridden in ReleaseManagerUtf
+     *
+     */
+    protected void queryRipples(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
+    {
+        if (!mDaemon){
+            return;
+        }
+        Phase phase = new Phase("rmData");
+        mLogger.debug("queryPackageVersions {}", mDaemon);
+        try
+        {
+            // Daemon Instruction: Force Package Ripple
+            //  An op code of 0 means force ripple
+            phase.setPhase("getDaemonInstructions1");
+            DaemonInstruction di = new DaemonInstruction( baseline, 0, true);
+            while ( getDaemonInst( di ) )
+            {
+                Package p = getPackageInfo(di.pvId, rippleEngine);
+                if ( p != NULL_PACKAGE )
+                {
+                    mLogger.info("queryPackageVersions forced ripple data {}", di.pvId);
+                    packageCollection.add(p);
+                    p.mForcedRippleInstruction = di.instruction;
+                    p.addEmail(di.userEmail);
+                    p.mBuildReason = BuildReason.Ripple;
+                    p.mIsNotReleased = true;
+                }
+                else
+                {
+                    // discard
+                    markDaemonInstCompleted( di.instruction );
+                }
+            }
+        }
+        catch ( SQLException e )
+        {
+            handleSQLException(e, "");
+        }
+        phase.setPhase("End");
+    }
+    /** Get all build information for a single package
+     *  Don't use this where lots of packages are expected, but should be OK to get data for TEST, WIP and Ripples
+     *
+     *  Does not get:
+     *      mBuildReason
+     *      mDirectlyPlanned
+     *
+     *  @param  pvId    - Package to process
+     * @param rippleEngine - Ripple engine associated wit the Release
+     * @throws Exception
+     *
+     *  @returns a package - May be null, but this is not good
+     */
+    Package getPackageInfo(int pvId, RippleEngine rippleEngine) throws Exception
+    {
+        Package p = NULL_PACKAGE;
+        try
+        {
+            // Get Package info
+            //
+            mLogger.debug("getPackageInfo: stmt1");
+            PreparedStatement stmt1 = mConnection.prepareStatement(
+                    "select pv.pv_id, p.pkg_id, p.pkg_name, pv.pkg_version, " +
+                            " pv.v_ext, pv.change_type, pv.ripple_field," +
+                            " pv.major_limit, pv.minor_limit, pv.patch_limit, pv.build_number_limit," +
+                            " pv.modified_stamp," +
+                            " release_manager.PK_RMAPI.return_vcs_tag(pl.pv_id) AS vcsTag," +
+                            " pv.build_time" +
+                            " from " +
+                            "      release_manager.package_versions pv," +
+                            "      release_manager.packages p" +
+                            " where pv.pv_id=" + pvId +
+                            "   and p.pkg_id=pv.pkg_id"
+                    );
+            stmt1.setFetchSize(500);
+            RmResultSet rset1 = new RmResultSet(stmt1.executeQuery(), "getPackageInfo rset1");
+            //  Package must exist
+            if ( ! rset1.next() )
+            {
+                return NULL_PACKAGE;
+            }
+            int pv_id = rset1.mustGetKeyInt("pv_id");
+            int pkg_id = rset1.mustGetInt("pkg_id");
+            String pkg_name = rset1.mustGetString("pkg_name");
+            String pkg_version = rset1.mustGetString("pkg_version");
+            int buildTime = rset1.getInt("build_time", 60);
+            // Previous Version of this package, without the project suffix
+            String pkg_prevVersion = getBaseVersionNumber(pv_id);
+            if ( pkg_prevVersion == null)
+            {
+                // show stopper
+                mLogger.error("getPackageInfo. No Previous version {}", pv_id);
+                throw new Exception("getPackageInfo. No Previous version" + pv_id);
+            }
+            String v_ext = rset1.getString("v_ext","");
+            String change_type = rset1.getString("change_type", "P");
+            char ct = 'P';
+            if ( change_type.compareTo("M") == 0 )
+            {
+                ct = 'M';
+            }
+            else if ( change_type.compareTo("N") == 0 )
+            {
+                ct = 'N';
+            }
+            else if ( change_type.compareTo("P") == 0 )
+            {
+                ct = 'P';
+            }
+            else if ( change_type.compareTo("F") == 0 )
+            {
+                ct = 'F';
+            }
+            String ripple_field = rset1.getString("ripple_field", "b");
+            int major_limit = rset1.getInt("major_limit", 0);
+            int minor_limit = rset1.getInt("minor_limit",0);
+            int patch_limit = rset1.getInt("patch_limit",0);
+            int build_number_limit = rset1.getInt("build_number_limit",0);
+            String vcs_tag = rset1.getString("vcsTag", "");
+            p = new Package(pkg_id, pv_id, pkg_name, pkg_version, v_ext, pkg_name + v_ext, vcs_tag, ripple_field.charAt(0), ct);
+            p.mMajorLimit = major_limit;
+            p.mMinorLimit = minor_limit;
+            p.mPatchLimit = patch_limit;
+            p.mBuildLimit = build_number_limit;
+            p.mPrevVersion = pkg_prevVersion;
+            p.mBuildTime = buildTime;
+            rset1.close();
+            stmt1.close();
+            // get Package dependency info
+            mLogger.debug("getPackageInfo: stmt2");
+            PreparedStatement stmt2 = mConnection.prepareStatement(
+                    "select dpv.v_ext" +
+                            "from " +
+                            "     release_manager.package_versions pv,"+
+                            "     release_manager.package_dependencies pd," +
+                            "     release_manager.package_versions dpv,"+
+                            " where pv.pv_id=" + pvId +
+                            "  and pd.pv_id=pv.pv_id"+
+                            "  and dpv.pv_id=pd.dpv_id"
+                    );
+            stmt2.setFetchSize(500);
+            RmResultSet rset2 = new RmResultSet(stmt2.executeQuery(), "getPackageInfo rset2");
+            if( rset2.next() )
+            {
+                String dpv_ext = rset2.getString("v_ext","");
+                p.mDependencyCollection.add(pkg_name + dpv_ext);
+                p.mDependencyIDCollection.add(-1);
+            }
+            rset2.close();
+            stmt2.close();
+            // get Package build info
+            mLogger.debug("getPackageInfo: stmt3");
+            PreparedStatement stmt3 = mConnection.prepareStatement(
+                    "select bm.bm_name, bsa.bsa_name" +
+                            "from " +
+                            "     release_manager.package_versions pv," +
+                            "     release_manager.package_build_info pbi," +
+                            "     release_manager.build_machines bm," +
+                            "     release_manager.build_standards_addendum bsa " +
+                            "where pv_id=" + pvId +
+                            "     and pbi.pv_id=pv.pv_id" +
+                            "     and bm.bm_id=pbi.bm_id" +
+                            "     and bsa.bsa_id=pbi.bsa_id "
+                    );
+            stmt3.setFetchSize(500);
+            RmResultSet rset3 = new RmResultSet(stmt3.executeQuery(), "getPackageInfo rset3");
+            if( rset3.next() )
+            {
+                String bm_name = rset3.mustGetString("bm_name");
+                String bsa_name = rset3.mustGetString("bsa_name");
+                BuildStandard bs = new BuildStandard(rippleEngine, bm_name, bsa_name);
+                if ( bs.supportedBuildStandard() )
+                {
+                    p.mBuildStandardCollection.add(bs);
+                }
+            }
+            rset3.close();
+            stmt3.close();
+            // get Package unit test info
+            mLogger.debug("getPackageInfo: stmt4");
+            PreparedStatement stmt4 = mConnection.prepareStatement(
+                    "select pv.pv_id, tt.test_type_name" +
+                    "  from "+
+                    "       release_manager.package_versions pv,"+
+                    "       release_manager.unit_tests ut," +
+                    "       release_manager.test_types tt" +
+                    " where pv.pv_id=" + pvId +
+                    "  and ut.pv_id=pv.pv_id" +
+                    "  and tt.test_type_id=ut.test_types_fk"
+                    );
+            stmt4.setFetchSize(500);
+            RmResultSet rset4 = new RmResultSet(stmt4.executeQuery(), "getPackageInfo rset4");
+            if( rset4.next() )
+            {
+                String test_type_name = rset4.mustGetString("test_type_name");
+                if ( test_type_name.compareTo("Autobuild UTF") == 0 )
+                {
+                    p.mHasAutomatedUnitTests = true;
+                }
+            }
+            rset4.close();
+            stmt4.close();
+            // get Package build failure info...
+            //      view based
+            mLogger.debug("getPackageInfo: stmt5");
+            PreparedStatement stmt5 = mConnection.prepareStatement(
+                    "select pv.pv_id, u.user_email" +
+                            " from " +
+                            "      release_manager.release_tags rt, " +
+                            "      release_manager.package_versions pv, " +
+                            "      release_manager.autobuild_failure af, " +
+                            "      release_manager.members_group mg, " +
+                            "      release_manager.users u " +
+                            " where pv.pv_id=" + pvId +
+                            "      and rt.rtag_id=" + rippleEngine.getRtagId() +
+                            "      and af.view_id=pv.view_id " +
+                            "      and mg.group_email_id=af.group_email_id " +
+                            "      and u.user_id=mg.user_id " +
+                            "      and af.proj_id=rt.proj_id "
+                    );
+            stmt5.setFetchSize(500);
+            RmResultSet rset5 = new RmResultSet(stmt5.executeQuery(), "getPackageInfo rset5");
+            if( rset5.next() )
+            {
+                p.addEmail(rset5.getString("user_email", null));
+            }
+            rset5.close();
+            stmt5.close();
+            // get Package build failure info...
+            // package version
+            mLogger.debug("getPackageInfo: stmt6");
+            PreparedStatement stmt6 = mConnection.prepareStatement(
+                    "select pv.pv_id, u1.user_email as creator, u2.user_email as owner, u3.user_email as modifier" +
+                    " from " +
+                    "      release_manager.release_tags rt," +
+                    "      release_manager.package_versions pv," +
+                    "      release_manager.users u1," +
+                    "      release_manager.users u2," +
+                    "      release_manager.users u3 " +
+                    " where pv.pv_id=" + pvId +
+                    "   and rt.rtag_id=" + rippleEngine.getRtagId() +
+                    "   and pv.build_type='A'" +
+                    "   and pv.dlocked='A' " +
+                    "   and pv.pv_id = pl.pv_id" +
+                    "   and u1.user_id=pv.creator_id" +
+                    "   and u2.user_id=pv.owner_id" +
+                    "   and u3.user_id=pv.modifier_id"
+                    );
+            stmt6.setFetchSize(500);
+            RmResultSet rset6 = new RmResultSet(stmt6.executeQuery(), "getPackageInfo rset6");
+            if( rset6.next() )
+            {
+                p.addEmail( rset6.getString("creator",null));
+                p.addEmail( rset6.getString("owner",null));
+                p.addEmail( rset6.getString("modifier",null));
+            }
+            rset6.close();
+            stmt6.close();
+            // get Package advisory ripple info
+            mLogger.debug("getPackageInfo: stmt7");
+            PreparedStatement stmt7 = mConnection.prepareStatement(
+                    "select pl.pv_id, pv.modified_stamp " +
+                    " from " +
+                    "      release_manager.package_versions pv," +
+                    "      release_manager.advisory_ripple ar " +
+                    " where pv.pv_id = " + pvId +
+                    "    and ar.rtag_id=" + rippleEngine.getRtagId() +
+                    "    and ar.pv_id=pv.pv_id "
+                    );
+            stmt7.setFetchSize(500);
+            RmResultSet rset7 = new RmResultSet(stmt7.executeQuery(), "getPackageInfo rset7");
+            if( rset7.next() )
+            {
+                p.mAdvisoryRipple = true;
+            }
+            rset7.close();
+            stmt7.close();
+        }
+        catch ( SQLException e )
+        {
+            handleSQLException(e, "");
+        }
+        return p;
+    }
-   /**	Determine the version number of the base package
+    /**	Determine the version number of the base package
     *   Used in a ripple build to determine the base for calculating the next version number
     *   Assumes that a database connection has been established
     *   Used in Daemon Mode Only
+    *
     *   History: Used to determine the last non-rippled package, but this had issues [JATS-402]
 			rset.close();
 			stmt.close();
     	} catch (SQLException e) {
     		baseVersion = null;
-    		mLogger.error("Exception for getBaseVersionNumber " + pv_id);
+    		mLogger.error("Exception for getBaseVersionNumber {}", pv_id);
+		}
         return baseVersion;
+    }
-    /**called only in escrow mode
+    /** Called only in escrow mode
+     *
+     * Used to process each package in the escrow list and to locate all dependent packages - recursively.
+     *
      * if checkCollection is true, checks the pv_id is in the packageCollection
      * if checkCollection is false, or the pv_id is not in the collection
-     * 1 traverses the pv_id package dependencies
+     *    Traverses the pv_id package dependencies
-     *   select dpv.pv_id, p.pkg_name, dpv.pkg_version, dpv.v_ext
-     *   from release_manager.package_versions pv, release_manager.package_dependencies pd, release_manager.package_versions dpv, release_manager.packages p
-     *   where pv.pv_id = <pv_id> and pd.pv_id=pv.pv_id and dpv.pv_id=pd.dpv_id and p.pkg_id=dpv.pkg_id
-     *   order by pv.pv_id;
-     * 2 for each dpv.pv_id in the resultset
+     *    for each dpv.pv_id in the resultset
      *     call traverseDependencies( packageCollection, dpv.pv_id, true )
      *     if the pv_id is not in the collection, add it
+     *
+     *   @param packageCollection   - Collection of packages being processed
+     *   @param pkg                 - Current package in the collection
+     *   @param checkCollection     - How to handle pkg not in the collection. False: Process all package dependencies. True: Skip if package is in collection
+     *   @param listIterator        - List iterator being used to iterate over packageCollection. Used to insert new packages
+     *
+     *   This function is called recursively
      */
-    private void traverseDependencies(ArrayList<Package> packageCollection, Package pkg,
+    private void traverseDependencies(ArrayList<Package> packageCollection, Package pkg, boolean checkCollection, ListIterator<Package> listIterator) throws SQLException, Exception
-            boolean checkCollection,
-            ListIterator<Package> listIterator) throws SQLException, Exception
-            {
+    {
-        mLogger.debug("traverseDependencies " + checkCollection);
+        mLogger.debug("traverseDependencies {}", checkCollection);
         boolean pvIdInCollection = false;
         if ( checkCollection )
+        {
             for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
             catch ( SQLException e )
+            {
                 handleSQLException(e, "");
+            }
+            //  Process each dependent package
             for (Iterator<Package> it = resultset.iterator(); it.hasNext();)
+            {
                 Package r = it.next();
                 traverseDependencies(packageCollection, r, true, listIterator);
                     listIterator.add(r);
+                }
+            }
+        }
-            }
+    }
-    /**called only in escrow mode to add build info to the Package
+    /** Called only in escrow mode
+     *
-     * select bm.bm_name, bsa.bsa_name
+     *  <p>Add build information to a Package
-     * from release_manager.package_versions pv, release_manager.package_build_info pbi, release_manager.build_machines bm, release_manager.build_standards_addendum bsa
+     *  <br>Adds: bm_name and bsa_name, but only if they are supported
+     *
-     * where pv.pv_id = <p.pv_id> and pbi.pv_id=pv.pv_id and bm.bm_id=pbi.bm_id and bsa.bsa_id=pbi.bsa_id
+     * @param   rippleEngine    - Ripple Engine being used
+     * @param   p               - Package to process
-     * order by pv.pv_id;
+     *
      */
     private void queryBuildInfo(RippleEngine rippleEngine, Package p) throws SQLException, Exception
+    {
         mLogger.debug("queryBuildInfo");
      * Find Package by pvid
      * @param   id                  - pvid of package to locate
      * @param   packageCollection   - Collection to scan
      * @return  Package with the matching mID or NULL_PACKAGE if no package has the mID
      */
+    int findPackageLastId = 0;
+    Package findPackageLastPackage = NULL_PACKAGE;
     protected Package findPackage(int id, ArrayList<Package> packageCollection)
+    {
-        mLogger.debug("findPackage 1 id " + id);
+        mLogger.debug("findPackage id {}", id);
         Package retVal = NULL_PACKAGE;
-        for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
+        if (findPackageLastId != 0 && findPackageLastId == id) {
+            mLogger.debug("findPackage id {} - cache hit", id);
+            retVal = findPackageLastPackage;
+        }
+        else
+        {
-            Package p = it.next();
+            for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
-            if ( p.mId == id )
+            {
+                Package p = it.next();
+                if ( p.mId == id )
+                {
+                    findPackageLastId = id;
+                    findPackageLastPackage = p;
-                retVal = p;
+                    retVal = p;
-                break;
+                    break;
+                }
+            }
+        }
-        mLogger.debug("findPackage 1 returned " + retVal.mName);
+        mLogger.debug("findPackage id {} returned {}", id, retVal.mName);
         return retVal;
+    }
     /**
      * Find Package by package alias
      * @param   packageCollection   - Collection to scan
      * @return  Package with the matching mAlias or NULL_PACKAGE if no package has the mAlias
      */
     protected Package findPackage(String alias, ArrayList<Package> packageCollection)
+    {
-        mLogger.debug("findPackage 2 alias " + alias);
+        mLogger.debug("findPackage alias {}", alias);
         Package retVal = NULL_PACKAGE;
         for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
+        {
             Package p = it.next();
                 retVal = p;
                 break;
+            }
+        }
-        mLogger.info("findPackage 2 returned " + retVal.mName);
+        mLogger.info("findPackage alias {} returned {}", alias, retVal.mName);
         return retVal;
+    }
     /**only used in daemon mode to determine version existence in the database
      *  1 select pkg_id from release_manager.package_versions where pkg_id=<pkg_id> and pkg_version=<pkg_version>;
                 rset1.close();
                 stmt1.close();
                 if ( rsetSize > 1 )
+                {
-                    mLogger.error("queryPackageVersions rsetSize > 1 " + pkg_id + " " + pkg_version);
+                    String msg = "queryPackageVersions rsetSize > 1 " + pkg_id + " " + pkg_version;
+                    mLogger.error(msg);
                     // show stopper
-                    throw new Exception("queryPackageVersions rsetSize > 1 " + pkg_id + " " + pkg_version);
+                    throw new Exception(msg);
+                }
                 if ( rsetSize == 1 )
+                {
                     retVal = true;
                     rset2.close();
                     stmt2.close();
                     if ( rsetSize > 1 )
+                    {
-                        mLogger.error("queryPackageVersions rsetSize > 1 " + pkg_id + " " + pkg_version);
+                        String msg = "queryPackageVersions rsetSize > 1 " + pkg_id + " " + pkg_version;
+                        mLogger.error(msg);
                         // show stopper
-                        throw new Exception("queryPackageVersions rsetSize > 1 " + pkg_id + " " + pkg_version);
+                        throw new Exception(msg);
+                    }
                     if ( rsetSize == 1 )
+                    {
                         retVal = true;
+            {
                 handleSQLException(e, "");
+            }
+        }
-        mLogger.info("queryPackageVersions returned " + retVal);
+        mLogger.info("queryPackageVersions returned {}", retVal);
         return retVal;
+    }
     /**
      * Determine the set of packages that have been excluded from the build
      * @exception SQLException
      * @exception Exception
      */
     public void queryBuildExclusions(List<BuildExclusion> buildExclusionCollection, int baseline) throws SQLException, Exception
+    {
-        mLogger.debug("queryBuildExclusions " + baseline);
+        mLogger.debug("queryBuildExclusions {}", baseline);
         try
+        {
             PreparedStatement stmt = mConnection.prepareStatement(
                     "select pv_id, root_pv_id, root_cause" +
             String rootPvId,
             String rootCause,
             String rootFile,
             boolean supercede, Boolean testBuildInstruction) throws SQLException, Exception
+    {
-        mLogger.debug("excludeFromBuild " + packageVersionId);
+        mLogger.debug("excludeFromBuild {}", packageVersionId);
         //  If a Test Build, then don't excluded package
         if ( testBuildInstruction )
+        {
             return;
                     int result = stmt.getInt( 1 );
                     if ( result != 0 )
+                    {
                         // flag build failure
-                        mLogger.error( "excludeFromBuild show stopper PK_RMAPI.EXCLUDE_INDIRECT_FROM_BUILD failed, returned " + result );
+                        mLogger.error( "excludeFromBuild show stopper PK_RMAPI.EXCLUDE_INDIRECT_FROM_BUILD failed, returned {}",  result );
                         throw new Exception("excludeFromBuild show stopper PK_RMAPI.EXCLUDE_INDIRECT_FROM_BUILD failed, returned " + result);
+                    }
                     stmt.close();
                     if (!hasConnection )
                         commit();
      * @exception Exception
      */
     public void includeToBuild(int packageVersionId, int rtagId) throws SQLException, Exception
+    {
-        mLogger.debug("includeToBuild " + packageVersionId);
+        mLogger.debug("includeToBuild {}", packageVersionId);
         if ( mUseDatabase )
+        {
             try
+            {
                 CallableStatement stmt = mConnection.prepareCall(
      */
     public String queryBuildFile(int rcon_id) throws SQLException, Exception
+    {
         String buildFile = null;
-        mLogger.debug("queryRunLevel 1 rcon_id " + rcon_id);
+        mLogger.debug("queryRunLevel 1 rcon_id {}", rcon_id);
         if ( !mUseDatabase )
+        {
             mLogger.info("queryRunLevel 1 !mUseDatabase");
             buildFile = "unit test build file content";
+        }
      *	Used by the Master Daemon
      * 	Overridden in ReleaseManagerUtf
      */
     public void queryRunLevel(final int rtag_id) throws SQLException, Exception
+    {
-        mLogger.debug("queryRunLevel 2 rtag_id " + rtag_id);
+        mLogger.debug("queryRunLevel 2 rtag_id {}", rtag_id);
         mRunLevelCollection.clear();
         try
+        {
      * @exception Exception Too many rows extracted from the database
      *                      Empty(NULL) data in database
      */
     public void querySingleRunLevel(final int rcon_id, String hostname, char daemon_mode) throws SQLException, Exception
+    {
-        mLogger.debug("querySingleRunLevel rcon_id " + rcon_id);
+        mLogger.debug("querySingleRunLevel rcon_id {}", rcon_id);
         mRunLevelCollection.clear();
         try
+        {
             connect();
                         if ( sr != null )
+                        {
                             Date scheduledResume = new Date( sr.getTime() );
                             int repeat = rset.getInt("repeat");
-                            mLogger.info("queryRunLevelSchedule repeat " + repeat);
+                            mLogger.info("queryRunLevelSchedule repeat {}", repeat);
                             //
                             //  Have scheduled_pause and scheduled_resume
                             //  Examine the repeat field and determine how these are used
                             //  Supported repeat:
+            {
                 handleSQLException(e, ":2");
+            }
+        }
-        mLogger.info("queryRunLevelSchedule returning " + retVal);
+        mLogger.info("queryRunLevelSchedule returning {}", retVal);
         return retVal;
+    }
     /**persists the runLevel in the RUN_LEVEL table for the rcon_id primary key
+     *
         try
+        {
             connect();
-            mLogger.warn("updateCurrentRunLevel: Set Runlevel:" + runLevel + ", rcon_id: " + rcon_id);
+            mLogger.warn("updateCurrentRunLevel: Set Runlevel:{}, rconId:{}", runLevel, rcon_id);
             PreparedStatement stmt = mConnection.prepareCall("update release_manager.run_level set current_run_level=" + runLevel + ", keep_alive=SYSDATE where rcon_id=" + rcon_id);
             stmt.executeUpdate();
             stmt.close();
             mLogger.info("updateCurrentRunLevel: committing");
      * @param mBuildOrder - Ordered list of PackageVersions that we plan to build
      * @throws Exception
      * @throws SQLException
      */
     public void reportPlan(int mRtagId, List<Package> mBuildOrder) throws SQLException, Exception {
-        mLogger.debug("reportPlan " + mRtagId);
+        mLogger.debug("reportPlan {}", mRtagId);
         if ( mUseDatabase )
+        {
             try
+            {
+            }
+        }
+    }
     public void updateBuildDuration(int pvId, int duration) throws Exception {
-        mLogger.debug("updateBuildDuration " + pvId + ":" + duration);
+        mLogger.debug("updateBuildDuration {}:{}", pvId, duration);
         if ( mUseDatabase )
+        {
             try
+            {
                 connect();

Subversion Repositories DevTools

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