Subversion Repositories DevTools

package com.erggroup.buildtool.ripple;

import java.sql.Array;

import java.sql.CallableStatement;

import java.sql.Clob;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Timestamp;

import java.sql.Types;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

import java.util.concurrent.locks.ReentrantLock;

import oracle.sql.ArrayDescriptor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.erggroup.buildtool.ripple.RunLevel.BuildState;

import com.erggroup.buildtool.utilities.MutableDate;

/**Release Manager schema abstraction

 */

public class ReleaseManager implements Cloneable

{

    /**Unit test hook.

     * Prevents Oracle interaction when false.

     * @attribute

     */

    public boolean mUseDatabase = true;

    /**Debug Support.

     * Set to false if EnvVar GBE_BUILDTOOL_DEBUG exists

     * Value of GBE_BUILDTOOL_DEBUG is expected to be an email if greater than

     * one character.

     *

     * When set to false will:

     *    Prevents use of Oracle Mutex and potential lockout during debug sessions.

     *    Prevent the initiation of an indefinite pause.

     *    Force abt_usetestarchive, Add -testArchive to the assemble_dpkg command

     * @attribute

     */

    private static boolean mUseMutex = true;

    /** 

     * Reasons for building a package

     * The character code is inserted directly into the Release Manager Database

     * 

     */

    public enum BuildReason {

        Ripple('R'),            // Caused by mismatched dependencies

        Test('T'),              // A test request via a daemon instruction

        NewVersion('N'),        // A user WIP will create a new version of a package

        Restore('P'),           // Package not present in dpkg_archive and must be rebuilt

        Forced('F');            // Forced Ripple Request via a daemon instruction

        private char reason;

        private BuildReason(char reason) { this.reason = reason; }

        @Override

        public  String toString() { return String.valueOf(reason); }

        public static BuildReason fromValue(String value) {  

            if (value != null) {  

              for (BuildReason vReason : values()) {  

                if (vReason.reason == value.charAt(0) ) {  

                  return vReason;  

                }  

              }  

            }

            return null;  

        }

    }

    /**

     * The build result : Error, Complete ...

     * The character code is inserted directly into the Release Manager Database

     */

    public enum BuildResult {

        Building('B'),

        BuildError('E'),

        Complete('C'),

        SystemError('S');

        private char state;

        private BuildResult(char state) { this.state = state; }

        @Override

        public  String toString() { return String.valueOf(state); }

//        public static BuildResult fromValue(String value) {  

//            if (value != null) {  

//              for (BuildResult vState : values()) {  

//                if (vState.state == value.charAt(0) ) {  

//                  return vState;  

//                }  

//              }  

//            }

//            return null;  

//        }

    }

    /**package object of no consequence

     * @attribute

     */

    public static final Package NULL_PACKAGE = new Package();

    /**Logger

     * @attribute

     */

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

    /** Class to contain a lock and a connection as a single entity

     * 

     */

    static class RmConnection {

    	/**

    	 *  Connection to the database

    	 */

    	public Connection mConnection = null;

    	/**

    	 *  Lock used to control access to the connection

    	 */

    	public final ReentrantLock mSession = new ReentrantLock();

    	/** 

    	 * Close the connection on disconnect

    	 */

    	public boolean mCloseOnDisconnect = false;

    	public RmConnection ( boolean closeMe)

    	{

    		mCloseOnDisconnect = closeMe;

    	}

    	/**

    	 *  Close the connection - do not throw an error

    	 */

    	void closeConnection()

    	{

    		closeConnection(mConnection);

    	}

    	/**

    	 *  Close the specified connection - do not throw an error.

    	 *  To be used for general error handling

    	 * @param connection

    	 */

    	static void closeConnection( Connection connection )

    	{

            try {

                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

     * @attribute

     */

    private static RmConnection mNonPlanningConnection = new RmConnection(false);

    /**database session handle for use when planning a build

     * @attribute

     */

    private static RmConnection mPlanningConnection = new RmConnection(true);

    /**database session handle

     * note this handle is only ever set to mNonPlanningConnection or mPlanningConnection

     * @attribute

     */

    private Connection mConnection = null;

    private boolean    mIsConnected = false;

    /**thread synchronization governing database connection request queuing

     * this lock is used by master threads with a low priority planning requirement

     * use the fairness parameter to grant access to the longest waiting thread

     * @attribute

     */

    private static final ReentrantLock mLowPriorityQueue = new ReentrantLock(true);

    /**collection of ReleaseConfig objects

     * @attribute

     */

    public ReleaseConfigData mReleaseConfigCollection = new ReleaseConfigData();

    /**database connection string

     * @attribute

     */

    public String mConnectionString = "";

    /**database username

     * @attribute

     */

    private String mUsername = "";

    /**database password

     * @attribute

     */

    private String mPassword = "";

    /**collection of RunLevel objects

     * @attribute

     */

    public List<RunLevelData> mRunLevelCollection = new ArrayList<RunLevelData>();

    /**set in claimVersion, cleared in discardVersion

     * @attribute

     */

    private String mPlannedPkgId = null;

    /**set in claimVersion, cleared in discardVersion

     * @attribute

     */

    private String mPlannedPkgVersion = null;

    /**prevents inadvertently attempting a commit which releases record locks in between claimMutex and releaseMutex

     * @attribute

     */

    private boolean mDoNotCommit = false;

     /**

     * Controls the data collection mode.

     * True : daemon Mode (default)

     * False: escrow Mode

     */

    public boolean mDaemon = true;

    /**

     * Indication of the state of the RM mutex

     * Used only for reporting

     */

    public String mMutexState = "";

    /**

     *  The number of seconds to postpone a shut down of a daemon set

     *  after the thread has started. 

     *  

     *  This will prevent a daemon from being automatically disabled as soon

     *  as it is restarted

     *  

     *  Set to four hours

     */

    private static final long mPostponeShutdown = 4L * 60L * 60L;

    /**constructor

     * @param connectionString

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

        if ( gbeBtDebug != null )

        {

            mLogger.error("GBE_BUILDTOOL_DEBUG set - Use of database mutex supressed");

            setNoMutex();

        }

    }

    /**

     * Clone an instance of this class

     */

    @Override

    public Object clone() throws CloneNotSupportedException {

        //  Clone myself - using Java's build in stuff

        ReleaseManager clonedObj = (ReleaseManager) super.clone();

        //  Fix up several members

        //

        clonedObj.mConnection = null;

        clonedObj.mReleaseConfigCollection = new ReleaseConfigData();

        clonedObj.mRunLevelCollection = new ArrayList<RunLevelData>();

        clonedObj.mPlannedPkgId = null;

        clonedObj.mDoNotCommit = false;

        clonedObj.mPlannedPkgVersion = null;

        return clonedObj;

    }

    /**constructor used when schema information is unknown eg location, username, password

     */

    public ReleaseManager()

    {

        // inherit mConnectionString, mUsername, mPassword

        mLogger.debug("ReleaseManager");

    }

    /**

     * Set the mode of operation to be either escrow mode or daemon mode

     * 

     * @param isDaemon True: Daemon Mode

     *               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 

     */

    public static void setNoMutex()

    {

        mUseMutex = false;

    }

    /**

     * Return the state of mUseMutex

     * True indicates that the system must use a Mutex to access data

     */

    public static boolean getUseMutex()

    {

        return mUseMutex;

    }

    /** Returns the current time

     * 

     *  Overridden in ReleaseManagerUtf

     */

    public long currentTimeMillis()

    {

        return System.currentTimeMillis();

    }

    /** Returns the applications major version number

     *  Used to stamp the generated XML files to ensure that producer and consumer match 

     * 

     * Overridden in ReleaseManagerUtf

     */

    public String getMajorVersionNumber()

    {

        return this.getClass().getPackage().getSpecificationVersion();

    }

    /**connect to oracle - in a non planning mode 

     * Overridden in ReleaseManagerUtf 

     */

    public void connect() throws SQLException

    {

        mLogger.debug("connect");

        mNonPlanningConnection = connect( mNonPlanningConnection );

    }

    /**connect to oracle - to plan a build

     * @param   priority - true: Connect with a high priority (last planning session resulted in a build)

     */

    public void connectForPlanning( boolean priority ) throws SQLException

    {

        mLogger.debug("connectForPlanning");

        if ( !priority )

        {

            // limit only one thread with a low priority build requirement to connect

            if ( mLowPriorityQueue.isHeldByCurrentThread() )

            {

                // by design a thread must NOT connect multiple times

                // this is to ensure the lock is claimed only once

                mLogger.error("connectForPlanning thread already has the lock");

            }

            else

            {

                mLogger.debug("connectForPlanning calling lock");

                mLowPriorityQueue.lock();

                mLogger.debug("connectForPlanning called lock");

            }

        }

        // threads with a high priority build requirement are not subject to the mLowPriorityQueue

        mPlanningConnection = connect( mPlanningConnection );    

    }

    /**Connect to oracle - finally

     *  @param  session         - Lock item to use

     *  @param  connection      - Connection to use 

     */

    private RmConnection connect( RmConnection rmc ) throws SQLException

    {

        mLogger.debug("connect");

        //  Reset the internal package caching mechanism

        findPackageResetCache();

        try

        {

            if ( rmc.mSession.isHeldByCurrentThread() )

            {

                // by design a thread must NOT connect multiple times

                // this is to ensure the lock is claimed only once

                mLogger.error("connect thread already has the lock");

            }

            else

            {

                mLogger.debug("connect calling lock");

                rmc.mSession.lock();

                mLogger.debug("connect called lock");

            }

            if ( !mUseDatabase )

            {

                mLogger.info("connect !mUseDatabase");

            }

            else

            {

                // DEVI 46868

                // loop indefinitely until a connection attempt succeeds

                // unless the failure is on the first attempt

                boolean problemConnecting;

                do

                {

                    mLogger.debug("connect check connection");

                    problemConnecting = false;

                    try

                    {

                        if ( rmc.mConnection == null || ( rmc.mConnection != null && !rmc.mConnection.isValid(10) ) )

                        {

                            mLogger.warn("connect calling getConnection");

                            rmc.mConnection = DriverManager.getConnection(mConnectionString, mUsername, mPassword);

                            // when connection to the database is established, the connection, by default, is in auto-commit mode

                            // to adhere to the design in the use of select for update, it is crucial to turn auto-commit off

                            // this also improves performance

                            rmc.mConnection.setAutoCommit(false);

                        }

                    }

                    catch(SQLException e)

                    {

                        mLogger.warn("connect determined problem connecting");

                        problemConnecting = true;

                        try

                        {

                            // sleep 30 secs

                            mLogger.warn("connect getConnection failed. sleep 30secs");

                            Thread.sleep(30000);

                        }

                        catch (InterruptedException f)

                        {

                            mLogger.warn("connect caught InterruptedException");

                            Thread.currentThread().interrupt();

                        }

                        if ( rmc.mConnection == null )

                        {

                            // failed on first connection attempt - unlikely due to database loading - likely bad connection parameters

                            throw new SQLException();

                        }

                    }

                } while ( problemConnecting );

                mLogger.debug("connect checked connection");

            }

        }

        finally

        {

            mConnection = rmc.mConnection;

            mIsConnected = true;

            mLogger.debug("connect finally connection");

        }

        return rmc;

    }

    /**Disconnect from oracle Database 

     * <br>Is overridden in ReleaseManagerUtf for test purposes 

     */

    public void disconnect()

    {

        mLogger.debug("disconnect");

        disconnect( mNonPlanningConnection );

    }

    /**Disconnect from oracle

     * @param   priority    - True: High priority planning thread

     */

    public void disconnectForPlanning( boolean priority )

    {

        mLogger.debug("disconnectForPlanning");

        if ( !priority )

        {

            // allow another low priority thread to connect

            try {

                mLowPriorityQueue.unlock();

            }

            catch( IllegalMonitorStateException e ) {

                mLogger.error("disconnectForPlanning. IllegalMonitorStateException exception");

            }

        }

        disconnect( mPlanningConnection );

    }

    /**Disconnect from oracle

     * Internal oracle disconnection method. Wrapped by publicly available disconnection methods

     * @param   session. Session Lock

     */

    private void disconnect( RmConnection connection )

    {

        mLogger.debug("disconnect");

        // The planning connection is flagged to close on disconnect

        // This is an attempt to prevent database deadlocks - which have been seen

        // under unknown conditions.

        // Done before the lock is released

        if (connection.mCloseOnDisconnect)

        {

            mLogger.debug("disconnect close on disconnect");

        	connection.closeConnection();

        }

        // by design, a thread may call disconnect multiple times

        // this is a technique used in finally blocks

        // it is to ensure the lock is released in all cases

        // only unlock if it is held by this thread

        // when unlock is called on a ReentrantLock held by this thread

        // the hold count is decremented

        // connect should only let the hold count be incremented to 1

        // when the hold count is 0 the lock is released

        // and the ReentrantLock is no longer held by this thread

        // only call unlock when the lock is held by this thread

        if ( connection.mSession.isHeldByCurrentThread() )

        {

            mLogger.debug("disconnect calling unlock");

            try {

                connection.mSession.unlock();

            }

            catch (IllegalMonitorStateException e) {

                mLogger.error("disconnect. IllegalMonitorStateException exception");

            }

            mLogger.debug("disconnect called unlock");

        }

        mIsConnected = false;

    }

    /** Common processing SQL Exceptions

     *  If it is a connection error then a new SQLException will be thrown otherwise

     *  its an error with the SQL itself and a normal Exception will be thrown.

     *  

     * @param e                 - Exception being thrown

     * @param instanceId        - Method suffix to differentiate multiple methods of the same name

     * 

     * @throws SQLException

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

     * Essentially locks the row in the BUILD_SERVICE_CONFIG table with a service of MUTEX

     * for the duration of the transaction this prevents other MasterThreads from 

     * generating build files in parallel and hence prevents planned version numbering contention 

     */

    public void claimMutex() throws SQLException, Exception

    {

        mLogger.debug("claimMutex");

        mMutexState = "Claiming Mutex";

        if ( mUseDatabase && mUseMutex )

        {

            try

            {

                CallableStatement stmt = mConnection.prepareCall("select CONFIG from release_manager.BUILD_SERVICE_CONFIG WHERE SERVICE='MUTEX' FOR UPDATE");

                mLogger.error("claimMutex calling stmt.executeUpdate");

                stmt.executeUpdate();

                mLogger.error("claimMutex called stmt.executeUpdate");

                stmt.close();

                mDoNotCommit = true;

                mMutexState = "Holding Mutex";

            }

            catch ( SQLException e )

            {

                mMutexState = "Mutex Claim Exception";

                handleSQLException(e, "");

            }

            // about to start the planning process again, discard previous

            discardVersions();

        }

    }

    /** Release the Build System Planning Lock 

     *  Essentially unlocks the row in the BUILD_SERVICE_CONFIG table with a service of MUTEX

     */

    public void releaseMutex() throws SQLException, Exception

    {

        mLogger.debug("releaseMutex");

        mMutexState = "Releasing Mutex";

        if ( mUseDatabase )

        {

            try

            {

                mDoNotCommit = false;

                mLogger.error("releaseMutex calling commit");

                commit();

                mLogger.error("releaseMutex called commit");

                mMutexState = "Released Mutex";

            }

            catch ( SQLException e )

            {

                mMutexState = "Mutex Release Exception";

                handleSQLException(e, "");

            }

        }

    }

    /**central commit protection

     */

    private void commit() throws SQLException, Exception

    {

        mLogger.debug("commit");

        if ( mUseDatabase )

        {

            if ( mDoNotCommit )

            {

                mLogger.error("commit attempted commit with mDoNotCommit set, this is a programming error");

            }

            else

            {

                mConnection.commit();

            }

        }

    }

    /**Flag a Build System Pause in the database

     * This is aimed at stopping ALL daemons dead in the water

     * 

     * Used when handling an unsupported exception case in either the main or slave daemons

     * typically an SQLException other than a database connection related on

     *

     * @param mRecoverable  True: Recoverable pause wait until recovery is detected

     *                  <br>False: Unrecoverable pause. Wait for 20 minutes 

     */

    public void indefinitePause(boolean mRecoverable)

    {

        mLogger.debug("indefinitePause");

        if ( mUseDatabase )

        {

            String sqlStr;

            if ( mRecoverable) {

                sqlStr = "begin PK_BUILDAPI.set_infinite_pause(); end;";

            }

            else {

                sqlStr = "begin PK_BUILDAPI.set_finite_pause(20); end;";

            }

            try

            {

                connect();

                CallableStatement stmt = mConnection.prepareCall( sqlStr );

                stmt.executeUpdate();

                stmt.close();

                commit();

            }

            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

                // ensure disconnect

                try

                {

                    disconnect();

                }

                catch( Exception e )

                {

                    // do not throw Exception

                    // this is part of Exception handling

                    mLogger.error( "indefinitePause2 caught Exception {}", e.getMessage() );

                    RmConnection.closeConnection(mConnection);

                }

            }

        }

    }

    /**ensures a run_level_schedule row with a non null indefinite_pause column does not exist

     * this is aimed at resuming all daemons

     * 

     * Assumes connection to database has been established

     */

    public void resumeIndefinitePause() throws SQLException, Exception

    {

        mLogger.debug("resume");

        if ( mUseDatabase )

        {

            try

            {

                CallableStatement stmt = mConnection.prepareCall( "begin PK_BUILDAPI.SET_RESUME(); end;" );

                stmt.executeUpdate();

                stmt.close();

                commit();

            }

            catch ( SQLException e )

            {

                handleSQLException(e, "");

            }

        }

    }

    /**

     *  Only used in daemon mode

     *  Update the Database information to show the package being built

     * 

     * @param pkgId  Identify the package (name) being built

     * 

     * @param pkgVersion

     *                The version at which the package is being built

     * 

     * @param rtagId The release Id in which the package is being built

     * 

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

            {

                if (isRtagIdConfigured( rtagId ))

                {

                    stmt1 = mConnection.prepareCall(

                            "insert into release_manager.planned_versions (pkg_id, pkg_version, planned_time) values (?,?, sysdate)");

                    stmt1.setInt(1, pkgId);

                    stmt1.setString(2, pkgVersion);

                    stmt1.executeUpdate();

                    mPlannedPkgId = String.valueOf(pkgId);

                    mPlannedPkgVersion = pkgVersion;

                }

            }

            catch ( SQLException e )

            {

                handleSQLException(e, "");

            }

            finally {

                if (stmt1 != null)

                    stmt1.close();

            }

        }

    }

    /**Only used in daemon mode

     * <br>Delete planned package package information from the last planned build

     * <p>

     * Note: There is an aging process to cleanup entries that are left around due to

     *       unforeseen errors.

     * <p>      

     * Resets mPlannedPkgId and mPlannedPkgVersion to null

     * 

     * @exception   SQLException

     * @exception   Exception

     */

    public void discardVersion() throws SQLException, Exception

    {

        mLogger.error("discardVersion");

        if ( mPlannedPkgId != null && mPlannedPkgVersion != null )

        {

            try

            {

                connect();

                CallableStatement stmt = mConnection.prepareCall(

                    "delete from release_manager.planned_versions" +

                    " where pkg_id=? and pkg_version=?");

                stmt.setString(1, mPlannedPkgId);

                stmt.setString(2, mPlannedPkgVersion);

                stmt.executeUpdate();

                stmt.close();

                commit();

                mPlannedPkgId = null;

                mPlannedPkgVersion = null;

            }

            catch ( SQLException e )

            {

                handleSQLException(e, "");

            }

            finally

            {

                disconnect();

            }

        }

    }

    /** Delete planned versions over 24 hours old (rounded to the nearest hour that is) 

     *  Only used in daemon mode 

     */

    private void discardVersions() throws SQLException, Exception

    {

        mLogger.debug("discardVersions");

        try

        {

            // housekeeping whilst the daemon has the mutex

            // trunc(sysdate, 'hh') returns the time now rounded to the nearest hour

            // trunc(sysdate, 'hh') - 1 returns the time 24 hours ago rounded to the nearest hour

            // this statement does not return any rows when planned_time is null, though this should never be the case

            CallableStatement stmt = mConnection.prepareCall("delete from release_manager.planned_versions where planned_time < trunc(sysdate, 'hh') - 1");

            stmt.executeUpdate();

            stmt.close();

        }

        catch ( SQLException e )

        {

            handleSQLException(e, "");

        }

    }

    /**Update the Database information to show that a package is being built 

     * Only used in daemon mode

     * 

     *  @param rconId - Identifies the Release Config table entry

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

            {

                connect();

                stmt = mConnection.prepareCall(

                        "update release_manager.run_level rl"+

                        " set current_pkg_id_being_built=?"+

                        "    ,current_pv_id=?" +

                        "    ,last_build=sysdate" +

                        " where rl.rcon_id=?" 

                        );

                stmt.setInt(1, pkgId);

                stmt.setInt(2, pkgPvId);

                stmt.setInt(3, rconId);                    

                stmt.executeUpdate();

                commit();

            }

            catch ( SQLException e )

            {

                handleSQLException(e, "");

            }

            finally

            {

                // this block is executed regardless of what happens in the try block

                // even if an exception is thrown

                // ensure disconnect

                if (stmt != null)

                    stmt.close();

                disconnect();

            }

        }

    }

    /**Update the Database information to show that no package is being built 

     * Only used in daemon mode

     * 

     *  @param rconId - Identifies the Release Config table entry

     */

    public void clearCurrentPackageBeingBuilt(int rconId) throws SQLException, Exception

    {

        mLogger.error("clearCurrentPackageBeingBuilt {}", rconId);

        if ( mUseDatabase )

        {

            try

            {

                connect();

                CallableStatement stmt4 = mConnection.prepareCall(

                        "update release_manager.run_level" +

                        " set current_pkg_id_being_built=NULL,"+

                        "     current_pv_id=NULL," +

                        "     current_build_files=NULL" +

                        " where rcon_id=?"

                         );

                stmt4.setInt(1, rconId);

                stmt4.executeUpdate();

                stmt4.close();

                commit();

            }

            catch ( SQLException e )

            {

                handleSQLException(e, "");

            }

            finally

            {

                // this block is executed regardless of what happens in the try block

                // even if an exception is thrown

                // ensure disconnect

                disconnect();

            }

        }

    }

    /**

     * Executes the AutoMakeRelease stored procedure with the passed parameters

     *          Handles database connection/disconnection

     * 

     * @param mReporting

     * 

     * @return A publishing error

     *         True: A publishing error that only affect the current package

     *         False: No publishing error

     * @exception SQLException

     * @exception Exception A publishing error that affects the entire build system.

     *                      This will cause an 'indefinite pause'

     */

    public boolean autoMakeRelease(ReportingData mReporting) throws SQLException, Exception

    {

        mReporting.errMsg = null;

        mLogger.debug("autoMakeRelease {}", mReporting.packageName);

        if ( mUseDatabase )

        {

            try

            {

                //  Create an array of dependencies

                //  Convert the string mReporting.packageDepends into an array

                //      mReporting.packageDepends is of the form 'PackageName','PackageVersion';'PackageName2','PackageVersion2'

                String [] depArrayData = mReporting.packageDepends.split(";"); 

                ArrayDescriptor desc = ArrayDescriptor.createDescriptor("RELEASE_MANAGER" + "." + "RELMGR_VARCHAR2_TAB_T", mConnection);

                Array depArray = new oracle.sql.ARRAY(desc, mConnection, depArrayData);                

                connect();

                CallableStatement stmt = mConnection.prepareCall( "begin ? := PK_RMAPI.AUTO_MAKE_VCSRELEASE2(?,?,?,?,?,?,?,?); end;" );

                stmt.registerOutParameter( 1, Types.INTEGER);

                stmt.setLong( 2, mReporting.rtagId );

                stmt.setString( 3, mReporting.packageName );

                stmt.setString( 4, mReporting.packageExtension );

                stmt.setString( 5, mReporting.packageVersion );

                stmt.setString( 6, mReporting.newVcsTag );

                stmt.setArray ( 7, depArray );

                stmt.setInt   ( 8, mReporting.isRipple ? 1 : 0 );

                stmt.setString( 9, "buildadm" );

                stmt.executeUpdate();

                int result = stmt.getInt( 1 );

                //

                //  Return values

                //      >0 PVID of package

                //      -1 Package not found in pending table