Page History

public void streamStates.add(ss_running);setProcessInstanceStatus(int processInstance, ProcessingStatus newProcessingStatus, Timestamp transitionTime) throws InvalidStatusTransitionException, SQLException
   {
   streamStates.add(ss_success);
   CallableStatement stmt = streamStatesconnection.add(ss_failedprepareCall("{call DATA_ACCESS.SetProcessInstanceStatus(?,?,?)}");
      streamStates.add(ss_terminating);
try
      streamStates.add(ss_terminated);{
      streamStates.add(ss_canceling);
      streamStates.add(ss_canceledstmt.setInt(1, processInstance);
   }

   private static HashSet finalStreamStates = new HashSet();
   static {
 stmt.setString(2, newProcessingStatus.toString());
         finalStreamStatesstmt.add(ss_terminatedsetTimestamp(3, transitionTime);
      finalStreamStates.add(ss_canceled   stmt.execute();
      finalStreamStates.add(ss_success);}
      finalStreamStates.add(ss_failed);catch(SQLException x)
   }

   private{
 static boolean allComplete(Map procStatMap, Map streamStatMap) {
      for (Iterator i int errorCode = processingStates.iterator(); i.hasNextx.getErrorCode();) {
         Stringif state(errorCode == (String)i.next();InvalidStatusTransitionException.errorCode)
         int   countthrow =new InvalidStatusTransitionException((Integer)procStatMap.get(state)).intValue()x);
         if ( !finalProcessingStates.contains(state) && (count != 0) )else
            returnthrow falsex;
      }

      forfinally
 (Iterator i = streamStates.iterator(); i.hasNext();) {
         String state = (String)i.nextstmt.close();
      }
   }

package org.glast.pipeline.server.sql.sp; public class SPStream
{
   // Package-specific Exception types:

   public static final int    invalid_stream_ex int count = ((Integer)streamStatMap.get(state)).intValue();
         if ( !finalStreamStates.contains(state) && (count != 0) )
            return false;
  =    }-20026;

   // ProcessingStatus  return true;
   }

Enumeration Constants:

   privatepublic static booleanfinal all(String key, Map map) {
 ps_waiting     = int total = 0"WAITING";
   public static final forString (Iterator i = map.values().iterator(); i.hasNext();) {
 ps_ready       =    total += ((Integer)i.next()).intValue()"READY";
   public static final String }
   ps_queued   return ((Integer)map.get(key)).intValue() == total;
   }
"QUEUED";
   privatepublic static booleanfinal any(String key, Map map) {
 ps_submitted    =  return ((Integer)map.get(key)).intValue() != 0 "SUBMITTED";
   }

   public static final String calculateStreamStatus(int stream) throws ClassNotFoundExceptionps_running {
     = String retVal = ss_waiting "RUNNING";
   public static final ConnectionString connection = null; // Database connection object ps_success	  =    "SUCCESS";
   public static final ResultSetString rset = null;
  ps_failed	   =  int parentStream = 0;

 "FAILED";
   public static final tryString {
   ps_terminated    =  // Get a"TERMINATED";
 Default Database Connectionpublic usingstatic Serverfinal SideString JDBC Driver.
  ps_canceled       //= Note : This class will be loaded on the Database Server and hence use a
      "CANCELED";
   public static final String    ps_skipped        =    "SKIPPED";


   // StreamStatus Server Side JDBC Driver to get default Connection to Database

  Enumeration Constants:

   public static final String    ss_waiting    =   if (System.getProperty("java.vendor").toLowerCase().indexOf("oracle") != -1) {
 "WAITING";
   public static final String    ss_queued    =   // we're running as a stored procedure, connect locally:
    "QUEUED";
   public static final String    ss_running     =    connection = DriverManager.getConnection("jdbc:default:connection")"RUNNING";
   public static final String   } elsess_success {
   =     "SUCCESS";
    // we're running outside the DB, connect via standard oracle jdbc driver:public static final String    ss_failed    =    "FAILED";
   public static final String    ss_terminated    =  Class.forName("oracle.jdbc.driver.OracleDriver")  "TERMINATED";
   public static final String    ss_canceled   connection = DriverManager.getConnection("jdbc:oracle:thin:@glast-oracle02.slac.stanford.edu:1521:GLASTDEV","GLAST_DP_TEST","BT33%Q9]MU")   "CANCELED";
   public static final String   }

 ss_terminating    =    //
   "TERMINATING";
   public static final String    ss_canceling  //  Get= information about current stream"CANCELING";

   private static HashSet processingStates =  //


new HashSet();
   static {
     String currentStatus processingStates.add(ps_waiting);
      processingStates.add(ps_ready);
   PreparedStatement stmt = connectionprocessingStates.prepareStatementadd(ps_queued);
      processingStates.add(ps_submitted);
      processingStates.add(ps_running);
   "select * " + processingStates.add(ps_success);
         processingStates.add(ps_failed);
      "from Stream " +processingStates.add(ps_terminated);
      processingStates.add(ps_canceled);
      processingStates.add(ps_terminated);
   "where Stream = ? " processingStates.add(ps_skipped);
   }

   private static HashSet finalProcessingStates = new    HashSet();
   static {
      stmtfinalProcessingStates.setInt(1,streamadd(ps_terminated);
      finalProcessingStates.add(ps_canceled);
   rset  = stmtfinalProcessingStates.executeQueryadd(ps_success);
 // Execute the query, get Resultset finalProcessingStates.add(ps_failed);
         if (rset.next()) {
  finalProcessingStates.add(ps_skipped);
   }

   private static HashSet streamStates = new HashSet();
 currentStatus = rset.getString("STREAMSTATUS" static {
      streamStates.add(ss_waiting);
      streamStates.add(ss_queued);
      parentStream = rset.getInt("PARENTSTREAM"streamStates.add(ss_running);
      streamStates.add(ss_success);
    } else { streamStates.add(ss_failed);
      streamStates.add(ss_terminating);
      throw new SQLException("No such stream", "", invalid_stream_exstreamStates.add(ss_terminated);
      streamStates.add(ss_canceling);
      streamStates.add(ss_canceled);
   }

   private static HashSet finalStreamStates = new stmt.closeHashSet();

   static {
      //finalStreamStates.add(ss_terminated);
      finalStreamStates.add(ss_canceled);
   //  Get a count of the Processes in each state for this Stream: finalStreamStates.add(ss_success);
      finalStreamStates.add(ss_failed);
   }

   private static boolean allComplete(Map procStatMap,  //

Map streamStatMap) {
      for (Iterator i stmt = connectionprocessingStates.prepareStatementiterator(
  ); i.hasNext();) {
         String state   "select ProcessingStatus, count(ProcessingStatus) AS COUNT " +
= (String)i.next();
         int count = ((Integer)procStatMap.get(state)).intValue();
       "from ProcessInstance "if +
       ( !finalProcessingStates.contains(state) && (count != 0) )
        "where Stream = ? "return +false;
      }

      for (Iterator i "group by ProcessingStatus "= streamStates.iterator(); i.hasNext();) {
         String state = (String)i.next();
   );
      int count  stmt.setInt(1,stream= ((Integer)streamStatMap.get(state)).intValue();
         rsetif =( stmt!finalStreamStates.executeQuerycontains(state); // Execute the query, get Resultset
&& (count != 0) )
            return false;
      }

      return true;
   }

  Map procStatCountsprivate =static newboolean HashMap();
   all(String key, Map map) {
      int total = 0;
      for (Iterator i = processingStatesmap.values().iterator(); i.hasNext();) {
         total   procStatCounts.put((String+= ((Integer)i.next(), new Integer(0)).intValue();
         while (rset.next()) {}
            procStatCounts.put(rset.getString("PROCESSINGSTATUS"), new Integer(rset.getInt("COUNT")));
      return ((Integer)map.get(key)).intValue() == total;
   }

   private static boolean any(String key, Map stmt.close();

map) {
      return ((Integer)map.get(key)).intValue() != //0;
   }

   public static String //  Get a count of the sub-Streams in each state for this Stream:
calculateStreamStatus(int stream) throws ClassNotFoundException {
      String retVal = ss_waiting;
      Connection connection = null; //

 Database connection object
      stmtResultSet rset = connection.prepareStatement(null;
      int parentStream = 0;


      "select StreamStatus, count(StreamStatus) AS COUNT " +
try {
         // Get a Default Database Connection using Server Side JDBC Driver.
 "from Stream " +
     // Note : This class will be loaded on the "whereDatabase ParentStreamServer =and ?hence "use +a
         // Server Side JDBC Driver to "groupget bydefault StreamStatus"
Connection to Database

         if (System.getProperty("java.vendor").toLowerCase().indexOf("oracle") != -1) );{
         stmt.setInt(1, stream);
  // we're running as a stored procedure, rsetconnect = stmt.executeQuery();
locally:
           Map subStreamStatCountsconnection = new HashMap(DriverManager.getConnection("jdbc:default:connection");
         for} (Iteratorelse i{
 = streamStates.iterator(); i.hasNext();)
         // we're  subStreamStatCounts.put((String)i.next(), new Integer(0));
         while (rset.next()) {running outside the DB, connect via standard oracle jdbc driver:
            subStreamStatCountsClass.put(rset.getString("STREAMSTATUS"), new Integer(rset.getInt("COUNT")))forName("oracle.jdbc.driver.OracleDriver");
         }
   connection =     stmt.close();

         if (currentStatus == ss_terminating) {DriverManager.getConnection("jdbc:oracle:thin:@glast-oracle02.slac.stanford.edu:1521:GLASTDEV","GLAST_DP_TEST","BT33%Q9]MU");
         }

         //
   if  (allComplete(procStatCounts, subStreamStatCounts)) {
  //  Get information about current stream
       retVal = ss_terminated; //


         String currentStatus;
  } else {
     PreparedStatement stmt = connection.prepareStatement(
       retVal = ss_terminating;
      "select * " +
   }
         } else if (currentStatus == ss_canceling) {"from Stream " +
            if (allComplete(procStatCounts, subStreamStatCounts)) {
     "where Stream = ? "
             retVal = ss_canceled);
         stmt.setInt(1,stream);
   } else {
               retVal = ss_canceling;
            }rset = stmt.executeQuery(); // Execute the query, get Resultset
         } else if ( any(ps_running, procStatCounts) || any(ss_running, subStreamStatCounts) rset.next()) {
            retValcurrentStatus = ss_runningrset.getString("STREAMSTATUS");
         } else if ( any(ps_queued, procStatCounts) || any(ps_submitted, procStatCounts) || any(ss_queued, subStreamStatCounts) ) {
 parentStream = rset.getInt("PARENTSTREAM");
         } else {
            throw new SQLException("No such retVal = ss_queuedstream", "", invalid_stream_ex);
         }
    else if ( any(ps_waiting, procStatCounts) || any(ss_waiting, subStreamStatCounts) ) {
 stmt.close();

         //
     retVal = ss_waiting;
  //  Get a count of the }Processes elsein ifeach ( any(ps_failed, procStatCounts) || any(ss_failed, subStreamStatCounts) ) {
state for this Stream:
         //

       retVal  stmt = ss_failed;connection.prepareStatement(
         } else if ( all(ps_success, procStatCounts) && all(ss_success, subStreamStatCounts) ) {
 "select ProcessingStatus, count(ProcessingStatus) AS COUNT " +
           retVal = ss_success;
  "from ProcessInstance " +
    }

         stmt = connection.prepareStatement("updatewhere Stream set StreamStatus = ? " where+
 Stream = ?");
             "group by ProcessingStatus "
              stmt.setString(1,retVal );
         stmt.setInt(21,stream);
         rset = stmt.executeUpdateexecuteQuery();

 // Execute the query,     if (parentStream != 0)
get Resultset
         Map procStatCounts = new  calculateStreamStatusHashMap(parentStream);

        } catchfor (SQLException ex) { // Trap SQL Errors
Iterator i = processingStates.iterator(); i.hasNext();)
            procStatCounts.put((String)i.next(), new ex.printStackTraceInteger(0));
       } finally {
          trywhile (rset.next()) {
            if (connection != null || !connection.isClosed())procStatCounts.put(rset.getString("PROCESSINGSTATUS"), new Integer(rset.getInt("COUNT")));
         }
       connection  stmt.close();

   // Close the database connection
  //
         // } catch(SQLException ex){
              ex.printStackTrace();
Get a count of the sub-Streams in each state for this Stream:
         //

     }
    stmt =  }

connection.prepareStatement(
        return retVal;
   }
}

%ORACLE_HOME%\bin\loadjava -user=GLAST_DP_TEST/BT33%%Q9]MU@glast-oracle02.slac.stanford.edu:1521:GLASTDEV -verbose -force -resolve %project_base%\src\main\java\org\glast\pipeline\server\sql\sp\*.java

%ORACLE_HOME%\bin\dropjava -user "GLAST_DP_TEST/BT33%Q9]MU@glast-oracle02.slac.stanford.edu:1521:GLASTDEV" -verbose org.glast.pipeline.server.sql.sp.OraEnv 

set CLASSPATH=%ORACLE_HOME%\sqlj\lib\translator.jar;%ORACLE_HOME%\sqlj\lib\runtime12.jar;%ORACLE_HOME%\jdbc\lib\ojdbc14.jar;%ORACLE_HOME%\sqlj\lib\utl_dbws.jar;%ORACLE_HOME%\jdbc\lib\orai18n.jar;%ORACLE_HOME%\sqlj\runtime12ee.jar;%ORACLE_HOME%\jpub\lib\jpub.jar;%ORACLE_HOME%\sqlj\lib\sqljutl.jar

%ORACLE_HOME%\bin\jpub -user=glast_dp_test/BT33%%Q9]MU -url=jdbc:oracle:thin:@glast-oracle02.slac.stanford.edu:1521:GLASTDEV -java=org.glast.pipeline.server.sql.sp.* -package=org.glast.pipeline.server.sql.spclient -compile=false -dir=%project_base%\src\main\java\

package org.glast.pipeline.server.sql.spclient;

public class SPStream
{
   public SPStream(java.sql.Connection conn) throws java.sql.SQLException
   { m_ctx = new sqlj.runtime.ref.DefaultContext(conn); }
// MORE GENERATED CODE HERE <clipped>    public java.lang.String calculateStreamStatus(int p0)
      throws java.lang.ClassNotFoundException
   {

         Object __jRt_0 = null;
         try {
         __jRt_0 = oracle.jpub.reflect.Client.invoke(_context(),null, "org.glast.pipeline.server.sql.sp.SPStream","calculateStreamStatus","I",new Object[]{new java.lang.Integer(p0)});
      }
      catch (java.lang.ClassNotFoundException e) {
         throw e;
      }
      catch (Throwable e) {
         e.printStackTrace();
      }
         return (java.lang.String)__jRt_0;
   }
}

CREATE OR REPLACE PACKAGE SP_STREAM
AS
    -- Package-specific types:
    TYPE CURSOR IS REF CURSOR;

    -- public static String calculateStreamStatus(int stream)
    FUNCTION calculateStreamStatus(Stream_in IN number) RETURN varchar2;
END SP_STREAM;
/

CREATE OR REPLACE PACKAGE BODY SP_STREAM
AS
    FUNCTION calculateStreamStatus(Stream_in IN number) RETURN varchar2 IS
               LANGUAGE JAVA
               NAME 'org.glast.pipeline.server.sql.sp.SPStream.calculateStreamStatus(int) return java.lang.String';
END SP_STREAM;
/