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



                if (connection != null)
                	connection.close();
            }
            catch (SQLException e)
            {
                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);
        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);
    }
    
    /**
     * 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("{} sql exception:{}", callingMethodName, e.getMessage());
        
        if ( mConnection == null || !mConnection.isValid(10) )
        {
            mLogger.error( "{} database access error only", callingMethodName);
            RmConnection.closeConnection(mConnection);
            throw new SQLException(e);
        }
        else
        {
            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() );
                RmConnection.closeConnection(mConnection);
            }
            catch( Exception e )
            {
                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() );
                    RmConnection.closeConnection(mConnection);
                }
            }
        }
    }

     * @exception SQLException
     * @exception Exception
     */
    void claimVersion(int pkgId, String pkgVersion, int rtagId) throws SQLException, Exception
    {
        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);
        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);
        if ( mUseDatabase )
        {
            try
            {
                connect();

     */
    public boolean autoMakeRelease(ReportingData mReporting) throws SQLException, Exception
    {
 
        mReporting.errMsg = null;
        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);
                    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);
        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);
                    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);
        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);
 
                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);
        if ( mUseDatabase )
        {
            try
            {
                connect();

                stmt.setLong( 3,pvId );
                stmt.setString( 4,result.toString() );
                stmt.executeUpdate();
                rv = stmt.getInt( 1 );
                
                mLogger.warn("updateBuildInstance: Result: {}", rv);
 
                stmt.close();
                commit();
            }
            catch ( SQLException e )

        if ( !mUseDatabase || !btr.mResultsFound )
        {
            return;
        }
 
        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);
        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);
 
        if ( mUseDatabase )
        {
            try
            {

     *  
     *  @param  instruction - PVID of Daemon Instruction to process
     */
    public void markDaemonInstCompleted(final int instruction) throws SQLException, Exception
    {
        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);
        StringBuilder retVal = new StringBuilder();
 
        String sql = "";
 
        if ( mDaemon )

        catch ( SQLException e )
        {
            handleSQLException(e, "");
        }
 
        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);
        return retVal;
    }
 
    /**only used in daemon mode
     * returns the configured service 

        catch ( SQLException e )
        {
            handleSQLException(e, "");
        }
 
        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);
        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 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());
            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);
        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 );
        
        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);
        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);
        boolean retVal = true;
 
        if ( mUseDatabase )
        {
            try

            {
                handleSQLException(e, "");
            }
        }
 
        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 );
                    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  );
 
                if ( pause <= 1 )
                {
                    retVal = true;
                }

        catch ( SQLException e )
        {
            handleSQLException(e, ":1");
        }
 
        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);
 
                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);
        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);
 
                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);
 
        int masterCount = 0;
        try
        {
            connect();

            disconnect();
        }
        return rv;
    }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    /**
 
 
 
 
 
 
     * Extract all package-version information for planned, test and released packages
 
 
     * In escrow mode there are no Planned or Test packages.
     * 
 
     * @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 queryPackageVersions(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
    {
        Phase phase = new Phase("rmData");
        mLogger.debug("queryPackageVersions {}", mDaemon);
 
        try
        {
            if (mDaemon)
            {

 
                    // 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","");

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

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

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

 
                    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 )

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

                {
                    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

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

              
                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

                    //  Otherwise, add the the package to the package collection
                    //
                    Package plannedPackage = findPackage(p.mAlias, packageCollection);
                    if ( plannedPackage == NULL_PACKAGE )
                    {
                        mLogger.info("queryPackageVersions rset8 no planned package {}", pv_id);
                        packageCollection.add(p);
                    }
                    else
                    {
                        //  Copy these flags from the package that will be replaced

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

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

 
                    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");
                    if ( !ignore )

                    int pv_id = rset12.mustGetKeyInt("pv_id");
                    Package p = findPackage(pv_id, packageCollection);
 
                    if ( p == NULL_PACKAGE )
                    {
                        mLogger.info("queryPackageVersions rset12 package superceded by planned {}", pv_id);
                    }
                    else
                    {
                        String user_email = rset12.getString("user_email",null);
 

 
                    int pv_id = rset14.mustGetInt("pv_id");
                    Package p = findPackage(pv_id, packageCollection);
                    if ( p == NULL_PACKAGE )
                    {
                        mLogger.info("queryPackageVersions rset14 package superceded by planned {}", pv_id);
                        ignore = true;
                    }
 
                    if ( !ignore )
                    {

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

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

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

                    }
                }
 
                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");
    }
    
    
   /**	Determine the version number of the base package

			rset.close();
			stmt.close();
        
    	} catch (SQLException e) {
    		baseVersion = null;
    		mLogger.error("Exception for getBaseVersionNumber {}", pv_id);
		}
        return baseVersion;
    }
 
    /** 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
     *    Traverses the pv_id package dependencies
 
 
 
 
     *    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, boolean checkCollection, ListIterator<Package> listIterator) throws SQLException, Exception
 
 
    {
        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
     * 
     *  <p>Add build information to a Package
     *  <br>Adds: bm_name and bsa_name, but only if they are supported
     * 
     * @param   rippleEngine    - Ripple Engine being used
     * @param   p               - Package to process
     * 
     */
    private void queryBuildInfo(RippleEngine rippleEngine, Package p) throws SQLException, Exception
    {
        mLogger.debug("queryBuildInfo");
 

     * @param   packageCollection   - Collection to scan
     * @return  Package with the matching mID or NULL_PACKAGE if no package has the mID
     */
    protected Package findPackage(int id, ArrayList<Package> packageCollection)
    {
        mLogger.debug("findPackage 1 id {}", id);
        Package retVal = NULL_PACKAGE;
 
        for (Iterator<Package> it = packageCollection.iterator(); it.hasNext(); )
        {
            Package p = it.next();

                retVal = p;
                break;
            }
        }
 
        mLogger.debug("findPackage 1 returned {}", 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);
        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);
        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 )
                {
                    String msg = "queryPackageVersions rsetSize > 1 " + pkg_id + " " + pkg_version;
                    mLogger.error(msg);
                    // show stopper
                    throw new Exception(msg);
                }
 
                if ( rsetSize == 1 )
                {
                    retVal = true;

                    rset2.close();
                    stmt2.close();
 
                    if ( rsetSize > 1 )
                    {
                        String msg = "queryPackageVersions rsetSize > 1 " + pkg_id + " " + pkg_version;
                        mLogger.error(msg);
                        // show stopper
                        throw new Exception(msg);
                    }
 
                    if ( rsetSize == 1 )
                    {
                        retVal = true;

            {
                handleSQLException(e, "");
            }
        }
 
        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);
 
        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);
 
        //  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 );
                        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);
        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);
        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);
 
        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);
        mRunLevelCollection.clear();
 
        try
        {
            connect();

 
                        if ( sr != null )
                        {
                            Date scheduledResume = new Date( sr.getTime() );
                            int repeat = rset.getInt("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);
        return retVal;
    }
 
    /**persists the runLevel in the RUN_LEVEL table for the rcon_id primary key
     * 

 
        try
        {
            connect();
 
            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);
 
        if ( mUseDatabase )
        {
            try
            {

            }
        }
    }
    
    public void updateBuildDuration(int pvId, int duration) throws Exception {
        mLogger.debug("updateBuildDuration {}:{}", pvId, duration);
        if ( mUseDatabase )
        {
            try
            {
                connect();

Rev 7033	Rev 7044
Line 159...	Line 159...
159	`if (connection != null)`	159	`if (connection != null)`
160	`connection.close();`	160	`connection.close();`
161	`}`	161	`}`
162	`catch (SQLException e)`	162	`catch (SQLException e)`
163	`{`	163	`{`
164	`mLogger.error("SQL Exception closing connection:" + e.getMessage());`	164	`mLogger.error("SQL Exception closing connection: {}", e.getMessage());`
165	`}`	165	`}`
166	`}`	166	`}`
167	`}`	167	`}`
168		168
169	`/**database connection for use when not planning a build`	169	`/**database connection for use when not planning a build`
Line 261...	Line 261...
261	`* @param username`	261	`* @param username`
262	`* @param password`	262	`* @param password`
263	`*/`	263	`*/`
264	`public ReleaseManager(final String connectionString, final String username, final String password)`	264	`public ReleaseManager(final String connectionString, final String username, final String password)`
265	`{`	265	`{`
266	`mLogger.debug("ReleaseManager " + connectionString);`	266	`mLogger.debug("ReleaseManager {}", connectionString);`
267	`mConnectionString = connectionString;`	267	`mConnectionString = connectionString;`
268	`mUsername = username;`	268	`mUsername = username;`
269	`mPassword = password;`	269	`mPassword = password;`
270		270
271	`String gbeBtDebug = System.getenv("GBE_BUILDTOOL_DEBUG");`	271	`String gbeBtDebug = System.getenv("GBE_BUILDTOOL_DEBUG");`
Line 313...	Line 313...
313	`* False: Escrow Mode`	313	`* False: Escrow Mode`
314	`*/`	314	`*/`
315	`public void setDaemonMode(boolean isDaemon)`	315	`public void setDaemonMode(boolean isDaemon)`
316	`{`	316	`{`
317	`mDaemon = isDaemon;`	317	`mDaemon = isDaemon;`
318	`mLogger.debug("DaemonMode:" + mDaemon);`	318	`mLogger.debug("DaemonMode:{}", mDaemon);`
319	`}`	319	`}`
320		320
321	`/**`	321	`/**`
322	`* Clear mUseMutex`	322	`* Clear mUseMutex`
323	`* Used only in test mode to prevent the use of a mutex`	323	`* Used only in test mode to prevent the use of a mutex`
Line 564...	Line 564...
564	`* @throws Exception`	564	`* @throws Exception`
565	`*/`	565	`*/`
566	`void handleSQLException(SQLException e, String instanceId ) throws SQLException, Exception`	566	`void handleSQLException(SQLException e, String instanceId ) throws SQLException, Exception`
567	`{`	567	`{`
568	`String callingMethodName = Thread.currentThread().getStackTrace()[2].getMethodName() + instanceId ;`	568	`String callingMethodName = Thread.currentThread().getStackTrace()[2].getMethodName() + instanceId ;`
569	`mLogger.error(callingMethodName + " sql exception:" + e.getMessage());`	569	`mLogger.error("{} sql exception:{}", callingMethodName, e.getMessage());`
570		570
571	`if ( mConnection == null \|\| !mConnection.isValid(10) )`	571	`if ( mConnection == null \|\| !mConnection.isValid(10) )`
572	`{`	572	`{`
573	`mLogger.error(callingMethodName + " database access error only");`	573	`mLogger.error( "{} database access error only", callingMethodName);`
574	`RmConnection.closeConnection(mConnection);`	574	`RmConnection.closeConnection(mConnection);`
575	`throw new SQLException(e);`	575	`throw new SQLException(e);`
576	`}`	576	`}`
577	`else`	577	`else`
578	`{`	578	`{`
579	`mLogger.error(callingMethodName + " show stopper");`	579	`mLogger.error( "{} show stopper", callingMethodName);`
580	`throw new Exception(callingMethodName + " show stopper");`	580	`throw new Exception(callingMethodName + " show stopper");`
581	`}`	581	`}`
582	`}`	582	`}`
583		583
584	`/** Claim the Build System Planning Lock`	584	`/** Claim the Build System Planning Lock`
Line 687...	Line 687...
687	`}`	687	`}`
688	`catch( SQLException e )`	688	`catch( SQLException e )`
689	`{`	689	`{`
690	`// do not throw Exception`	690	`// do not throw Exception`
691	`// this is part of Exception handling`	691	`// this is part of Exception handling`
692	`mLogger.error( "indefinitePause caught SQLException " + e.getMessage() );`	692	`mLogger.error( "indefinitePause caught SQLException {}", e.getMessage() );`
693	`RmConnection.closeConnection(mConnection);`	693	`RmConnection.closeConnection(mConnection);`
694	`}`	694	`}`
695	`catch( Exception e )`	695	`catch( Exception e )`
696	`{`	696	`{`
697	`mLogger.error( "indefinitePause caught Exception " + e.getMessage() );`	697	`mLogger.error( "indefinitePause caught Exception {}", e.getMessage() );`
698	`}`	698	`}`
699	`finally`	699	`finally`
700	`{`	700	`{`
701	`// this block is executed regardless of what happens in the try block`	701	`// this block is executed regardless of what happens in the try block`
702	`// even if an exception is thrown`	702	`// even if an exception is thrown`
Line 707...	Line 707...
707	`}`	707	`}`
708	`catch( Exception e )`	708	`catch( Exception e )`
709	`{`	709	`{`
710	`// do not throw Exception`	710	`// do not throw Exception`
711	`// this is part of Exception handling`	711	`// this is part of Exception handling`
712	`mLogger.error( "indefinitePause2 caught Exception " + e.getMessage() );`	712	`mLogger.error( "indefinitePause2 caught Exception {}", e.getMessage() );`
713	`RmConnection.closeConnection(mConnection);`	713	`RmConnection.closeConnection(mConnection);`
714	`}`	714	`}`
715	`}`	715	`}`
716	`}`	716	`}`
717	`}`	717	`}`
Line 755...	Line 755...
755	`* @exception SQLException`	755	`* @exception SQLException`
756	`* @exception Exception`	756	`* @exception Exception`
757	`*/`	757	`*/`
758	`void claimVersion(int pkgId, String pkgVersion, int rtagId) throws SQLException, Exception`	758	`void claimVersion(int pkgId, String pkgVersion, int rtagId) throws SQLException, Exception`
759	`{`	759	`{`
760	`mLogger.debug("claimVersion " + pkgId + " " + pkgVersion);`	760	`mLogger.debug("claimVersion {} {}", pkgId, pkgVersion);`
761	`if ( mUseDatabase )`	761	`if ( mUseDatabase )`
762	`{`	762	`{`
763	`CallableStatement stmt1 = null;`	763	`CallableStatement stmt1 = null;`
764	`try`	764	`try`
765	`{`	765	`{`
Line 856...	Line 856...
856	`* @param pkgId - Identifies the name of the package being built`	856	`* @param pkgId - Identifies the name of the package being built`
857	`* @param pkgPvId - Identifies the packageVersion the build is based upon`	857	`* @param pkgPvId - Identifies the packageVersion the build is based upon`
858	`*/`	858	`*/`
859	`public void setCurrentPackageBeingBuilt(int rconId, int pkgId, int pkgPvId) throws SQLException, Exception`	859	`public void setCurrentPackageBeingBuilt(int rconId, int pkgId, int pkgPvId) throws SQLException, Exception`
860	`{`	860	`{`
861	`mLogger.error("setCurrentPackageBeingBuilt " + rconId);`	861	`mLogger.error("setCurrentPackageBeingBuilt {}", rconId);`
862	`if ( mUseDatabase )`	862	`if ( mUseDatabase )`
863	`{`	863	`{`
864	`CallableStatement stmt = null;`	864	`CallableStatement stmt = null;`
865	`try`	865	`try`
866	`{`	866	`{`
Line 902...	Line 902...
902	`*`	902	`*`
903	`* @param rconId - Identifies the Release Config table entry`	903	`* @param rconId - Identifies the Release Config table entry`
904	`*/`	904	`*/`
905	`public void clearCurrentPackageBeingBuilt(int rconId) throws SQLException, Exception`	905	`public void clearCurrentPackageBeingBuilt(int rconId) throws SQLException, Exception`
906	`{`	906	`{`
907	`mLogger.error("clearCurrentPackageBeingBuilt " + rconId);`	907	`mLogger.error("clearCurrentPackageBeingBuilt {}", rconId);`
908	`if ( mUseDatabase )`	908	`if ( mUseDatabase )`
909	`{`	909	`{`
910	`try`	910	`try`
911	`{`	911	`{`
912	`connect();`	912	`connect();`
Line 951...	Line 951...
951	`*/`	951	`*/`
952	`public boolean autoMakeRelease(ReportingData mReporting) throws SQLException, Exception`	952	`public boolean autoMakeRelease(ReportingData mReporting) throws SQLException, Exception`
953	`{`	953	`{`
954		954
955	`mReporting.errMsg = null;`	955	`mReporting.errMsg = null;`
956	`mLogger.debug("autoMakeRelease " + mReporting.packageName);`	956	`mLogger.debug("autoMakeRelease {}", mReporting.packageName);`
957	`if ( mUseDatabase )`	957	`if ( mUseDatabase )`
958	`{`	958	`{`
959	`try`	959	`try`
960	`{`	960	`{`
961	`// Create an array of dependencies`	961	`// Create an array of dependencies`
Line 1003...	Line 1003...
1003	`// Report per-package errors directly`	1003	`// Report per-package errors directly`
1004	`// Exceptions are for errors that need to halt the entire system`	1004	`// Exceptions are for errors that need to halt the entire system`
1005	`//`	1005	`//`
1006	`if ( result <= 0 )`	1006	`if ( result <= 0 )`
1007	`{`	1007	`{`
1008	`mLogger.error("autoMakeRelease PK_RMAPI.AUTO_MAKE_VCSRELEASE failed, returned " + result);`	1008	`mLogger.error("autoMakeRelease PK_RMAPI.AUTO_MAKE_VCSRELEASE failed, returned {}", result);`
1009	`if ( result == -4 ) {`	1009	`if ( result == -4 ) {`
1010	`mReporting.errMsg = "Package migrated to SVN being built from CC tag";`	1010	`mReporting.errMsg = "Package migrated to SVN being built from CC tag";`
1011	`} else if ( result == -3 ) {`	1011	`} else if ( result == -3 ) {`
1012	`mReporting.errMsg = "Package not approved for autobuild";`	1012	`mReporting.errMsg = "Package not approved for autobuild";`
1013	`} else if ( result == -2 ) {`	1013	`} else if ( result == -2 ) {`
Line 1051...	Line 1051...
1051	`* Handles database connection/disconnection`	1051	`* Handles database connection/disconnection`
1052	`*/`	1052	`*/`
1053	`public void insertPackageMetrics(int mRtagId, String packageName,`	1053	`public void insertPackageMetrics(int mRtagId, String packageName,`
1054	`String packageExtension, String metrics) throws SQLException, Exception`	1054	`String packageExtension, String metrics) throws SQLException, Exception`
1055	`{`	1055	`{`
1056	`mLogger.debug("insertPackageMetrics " + packageName);`	1056	`mLogger.debug("insertPackageMetrics {}", packageName);`
1057	`if ( mUseDatabase )`	1057	`if ( mUseDatabase )`
1058	`{`	1058	`{`
1059	`try`	1059	`try`
1060	`{`	1060	`{`
1061	`connect();`	1061	`connect();`
Line 1069...	Line 1069...
1069	`int result = stmt.getInt( 1 );`	1069	`int result = stmt.getInt( 1 );`
1070		1070
1071	`if ( result != 0 )`	1071	`if ( result != 0 )`
1072	`{`	1072	`{`
1073	`// flag build failure`	1073	`// flag build failure`
1074	`mLogger.error("insertPackageMetrics show stopper PK_RMAPI.INSERT_PACKAGE_METRICS failed, returned" + result);`	1074	`mLogger.error("insertPackageMetrics show stopper PK_RMAPI.INSERT_PACKAGE_METRICS failed, returned {}", result);`
1075	`throw new Exception("insertPackageMetrics show stopper PK_RMAPI.INSERT_PACKAGE_METRICS failed, returned" + result);`	1075	`throw new Exception("insertPackageMetrics show stopper PK_RMAPI.INSERT_PACKAGE_METRICS failed, returned" + result);`
1076	`}`	1076	`}`
1077	`stmt.close();`	1077	`stmt.close();`
1078	`commit();`	1078	`commit();`
1079	`}`	1079	`}`
Line 1100...	Line 1100...
1100	`*/`	1100	`*/`
1101	`public int createBuildInstance(int rtagId, int pvId, BuildReason reason) throws SQLException, Exception`	1101	`public int createBuildInstance(int rtagId, int pvId, BuildReason reason) throws SQLException, Exception`
1102	`{`	1102	`{`
1103	`int buildId = 0;`	1103	`int buildId = 0;`
1104		1104
1105	`mLogger.debug("createBuildInstance " + rtagId + ":" + pvId);`	1105	`mLogger.debug("createBuildInstance {}:{}", rtagId, pvId);`
1106	`if ( mUseDatabase )`	1106	`if ( mUseDatabase )`
1107	`{`	1107	`{`
1108	`try`	1108	`try`
1109	`{`	1109	`{`
1110	`connect();`	1110	`connect();`
Line 1115...	Line 1115...
1115	`stmt.setLong( 3,pvId );`	1115	`stmt.setLong( 3,pvId );`
1116	`stmt.setString( 4,reason.toString() );`	1116	`stmt.setString( 4,reason.toString() );`
1117	`stmt.executeUpdate();`	1117	`stmt.executeUpdate();`
1118	`buildId = stmt.getInt( 1 );`	1118	`buildId = stmt.getInt( 1 );`
1119		1119
1120	`mLogger.warn("createBuildInstance: Build Instance ID: " + buildId);`	1120	`mLogger.warn("createBuildInstance: Build Instance ID: {}", buildId);`
1121		1121
1122	`stmt.close();`	1122	`stmt.close();`
1123	`commit();`	1123	`commit();`
1124	`}`	1124	`}`
1125	`catch ( SQLException e )`	1125	`catch ( SQLException e )`
Line 1152...	Line 1152...
1152	`*/`	1152	`*/`
1153	`public int updateBuildInstance(int buildID, int pvId, BuildResult result) throws SQLException, Exception`	1153	`public int updateBuildInstance(int buildID, int pvId, BuildResult result) throws SQLException, Exception`
1154	`{`	1154	`{`
1155	`int rv = 0;`	1155	`int rv = 0;`
1156		1156
1157	`mLogger.debug("updateBuildInstance " + buildID + ":" + pvId + ":" + result);`	1157	`mLogger.debug("updateBuildInstance {}:{}:{}", buildID, pvId, result);`
1158	`if ( mUseDatabase )`	1158	`if ( mUseDatabase )`
1159	`{`	1159	`{`
1160	`try`	1160	`try`
1161	`{`	1161	`{`
1162	`connect();`	1162	`connect();`
Line 1169...	Line 1169...
1169	`stmt.setLong( 3,pvId );`	1169	`stmt.setLong( 3,pvId );`
1170	`stmt.setString( 4,result.toString() );`	1170	`stmt.setString( 4,result.toString() );`
1171	`stmt.executeUpdate();`	1171	`stmt.executeUpdate();`
1172	`rv = stmt.getInt( 1 );`	1172	`rv = stmt.getInt( 1 );`
1173		1173
1174	`mLogger.warn("updateBuildInstance: Result: " + rv);`	1174	`mLogger.warn("updateBuildInstance: Result: {}", rv);`
1175		1175
1176	`stmt.close();`	1176	`stmt.close();`
1177	`commit();`	1177	`commit();`
1178	`}`	1178	`}`
1179	`catch ( SQLException e )`	1179	`catch ( SQLException e )`
Line 1210...	Line 1210...
1210	`if ( !mUseDatabase \|\| !btr.mResultsFound )`	1210	`if ( !mUseDatabase \|\| !btr.mResultsFound )`
1211	`{`	1211	`{`
1212	`return;`	1212	`return;`
1213	`}`	1213	`}`
1214		1214
1215	`mLogger.warn("insertTestResults: " + buildId + ", Number:" + btr.mTestResults.size() );`	1215	`mLogger.warn("insertTestResults: {}, Number:{}", buildId, btr.mTestResults.size() );`
1216	`try`	1216	`try`
1217	`{`	1217	`{`
1218	`connect();`	1218	`connect();`
1219	`String sql = "BEGIN ? := PK_RMAPI.insert_test_run(?, ?, ?, ?, ?, ?, ?);end;";`	1219	`String sql = "BEGIN ? := PK_RMAPI.insert_test_run(?, ?, ?, ?, ?, ?, ?);end;";`
1220	`CallableStatement stmt = mConnection.prepareCall(sql);`	1220	`CallableStatement stmt = mConnection.prepareCall(sql);`
Line 1282...	Line 1282...
1282	`*`	1282	`*`
1283	`* @return true if an instruction exists - for use in a while loop`	1283	`* @return true if an instruction exists - for use in a while loop`
1284	`*/`	1284	`*/`
1285	`public boolean getDaemonInst(DaemonInstruction di ) throws SQLException, Exception`	1285	`public boolean getDaemonInst(DaemonInstruction di ) throws SQLException, Exception`
1286	`{`	1286	`{`
1287	`mLogger.debug("getDaemonInst " + di.instruction);`	1287	`mLogger.debug("getDaemonInst {}", di.instruction);`
1288	`boolean retVal = false;`	1288	`boolean retVal = false;`
1289		1289
1290	`if ( mUseDatabase )`	1290	`if ( mUseDatabase )`
1291	`{`	1291	`{`
1292	`try`	1292	`try`
Line 1350...	Line 1350...
1350	`*`	1350	`*`
1351	`* @param instruction - PVID of the daemon instruction to process`	1351	`* @param instruction - PVID of the daemon instruction to process`
1352	`*/`	1352	`*/`
1353	`public void markDaemonInstInProgress(final int instruction) throws SQLException, Exception`	1353	`public void markDaemonInstInProgress(final int instruction) throws SQLException, Exception`
1354	`{`	1354	`{`
1355	`mLogger.debug("markDaemonInstInProgress " + instruction);`	1355	`mLogger.debug("markDaemonInstInProgress {}", instruction);`
1356		1356
1357	`if ( mUseDatabase )`	1357	`if ( mUseDatabase )`
1358	`{`	1358	`{`
1359	`try`	1359	`try`
1360	`{`	1360	`{`
Line 1376...	Line 1376...
1376	`*`	1376	`*`
1377	`* @param instruction - PVID of Daemon Instruction to process`	1377	`* @param instruction - PVID of Daemon Instruction to process`
1378	`*/`	1378	`*/`
1379	`public void markDaemonInstCompleted(final int instruction) throws SQLException, Exception`	1379	`public void markDaemonInstCompleted(final int instruction) throws SQLException, Exception`
1380	`{`	1380	`{`
1381	`mLogger.debug("markDaemonInstCompletedConnect " + instruction);`	1381	`mLogger.debug("markDaemonInstCompletedConnect {}", instruction);`
1382	`boolean connectionCreated = false;`	1382	`boolean connectionCreated = false;`
1383		1383
1384	`try`	1384	`try`
1385	`{`	1385	`{`
1386	`if (! mIsConnected)`	1386	`if (! mIsConnected)`
Line 1461...	Line 1461...
1461	`*`	1461	`*`
1462	`* Overridden in ReleaseManagerUtf`	1462	`* Overridden in ReleaseManagerUtf`
1463	`*/`	1463	`*/`
1464	`public String queryBaselineName(int baseline) throws SQLException, Exception`	1464	`public String queryBaselineName(int baseline) throws SQLException, Exception`
1465	`{`	1465	`{`
1466	`mLogger.debug("queryBaselineName " + mDaemon);`	1466	`mLogger.debug("queryBaselineName {}", mDaemon);`
1467	`StringBuilder retVal = new StringBuilder();`	1467	`StringBuilder retVal = new StringBuilder();`
1468		1468
1469	`String sql = "";`	1469	`String sql = "";`
1470		1470
1471	`if ( mDaemon )`	1471	`if ( mDaemon )`
Line 1535...	Line 1535...
1535	`catch ( SQLException e )`	1535	`catch ( SQLException e )`
1536	`{`	1536	`{`
1537	`handleSQLException(e, "");`	1537	`handleSQLException(e, "");`
1538	`}`	1538	`}`
1539		1539
1540	`mLogger.info("queryBaselineName returned " + retVal);`	1540	`mLogger.info("queryBaselineName returned {}", retVal);`
1541	`return retVal.toString();`	1541	`return retVal.toString();`
1542	`}`	1542	`}`
1543		1543
1544	`/**only used in daemon mode`	1544	`/**only used in daemon mode`
1545	`* select config from release_manager.build_service_config where service='MAIL SERVER';`	1545	`* select config from release_manager.build_service_config where service='MAIL SERVER';`
Line 1577...	Line 1577...
1577	`{`	1577	`{`
1578	`handleSQLException(e, "");`	1578	`handleSQLException(e, "");`
1579	`}`	1579	`}`
1580		1580
1581		1581
1582	`mLogger.info("queryMailServer returned " + retVal);`	1582	`mLogger.info("queryMailServer returned {}", retVal);`
1583	`return retVal;`	1583	`return retVal;`
1584	`}`	1584	`}`
1585		1585
1586	`/**only used in daemon mode`	1586	`/**only used in daemon mode`
1587	`* returns the configured service`	1587	`* returns the configured service`
Line 1616...	Line 1616...
1616	`catch ( SQLException e )`	1616	`catch ( SQLException e )`
1617	`{`	1617	`{`
1618	`handleSQLException(e, "");`	1618	`handleSQLException(e, "");`
1619	`}`	1619	`}`
1620		1620
1621	`mLogger.debug("queryMailSender returned " + retVal);`	1621	`mLogger.debug("queryMailSender returned {}", retVal);`
1622	`return retVal;`	1622	`return retVal;`
1623	`}`	1623	`}`
1624		1624
1625	`/**only used in daemon mode`	1625	`/**only used in daemon mode`
1626	`* returns the configured global email addresses`	1626	`* returns the configured global email addresses`
Line 1658...	Line 1658...
1658	`{`	1658	`{`
1659	`handleSQLException(e, "");`	1659	`handleSQLException(e, "");`
1660	`}`	1660	`}`
1661		1661
1662		1662
1663	`mLogger.debug("queryGlobalAddresses returned " + retVal);`	1663	`mLogger.debug("queryGlobalAddresses returned {}", retVal);`
1664	`return retVal;`	1664	`return retVal;`
1665	`}`	1665	`}`
1666		1666
1667	`/**`	1667	`/**`
1668	`* Determine a list of global, project wide and release email recipients`	1668	`* Determine a list of global, project wide and release email recipients`
Line 1776...	Line 1776...
1776	`* @param rtag_id - Target Release`	1776	`* @param rtag_id - Target Release`
1777	`* @param buildFile - buildfile content to be saved`	1777	`* @param buildFile - buildfile content to be saved`
1778	`*/`	1778	`*/`
1779	`public void publishBuildFile(int rtag_id, BuildFile buildFile) throws SQLException, Exception`	1779	`public void publishBuildFile(int rtag_id, BuildFile buildFile) throws SQLException, Exception`
1780	`{`	1780	`{`
1781	`mLogger.debug("publishBuildFile publishing a build file of length " + buildFile.content.length());`	1781	`mLogger.debug("publishBuildFile publishing a build file of length {}", buildFile.content.length());`
1782	`mLogger.debug("publishBuildFile publishing pkgId: " + buildFile.mPkgId + " pvid: " + buildFile.mPvId);`	1782	`mLogger.debug("publishBuildFile publishing pkgId: {} pvid: {}", buildFile.mPkgId, buildFile.mPvId);`
1783		1783
1784	`try`	1784	`try`
1785	`{`	1785	`{`
1786	`connect();`	1786	`connect();`
1787		1787
Line 1824...	Line 1824...
1824	`}`	1824	`}`
1825	`catch ( Exception e )`	1825	`catch ( Exception e )`
1826	`{`	1826	`{`
1827	`// this catch and rethrow is historical`	1827	`// this catch and rethrow is historical`
1828	`// problems were found using CallableStatement when updating a CLOB column with data > 4000 bytes`	1828	`// problems were found using CallableStatement when updating a CLOB column with data > 4000 bytes`
1829	`mLogger.error("publishBuildFile caught Exception " + e.getMessage());`	1829	`mLogger.error("publishBuildFile caught Exception {}", e.getMessage());`
1830	`throw new Exception("publishBuildFile caught Exception " + e.getMessage());`	1830	`throw new Exception("publishBuildFile caught Exception " + e.getMessage());`
1831	`}`	1831	`}`
1832	`finally`	1832	`finally`
1833	`{`	1833	`{`
1834	`// this block is executed regardless of what happens in the try block`	1834	`// this block is executed regardless of what happens in the try block`
Line 1897...	Line 1897...
1897	`{`	1897	`{`
1898	`disconnect();`	1898	`disconnect();`
1899	`}`	1899	`}`
1900	`}`	1900	`}`
1901		1901
1902	`mLogger.warn("queryReleaseSeqNum returned " + retVal);`	1902	`mLogger.warn("queryReleaseSeqNum returned {}", retVal);`
1903	`return retVal;`	1903	`return retVal;`
1904	`}`	1904	`}`
1905		1905
1906	`/**`	1906	`/**`
1907	`* Disable all the daemons for a specific release`	1907	`* Disable all the daemons for a specific release`
Line 1912...	Line 1912...
1912	`* @throws SQLException`	1912	`* @throws SQLException`
1913	`* @throws Exception`	1913	`* @throws Exception`
1914	`*/`	1914	`*/`
1915	`private void disableDaemons(final int rtag_id) throws SQLException, Exception`	1915	`private void disableDaemons(final int rtag_id) throws SQLException, Exception`
1916	`{`	1916	`{`
1917	`mLogger.error("disableDaemons: " + rtag_id );`	1917	`mLogger.error("disableDaemons: {}", rtag_id );`
1918		1918
1919	`try`	1919	`try`
1920	`{`	1920	`{`
1921	`CallableStatement stmt1 = mConnection.prepareCall( "call PK_BUILDAPI.set_daemon_states(?,2)" );`	1921	`CallableStatement stmt1 = mConnection.prepareCall( "call PK_BUILDAPI.set_daemon_states(?,2)" );`
1922	`stmt1.setInt( 1, rtag_id );`	1922	`stmt1.setInt( 1, rtag_id );`
Line 1963...	Line 1963...
1963	`}`	1963	`}`
1964	`catch ( SQLException e )`	1964	`catch ( SQLException e )`
1965	`{`	1965	`{`
1966	`handleSQLException(e, "");`	1966	`handleSQLException(e, "");`
1967	`}`	1967	`}`
1968	`mLogger.info("isRtagIdConfigured returning " + retVal);`	1968	`mLogger.info("isRtagIdConfigured returning {}", retVal);`
1969	`return retVal;`	1969	`return retVal;`
1970	`}`	1970	`}`
1971		1971
1972	`/**queries the RUN_LEVEL table for daemon to determine if the daemon has been paused`	1972	`/**queries the RUN_LEVEL table for daemon to determine if the daemon has been paused`
1973	`* or disabled.`	1973	`* or disabled.`
Line 1987...	Line 1987...
1987	`* @exception SQLException`	1987	`* @exception SQLException`
1988	`* @exception Exception`	1988	`* @exception Exception`
1989	`*/`	1989	`*/`
1990	`public boolean queryDirectedRunLevel(final int rcon_id) throws SQLException, Exception`	1990	`public boolean queryDirectedRunLevel(final int rcon_id) throws SQLException, Exception`
1991	`{`	1991	`{`
1992	`mLogger.debug("queryDirectedRunLevel " + rcon_id);`	1992	`mLogger.debug("queryDirectedRunLevel {}", rcon_id);`
1993	`boolean retVal = true;`	1993	`boolean retVal = true;`
1994		1994
1995	`if ( mUseDatabase )`	1995	`if ( mUseDatabase )`
1996	`{`	1996	`{`
1997	`try`	1997	`try`
Line 2035...	Line 2035...
2035	`{`	2035	`{`
2036	`handleSQLException(e, "");`	2036	`handleSQLException(e, "");`
2037	`}`	2037	`}`
2038	`}`	2038	`}`
2039		2039
2040	`mLogger.info("queryDirectedRunLevel returning " + retVal);`	2040	`mLogger.info("queryDirectedRunLevel returning {}", retVal);`
2041	`return retVal;`	2041	`return retVal;`
2042	`}`	2042	`}`
2043		2043
2044	`/**`	2044	`/**`
2045	`* queries the RELEASE_CONFIG and BUILD_MACHINE_CONFIG tables using the rcon_id primary key, rtag_id, machine_hostname, daemon_mode`	2045	`* queries the RELEASE_CONFIG and BUILD_MACHINE_CONFIG tables using the rcon_id primary key, rtag_id, machine_hostname, daemon_mode`
Line 2122...	Line 2122...
2122	`// Handles case where daemon has just been started/restarted`	2122	`// Handles case where daemon has just been started/restarted`
2123	`//`	2123	`//`
2124	`if ( daemon_mode == 'M' && build_age > 0 && days_since_last_build > (build_age + 1) )`	2124	`if ( daemon_mode == 'M' && build_age > 0 && days_since_last_build > (build_age + 1) )`
2125	`{`	2125	`{`
2126	`long upTimeSecs = (System.currentTimeMillis() - threadStartTime)/1000;`	2126	`long upTimeSecs = (System.currentTimeMillis() - threadStartTime)/1000;`
2127	`mLogger.error("queryReleaseConfig 1: " + rtag_id + ", " + rcon_id + ", "+ daemon_mode + ", " + pause + ", " + build_age + ", " + days_since_last_build + ", " + upTimeSecs );`	2127	`mLogger.error("queryReleaseConfig 1: {},{},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build, upTimeSecs );`
2128	`if ( upTimeSecs > mPostponeShutdown)`	2128	`if ( upTimeSecs > mPostponeShutdown)`
2129	`{`	2129	`{`
2130	`disableDaemons(rtag_id);`	2130	`disableDaemons(rtag_id);`
2131	`pause = 2;`	2131	`pause = 2;`
2132	`}`	2132	`}`
Line 2134...	Line 2134...
2134	`{`	2134	`{`
2135	`mLogger.error("queryReleaseConfig 1: Shutdown Postponed" );`	2135	`mLogger.error("queryReleaseConfig 1: Shutdown Postponed" );`
2136	`}`	2136	`}`
2137	`}`	2137	`}`
2138		2138
2139	`mLogger.info("queryReleaseConfig 1: " + rtag_id + ", " + rcon_id + ", "+ daemon_mode + ", " + pause + ", " + build_age + ", " + days_since_last_build );`	2139	`mLogger.info("queryReleaseConfig 1: {},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build );`
2140		2140
2141	`if ( pause <= 1 )`	2141	`if ( pause <= 1 )`
2142	`{`	2142	`{`
2143	`retVal = true;`	2143	`retVal = true;`
2144	`}`	2144	`}`
Line 2157...	Line 2157...
2157	`catch ( SQLException e )`	2157	`catch ( SQLException e )`
2158	`{`	2158	`{`
2159	`handleSQLException(e, ":1");`	2159	`handleSQLException(e, ":1");`
2160	`}`	2160	`}`
2161		2161
2162	`mLogger.info("queryReleaseConfig 1 returning " + retVal);`	2162	`mLogger.info("queryReleaseConfig 1 returning {}", retVal);`
2163	`return retVal;`	2163	`return retVal;`
2164	`}`	2164	`}`
2165		2165
2166	`/**removes all elements from the mReleaseConfigCollection`	2166	`/**removes all elements from the mReleaseConfigCollection`
2167	`* handles database connection and disconnection`	2167	`* handles database connection and disconnection`
Line 2213...	Line 2213...
2213	`int rcon_id = rset.mustGetInt("rcon_id");`	2213	`int rcon_id = rset.mustGetInt("rcon_id");`
2214		2214
2215	`char dm = 'S';`	2215	`char dm = 'S';`
2216	`String daemon_mode = rset.getString("daemon_mode","S");`	2216	`String daemon_mode = rset.getString("daemon_mode","S");`
2217		2217
2218	`mLogger.info("queryReleaseConfig 2 daemon_mode " + daemon_mode + ".");`	2218	`mLogger.info("queryReleaseConfig 2 daemon_mode '{}'", daemon_mode);`
2219		2219
2220	`if ( daemon_mode.compareTo("M") == 0 )`	2220	`if ( daemon_mode.compareTo("M") == 0 )`
2221	`{`	2221	`{`
2222	`dm = 'M';`	2222	`dm = 'M';`
2223	`}`	2223	`}`
Line 2271...	Line 2271...
2271	`*`	2271	`*`
2272	`* Used by the BuildDaemon thread to determine daemons to start and stop`	2272	`* Used by the BuildDaemon thread to determine daemons to start and stop`
2273	`*/`	2273	`*/`
2274	`public void queryReleaseConfig(final String hostname) throws SQLException, Exception`	2274	`public void queryReleaseConfig(final String hostname) throws SQLException, Exception`
2275	`{`	2275	`{`
2276	`mLogger.debug("queryReleaseConfig 3 " + hostname);`	2276	`mLogger.debug("queryReleaseConfig 3 {}", hostname);`
2277	`mReleaseConfigCollection.resetData();`	2277	`mReleaseConfigCollection.resetData();`
2278		2278
2279	`try`	2279	`try`
2280	`{`	2280	`{`
2281	`connect();`	2281	`connect();`
Line 2314...	Line 2314...
2314	`int rcon_id = rset.mustGetInt("rcon_id");`	2314	`int rcon_id = rset.mustGetInt("rcon_id");`
2315		2315
2316	`char dm = 'S';`	2316	`char dm = 'S';`
2317	`String daemon_mode = rset.getString("daemon_mode", "S");`	2317	`String daemon_mode = rset.getString("daemon_mode", "S");`
2318		2318
2319	`mLogger.info("queryReleaseConfig 3 daemon_mode " + daemon_mode + ".");`	2319	`mLogger.info("queryReleaseConfig 3 daemon_mode '{}'", daemon_mode);`
2320		2320
2321	`if ( daemon_mode.compareTo("M") == 0 )`	2321	`if ( daemon_mode.compareTo("M") == 0 )`
2322	`{`	2322	`{`
2323	`dm = 'M';`	2323	`dm = 'M';`
2324	`}`	2324	`}`
Line 2376...	Line 2376...
2376	`* Used by the Master and Slave Daemons`	2376	`* Used by the Master and Slave Daemons`
2377	`* Overridden in ReleaseManagerUtf`	2377	`* Overridden in ReleaseManagerUtf`
2378	`*/`	2378	`*/`
2379	`public int queryMasterCount(final int rtag_id) throws SQLException, Exception`	2379	`public int queryMasterCount(final int rtag_id) throws SQLException, Exception`
2380	`{`	2380	`{`
2381	`mLogger.debug("queryMasterCount rtag_id " + rtag_id);`	2381	`mLogger.debug("queryMasterCount rtag_id {}", rtag_id);`
2382		2382
2383	`int masterCount = 0;`	2383	`int masterCount = 0;`
2384	`try`	2384	`try`
2385	`{`	2385	`{`
2386	`connect();`	2386	`connect();`
Line 2469...	Line 2469...
2469	`disconnect();`	2469	`disconnect();`
2470	`}`	2470	`}`
2471	`return rv;`	2471	`return rv;`

Subversion Repositories DevTools

(root)/buildtool/trunk/src/main/java/com/erggroup/buildtool/ripple/ReleaseManager.java – Rev 7033 → 7044