Subversion Repositories DevTools

package com.erggroup.buildtool.ripple;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.erggroup.buildtool.smtp.CreateUrls;
import com.erggroup.buildtool.smtp.Smtpsend;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;

/**entity class holding build exclusion data
 */
public class BuildExclusion
{
  /**Logger
   * @attribute
   */
  private static final Logger mLogger = LoggerFactory.getLogger(BuildExclusion.class);

  /**The pvid of the package being excluded
   * @attribute
   */
  private 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
   * @attribute
   */
  private int mRootId;

  /**root cause
   * If not NULL, then this is the reason this package is being excluded
   * @attribute
   */
  private String mRootCause;

  /**test build instruction
   * @attribute
   */
  private int mTestBuildInstruction;

  /**Indicates that the item has been processed
   * @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
   *  Really only applied to indirect exclusions where the reason for the exclusion no longer exists
   *  
   */
  private boolean mImported = false;

  /**constructor
   *    @param  identifier - pvid of the package being excluded
   *    @param  rootIdentifier  - pvid of the root package causing the exclusion. May be null
   *    @param  rootCause - Short (< 50 Char) string explaining the cause
   *    @param  testBuildInstruction - Indicates a text build instruction
   */
  public BuildExclusion(int identifier, int rootIdentifier, String rootCause, int testBuildInstruction )
  {
    mLogger.debug("BuildExclusion");
    mId = identifier;
    mRootId = dealWithNullRootPvId(identifier, rootIdentifier);
    mRootCause = rootCause;
    mTestBuildInstruction = testBuildInstruction;
  }

  /**sets mProcessed true
   */
  void setProcessed()
  {
    mLogger.debug("process {}", mId);
    mProcessed = true;
  }

  /** @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);
    return mProcessed;
  }
  
  /** Flag as an imported entry
   *  Used to detect indirect exclusions that are no longer valid
   */
  void setImported()
  {
      mImported = true;
  }

  /** Test the state of the imported flag
   * 
   */
  boolean isImported()
  {
      return mImported;
  }
  
  /**
   * 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
   */
  boolean compare( int identifier, int rootIdentifier, String rootCause)
  {
    mLogger.debug("compare {}, {}, {}, {}", mId, identifier, rootIdentifier,  rootCause);
    boolean retVal = false;
    rootIdentifier = dealWithNullRootPvId(identifier, rootIdentifier);
    
    if ( mRootCause == null )
    {
      if ( mId == identifier && mRootId == rootIdentifier && rootCause == null )
      {
        retVal = true;
      }
    }
    else
    {
      if ( mId == identifier && mRootId == rootIdentifier && mRootCause.compareTo(rootCause) == 0 )
      {
        retVal = true;
      }
    }
    
    mLogger.info("compare returned {}", retVal);
    return retVal;
  }
  
  /**
   * @param identifier  - identifier to match
   * @return true if mId attribute matches
   */
  boolean compare( int identifier )
  {
    mLogger.debug("compare {},{}", mId,  identifier);
    boolean retVal = false;
    
    if ( mId == identifier )
    {
      retVal = true;
    }
    
    mLogger.info("compare returned {}", retVal);
    return retVal;
  }
  
  /**runs exclude from build
   * Assumes that a connection to RM has been established
   * 
   * @param rm          Release Manager instance
   * @param rtagId      Rtag Id we are working against
   */
  void excludeFromBuild( ReleaseManager rm, int rtagId ) throws SQLException, Exception
  {
    mLogger.debug("excludeFromBuild {}", mId);
    
    // a null version and log file is passed to oracle
    // the planned version is only needed to remove a planned version from the planned version table
    // the ripple engine does not get this far ie it excludes pvs before claiming a version
    // this is the one instance where an existing build failure must be superseded in the database
    rm.excludeFromBuild(true, 
                        mId, 
                        null, 
                        rtagId, 
                            mRootId == -1 ? null : String.valueOf(mRootId), 
                            mRootCause, 
                            null, 
                            true, (mTestBuildInstruction > 0) );
  }
  
  /**runs include to build
   * Include a previously excluded package-version back into the build set
   * 
   * @param rm          Release Manager instance
   * @param rtagId      Rtag Id we are working against
   */
  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
   *     the root cause of the exclusion has been removed.
   *     
   * @param buildExclusionCollection - Collection to be processed
   * @return false: Indirectly excluded package whose root cause no longer exists
   */
  boolean isRelevant(ArrayList<BuildExclusion> buildExclusionCollection)
  {
    mLogger.debug("isRelevant {}", mId);
    boolean retVal = false;
    
    if ( mRootId == -1 )     {
      retVal = true;
      
    } else if(mRootId == -2 ) {
        // Excluded due to Ripple Stop
        // Will be recalculated so its not relevant
        retVal = false;
        
    } else {
        
      retVal = false;
      for (Iterator<BuildExclusion> it = buildExclusionCollection.iterator(); it.hasNext(); )
      {
        BuildExclusion buildExclusion = it.next();
        
        if ( buildExclusion.isRelevant( 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
   * 
   * i.e. only send email if the build exclusion has a null root pv id
   * and a non null root cause
   * 
   * @param    rippleEngine        - Ripple Engine Instance
   * @param    packageCollection   - Collection to process
   */
    public void email(RippleEngine rippleEngine, ArrayList<Package> packageCollection) throws SQLException, Exception
    {
      mLogger.debug("email {}", mId);
      
      //
      //    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 )
      {
        //  Locate the associated package entry
        Package pkg= rippleEngine.mReleaseManager.findPackage(mId, packageCollection);
        
        if ( pkg != ReleaseManager.NULL_PACKAGE )
        {

          // Is there anyone to send an email to
          String owners = pkg.emailInfoNonAntTask(rippleEngine);
          
          if ( owners != null )
          {
              
            String body =
            "Release: " + rippleEngine.mBaselineName + "<p>" +
            "Package: " + pkg.mName + "<p>" + 
            "Cause: "   + mRootCause + "<p>"+
            "RmRef: "   + CreateUrls.generateRmUrl(rippleEngine.getRtagId(), pkg.mId) +"<p>";
            
            try
            {
              Smtpsend.send(
              rippleEngine.getMailServer(),             // mailServer
              rippleEngine.getMailSender(),             // source
              owners,                                   // target
              null,                                     // cc
              null,                                     // bcc
              "BUILD FAILURE on package " + pkg.mName,  // subject
              body,                                     // body
              null                                      // attachment
              );
            }
            catch( Exception e )
            {
                mLogger.info("email send exception. {}", e);
            }
          }
          
          // Having sent the build failure email, complete a test build if applicable.
          // This ensures the test build instruction is not processed indefinitely
          // as there is no notion of excluding test builds
          pkg.completeTestBuild(rippleEngine, false);
        }
      }
    }
    
    /**
     * Hides how a rootPvId is treated
     * Only use rootPvId if not equal to the pvid
     * 
     * If the provided rootPvId matches the pvId, then the rootPvId will be set to null (-1)
     * This is to drive a direct build exclusion in the release manager
     * 
     * @param   pvid        - id
     * @param   rootPvId    - rootPvid
     * 
     * @returns rootPvId unless pvId matches= rootPvId, when it returns a null (-1)
    */
    private int dealWithNullRootPvId( int pvId, int rootPvId )
    {
      int retVal = rootPvId;
      
      if ( pvId == rootPvId )
      {
        retVal = -1;    // -1 == null entry
      }
      
      return retVal;
    }

    /**
     * Generate a single text line of info
     * Used within the UTF to 
     * @return String form of the state of the entry
     */
    public String info()
    {
        String rv = "";
        rv += "pvid=" + mId + ",RootId=" + mRootId + ",Processed=" + mProcessed + ",TestBuild=" + mTestBuildInstruction + ",RootCause=" + mRootCause;
        if ( mImported ) {
            rv += ",Imported=" + mImported;
        }
        return rv;
    }
}