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
      {
         streamStatesstmt.add(ss_terminatedsetInt(1, processInstance);
          streamStates.add(ss_cancelingstmt.setString(2, newProcessingStatus.toString());
        streamStates stmt.add(ss_canceled);
   }

setTimestamp(3, transitionTime);
   private static HashSet finalStreamStates = new HashSetstmt.execute();
     static {}
      finalStreamStates.add(ss_terminated);catch(SQLException x)
      finalStreamStates.add(ss_canceled);{
      finalStreamStates.add(ss_success);
   int errorCode = finalStreamStatesx.addgetErrorCode(ss_failed);
   }

    private static booleanif allComplete(Map procStatMap, Map streamStatMap) {
(errorCode == InvalidStatusTransitionException.errorCode)
          for (Iterator ithrow =new processingStates.iteratorInvalidStatusTransitionException(x); i.hasNext();) {

         else
          String state = (String)i.next()throw x;
      }
   int count = ((Integer)procStatMap.get(state)).intValue(); finally
      {
   if ( !finalProcessingStates.contains(state) && (count != 0) stmt.close();
      }
   }

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

   public static final forint (Iterator i = streamStates.iterator(); i.hasNext();) {
 invalid_stream_ex           String state = (String)i.next();
  =    -20026;

   int// countProcessingStatus = ((Integer)streamStatMap.get(state)).intValue();Enumeration Constants:

   public static final String    ifps_waiting ( !finalStreamStates.contains(state) && (count != 0) )
  "WAITING";
   public static final String    return false;
ps_ready       }

=      return true"READY";
   }

   private public static booleanfinal all(String key, Map map) {
 ps_queued     = int total = 0"QUEUED";
   public static final  for (Iterator i = map.values().iterator(); i.hasNext();) {String    ps_submitted    =    "SUBMITTED";
   public static final String   total += ((Integer)i.next()).intValue() ps_running      =    "RUNNING";
   public static final }
String    ps_success	  return ((Integer)map.get(key)).intValue() == total;
   }
"SUCCESS";
   privatepublic static booleanfinal any(String key, Map map) {
 ps_failed	   =   return ((Integer)map.get(key)).intValue() != 0;
   }

 "FAILED";
   public static final String calculateStreamStatus(int stream) throws ClassNotFoundExceptionps_terminated {
   =   String retVal = ss_waiting "TERMINATED";
   public static final ConnectionString connection = null; // Database connection object
 ps_canceled       =  ResultSet rset = null "CANCELED";
   public static final intString parentStream = 0;


  ps_skipped     try {
  =    "SKIPPED";


   // GetStreamStatus a Default Database Connection using Server Side JDBC Driver.
   Enumeration Constants:

   public static final String    ss_waiting    =  // Note :"WAITING";
 This class willpublic bestatic loadedfinal onString the Database Server andss_queued hence use a
 =    "QUEUED";
   public //static Serverfinal SideString JDBC Driver to getss_running default Connection to Database

=    "RUNNING";
   public static if (System.getProperty("java.vendor").toLowerCase().indexOf("oracle") != -1) {
final String    ss_success    =    "SUCCESS";
 // we're runningpublic asstatic afinal storedString procedure, connect locally:
 ss_failed         =  connection = DriverManager.getConnection("jdbc:default:connection")"FAILED";
   public static final String   } elsess_terminated {
   =    "TERMINATED";
   public static // we're running outside the DB, connect via standard oracle jdbc driver:final String    ss_canceled    =    "CANCELED";
   public static final String    ss_terminating    Class.forName("oracle.jdbc.driver.OracleDriver")=    "TERMINATING";
   public static final String    ss_canceling   connection = DriverManager.getConnection("jdbc:oracle:thin:@glast-oracle02.slac.stanford.edu:1521:GLASTDEV","GLAST_DP_TEST","BT33%Q9]MU");
         }

      "CANCELING";

   private static HashSet processingStates = new HashSet();
   static {
      //processingStates.add(ps_waiting);
      processingStates.add(ps_ready);
   //  Get information about current stream
    processingStates.add(ps_queued);
      processingStates.add(ps_submitted);
      //


processingStates.add(ps_running);
      processingStates.add(ps_success);
   String currentStatus   processingStates.add(ps_failed);
      processingStates.add(ps_terminated);
   PreparedStatement stmt = connectionprocessingStates.prepareStatementadd(ps_canceled);
      processingStates.add(ps_terminated);
      processingStates.add(ps_skipped);
   "select}

 * " +
private static HashSet finalProcessingStates = new HashSet();
   static {
     "from Stream " + finalProcessingStates.add(ps_terminated);
      finalProcessingStates.add(ps_canceled);
      finalProcessingStates.add(ps_success);
   "where Stream = ? " finalProcessingStates.add(ps_failed);
      finalProcessingStates.add(ps_skipped);
         );}

   private static HashSet streamStates = new stmt.setInt(1,streamHashSet();
   static  {
    rset = stmtstreamStates.executeQueryadd(ss_waiting);
 // Execute the query, get Resultset streamStates.add(ss_queued);
         if (rset.next()) {streamStates.add(ss_running);
      streamStates.add(ss_success);
      currentStatus = rset.getString("STREAMSTATUS"streamStates.add(ss_failed);
      streamStates.add(ss_terminating);
      parentStream = rset.getInt("PARENTSTREAM"streamStates.add(ss_terminated);
      streamStates.add(ss_canceling);
   }  else { streamStates.add(ss_canceled);
   }

   private static HashSet finalStreamStates   throw= new SQLException("No such stream", "", invalid_stream_ex);HashSet();
   static {
      finalStreamStates.add(ss_terminated);
   }
   finalStreamStates.add(ss_canceled);
      stmtfinalStreamStates.closeadd(ss_success);

      finalStreamStates.add(ss_failed);
   //}

   private static boolean allComplete(Map procStatMap, Map //streamStatMap) {
 Get a count of the Processesfor in(Iterator eachi state for this Stream:
= processingStates.iterator(); i.hasNext();) {
         String  //

state = (String)i.next();
         stmtint count = connection.prepareStatement(((Integer)procStatMap.get(state)).intValue();
         if ( !finalProcessingStates.contains(state) && (count  "select ProcessingStatus, count(ProcessingStatus) AS COUNT " +!= 0) )
               "from ProcessInstance " +return false;
      }

      for (Iterator  "wherei Stream = ? " +streamStates.iterator(); i.hasNext();) {
         String state   = (String)i.next();
  "group by ProcessingStatus "
    int count          = ((Integer)streamStatMap.get(state)).intValue();
         stmt.setInt(1,stream);
    if ( !finalStreamStates.contains(state) && (count != 0) )
     rset = stmt.executeQuery(); // Execute the query, getreturn Resultsetfalse;
      }

   Map procStatCounts = newreturn HashMap()true;
   }

   private static boolean all(String key, Map map) {
      int total = 0;
      for (Iterator i = processingStatesmap.values().iterator(); i.hasNext();) {
         total +=  procStatCounts.put((StringInteger)i.next(), new Integer(0)))).intValue();
      }
    while  return (rset.next()) {(Integer)map.get(key)).intValue() == total;
   }

   private static boolean any(String key,  procStatCounts.put(rset.getString("PROCESSINGSTATUS"), new Integer(rset.getInt("COUNT")))Map map) {
      return ((Integer)map.get(key)).intValue() != 0;
   }

   public static String }
    calculateStreamStatus(int stream) throws ClassNotFoundException {
     stmt.close();

     String retVal = ss_waiting;
     //
 Connection connection =    null;  // Database Getconnection aobject
 count of the sub-Streams in eachResultSet staterset for this Stream:= null;
      int parentStream = //0;


      try {
  stmt = connection.prepareStatement(
     // Get a Default Database Connection using Server Side JDBC "select StreamStatus, count(StreamStatus) AS COUNT " +
Driver.
         // Note : This class will be loaded on the Database Server "fromand Streamhence "use +a
         // Server Side JDBC Driver to "whereget ParentStreamdefault =Connection ? " +to Database

               "group by StreamStatus"
  if (System.getProperty("java.vendor").toLowerCase().indexOf("oracle") != -1) {
             );
         stmt.setInt(1, stream);
// we're running as a stored procedure, connect locally:
            rsetconnection = stmtDriverManager.executeQuery(getConnection("jdbc:default:connection");
         Map} subStreamStatCounts = new HashMap();else {
         for (Iterator i = streamStates.iterator(); i.hasNext();)
            subStreamStatCounts.put((String)i.next(), new Integer(0));
// we're running outside the DB, connect via standard oracle jdbc driver:
              while (rset.next()) {
Class.forName("oracle.jdbc.driver.OracleDriver");
            connection = subStreamStatCountsDriverManager.put(rset.getString("STREAMSTATUS"), new Integer(rset.getInt("COUNT")))getConnection("jdbc:oracle:thin:@glast-oracle02.slac.stanford.edu:1521:GLASTDEV","GLAST_DP_TEST","BT33%Q9]MU");
         }

         stmt.close();

//
         //  ifGet (currentStatusinformation == ss_terminating) {about current stream
         //


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

         }//
 else if ( any(ps_queued, procStatCounts) || any(ps_submitted, procStatCounts) || any(ss_queued, subStreamStatCounts) ) {
            retVal = ss_queued;
    //  Get a count of the Processes in each state for this Stream:
         //

     } else if ( any(ps_waiting, procStatCounts) || any(ss_waiting, subStreamStatCounts) ) {
 stmt = connection.prepareStatement(
               retVal = ss_waiting;"select ProcessingStatus, count(ProcessingStatus) AS COUNT " +
         }    else if ( any(ps_failed, procStatCounts) || any(ss_failed, subStreamStatCounts) ) {
"from ProcessInstance " +
               "where retValStream = ss_failed; ? " +
         } else if ( all(ps_success, procStatCounts) && all(ss_success, subStreamStatCounts) ) {
"group by ProcessingStatus "
             retVal = ss_success);
         }

stmt.setInt(1,stream);
         stmtrset = connectionstmt.prepareStatement("update Stream set StreamStatus = ? where Stream = ?");
executeQuery(); // Execute the query, get Resultset
         Map procStatCounts = new stmt.setString(1,retValHashMap();
         stmt.setInt(2,stream);
         stmt.executeUpdate();

for (Iterator i = processingStates.iterator(); i.hasNext();)
           if (parentStream != 0) procStatCounts.put((String)i.next(), new Integer(0));
            calculateStreamStatus(parentStream);

 while (rset.next()) {
      } catch (SQLException ex) { // Trap SQL Errors procStatCounts.put(rset.getString("PROCESSINGSTATUS"), new Integer(rset.getInt("COUNT")));
          ex.printStackTrace();}
       } finally { stmt.close();

          try{//
         //  Get ifa (connectioncount !=of null || !connection.isClosed())
     the sub-Streams in each state for this Stream:
         //

         stmt = connection.closeprepareStatement();
   // Close the database connection
        "select StreamStatus, count(StreamStatus) AS }COUNT catch(SQLException ex){
" +
               "from Stream  ex.printStackTrace();
" +
             }
  "where ParentStream = ? " }+

         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

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