WebSVN – DevTools – Diff – /buildtool/branches/planMetrics2/src/main/java/com/erggroup/buildtool/ripple/BuildExclusion.java

 import java.util.Iterator;
 /**entity class holding build exclusion data
+ *
  * There are three types of exclusion
- * Errors detected during planing. They may go away on the next plan
+ * Package Errors. Errors detected during planing. They may go away on the next plan
  *      These are 'hard' errors
  *          Have a rootCase string
  *          Have a null rootId
+ *
  * Build Errors
    * @attribute
    */
   private static final Logger mLogger = LoggerFactory.getLogger(BuildExclusion.class);
   /**The pvid of the package being excluded
-   * @attribute
    */
   public int mId;
   /**root identifier is the PVID of the package that is causing the exclusion
-   * A NULL value indicates that this entry(package) is the root cause of the of an exclusion
+   * A NULL (-1) value indicates that this entry(package) is the root cause of the of an exclusion
-   * @attribute
+   * A Value of -2 indicates that cause is a RippleStop
    */
-  public int mRootId;
+  private int mRootId;
   /**root cause
    * If not NULL, then this is the reason this package is being excluded
-   * @attribute
    */
-  public String mRootCause;
+  private String mRootCause;
   /**test build instruction
-   * @attribute
+   * Associated package is a test build
    */
   private int mTestBuildInstruction;
-  /**Indicates that the item has been processed
+  /** Indicates that the error associated with this package has been seen again
+   *  Set if we discover 'Package Error'
+   *
+   *  Used to determine if a 'Package Error' should be removed
-   * @attribute
+   *
    */
   private boolean mProcessed = false;
   /** Indicates that the entry was imported from the database
    *  Used to determine entries that are no-longer needed and can be removed from the database
   /** @returns true if the item has been marked as processed.
    * Appears to be an indication that the entry has been superseded.
    */
   boolean isProcessed()
+  {
-    mLogger.debug("isProcessed {}", mId);
-    mLogger.info("isProcessed returned {}", mProcessed);
+    mLogger.debug("isProcessed returned {}", mProcessed);
     return mProcessed;
+  }
   /** Flag as an imported entry
    *  Used to detect indirect exclusions that are no longer valid
+  {
       return mImported;
+  }
   /**
+   * Determine the entry type
+   * Have three types - see class comments above
+   */
+  boolean isAPackageError()
+  {
+      return (mRootCause != null && mRootId < 0);
+  }
+  boolean isABuildError()
+  {
+      return (mRootCause == null && mRootId < 0);
+  }
+  boolean isAIndirectError()
+  {
+      return (mRootId >= 0);
+  }
+  /**
+   * @return true if this item is the root case, and is not simply a by product of some other cause.
+   * This is the same as !isAIndirectError()
+   */
+  boolean isARootCause()
+  {
+    boolean retVal = false;
+    if ( mRootId == -1 )
+    {
+      retVal = true;
+    }
+    mLogger.info("isARootCause {} returned {}",mId, retVal);
+    return retVal;
+  }
+  /**
    * Compare this item with parameters
    * @param identifier          - Related Package identifier
    * @param rootIdentifier      - Package identifier of root cause
    * @param  rootCause          - Root cause string. May be null
    * @return true if all attributes match
     mLogger.info("compare returned {}", retVal);
     return retVal;
+  }
+  /**   Does this entry relate to the package with a specified mId
-  /**
+   *
-   * @param identifier  - identifier to match
+   * @param identifier  - Package Identifier (mId) to match
    * @return true if mId attribute matches
    */
   boolean compare( int identifier )
+  {
     mLogger.debug("compare {},{}", mId,  identifier);
   void includeToBuild( ReleaseManager rm, int rtagId ) throws SQLException, Exception
+  {
     mLogger.debug("includeToBuild {}", mId);
     rm.includeToBuild(mId, rtagId);
+  }
-  /**
-   * Match this items id against that provided
-   * @param id  - Id to match
-   * @return true if id matches mId
-   */
-    private boolean isRelevant(int id)
-    {
-      mLogger.debug("isRelevant {},{}", mId, id);
-      boolean retVal = false;
-      if ( mId == id )
-      {
-        retVal = true;
-      }
-      mLogger.info("isRelevant {},{}, returned {}",  mId,  id, retVal);
-      return retVal;
-    }
   /**
    * Match this items mRootId against the id's provided in a collection
    * ie: Determine if any items in the collection are the root cause of this items
    * ie: Used to determine if an entry is for an indirectly excluded package where
+  {
     mLogger.debug("isRelevant {}", mId);
     boolean retVal = false;
     if ( mRootId == -1 )     {
+        // This is a Build or Package Error
-      retVal = true;
+        retVal = true;
     } else if(mRootId == -2 ) {
         // Excluded due to Ripple Stop
         // Will be recalculated so its not relevant
         retVal = false;
     } else {
+        //
+        //  Must be an indirect exclusion
+        //  Scan to see if the rootCause is still present. It may have been removed by the user
       retVal = false;
       for (Iterator<BuildExclusion> it = buildExclusionCollection.iterator(); it.hasNext(); )
+      {
         BuildExclusion buildExclusion = it.next();
-        if ( buildExclusion.isRelevant( mRootId ) )
+        if ( buildExclusion.mRootId == mRootId )
+        {
           retVal = true;
           break;
+        }
+      }
     mLogger.info("isRelevant {} returned {}", mId, retVal);
     return retVal;
+  }
-  /**
-   * @return true if the root_pv_id is null (-1). This indicates that the item is the root case, and is not simply
-   *         a by product of some other cause.
-   */
-  boolean isARootCause()
-  {
-    mLogger.debug("isARootCause {}", mId);
-    boolean retVal = false;
-    if ( mRootId == -1 )
-    {
-      retVal = true;
-    }
-    mLogger.info("isARootCause {} returned {}",mId, retVal);
-    return retVal;
-  }
   /**
    * Send an email notifying users about a build excluded package
    * It is user friendly, in that it does not trigger a storm of emails because a low level package
    * has a build issue. It limits the emails to the low level package
       //    Only process entries that are direct failures of ripple engine detected failure
       //    Do not process entries that are indirectly excluded as this will cause an email storm
       //    Direct build failure:
       //        Have no RootId and have a rootCause
       //
-      if ( mRootId == -1 && mRootCause != null )
+      if ( isAPackageError() )
+      {
         //  Locate the associated package entry
         Package pkg= rippleEngine.mReleaseManager.findPackage(mId, packageCollection);
         if ( pkg != ReleaseManager.NULL_PACKAGE )
       return retVal;
+    }
     /**
      * Generate a single text line of info
-     * Used within the UTF to
+     * Used within the UTF to display diagnostic info
      * @return String form of the state of the entry
      */
-    public String info()
+    public String toString()
+    {
         String rv = "";
         rv += "pvid=" + mId + ",RootId=" + mRootId + ",Processed=" + mProcessed + ",TestBuild=" + mTestBuildInstruction + ",RootCause=" + mRootCause;
         if ( mImported ) {
             rv += ",Imported=" + mImported;

Subversion Repositories DevTools

(root)/buildtool/branches/planMetrics2/src/main/java/com/erggroup/buildtool/ripple/BuildExclusion.java – Rev 7080 → 7081