PersistentState.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:5k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.contrib.failmon;
  19. import java.util.Properties;
  20. import java.util.Calendar;
  21. import java.io.FileInputStream;
  22. import java.io.FileOutputStream;
  23. import java.io.FileNotFoundException;
  24. import java.io.IOException;
  25. /**********************************************************
  26.  * This class takes care of the information that needs to be
  27.  * persistently stored locally on nodes. Bookkeeping is done for the
  28.  * state of parsing of log files, so that the portion of the file that
  29.  * has already been parsed in previous calls will not be parsed again.
  30.  * For each log file, we maintain the byte offset of the last
  31.  * character parsed in previous passes. Also, the first entry in the
  32.  * log file is stored, so that FailMon can determine when a log file
  33.  * has been rotated (and thus parsing needs to start from the
  34.  * beginning of the file). We use a property file to store that
  35.  * information. For each log file we create a property keyed by the
  36.  * filename, the value of which contains the byte offset and first log
  37.  * entry separated by a SEPARATOR.
  38.  * 
  39.  **********************************************************/
  40. public class PersistentState {
  41.   private final static String SEPARATOR = "###";
  42.   
  43.   static String filename;
  44.   static Properties persData = new Properties();
  45.   
  46.   /**
  47.    * Read the state of parsing for all open log files from a property
  48.    * file.
  49.    * 
  50.    * @param fname the filename of the property file to be read
  51.    */
  52.   public static void readState(String fname) {
  53.     filename = fname;
  54.     
  55.     try {
  56.       persData.load(new FileInputStream(filename));
  57.     } catch (FileNotFoundException e1) {
  58.       // ignore
  59.     } catch (IOException e) {
  60.       e.printStackTrace();
  61.     }
  62.   }
  63.    /**
  64.    * Read and return the state of parsing for a particular log file.
  65.    * 
  66.    * @param fname the log file for which to read the state
  67.    */
  68.   public static ParseState getState(String fname) {
  69.     String [] fields = persData.getProperty(fname, "null" + SEPARATOR + "0").split(SEPARATOR, 2);
  70.     String firstLine;
  71.     long offset;
  72.     
  73.     if (fields.length < 2) {
  74.       System.err.println("Malformed persistent state data found");
  75.       Environment.logInfo("Malformed persistent state data found");
  76.       firstLine = null;
  77.       offset = 0;
  78.     } else {
  79.       firstLine = (fields[0].equals("null") ? null : fields[0]);
  80.       offset = Long.parseLong(fields[1]);
  81.     }
  82.     return new ParseState(fname, firstLine, offset);
  83.   }
  84.   /**
  85.    * Set the state of parsing for a particular log file.
  86.    * 
  87.    * @param state the ParseState to set
  88.    */
  89.   public static void setState(ParseState state) {
  90.     if (state == null) {
  91.       System.err.println("Null state found");
  92.       Environment.logInfo("Null state found");
  93.     }
  94.     persData.setProperty(state.filename, state.firstLine + SEPARATOR + state.offset);
  95.   }
  96.   /**
  97.    * Upadate the state of parsing for a particular log file.
  98.    * 
  99.    * @param filename the log file for which to update the state
  100.    * @param firstLine the first line of the log file currently
  101.    * @param offset the byte offset of the last character parsed
  102.    */ 
  103.   public static void updateState(String filename, String firstLine, long offset) {
  104.     ParseState ps = getState(filename);
  105.     if (firstLine != null)
  106.       ps.firstLine = firstLine;
  107.     ps.offset = offset;
  108.     setState(ps);
  109.   }
  110.   /**
  111.    * Write the state of parsing for all open log files to a property
  112.    * file on disk.
  113.    * 
  114.    * @param fname the filename of the property file to write to
  115.    */
  116.   public static void writeState(String fname) {
  117.     try {
  118.       persData.store(new FileOutputStream(fname), Calendar.getInstance().getTime().toString());
  119.     } catch (FileNotFoundException e1) {
  120.       e1.printStackTrace();
  121.     } catch (IOException e) {
  122.       e.printStackTrace();
  123.     }
  124.   }
  125.   
  126. }
  127. /**********************************************************
  128.  * This class represents the state of parsing for a particular log
  129.  * file.
  130.  * 
  131.  **********************************************************/
  132. class ParseState {
  133.   public String filename;
  134.   public String firstLine;
  135.   public long offset;
  136.   public ParseState(String _filename, String _firstLine, long _offset) {
  137.     this.filename = _filename;
  138.     this.firstLine = _firstLine;
  139.     this.offset = _offset;
  140.   }
  141. }