View Javadoc

1   /**
2    *
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *     http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing, software
14   * distributed under the License is distributed on an "AS IS" BASIS,
15   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   * See the License for the specific language governing permissions and
17   * limitations under the License.
18   */
19  
20  package org.apache.hadoop.hbase.regionserver.wal;
21  
22  import java.io.FilterInputStream;
23  import java.io.IOException;
24  import java.lang.reflect.Field;
25  import java.lang.reflect.Method;
26  import java.util.NavigableMap;
27  
28  import org.apache.commons.logging.Log;
29  import org.apache.commons.logging.LogFactory;
30  import org.apache.hadoop.classification.InterfaceAudience;
31  import org.apache.hadoop.conf.Configuration;
32  import org.apache.hadoop.fs.FSDataInputStream;
33  import org.apache.hadoop.fs.FileSystem;
34  import org.apache.hadoop.fs.Path;
35  import org.apache.hadoop.hbase.HBaseInterfaceAudience;
36  import org.apache.hadoop.hbase.regionserver.wal.HLog.Entry;
37  import org.apache.hadoop.io.SequenceFile;
38  import org.apache.hadoop.io.SequenceFile.Metadata;
39  import org.apache.hadoop.io.Text;
40  
41  @InterfaceAudience.LimitedPrivate({HBaseInterfaceAudience.COPROC, HBaseInterfaceAudience.PHOENIX, HBaseInterfaceAudience.CONFIG})
42  public class SequenceFileLogReader extends ReaderBase {
43    private static final Log LOG = LogFactory.getLog(SequenceFileLogReader.class);
44  
45    // Legacy stuff from pre-PB WAL metadata.
46    private static final Text WAL_VERSION_KEY = new Text("version");
47    // Let the version be 1.  Let absence of a version meta tag be old, version 0.
48    // Set this version '1' to be the version that introduces compression,
49    // the COMPRESSION_VERSION.
50    private static final int COMPRESSION_VERSION = 1;
51    private static final Text WAL_COMPRESSION_TYPE_KEY = new Text("compression.type");
52    private static final Text DICTIONARY_COMPRESSION_TYPE = new Text("dictionary");
53  
54    /**
55     * Hack just to set the correct file length up in SequenceFile.Reader.
56     * See HADOOP-6307.  The below is all about setting the right length on the
57     * file we are reading.  fs.getFileStatus(file).getLen() is passed down to
58     * a private SequenceFile.Reader constructor.  This won't work.  Need to do
59     * the available on the stream.  The below is ugly.  It makes getPos, the
60     * first time its called, return length of the file -- i.e. tell a lie -- just
61     * so this line up in SF.Reader's constructor ends up with right answer:
62     *
63     *         this.end = in.getPos() + length;
64     *
65     */
66    private static class WALReader extends SequenceFile.Reader {
67  
68      WALReader(final FileSystem fs, final Path p, final Configuration c)
69      throws IOException {
70        super(fs, p, c);
71      }
72  
73      @Override
74      protected FSDataInputStream openFile(FileSystem fs, Path file,
75        int bufferSize, long length)
76      throws IOException {
77        return new WALReaderFSDataInputStream(super.openFile(fs, file,
78          bufferSize, length), length);
79      }
80  
81      /**
82       * Override just so can intercept first call to getPos.
83       */
84      static class WALReaderFSDataInputStream extends FSDataInputStream {
85        private boolean firstGetPosInvocation = true;
86        private long length;
87  
88        WALReaderFSDataInputStream(final FSDataInputStream is, final long l)
89        throws IOException {
90          super(is);
91          this.length = l;
92        }
93  
94        // This section can be confusing.  It is specific to how HDFS works.
95        // Let me try to break it down.  This is the problem:
96        //
97        //  1. HDFS DataNodes update the NameNode about a filename's length
98        //     on block boundaries or when a file is closed. Therefore,
99        //     if an RS dies, then the NN's fs.getLength() can be out of date
100       //  2. this.in.available() would work, but it returns int &
101       //     therefore breaks for files > 2GB (happens on big clusters)
102       //  3. DFSInputStream.getFileLength() gets the actual length from the DNs
103       //  4. DFSInputStream is wrapped 2 levels deep : this.in.in
104       //
105       // So, here we adjust getPos() using getFileLength() so the
106       // SequenceFile.Reader constructor (aka: first invocation) comes out
107       // with the correct end of the file:
108       //         this.end = in.getPos() + length;
109       @Override
110       public long getPos() throws IOException {
111         if (this.firstGetPosInvocation) {
112           this.firstGetPosInvocation = false;
113           long adjust = 0;
114 
115           try {
116             Field fIn = FilterInputStream.class.getDeclaredField("in");
117             fIn.setAccessible(true);
118             Object realIn = fIn.get(this.in);
119             // In hadoop 0.22, DFSInputStream is a standalone class.  Before this,
120             // it was an inner class of DFSClient.
121             if (realIn.getClass().getName().endsWith("DFSInputStream")) {
122               Method getFileLength = realIn.getClass().
123                 getDeclaredMethod("getFileLength", new Class<?> []{});
124               getFileLength.setAccessible(true);
125               long realLength = ((Long)getFileLength.
126                 invoke(realIn, new Object []{})).longValue();
127               assert(realLength >= this.length);
128               adjust = realLength - this.length;
129             } else {
130               LOG.info("Input stream class: " + realIn.getClass().getName() +
131                   ", not adjusting length");
132             }
133           } catch(Exception e) {
134             SequenceFileLogReader.LOG.warn(
135               "Error while trying to get accurate file length.  " +
136               "Truncation / data loss may occur if RegionServers die.", e);
137           }
138 
139           return adjust + super.getPos();
140         }
141         return super.getPos();
142       }
143     }
144   }
145 
146   // Protected for tests.
147   protected SequenceFile.Reader reader;
148   long entryStart = 0; // needed for logging exceptions
149 
150   public SequenceFileLogReader() {
151     super();
152   }
153 
154   @Override
155   public void close() throws IOException {
156     try {
157       if (reader != null) {
158         this.reader.close();
159         this.reader = null;
160       }
161     } catch (IOException ioe) {
162       throw addFileInfoToException(ioe);
163     }
164   }
165 
166   @Override
167   public long getPosition() throws IOException {
168     return reader != null ? reader.getPosition() : 0;
169   }
170 
171   @Override
172   public void reset() throws IOException {
173     // Resetting the reader lets us see newly added data if the file is being written to
174     // We also keep the same compressionContext which was previously populated for this file
175     reader = new WALReader(fs, path, conf);
176   }
177 
178   @Override
179   protected String initReader(FSDataInputStream stream) throws IOException {
180     // We don't use the stream because we have to have the magic stream above.
181     if (stream != null) {
182       stream.close();
183     }
184     reset();
185     return null;
186   }
187   
188   @Override
189   protected void initAfterCompression(String cellCodecClsName) throws IOException {
190     // Nothing to do here
191   }
192 
193   @Override
194   protected void initAfterCompression() throws IOException {
195     // Nothing to do here
196   }
197 
198   @Override
199   protected boolean hasCompression() {
200     return isWALCompressionEnabled(reader.getMetadata());
201   }
202 
203   @Override
204   protected boolean hasTagCompression() {
205     // Tag compression not supported with old SequenceFileLog Reader/Writer
206     return false;
207   }
208 
209   /**
210    * Call this method after init() has been executed
211    * @return whether WAL compression is enabled
212    */
213   static boolean isWALCompressionEnabled(final Metadata metadata) {
214     // Check version is >= VERSION?
215     Text txt = metadata.get(WAL_VERSION_KEY);
216     if (txt == null || Integer.parseInt(txt.toString()) < COMPRESSION_VERSION) {
217       return false;
218     }
219     // Now check that compression type is present.  Currently only one value.
220     txt = metadata.get(WAL_COMPRESSION_TYPE_KEY);
221     return txt != null && txt.equals(DICTIONARY_COMPRESSION_TYPE);
222   }
223 
224 
225   @Override
226   protected boolean readNext(Entry e) throws IOException {
227     try {
228       boolean hasNext = this.reader.next(e.getKey(), e.getEdit());
229       if (!hasNext) return false;
230       // Scopes are probably in WAL edit, move to key
231       NavigableMap<byte[], Integer> scopes = e.getEdit().getAndRemoveScopes();
232       if (scopes != null) {
233         e.getKey().readOlderScopes(scopes);
234       }
235       return true;
236     } catch (IOException ioe) {
237       throw addFileInfoToException(ioe);
238     }
239   }
240 
241   @Override
242   protected void seekOnFs(long pos) throws IOException {
243     try {
244       reader.seek(pos);
245     } catch (IOException ioe) {
246       throw addFileInfoToException(ioe);
247     }
248   }
249 
250   protected IOException addFileInfoToException(final IOException ioe)
251   throws IOException {
252     long pos = -1;
253     try {
254       pos = getPosition();
255     } catch (IOException e) {
256       LOG.warn("Failed getting position to add to throw", e);
257     }
258 
259     // See what SequenceFile.Reader thinks is the end of the file
260     long end = Long.MAX_VALUE;
261     try {
262       Field fEnd = SequenceFile.Reader.class.getDeclaredField("end");
263       fEnd.setAccessible(true);
264       end = fEnd.getLong(this.reader);
265     } catch(NoSuchFieldException nfe) {
266        /* reflection failure, keep going */
267     } catch(IllegalAccessException iae) {
268        /* reflection failure, keep going */
269     } catch(Exception e) {
270        /* All other cases. Should we handle it more aggressively? */
271        LOG.warn("Unexpected exception when accessing the end field", e);
272     }
273  
274     String msg = (this.path == null? "": this.path.toString()) +
275       ", entryStart=" + entryStart + ", pos=" + pos +
276       ((end == Long.MAX_VALUE) ? "" : ", end=" + end) +
277       ", edit=" + this.edit;
278 
279     // Enhance via reflection so we don't change the original class type
280     try {
281       return (IOException) ioe.getClass()
282         .getConstructor(String.class)
283         .newInstance(msg)
284         .initCause(ioe);
285     } catch(NoSuchMethodException nfe) {
286        /* reflection failure, keep going */
287     } catch(IllegalAccessException iae) {
288        /* reflection failure, keep going */
289     } catch(Exception e) {
290        /* All other cases. Should we handle it more aggressively? */
291        LOG.warn("Unexpected exception when accessing the end field", e);
292     }
293     return ioe;
294   }
295 }