package net.sf.logdistiller.logtypes;
   
   /*
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  import java.io.*;
  import java.text.SimpleDateFormat;
  import java.text.DateFormat;
  import java.text.ParseException;
  import java.util.Date;
  import java.util.Locale;
  import java.util.regex.Pattern;
  
  import net.sf.logdistiller.LogEvent;
  import net.sf.logdistiller.LogType;
  
  /**
   * Oracle Database's <code>alert.log</code> file parser. A typical rule configuration with such log files is:
   *
   * <pre>
   * &lt;group id=&quot;ORA&quot;&gt;
   *  &lt;description&gt;ORA-* messages&lt;/description&gt;
   *  &lt;condition&gt;
   *    &lt;match attribute=&quot;message&quot; type=&quot;contains&quot;&gt;ORA-&lt;/match&gt;
   *  &lt;/condition&gt;
   *  &lt;plugin type=&quot;sampling&quot;&gt;
   *    &lt;param name=&quot;attribute&quot;&gt;message&lt;/param&gt;
   *    &lt;param name=&quot;regexp&quot;&gt;(ORA-\d+)&lt;/param&gt;
   *  &lt;/plugin&gt;
   * lt;/group&gt;
   * </pre>
   *
   * By default, the classification rules generated by the GUI for this type of logs:
   * <ol>
   * <li>will contain a such "ORA" group for events with an ORA- id</li>
   * <li>but won't be able to sort other events, as the log event structure is too generic (the message has no specific
   * format).</li>
   * </ol>
   *
   * @since 0.9
   */
  public class OracleAlertLogEvent
      extends LogEvent
      implements Comparable
  {
      public final static String ID = "oracle-alert";
  
      public final String timestamp;
  
      public final Date date;
  
      public final String message;
  
      public final static LogType LOGTYPE = new LogType.Basic( ID );
  
      private final static DateFormat DATE_FORMAT = new SimpleDateFormat( "EEE MMM dd HH:mm:ss yyyy", Locale.US );
  
      private final static String[] ATTRIBUTE_NAMES =
          { "logSource", "timestamp", "timestamp.day", "timestamp.time", "message" };
  
      public final static LogType.Description DESCRIPTION = new Description( (LogType.Basic) LOGTYPE, ATTRIBUTE_NAMES );
  
      public OracleAlertLogEvent( Factory factory, String firstLine, String message )
          throws ParseException
      {
          super( factory, firstLine + Factory.NEWLINE + message );
          timestamp = firstLine;
          date = DATE_FORMAT.parse( timestamp );
          this.message = message;
          setAttributes( new String[] { factory.getLogSource(), timestamp,
              timestamp.substring( 0, 10 ) + timestamp.substring( 19, 24 ), timestamp.substring( 11, 19 ), message } );
      }
  
      public int compareTo( Object o )
      {
          return date.compareTo( ( (OracleAlertLogEvent) o ).date );
      }
  
      private static class Description
          extends LogType.Description
      {
          public Description( LogType.Basic logtype, String[] attributeNames )
          {
              super( logtype, attributeNames );
              logtype.setDescription( this );
          }
  
          public LogEvent.Factory newFactory( Reader reader, String logSource )
             throws IOException
         {
             return new Factory( this, reader, logSource );
         }
 
         public String getDefaultSpecificGroups()
         {
             return "  <group id=\"ORA\">\n"
                 + "    <description>ORA-* messages</description>\n"
                 + "    <condition>\n"
                 + "      <match attribute=\"message\" type=\"contains\">ORA-</match>\n"
                 + "    </condition>\n"
                 + "    <report publisher=\"file\"/>\n"
                 + "    <plugin type=\"sampling\">\n"
                 + "      <param name=\"attribute\">message</param>\n"
                 + "      <param name=\"regexp\">(ORA-\\d+)</param>\n"
                 + "    </plugin>\n"
                 + "  </group>";
         }
     }
 
     private static class Factory
         extends LogEvent.Factory
     {
         private final LineNumberReader reader;
 
         private String curLine;
 
         private final static Pattern DATE_PATTERN =
             Pattern.compile( "\\w{3} \\w{3} \\d{2} \\d{2}:\\d{2}:\\d{2} \\d{4}" );
 
         public Factory( Description description, Reader reader, String logSource )
             throws FileNotFoundException
         {
             super( description, logSource );
             this.reader = new LineNumberReader( reader );
         }
 
         /**
          * Detect the start of a new log event
          */
         protected boolean detectLogEventStart( String line )
         {
             return DATE_PATTERN.matcher( line ).matches();
         }
 
         protected LogEvent readNextEvent()
             throws IOException, ParseException
         {
             if ( curLine == null )
             {
                 curLine = reader.readLine();
                 if ( curLine == null )
                 {
                     // EOF
                     return null;
                 }
                 // beginning of log file does not start with a complete log event with timestamp
                 while ( !detectLogEventStart( curLine ) )
                 {
                     curLine = reader.readLine();
                     if ( curLine == null )
                     {
                         // EOF
                         return null;
                     }
                 }
             }
             String firstLine = curLine;
             StringBuffer buffer = new StringBuffer();
             while ( ( ( curLine = reader.readLine() ) != null ) && ( !detectLogEventStart( curLine ) ) )
             {
                 if ( buffer.length() > 0 )
                 {
                     buffer.append( NEWLINE );
                 }
                 buffer.append( curLine );
             }
             return new OracleAlertLogEvent( this, firstLine, buffer.toString() );
         }
     }
 }