org.apache.hadoop.hive.io.HiveIOExceptionHandlerChain Maven / Gradle / Ivy
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.hadoop.hive.io;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.hadoop.mapred.InputFormat;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.RecordReader;
import org.apache.hadoop.util.ReflectionUtils;
/**
* An exception handler chain that process the input exception by going through
* all exceptions defined in this chain one by one until either one exception
* handler returns true or it reaches the end of the chain. If it reaches the
* end of the chain, and still no exception handler returns true, throw the
* exception to the caller.
*/
public class HiveIOExceptionHandlerChain {
public static String HIVE_IO_EXCEPTION_HANDLE_CHAIN = "hive.io.exception.handlers";
@SuppressWarnings("unchecked")
public static HiveIOExceptionHandlerChain getHiveIOExceptionHandlerChain(
JobConf conf) {
HiveIOExceptionHandlerChain chain = new HiveIOExceptionHandlerChain();
String exceptionHandlerStr = conf.get(HIVE_IO_EXCEPTION_HANDLE_CHAIN);
List handlerChain = new ArrayList();
if (exceptionHandlerStr != null && !exceptionHandlerStr.trim().equals("")) {
String[] handlerArr = exceptionHandlerStr.split(",");
if (handlerArr != null && handlerArr.length > 0) {
for (String handlerStr : handlerArr) {
if (!handlerStr.trim().equals("")) {
try {
Class handlerCls =
(Class) Class.forName(handlerStr);
HiveIOExceptionHandler handler = ReflectionUtils.newInstance(handlerCls, null);
handlerChain.add(handler);
} catch (Exception e) {
}
}
}
}
}
chain.setHandlerChain(handlerChain);
return chain;
}
private List handlerChain;
/**
* @return the exception handler chain defined
*/
protected List getHandlerChain() {
return handlerChain;
}
/**
* set the exception handler chain
* @param handlerChain
*/
protected void setHandlerChain(List handlerChain) {
this.handlerChain = handlerChain;
}
public RecordReader handleRecordReaderCreationException(Exception e) throws IOException {
RecordReader ret = null;
if (handlerChain != null && handlerChain.size() > 0) {
for (HiveIOExceptionHandler handler : handlerChain) {
ret = handler.handleRecordReaderCreationException(e);
if (ret != null) {
return ret;
}
}
}
//re-throw the exception as an IOException
throw new IOException(e);
}
/**
* This is to handle exception when doing next operations. Here we use a
* HiveIOExceptionNextHandleResult to store the results of each handler. If
* the exception is handled by one handler, the handler should set
* HiveIOExceptionNextHandleResult to be handled, and also set the handle
* result. The handle result is used to return the reader's next to determine
* if need to open a new file for read or not.
*/
public boolean handleRecordReaderNextException(Exception e)
throws IOException {
HiveIOExceptionNextHandleResult result = new HiveIOExceptionNextHandleResult();
if (handlerChain != null && handlerChain.size() > 0) {
for (HiveIOExceptionHandler handler : handlerChain) {
handler.handleRecorReaderNextException(e, result);
if (result.getHandled()) {
return result.getHandleResult();
}
}
}
//re-throw the exception as an IOException
throw new IOException(e);
}
}