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



            // allow another low priority thread to connect
            try {
                mLowPriorityQueue.unlock();
            }
            catch( IllegalMonitorStateException e ) {
                mLogger.error("disconnectForPlanning. IllegalMonitorStateException exception {}", e);
            }
        }
 
        disconnect( mPlanningConnection );
    }

            mLogger.debug("disconnect calling unlock");
            try {
                connection.mSession.unlock();
            }
            catch (IllegalMonitorStateException e) {
                mLogger.error("disconnect. IllegalMonitorStateException exception {}", e);
            }
            mLogger.debug("disconnect called unlock");
        }
        
        mIsConnected = false;

        if ( mUseDatabase && mUseMutex )
        {
            try
            {
                CallableStatement stmt = mConnection.prepareCall("select CONFIG from release_manager.BUILD_SERVICE_CONFIG WHERE SERVICE='MUTEX' FOR UPDATE");
                mLogger.warn("claimMutex calling stmt.executeUpdate");
                stmt.executeUpdate();
                mLogger.warn("claimMutex called stmt.executeUpdate");
                stmt.close();
                mDoNotCommit = true;
                mMutexState = "Holding Mutex";
            }
            catch ( SQLException e )

        if ( mUseDatabase )
        {
            try
            {
                mDoNotCommit = false;
                mLogger.warn("releaseMutex calling commit");
                commit();
                mLogger.warn("releaseMutex called commit");
                mMutexState = "Released Mutex";
            }
            catch ( SQLException e )
            {
                mMutexState = "Mutex Release Exception";

     * @exception   SQLException
     * @exception   Exception
     */
    public void discardVersion() throws SQLException, Exception
    {
        mLogger.warn("discardVersion");
        
        if ( mPlannedPkgId != null && mPlannedPkgVersion != 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.warn("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.warn("clearCurrentPackageBeingBuilt {}", rconId);
        if ( mUseDatabase )
        {
            try
            {
                connect();

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

     * @throws SQLException
     * @throws Exception
     */
    private void disableDaemons(final int rtag_id) throws SQLException, Exception
    {
        mLogger.warn("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.debug("isRtagIdConfigured returning {}", retVal);
        return retVal;
    }
 
    /**queries the RUN_LEVEL table for daemon to determine if the daemon has been paused
     * or disabled.

            {
                handleSQLException(e, "");
            }
        }
 
        mLogger.debug("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.warn("queryReleaseConfig 1: {},{},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build, upTimeSecs );
                    if ( upTimeSecs > mPostponeShutdown)
                    {
                        disableDaemons(rtag_id);
                        pause = 2;
                    }
                    else
                    {
                        mLogger.warn("queryReleaseConfig 1: Shutdown Postponed"  );    
                    }
                }
 
                mLogger.info("queryReleaseConfig 1: {},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build  );
 

        catch ( SQLException e )
        {
            handleSQLException(e, ":1");
        }
 
        mLogger.debug("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.debug("queryReleaseConfig 2 daemon_mode '{}'", daemon_mode);
 
                if ( daemon_mode.compareTo("M") == 0 )
                {
                    dm = 'M';
                }

                int rcon_id = rset.mustGetInt("rcon_id");
 
                char dm = 'S';          
                String daemon_mode = rset.getString("daemon_mode", "S");
 
                mLogger.debug("queryReleaseConfig 3 daemon_mode '{}'", daemon_mode);
 
                if ( daemon_mode.compareTo("M") == 0 )
                {
                    dm = 'M';
                }

            connect();
            PreparedStatement stmt = mConnection.prepareStatement(
                    "SELECT rl.rcon_id, rc.RTAG_ID" +
                    " FROM run_level rl, release_config rc, release_tags rt" +
                    " WHERE  rt.rtag_id = rc.RTAG_ID" +
                    " AND UPPER(rc.daemon_hostname) = UPPER(?)" +
                    " AND rc.DAEMON_MODE != 'M'" +
                    " AND rc.RCON_ID = rl.rcon_id" +
                    " AND CURRENT_BUILD_FILES IS NOT NULL" +
                    " AND rl.pause is null" +
                    " AND rl.rcon_id in (?)"
                    );
            
            stmt.setString(1, mHostname);
            stmt.setString(2, rconIdList);
 
            ResultSet rset = stmt.executeQuery();
 
            while (rset.next()) {
                Integer ii = rset.getInt("rcon_id");

                                " 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=?" +
                                " AND pv.pv_id    = rc.pv_id" +
                                " AND p.pkg_id    = pv.pkg_id" +
                                " AND peg.rtag_id(+) = rc.rtag_id" +
                                " AND peg.pv_id(+) = rc.pv_id" +
                                " ORDER BY rc.pv_id"
                        );
                stmt8.setInt(1, baseline);
                mLogger.debug("queryPackageVersions: stmt8 Prepared");
                stmt8.setFetchSize(1000);
                RmResultSet rset8 = new RmResultSet(stmt8.executeQuery(), "queryPackageVersions rset8");
                mLogger.debug("queryPackageVersions: stmt8 Query Done");
 

                    //  TODO - Not sure this code is in use anymore
 
                    Package plannedPackage = findPackage(p.mAlias, packageCollection);
                    if ( plannedPackage == NULL_PACKAGE )
                    {
                        mLogger.debug("queryPackageVersions rset8 no planned package {}", pv_id);
                        packageCollection.add(p);
                    }
                    else
                    {
                        //  Copy these flags from the package that will be replaced

                                " 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=?" + 
                                "  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"
                        );
                mLogger.debug("queryPackageVersions: stmt9 prepared");
                stmt9.setInt(1, baseline);
                stmt9.setFetchSize(1000);
                RmResultSet rset9 = new RmResultSet(stmt9.executeQuery(), "queryPackageVersions rset9");
                mLogger.debug("queryPackageVersions: stmt9 query done");
 
                while( rset9.next() )

                mLogger.debug("queryPackageVersions: stmt11");
                phase.setPhase("getAllPkgs4");
                PreparedStatement stmt11 = mConnection.prepareStatement(
                        "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=?" +
                                " 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"
                        );
                stmt11.setInt(1, baseline);
                stmt11.setFetchSize(1000);
                RmResultSet rset11 = new RmResultSet(stmt11.executeQuery(), "queryPackageVersions rset11");
 
                while( rset11.next() )
                {

                        "  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     = ?" +
                        " 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"
                        );
                stmt12.setInt(1, baseline);
                stmt12.setFetchSize(1000);
                RmResultSet rset12 = new RmResultSet(stmt12.executeQuery(), "queryPackageVersions rset12");
 
                while( rset12.next() )
                {

                mLogger.debug("queryPackageVersions: stmt14");
                phase.setPhase("getAllPkgs6");
                PreparedStatement stmt14 = mConnection.prepareStatement(
                        "select rc.pv_id " +
                                "from release_manager.release_content rc, release_manager.package_versions pv, release_manager.advisory_ripple ar " +
                                "where rc.rtag_id=?" +
                                " 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"
                        );
                stmt14.setFetchSize(1000);
                stmt14.setInt(1, baseline);
                RmResultSet rset14 = new RmResultSet(stmt14.executeQuery(), "queryPackageVersions rset14");
 
                while( rset14.next() )
                {
                    int pv_id = rset14.mustGetInt("pv_id");

                                " 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=?" +
                                " 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"
                        );
                stmt.setFetchSize(1000);
                stmt.setInt(1, baseline);
                RmResultSet rset = new RmResultSet(stmt.executeQuery(), "queryPackageVersions rset");
 
                while( rset.next() )
                {
                    int pv_id = rset.mustGetKeyInt("prod_id");

            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=?" +
                            "   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);
            stmt1.setInt(1, baseline);
            RmResultSet rset1 = new RmResultSet(stmt1.executeQuery(), "queryPackageVersions rset1");
 
            while( rset1.next() )
            {
                int pvId = rset1.mustGetKeyInt("pv_id");

                    // to be built
 
                    Package prevPlannedPackage = findPackage(p.mAlias, packageCollection);
                    if ( prevPlannedPackage == NULL_PACKAGE )
                    {
                        mLogger.debug("queryWips rset1 no previous WIP package {}", pvId);
                        packageCollection.add(p);
                    }
                }
            }
 

            mLogger.debug("queryTest: stmt141");
            phase.setPhase("getTestBuild1");
            DaemonInstruction di = new DaemonInstruction( baseline, 1, true);
            while ( getDaemonInst( di ) )
            {
                mLogger.debug("queryPackageVersions test build data {}", di.pvId);
 
                Package p = getPackageInfo(di.pvId, rippleEngine, false);
                if ( p == NULL_PACKAGE )
                {
                    mLogger.error("queryTest rset15 no data found {}", di.instruction);

            while ( getDaemonInst( di ) )
            {
                Package p = getPackageInfo(di.pvId, rippleEngine, false);
                if ( p != NULL_PACKAGE )
                {
                    mLogger.debug("queryPackageVersions forced ripple data {}", di.pvId);
                    packageCollection.add(p);
                    p.mForcedRippleInstruction = di.instruction;
                    p.addEmail(di.userEmail);
                    p.mBuildReason = BuildReason.Forced;
                    p.mIsNotReleased = true;

                            " release_manager.PK_RMAPI.return_vcs_tag(pv.pv_id) AS vcsTag," +
                            " pv.build_time" +
                            " from " +
                            "      release_manager.package_versions pv," +
                            "      release_manager.packages p" +
                            " where pv.pv_id=?" +
                            "   and p.pkg_id=pv.pkg_id"
 
                    );
            stmt1.setInt(1, pvId);
            stmt1.setFetchSize(500);
            RmResultSet rset1 = new RmResultSet(stmt1.executeQuery(), "getPackageInfo rset1");
 
            //  Package must exist
            if ( ! rset1.next() )

                            " from " +
                            "     release_manager.package_versions pv,"+
                            "     release_manager.package_dependencies pd," +
                            "     release_manager.package_versions dpv,"+
                            "     release_manager.packages p" +
                            " where pv.pv_id=?" + 
                            "  and pd.pv_id=pv.pv_id"+
                            "  and dpv.pv_id=pd.dpv_id" +
                            "  and pd.dpkg_id = p.pkg_id"
                    );
            stmt2.setFetchSize(500);
            stmt2.setInt(1, pvId);
            RmResultSet rset2 = new RmResultSet(stmt2.executeQuery(), "getPackageInfo rset2");
 
            while ( rset2.next() )
            {
                String dpv_name = rset2.mustGetKeyString("pkg_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=?" + 
                            "   and pbi.pv_id=pv.pv_id" +
                            "   and bm.bm_id=pbi.bm_id" +
                            "   and bsa.bsa_id=pbi.bsa_id "
                    );
            stmt3.setFetchSize(500);
            stmt3.setInt(1, pvId);
            RmResultSet rset3 = new RmResultSet(stmt3.executeQuery(), "getPackageInfo rset3");
 
            while ( rset3.next() )
            {
                String bm_name = rset3.mustGetString("bm_name");

                    "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=?" + 
                    "  and ut.pv_id=pv.pv_id" +
                    "  and tt.test_type_id=ut.test_types_fk"
                    );
            stmt4.setFetchSize(500);
            stmt4.setInt(1, pvId);
            RmResultSet rset4 = new RmResultSet(stmt4.executeQuery(), "getPackageInfo rset4");
 
            while ( rset4.next() )
            {
                String test_type_name = rset4.mustGetString("test_type_name");

                            "  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     = ?" +
                            " AND rt.rtag_id       = rc.rtag_id" +
                            " AND pv.pv_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"
                    );
            stmt5.setFetchSize(500);
            stmt5.setInt(1, rippleEngine.getRtagId());
            stmt5.setInt(2, pvId);
 
            
            RmResultSet rset5 = new RmResultSet(stmt5.executeQuery(), "getPackageInfo rset5");
 
            while ( rset5.next() )
            {
                p.addEmail(rset5.getString("user_email", null));

                    "      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=?" +  
                    "   and rt.rtag_id=?" + 
                    "   and pv.build_type='A'" +
                    "   and pv.dlocked='A' " +
                    "   and u1.user_id=pv.creator_id" +
                    "   and u2.user_id=pv.owner_id" +
                    "   and u3.user_id=pv.modifier_id"
                    );
            stmt6.setFetchSize(500);
            stmt6.setInt(1, pvId);
            stmt6.setInt(2, rippleEngine.getRtagId());
 
            RmResultSet rset6 = new RmResultSet(stmt6.executeQuery(), "getPackageInfo rset6");
 
            while ( rset6.next() )
            {
                p.addEmail( rset6.getString("creator",null));

            PreparedStatement stmt7 = mConnection.prepareStatement(
                    "select pv.pv_id, pv.modified_stamp " +
                    " from " +
                    "      release_manager.package_versions pv," +
                    "      release_manager.advisory_ripple ar " +
                    " where pv.pv_id = ?" +
                    "    and ar.rtag_id= ?" +
                    "    and ar.pv_id=pv.pv_id "
                    );
            stmt7.setFetchSize(500);
            stmt7.setInt(1, pvId);
            stmt7.setInt(2, rippleEngine.getRtagId());
 
            RmResultSet rset7 = new RmResultSet(stmt7.executeQuery(), "getPackageInfo rset7");
 
            if( rset7.next() )
            {
                p.mAdvisoryRipple = true;

            {
                handleSQLException(e, "");
            }
        }
 
        mLogger.debug("queryPlanControl {}", mPlanControl);
    }
 
    /**	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

                                "release_manager.PK_RMAPI.return_vcs_tag(dpv.pv_id) AS vcsTag" + 
                                " from release_manager.package_versions pv," + 
                                "release_manager.package_dependencies pd," + 
                                "release_manager.package_versions dpv," + 
                                "release_manager.packages p" + 
                                " where pv.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");
                stmt.setInt(1, pkg.mId);
                stmt.setFetchSize(1000);
                RmResultSet rset = new RmResultSet(stmt.executeQuery(),"traverseDependencies");
 
                while (rset.next())
                {

            {
                handleSQLException(e, "");
            }
        }
 
        mLogger.debug("queryPackageVersions returned {}", retVal);
        return retVal;
    }
 
    /**
     * Determine the set of packages that have been excluded from the build 

        try
        {
            PreparedStatement stmt = mConnection.prepareStatement(
                    "select pv_id, root_pv_id, root_cause" +
                    " from release_manager.do_not_ripple" + 
                    " where rtag_id=?");
            stmt.setFetchSize(1000);
            stmt.setInt(1, baseline);
 
            RmResultSet rset = new RmResultSet(stmt.executeQuery(),"queryBuildExclusions");
 
            while( rset.next() )
            {
                int pvId = rset.mustGetKeyInt("pv_id");

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

        {
            try
            {
                connect();
 
                PreparedStatement stmt = mConnection.prepareStatement("update release_manager.package_versions set BUILD_TIME = ? where pv_id = ?");
 
 
                stmt.setLong( 1,duration );
                stmt.setLong( 2,pvId );
                stmt.executeUpdate();
                stmt.close();
                commit();

        
    }
 
    /** Reset the dumpPlan request
     *  Assume that we have a database connection
     *  @param mRtagId - Identify the target release
     *  @throws Exception 
     */
    public void resetPlanControl(int mRtagId) throws Exception {
        mLogger.debug("resetPlanControl {}", mRtagId);
 
        if ( mUseDatabase )

                CallableStatement stmt = mConnection.prepareCall(
                        "UPDATE release_manager.release_tags SET PLAN_DROP = 'N' WHERE rtag_id  = ?" );
                stmt.setInt(1, mRtagId);
                stmt.executeUpdate();
                stmt.close();
 
                //  Commit only if not covered by the Mutex
                if ( ! mDoNotCommit )
                    commit();
 
            }
            catch ( SQLException e )
            {
                handleSQLException(e, "");
            }
        }
 
        mLogger.debug("resetPlanControl {} Done", mRtagId);        
    }
 
}
 

Rev 7169	Rev 7176
Line 505...	Line 505...
505	`// allow another low priority thread to connect`	505	`// allow another low priority thread to connect`
506	`try {`	506	`try {`
507	`mLowPriorityQueue.unlock();`	507	`mLowPriorityQueue.unlock();`
508	`}`	508	`}`
509	`catch( IllegalMonitorStateException e ) {`	509	`catch( IllegalMonitorStateException e ) {`
510	`mLogger.error("disconnectForPlanning. IllegalMonitorStateException exception");`	510	`mLogger.error("disconnectForPlanning. IllegalMonitorStateException exception {}", e);`
511	`}`	511	`}`
512	`}`	512	`}`
513		513
514	`disconnect( mPlanningConnection );`	514	`disconnect( mPlanningConnection );`
515	`}`	515	`}`
Line 547...	Line 547...
547	`mLogger.debug("disconnect calling unlock");`	547	`mLogger.debug("disconnect calling unlock");`
548	`try {`	548	`try {`
549	`connection.mSession.unlock();`	549	`connection.mSession.unlock();`
550	`}`	550	`}`
551	`catch (IllegalMonitorStateException e) {`	551	`catch (IllegalMonitorStateException e) {`
552	`mLogger.error("disconnect. IllegalMonitorStateException exception");`	552	`mLogger.error("disconnect. IllegalMonitorStateException exception {}", e);`
553	`}`	553	`}`
554	`mLogger.debug("disconnect called unlock");`	554	`mLogger.debug("disconnect called unlock");`
555	`}`	555	`}`
556		556
557	`mIsConnected = false;`	557	`mIsConnected = false;`
Line 597...	Line 597...
597	`if ( mUseDatabase && mUseMutex )`	597	`if ( mUseDatabase && mUseMutex )`
598	`{`	598	`{`
599	`try`	599	`try`
600	`{`	600	`{`
601	`CallableStatement stmt = mConnection.prepareCall("select CONFIG from release_manager.BUILD_SERVICE_CONFIG WHERE SERVICE='MUTEX' FOR UPDATE");`	601	`CallableStatement stmt = mConnection.prepareCall("select CONFIG from release_manager.BUILD_SERVICE_CONFIG WHERE SERVICE='MUTEX' FOR UPDATE");`
602	`mLogger.error("claimMutex calling stmt.executeUpdate");`	602	`mLogger.warn("claimMutex calling stmt.executeUpdate");`
603	`stmt.executeUpdate();`	603	`stmt.executeUpdate();`
604	`mLogger.error("claimMutex called stmt.executeUpdate");`	604	`mLogger.warn("claimMutex called stmt.executeUpdate");`
605	`stmt.close();`	605	`stmt.close();`
606	`mDoNotCommit = true;`	606	`mDoNotCommit = true;`
607	`mMutexState = "Holding Mutex";`	607	`mMutexState = "Holding Mutex";`
608	`}`	608	`}`
609	`catch ( SQLException e )`	609	`catch ( SQLException e )`
Line 627...	Line 627...
627	`if ( mUseDatabase )`	627	`if ( mUseDatabase )`
628	`{`	628	`{`
629	`try`	629	`try`
630	`{`	630	`{`
631	`mDoNotCommit = false;`	631	`mDoNotCommit = false;`
632	`mLogger.error("releaseMutex calling commit");`	632	`mLogger.warn("releaseMutex calling commit");`
633	`commit();`	633	`commit();`
634	`mLogger.error("releaseMutex called commit");`	634	`mLogger.warn("releaseMutex called commit");`
635	`mMutexState = "Released Mutex";`	635	`mMutexState = "Released Mutex";`
636	`}`	636	`}`
637	`catch ( SQLException e )`	637	`catch ( SQLException e )`
638	`{`	638	`{`
639	`mMutexState = "Mutex Release Exception";`	639	`mMutexState = "Mutex Release Exception";`
Line 801...	Line 801...
801	`* @exception SQLException`	801	`* @exception SQLException`
802	`* @exception Exception`	802	`* @exception Exception`
803	`*/`	803	`*/`
804	`public void discardVersion() throws SQLException, Exception`	804	`public void discardVersion() throws SQLException, Exception`
805	`{`	805	`{`
806	`mLogger.error("discardVersion");`	806	`mLogger.warn("discardVersion");`
807		807
808	`if ( mPlannedPkgId != null && mPlannedPkgVersion != null )`	808	`if ( mPlannedPkgId != null && mPlannedPkgVersion != null )`
809	`{`	809	`{`
810	`try`	810	`try`
811	`{`	811	`{`
Line 861...	Line 861...
861	`* @param pkgId - Identifies the name of the package being built`	861	`* @param pkgId - Identifies the name of the package being built`
862	`* @param pkgPvId - Identifies the packageVersion the build is based upon`	862	`* @param pkgPvId - Identifies the packageVersion the build is based upon`
863	`*/`	863	`*/`
864	`public void setCurrentPackageBeingBuilt(int rconId, int pkgId, int pkgPvId) throws SQLException, Exception`	864	`public void setCurrentPackageBeingBuilt(int rconId, int pkgId, int pkgPvId) throws SQLException, Exception`
865	`{`	865	`{`
866	`mLogger.error("setCurrentPackageBeingBuilt {}", rconId);`	866	`mLogger.warn("setCurrentPackageBeingBuilt {}", rconId);`
867	`if ( mUseDatabase )`	867	`if ( mUseDatabase )`
868	`{`	868	`{`
869	`CallableStatement stmt = null;`	869	`CallableStatement stmt = null;`
870	`try`	870	`try`
871	`{`	871	`{`
Line 907...	Line 907...
907	`*`	907	`*`
908	`* @param rconId - Identifies the Release Config table entry`	908	`* @param rconId - Identifies the Release Config table entry`
909	`*/`	909	`*/`
910	`public void clearCurrentPackageBeingBuilt(int rconId) throws SQLException, Exception`	910	`public void clearCurrentPackageBeingBuilt(int rconId) throws SQLException, Exception`
911	`{`	911	`{`
912	`mLogger.error("clearCurrentPackageBeingBuilt {}", rconId);`	912	`mLogger.warn("clearCurrentPackageBeingBuilt {}", rconId);`
913	`if ( mUseDatabase )`	913	`if ( mUseDatabase )`
914	`{`	914	`{`
915	`try`	915	`try`
916	`{`	916	`{`
917	`connect();`	917	`connect();`
Line 1541...	Line 1541...
1541	`catch ( SQLException e )`	1541	`catch ( SQLException e )`
1542	`{`	1542	`{`
1543	`handleSQLException(e, "");`	1543	`handleSQLException(e, "");`
1544	`}`	1544	`}`
1545		1545
1546	`mLogger.info("queryBaselineName returned {}", retVal);`	1546	`mLogger.debug("queryBaselineName returned {}", retVal);`
1547	`return retVal.toString();`	1547	`return retVal.toString();`
1548	`}`	1548	`}`
1549		1549
1550	`/**only used in daemon mode`	1550	`/**only used in daemon mode`
1551	`* select config from release_manager.build_service_config where service='MAIL SERVER';`	1551	`* select config from release_manager.build_service_config where service='MAIL SERVER';`
Line 1583...	Line 1583...
1583	`{`	1583	`{`
1584	`handleSQLException(e, "");`	1584	`handleSQLException(e, "");`
1585	`}`	1585	`}`
1586		1586
1587		1587
1588	`mLogger.info("queryMailServer returned {}", retVal);`	1588	`mLogger.debug("queryMailServer returned {}", retVal);`
1589	`return retVal;`	1589	`return retVal;`
1590	`}`	1590	`}`
1591		1591
1592	`/**only used in daemon mode`	1592	`/**only used in daemon mode`
1593	`* returns the configured service`	1593	`* returns the configured service`
Line 1923...	Line 1923...
1923	`* @throws SQLException`	1923	`* @throws SQLException`
1924	`* @throws Exception`	1924	`* @throws Exception`
1925	`*/`	1925	`*/`
1926	`private void disableDaemons(final int rtag_id) throws SQLException, Exception`	1926	`private void disableDaemons(final int rtag_id) throws SQLException, Exception`
1927	`{`	1927	`{`
1928	`mLogger.error("disableDaemons: {}", rtag_id );`	1928	`mLogger.warn("disableDaemons: {}", rtag_id );`
1929		1929
1930	`try`	1930	`try`
1931	`{`	1931	`{`
1932	`CallableStatement stmt1 = mConnection.prepareCall( "call PK_BUILDAPI.set_daemon_states(?,2)" );`	1932	`CallableStatement stmt1 = mConnection.prepareCall( "call PK_BUILDAPI.set_daemon_states(?,2)" );`
1933	`stmt1.setInt( 1, rtag_id );`	1933	`stmt1.setInt( 1, rtag_id );`
Line 1975...	Line 1975...
1975	`}`	1975	`}`
1976	`catch ( SQLException e )`	1976	`catch ( SQLException e )`
1977	`{`	1977	`{`
1978	`handleSQLException(e, "");`	1978	`handleSQLException(e, "");`
1979	`}`	1979	`}`
1980	`mLogger.info("isRtagIdConfigured returning {}", retVal);`	1980	`mLogger.debug("isRtagIdConfigured returning {}", retVal);`
1981	`return retVal;`	1981	`return retVal;`
1982	`}`	1982	`}`
1983		1983
1984	`/**queries the RUN_LEVEL table for daemon to determine if the daemon has been paused`	1984	`/**queries the RUN_LEVEL table for daemon to determine if the daemon has been paused`
1985	`* or disabled.`	1985	`* or disabled.`
Line 2048...	Line 2048...
2048	`{`	2048	`{`
2049	`handleSQLException(e, "");`	2049	`handleSQLException(e, "");`
2050	`}`	2050	`}`
2051	`}`	2051	`}`
2052		2052
2053	`mLogger.info("queryDirectedRunLevel returning {}", retVal);`	2053	`mLogger.debug("queryDirectedRunLevel returning {}", retVal);`
2054	`return retVal;`	2054	`return retVal;`
2055	`}`	2055	`}`
2056		2056
2057	`/**`	2057	`/**`
2058	`* queries the RELEASE_CONFIG and BUILD_MACHINE_CONFIG tables using the rcon_id primary key, rtag_id, machine_hostname, daemon_mode`	2058	`* queries the RELEASE_CONFIG and BUILD_MACHINE_CONFIG tables using the rcon_id primary key, rtag_id, machine_hostname, daemon_mode`
Line 2135...	Line 2135...
2135	`// Handles case where daemon has just been started/restarted`	2135	`// Handles case where daemon has just been started/restarted`
2136	`//`	2136	`//`
2137	`if ( daemon_mode == 'M' && build_age > 0 && days_since_last_build > (build_age + 1) )`	2137	`if ( daemon_mode == 'M' && build_age > 0 && days_since_last_build > (build_age + 1) )`
2138	`{`	2138	`{`
2139	`long upTimeSecs = (System.currentTimeMillis() - threadStartTime)/1000;`	2139	`long upTimeSecs = (System.currentTimeMillis() - threadStartTime)/1000;`
2140	`mLogger.error("queryReleaseConfig 1: {},{},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build, upTimeSecs );`	2140	`mLogger.warn("queryReleaseConfig 1: {},{},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build, upTimeSecs );`
2141	`if ( upTimeSecs > mPostponeShutdown)`	2141	`if ( upTimeSecs > mPostponeShutdown)`
2142	`{`	2142	`{`
2143	`disableDaemons(rtag_id);`	2143	`disableDaemons(rtag_id);`
2144	`pause = 2;`	2144	`pause = 2;`
2145	`}`	2145	`}`
2146	`else`	2146	`else`
2147	`{`	2147	`{`
2148	`mLogger.error("queryReleaseConfig 1: Shutdown Postponed" );`	2148	`mLogger.warn("queryReleaseConfig 1: Shutdown Postponed" );`
2149	`}`	2149	`}`
2150	`}`	2150	`}`
2151		2151
2152	`mLogger.info("queryReleaseConfig 1: {},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build );`	2152	`mLogger.info("queryReleaseConfig 1: {},{},{},{},{},{}",rtag_id, rcon_id, daemon_mode, pause, build_age, days_since_last_build );`
2153		2153
Line 2170...	Line 2170...
2170	`catch ( SQLException e )`	2170	`catch ( SQLException e )`
2171	`{`	2171	`{`
2172	`handleSQLException(e, ":1");`	2172	`handleSQLException(e, ":1");`
2173	`}`	2173	`}`
2174		2174
2175	`mLogger.info("queryReleaseConfig 1 returning {}", retVal);`	2175	`mLogger.debug("queryReleaseConfig 1 returning {}", retVal);`
2176	`return retVal;`	2176	`return retVal;`
2177	`}`	2177	`}`
2178		2178
2179	`/**removes all elements from the mReleaseConfigCollection`	2179	`/**removes all elements from the mReleaseConfigCollection`
2180	`* handles database connection and disconnection`	2180	`* handles database connection and disconnection`
Line 2226...	Line 2226...
2226	`int rcon_id = rset.mustGetInt("rcon_id");`	2226	`int rcon_id = rset.mustGetInt("rcon_id");`
2227		2227
2228	`char dm = 'S';`	2228	`char dm = 'S';`
2229	`String daemon_mode = rset.getString("daemon_mode","S");`	2229	`String daemon_mode = rset.getString("daemon_mode","S");`
2230		2230
2231	`mLogger.info("queryReleaseConfig 2 daemon_mode '{}'", daemon_mode);`	2231	`mLogger.debug("queryReleaseConfig 2 daemon_mode '{}'", daemon_mode);`
2232		2232
2233	`if ( daemon_mode.compareTo("M") == 0 )`	2233	`if ( daemon_mode.compareTo("M") == 0 )`
2234	`{`	2234	`{`
2235	`dm = 'M';`	2235	`dm = 'M';`
2236	`}`	2236	`}`
Line 2327...	Line 2327...
2327	`int rcon_id = rset.mustGetInt("rcon_id");`	2327	`int rcon_id = rset.mustGetInt("rcon_id");`
2328		2328
2329	`char dm = 'S';`	2329	`char dm = 'S';`
2330	`String daemon_mode = rset.getString("daemon_mode", "S");`	2330	`String daemon_mode = rset.getString("daemon_mode", "S");`
2331		2331
2332	`mLogger.info("queryReleaseConfig 3 daemon_mode '{}'", daemon_mode);`	2332	`mLogger.debug("queryReleaseConfig 3 daemon_mode '{}'", daemon_mode);`
2333		2333
2334	`if ( daemon_mode.compareTo("M") == 0 )`	2334	`if ( daemon_mode.compareTo("M") == 0 )`
2335	`{`	2335	`{`
2336	`dm = 'M';`	2336	`dm = 'M';`
2337	`}`	2337	`}`
Line 2450...	Line 2450...
2450	`connect();`	2450	`connect();`
2451	`PreparedStatement stmt = mConnection.prepareStatement(`	2451	`PreparedStatement stmt = mConnection.prepareStatement(`
2452	`"SELECT rl.rcon_id, rc.RTAG_ID" +`	2452	`"SELECT rl.rcon_id, rc.RTAG_ID" +`
2453	`" FROM run_level rl, release_config rc, release_tags rt" +`	2453	`" FROM run_level rl, release_config rc, release_tags rt" +`
2454	`" WHERE rt.rtag_id = rc.RTAG_ID" +`	2454	`" WHERE rt.rtag_id = rc.RTAG_ID" +`
2455	`" AND UPPER(rc.daemon_hostname) = UPPER('"+mHostname+"')" +`	2455	`" AND UPPER(rc.daemon_hostname) = UPPER(?)" +`
2456	`" AND rc.DAEMON_MODE != 'M'" +`	2456	`" AND rc.DAEMON_MODE != 'M'" +`
2457	`" AND rc.RCON_ID = rl.rcon_id" +`	2457	`" AND rc.RCON_ID = rl.rcon_id" +`
2458	`" AND CURRENT_BUILD_FILES IS NOT NULL" +`	2458	`" AND CURRENT_BUILD_FILES IS NOT NULL" +`
2459	`" AND rl.pause is null" +`	2459	`" AND rl.pause is null" +`
2460	`" AND rl.rcon_id in ("+rconIdList+")"`	2460	`" AND rl.rcon_id in (?)"`
2461	`);`	2461	`);`
-		2462
-		2463	`stmt.setString(1, mHostname);`
-		2464	`stmt.setString(2, rconIdList);`
2462		2465
2463	`ResultSet rset = stmt.executeQuery();`	2466	`ResultSet rset = stmt.executeQuery();`
2464		2467
2465	`while (rset.next()) {`	2468	`while (rset.next()) {`
2466	`Integer ii = rset.getInt("rcon_id");`	2469	`Integer ii = rset.getInt("rcon_id");`
Line 2527...	Line 2530...
2527	`" pv.build_time" +`	2530	`" pv.build_time" +`
2528	`" FROM release_manager.release_content rc," +`	2531	`" FROM release_manager.release_content rc," +`
2529	`" release_manager.package_versions pv," +`	2532	`" release_manager.package_versions pv," +`
2530	`" release_manager.packages p," +`	2533	`" release_manager.packages p," +`
2531	`" release_manager.pegged_versions peg" +`	2534	`" release_manager.pegged_versions peg" +`
2532	`" WHERE rc.rtag_id= " + baseline +`	2535	`" WHERE rc.rtag_id=?" +`
2533	`" AND pv.pv_id = rc.pv_id" +`	2536	`" AND pv.pv_id = rc.pv_id" +`
2534	`" AND p.pkg_id = pv.pkg_id" +`	2537	`" AND p.pkg_id = pv.pkg_id" +`
2535	`" AND peg.rtag_id(+) = rc.rtag_id" +`	2538	`" AND peg.rtag_id(+) = rc.rtag_id" +`
2536	`" AND peg.pv_id(+) = rc.pv_id" +`	2539	`" AND peg.pv_id(+) = rc.pv_id" +`
2537	`" ORDER BY rc.pv_id"`	2540	`" ORDER BY rc.pv_id"`
2538	`);`	2541	`);`
-		2542	`stmt8.setInt(1, baseline);`
2539	`mLogger.debug("queryPackageVersions: stmt8 Prepared");`	2543	`mLogger.debug("queryPackageVersions: stmt8 Prepared");`
2540	`stmt8.setFetchSize(1000);`	2544	`stmt8.setFetchSize(1000);`
2541	`RmResultSet rset8 = new RmResultSet(stmt8.executeQuery(), "queryPackageVersions rset8");`	2545	`RmResultSet rset8 = new RmResultSet(stmt8.executeQuery(), "queryPackageVersions rset8");`
2542	`mLogger.debug("queryPackageVersions: stmt8 Query Done");`	2546	`mLogger.debug("queryPackageVersions: stmt8 Query Done");`
2543		2547
Line 2580...	Line 2584...
2580	`// TODO - Not sure this code is in use anymore`	2584	`// TODO - Not sure this code is in use anymore`
2581		2585
2582	`Package plannedPackage = findPackage(p.mAlias, packageCollection);`	2586	`Package plannedPackage = findPackage(p.mAlias, packageCollection);`
2583	`if ( plannedPackage == NULL_PACKAGE )`	2587	`if ( plannedPackage == NULL_PACKAGE )`
2584	`{`	2588	`{`
2585	`mLogger.info("queryPackageVersions rset8 no planned package {}", pv_id);`	2589	`mLogger.debug("queryPackageVersions rset8 no planned package {}", pv_id);`
2586	`packageCollection.add(p);`	2590	`packageCollection.add(p);`
2587	`}`	2591	`}`
2588	`else`	2592	`else`
2589	`{`	2593	`{`
2590	`// Copy these flags from the package that will be replaced`	2594	`// Copy these flags from the package that will be replaced`
Line 2609...	Line 2613...
2609	`" from release_manager.release_content rc," +`	2613	`" from release_manager.release_content rc," +`
2610	`" release_manager.package_versions pv," +`	2614	`" release_manager.package_versions pv," +`
2611	`" release_manager.package_dependencies pd,"+`	2615	`" release_manager.package_dependencies pd,"+`
2612	`" release_manager.package_versions dpv,"+`	2616	`" release_manager.package_versions dpv,"+`
2613	`" release_manager.packages p" +`	2617	`" release_manager.packages p" +`
2614	`" where rc.rtag_id=" + baseline +`	2618	`" where rc.rtag_id=?" +`
2615	`" and pv.pv_id = rc.pv_id" +`	2619	`" and pv.pv_id = rc.pv_id" +`
2616	`" and pd.pv_id=pv.pv_id" +`	2620	`" and pd.pv_id=pv.pv_id" +`
2617	`" and dpv.pv_id=pd.dpv_id" +`	2621	`" and dpv.pv_id=pd.dpv_id" +`
2618	`" and p.pkg_id=dpv.pkg_id" +`	2622	`" and p.pkg_id=dpv.pkg_id" +`
2619	`" order by rc.pv_id"`	2623	`" order by rc.pv_id"`
2620	`);`	2624	`);`
2621	`mLogger.debug("queryPackageVersions: stmt9 prepared");`	2625	`mLogger.debug("queryPackageVersions: stmt9 prepared");`
-		2626	`stmt9.setInt(1, baseline);`
2622	`stmt9.setFetchSize(1000);`	2627	`stmt9.setFetchSize(1000);`
2623	`RmResultSet rset9 = new RmResultSet(stmt9.executeQuery(), "queryPackageVersions rset9");`	2628	`RmResultSet rset9 = new RmResultSet(stmt9.executeQuery(), "queryPackageVersions rset9");`
2624	`mLogger.debug("queryPackageVersions: stmt9 query done");`	2629	`mLogger.debug("queryPackageVersions: stmt9 query done");`
2625		2630
2626	`while( rset9.next() )`	2631	`while( rset9.next() )`
Line 2687...	Line 2692...
2687	`mLogger.debug("queryPackageVersions: stmt11");`	2692	`mLogger.debug("queryPackageVersions: stmt11");`
2688	`phase.setPhase("getAllPkgs4");`	2693	`phase.setPhase("getAllPkgs4");`
2689	`PreparedStatement stmt11 = mConnection.prepareStatement(`	2694	`PreparedStatement stmt11 = mConnection.prepareStatement(`
2690	`"select rc.pv_id, tt.test_type_name " +`	2695	`"select rc.pv_id, tt.test_type_name " +`
2691	`"from release_manager.release_content rc, release_manager.package_versions pv, release_manager.unit_tests ut, release_manager.test_types tt " +`	2696	`"from release_manager.release_content rc, release_manager.package_versions pv, release_manager.unit_tests ut, release_manager.test_types tt " +`
2692	`"where rc.rtag_id=" + baseline +`	2697	`"where rc.rtag_id=?" +`
2693	`" and pv.pv_id = rc.pv_id and ut.pv_id=pv.pv_id and tt.test_type_id=ut.test_types_fk " +`	2698	`" and pv.pv_id = rc.pv_id and ut.pv_id=pv.pv_id and tt.test_type_id=ut.test_types_fk " +`
2694	`"order by rc.pv_id"`	2699	`"order by rc.pv_id"`
2695	`);`	2700	`);`
-		2701	`stmt11.setInt(1, baseline);`
2696	`stmt11.setFetchSize(1000);`	2702	`stmt11.setFetchSize(1000);`
2697	`RmResultSet rset11 = new RmResultSet(stmt11.executeQuery(), "queryPackageVersions rset11");`	2703	`RmResultSet rset11 = new RmResultSet(stmt11.executeQuery(), "queryPackageVersions rset11");`
2698		2704
2699	`while( rset11.next() )`	2705	`while( rset11.next() )`
2700	`{`	2706	`{`
Line 2724...	Line 2730...
2724	`" release_manager.release_tags rt," +`	2730	`" release_manager.release_tags rt," +`
2725	`" release_manager.package_versions pv," +`	2731	`" release_manager.package_versions pv," +`
2726	`" release_manager.autobuild_failure af," +`	2732	`" release_manager.autobuild_failure af," +`
2727	`" release_manager.members_group mg," +`	2733	`" release_manager.members_group mg," +`
2728	`" release_manager.users u" +`	2734	`" release_manager.users u" +`
2729	`" WHERE rc.rtag_id = " + baseline +`	2735	`" WHERE rc.rtag_id = ?" +`
2730	`" AND rt.rtag_id = rc.rtag_id" +`	2736	`" AND rt.rtag_id = rc.rtag_id" +`
2731	`" AND pv.pv_id = rc.pv_id" +`	2737	`" AND pv.pv_id = rc.pv_id" +`
2732	`" AND af.view_id = rc.base_view_id" +`	2738	`" AND af.view_id = rc.base_view_id" +`
2733	`" AND mg.group_email_id= af.group_email_id" +`	2739	`" AND mg.group_email_id= af.group_email_id" +`
2734	`" AND u.user_id = mg.user_id" +`	2740	`" AND u.user_id = mg.user_id" +`
2735	`" AND af.proj_id = rt.proj_id" +`	2741	`" AND af.proj_id = rt.proj_id" +`
2736	`" ORDER BY rc.pv_id"`	2742	`" ORDER BY rc.pv_id"`
2737	`);`	2743	`);`
-		2744	`stmt12.setInt(1, baseline);`
2738	`stmt12.setFetchSize(1000);`	2745	`stmt12.setFetchSize(1000);`
2739	`RmResultSet rset12 = new RmResultSet(stmt12.executeQuery(), "queryPackageVersions rset12");`	2746	`RmResultSet rset12 = new RmResultSet(stmt12.executeQuery(), "queryPackageVersions rset12");`
2740		2747
2741	`while( rset12.next() )`	2748	`while( rset12.next() )`
2742	`{`	2749	`{`
Line 2757...	Line 2764...
2757	`mLogger.debug("queryPackageVersions: stmt14");`	2764	`mLogger.debug("queryPackageVersions: stmt14");`
2758	`phase.setPhase("getAllPkgs6");`	2765	`phase.setPhase("getAllPkgs6");`
2759	`PreparedStatement stmt14 = mConnection.prepareStatement(`	2766	`PreparedStatement stmt14 = mConnection.prepareStatement(`
2760	`"select rc.pv_id " +`	2767	`"select rc.pv_id " +`
2761	`"from release_manager.release_content rc, release_manager.package_versions pv, release_manager.advisory_ripple ar " +`	2768	`"from release_manager.release_content rc, release_manager.package_versions pv, release_manager.advisory_ripple ar " +`
2762	`"where rc.rtag_id=" + baseline +`	2769	`"where rc.rtag_id=?" +`
2763	`" and pv.pv_id = rc.pv_id and ar.rtag_id=rc.rtag_id and ar.pv_id=rc.pv_id " +`	2770	`" and pv.pv_id = rc.pv_id and ar.rtag_id=rc.rtag_id and ar.pv_id=rc.pv_id " +`
2764	`"order by rc.pv_id"`	2771	`"order by rc.pv_id"`
2765	`);`	2772	`);`
2766	`stmt14.setFetchSize(1000);`	2773	`stmt14.setFetchSize(1000);`
-		2774	`stmt14.setInt(1, baseline);`
2767	`RmResultSet rset14 = new RmResultSet(stmt14.executeQuery(), "queryPackageVersions rset14");`	2775	`RmResultSet rset14 = new RmResultSet(stmt14.executeQuery(), "queryPackageVersions rset14");`
2768		2776
2769	`while( rset14.next() )`	2777	`while( rset14.next() )`
2770	`{`	2778	`{`
2771	`int pv_id = rset14.mustGetInt("pv_id");`	2779	`int pv_id = rset14.mustGetInt("pv_id");`
Line 2791...	Line 2799...
2791	`" from deployment_manager.bom_contents bc," +`	2799	`" from deployment_manager.bom_contents bc," +`
2792	`"deployment_manager.operating_systems os," +`	2800	`"deployment_manager.operating_systems os," +`
2793	`"deployment_manager.os_contents oc," +`	2801	`"deployment_manager.os_contents oc," +`
2794	`"release_manager.package_versions pv," +`	2802	`"release_manager.package_versions pv," +`
2795	`"release_manager.packages p" +`	2803	`"release_manager.packages p" +`
2796	`" where bc.bom_id=" + baseline +`	2804	`" where bc.bom_id=?" +`
2797	`" and os.node_id=bc.node_id" +`	2805	`" and os.node_id=bc.node_id" +`
2798	`" and oc.os_id=os.os_id" +`	2806	`" and oc.os_id=os.os_id" +`
2799	`" and pv.pv_id=oc.prod_id" +`	2807	`" and pv.pv_id=oc.prod_id" +`
2800	`" and p.pkg_id=pv.pkg_id" +`	2808	`" and p.pkg_id=pv.pkg_id" +`
2801	`" order by oc.prod_id"`	2809	`" order by oc.prod_id"`
2802	`);`	2810	`);`
2803	`stmt.setFetchSize(1000);`	2811	`stmt.setFetchSize(1000);`
-		2812	`stmt.setInt(1, baseline);`
2804	`RmResultSet rset = new RmResultSet(stmt.executeQuery(), "queryPackageVersions rset");`	2813	`RmResultSet rset = new RmResultSet(stmt.executeQuery(), "queryPackageVersions rset");`
2805		2814
2806	`while( rset.next() )`	2815	`while( rset.next() )`
2807	`{`	2816	`{`
2808	`int pv_id = rset.mustGetKeyInt("prod_id");`	2817	`int pv_id = rset.mustGetKeyInt("prod_id");`
Line 2880...	Line 2889...
2880	`PreparedStatement stmt1 = mConnection.prepareStatement(`	2889	`PreparedStatement stmt1 = mConnection.prepareStatement(`
2881	`"select pl.pv_id, pv.modified_stamp" +`	2890	`"select pl.pv_id, pv.modified_stamp" +`
2882	`" from release_manager.planned pl," +`	2891	`" from release_manager.planned pl," +`
2883	`" release_manager.package_versions pv," +`	2892	`" release_manager.package_versions pv," +`
2884	`" release_manager.packages p" +`	2893	`" release_manager.packages p" +`
2885	`" where pl.rtag_id=" + baseline +`	2894	`" where pl.rtag_id=?" +`
2886	`" and pv.build_type='A' and pv.dlocked='A'" +`	2895	`" and pv.build_type='A' and pv.dlocked='A'" +`
2887	`" and pv.pv_id=pl.pv_id and p.pkg_id=pv.pkg_id" +`	2896	`" and pv.pv_id=pl.pv_id and p.pkg_id=pv.pkg_id" +`
2888	`" order by pv.modified_stamp"`	2897	`" order by pv.modified_stamp"`
2889	`);`	2898	`);`
2890	`stmt1.setFetchSize(500);`	2899	`stmt1.setFetchSize(500);`
-		2900	`stmt1.setInt(1, baseline);`
2891	`RmResultSet rset1 = new RmResultSet(stmt1.executeQuery(), "queryPackageVersions rset1");`	2901	`RmResultSet rset1 = new RmResultSet(stmt1.executeQuery(), "queryPackageVersions rset1");`
2892		2902
2893	`while( rset1.next() )`	2903	`while( rset1.next() )`
2894	`{`	2904	`{`
2895	`int pvId = rset1.mustGetKeyInt("pv_id");`	2905	`int pvId = rset1.mustGetKeyInt("pv_id");`
Line 2906...	Line 2916...
2906	`// to be built`	2916	`// to be built`
2907		2917
2908	`Package prevPlannedPackage = findPackage(p.mAlias, packageCollection);`	2918	`Package prevPlannedPackage = findPackage(p.mAlias, packageCollection);`
2909	`if ( prevPlannedPackage == NULL_PACKAGE )`	2919	`if ( prevPlannedPackage == NULL_PACKAGE )`
2910	`{`	2920	`{`
2911	`mLogger.info("queryWips rset1 no previous WIP package {}", pvId);`	2921	`mLogger.debug("queryWips rset1 no previous WIP package {}", pvId);`
2912	`packageCollection.add(p);`	2922	`packageCollection.add(p);`
2913	`}`	2923	`}`
2914	`}`	2924	`}`
2915	`}`	2925	`}`
2916		2926
Line 2999...	Line 3009...
2999	`mLogger.debug("queryTest: stmt141");`	3009	`mLogger.debug("queryTest: stmt141");`
3000	`phase.setPhase("getTestBuild1");`	3010	`phase.setPhase("getTestBuild1");`
3001	`DaemonInstruction di = new DaemonInstruction( baseline, 1, true);`	3011	`DaemonInstruction di = new DaemonInstruction( baseline, 1, true);`
3002	`while ( getDaemonInst( di ) )`	3012	`while ( getDaemonInst( di ) )`
3003	`{`	3013	`{`
3004	`mLogger.info("queryPackageVersions test build data {}", di.pvId);`	3014	`mLogger.debug("queryPackageVersions test build data {}", di.pvId);`
3005		3015
3006	`Package p = getPackageInfo(di.pvId, rippleEngine, false);`	3016	`Package p = getPackageInfo(di.pvId, rippleEngine, false);`
3007	`if ( p == NULL_PACKAGE )`	3017	`if ( p == NULL_PACKAGE )`
3008	`{`	3018	`{`
3009	`mLogger.error("queryTest rset15 no data found {}", di.instruction);`	3019	`mLogger.error("queryTest rset15 no data found {}", di.instruction);`
Line 3064...	Line 3074...
3064	`while ( getDaemonInst( di ) )`	3074	`while ( getDaemonInst( di ) )`
3065	`{`	3075	`{`
3066	`Package p = getPackageInfo(di.pvId, rippleEngine, false);`	3076	`Package p = getPackageInfo(di.pvId, rippleEngine, false);`
3067	`if ( p != NULL_PACKAGE )`	3077	`if ( p != NULL_PACKAGE )`
3068	`{`	3078	`{`
3069	`mLogger.info("queryPackageVersions forced ripple data {}", di.pvId);`	3079	`mLogger.debug("queryPackageVersions forced ripple data {}", di.pvId);`
3070	`packageCollection.add(p);`	3080	`packageCollection.add(p);`
3071	`p.mForcedRippleInstruction = di.instruction;`	3081	`p.mForcedRippleInstruction = di.instruction;`
3072	`p.addEmail(di.userEmail);`	3082	`p.addEmail(di.userEmail);`
3073	`p.mBuildReason = BuildReason.Forced;`	3083	`p.mBuildReason = BuildReason.Forced;`
3074	`p.mIsNotReleased = true;`	3084	`p.mIsNotReleased = true;`
Line 3119...	Line 3129...
3119	`" release_manager.PK_RMAPI.return_vcs_tag(pv.pv_id) AS vcsTag," +`	3129	`" release_manager.PK_RMAPI.return_vcs_tag(pv.pv_id) AS vcsTag," +`
3120	`" pv.build_time" +`	3130	`" pv.build_time" +`
3121	`" from " +`	3131	`" from " +`
3122	`" release_manager.package_versions pv," +`	3132	`" release_manager.package_versions pv," +`
3123	`" release_manager.packages p" +`	3133	`" release_manager.packages p" +`
3124	`" where pv.pv_id=" + pvId +`	3134	`" where pv.pv_id=?" +`
3125	`" and p.pkg_id=pv.pkg_id"`	3135	`" and p.pkg_id=pv.pkg_id"`
3126		3136
3127	`);`	3137	`);`
-		3138	`stmt1.setInt(1, pvId);`
3128	`stmt1.setFetchSize(500);`	3139	`stmt1.setFetchSize(500);`
3129	`RmResultSet rset1 = new RmResultSet(stmt1.executeQuery(), "getPackageInfo rset1");`	3140	`RmResultSet rset1 = new RmResultSet(stmt1.executeQuery(), "getPackageInfo rset1");`
3130		3141
3131	`// Package must exist`	3142	`// Package must exist`
3132	`if ( ! rset1.next() )`	3143	`if ( ! rset1.next() )`
Line 3206...	Line 3217...
3206	`" from " +`	3217	`" from " +`
3207	`" release_manager.package_versions pv,"+`	3218	`" release_manager.package_versions pv,"+`
3208	`" release_manager.package_dependencies pd," +`	3219	`" release_manager.package_dependencies pd," +`
3209	`" release_manager.package_versions dpv,"+`	3220	`" release_manager.package_versions dpv,"+`
3210	`" release_manager.packages p" +`	3221	`" release_manager.packages p" +`
3211	`" where pv.pv_id=" + pvId +`	3222	`" where pv.pv_id=?" +`
3212	`" and pd.pv_id=pv.pv_id"+`	3223	`" and pd.pv_id=pv.pv_id"+`
3213	`" and dpv.pv_id=pd.dpv_id" +`	3224	`" and dpv.pv_id=pd.dpv_id" +`
3214	`" and pd.dpkg_id = p.pkg_id"`	3225	`" and pd.dpkg_id = p.pkg_id"`
3215	`);`	3226	`);`
3216	`stmt2.setFetchSize(500);`	3227	`stmt2.setFetchSize(500);`
-		3228	`stmt2.setInt(1, pvId);`
3217	`RmResultSet rset2 = new RmResultSet(stmt2.executeQuery(), "getPackageInfo rset2");`	3229	`RmResultSet rset2 = new RmResultSet(stmt2.executeQuery(), "getPackageInfo rset2");`
3218		3230
3219	`while ( rset2.next() )`	3231	`while ( rset2.next() )`
3220	`{`	3232	`{`
3221	`String dpv_name = rset2.mustGetKeyString("pkg_name");`	3233	`String dpv_name = rset2.mustGetKeyString("pkg_name");`
Line 3235...	Line 3247...
3235	`" from " +`	3247	`" from " +`
3236	`" release_manager.package_versions pv," +`	3248	`" release_manager.package_versions pv," +`
3237	`" release_manager.package_build_info pbi," +`	3249	`" release_manager.package_build_info pbi," +`
3238	`" release_manager.build_machines bm," +`	3250	`" release_manager.build_machines bm," +`
3239	`" release_manager.build_standards_addendum bsa " +`	3251	`" release_manager.build_standards_addendum bsa " +`
3240	`" where pv.pv_id=" + pvId +`	3252	`" where pv.pv_id=?" +`
3241	`" and pbi.pv_id=pv.pv_id" +`	3253	`" and pbi.pv_id=pv.pv_id" +`
3242	`" and bm.bm_id=pbi.bm_id" +`	3254	`" and bm.bm_id=pbi.bm_id" +`
3243	`" and bsa.bsa_id=pbi.bsa_id "`	3255	`" and bsa.bsa_id=pbi.bsa_id "`
3244	`);`	3256	`);`
3245	`stmt3.setFetchSize(500);`	3257	`stmt3.setFetchSize(500);`
-		3258	`stmt3.setInt(1, pvId);`
3246	`RmResultSet rset3 = new RmResultSet(stmt3.executeQuery(), "getPackageInfo rset3");`	3259	`RmResultSet rset3 = new RmResultSet(stmt3.executeQuery(), "getPackageInfo rset3");`
3247		3260
3248	`while ( rset3.next() )`	3261	`while ( rset3.next() )`
3249	`{`	3262	`{`
3250	`String bm_name = rset3.mustGetString("bm_name");`	3263	`String bm_name = rset3.mustGetString("bm_name");`
Line 3266...	Line 3279...
3266	`"select pv.pv_id, tt.test_type_name" +`	3279	`"select pv.pv_id, tt.test_type_name" +`
3267	`" from "+`	3280	`" from "+`
3268	`" release_manager.package_versions pv,"+`	3281	`" release_manager.package_versions pv,"+`
3269	`" release_manager.unit_tests ut," +`	3282	`" release_manager.unit_tests ut," +`
3270	`" release_manager.test_types tt" +`	3283	`" release_manager.test_types tt" +`
3271	`" where pv.pv_id=" + pvId +`	3284	`" where pv.pv_id=?" +`
3272	`" and ut.pv_id=pv.pv_id" +`	3285	`" and ut.pv_id=pv.pv_id" +`
3273	`" and tt.test_type_id=ut.test_types_fk"`	3286	`" and tt.test_type_id=ut.test_types_fk"`
3274	`);`	3287	`);`
3275	`stmt4.setFetchSize(500);`	3288	`stmt4.setFetchSize(500);`
-		3289	`stmt4.setInt(1, pvId);`
3276	`RmResultSet rset4 = new RmResultSet(stmt4.executeQuery(), "getPackageInfo rset4");`	3290	`RmResultSet rset4 = new RmResultSet(stmt4.executeQuery(), "getPackageInfo rset4");`
3277		3291
3278	`while ( rset4.next() )`	3292	`while ( rset4.next() )`
3279	`{`	3293	`{`
3280	`String test_type_name = rset4.mustGetString("test_type_name");`	3294	`String test_type_name = rset4.mustGetString("test_type_name");`
Line 3297...	Line 3311...
3297	`" release_manager.release_tags rt," +`	3311	`" release_manager.release_tags rt," +`
3298	`" release_manager.package_versions pv," +`	3312	`" release_manager.package_versions pv," +`
3299	`" release_manager.autobuild_failure af," +`	3313	`" release_manager.autobuild_failure af," +`
3300	`" release_manager.members_group mg," +`	3314	`" release_manager.members_group mg," +`
3301	`" release_manager.users u" +`	3315	`" release_manager.users u" +`
3302	`" WHERE rc.rtag_id = " + rippleEngine.getRtagId() +`	3316	`" WHERE rc.rtag_id = ?" +`
3303	`" AND rt.rtag_id = rc.rtag_id" +`	3317	`" AND rt.rtag_id = rc.rtag_id" +`
3304	`" AND pv.pv_id=" + pvId +`	3318	`" AND pv.pv_id =?" +`
3305	`" AND pv.pv_id = rc.pv_id" +`	3319	`" AND pv.pv_id = rc.pv_id" +`
3306	`" AND af.view_id = rc.base_view_id" +`	3320	`" AND af.view_id = rc.base_view_id" +`
3307	`" AND mg.group_email_id= af.group_email_id" +`	3321	`" AND mg.group_email_id= af.group_email_id" +`
3308	`" AND u.user_id = mg.user_id" +`	3322	`" AND u.user_id = mg.user_id" +`
3309	`" AND af.proj_id = rt.proj_id"`	3323	`" AND af.proj_id = rt.proj_id"`
3310	`);`	3324	`);`
3311	`stmt5.setFetchSize(500);`	3325	`stmt5.setFetchSize(500);`
-		3326	`stmt5.setInt(1, rippleEngine.getRtagId());`
-		3327	`stmt5.setInt(2, pvId);`
-		3328
-		3329
3312	`RmResultSet rset5 = new RmResultSet(stmt5.executeQuery(), "getPackageInfo rset5");`	3330	`RmResultSet rset5 = new RmResultSet(stmt5.executeQuery(), "getPackageInfo rset5");`
3313		3331
3314	`while ( rset5.next() )`	3332	`while ( rset5.next() )`
3315	`{`	3333	`{`
3316	`p.addEmail(rset5.getString("user_email", null));`	3334	`p.addEmail(rset5.getString("user_email", null));`
Line 3328...	Line 3346...
3328	`" release_manager.release_tags rt," +`	3346	`" release_manager.release_tags rt," +`

Subversion Repositories DevTools

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