| /** |
| * 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.sqoop; |
| |
| import java.util.Arrays; |
| |
| import org.apache.commons.lang.ArrayUtils; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| import org.apache.hadoop.conf.Configuration; |
| import org.apache.hadoop.conf.Configured; |
| import org.apache.hadoop.util.Tool; |
| import org.apache.hadoop.util.ToolRunner; |
| |
| import com.cloudera.sqoop.SqoopOptions; |
| import com.cloudera.sqoop.cli.ToolOptions; |
| import com.cloudera.sqoop.tool.SqoopTool; |
| import com.cloudera.sqoop.util.OptionsFileUtil; |
| |
| import static com.cloudera.sqoop.SqoopOptions.isSqoopRethrowSystemPropertySet; |
| import static org.apache.sqoop.tool.BaseSqoopTool.THROW_ON_ERROR_ARG; |
| |
| /** |
| * Main entry-point for Sqoop |
| * Usage: hadoop jar (this_jar_name) com.cloudera.sqoop.Sqoop (options) |
| * See the SqoopOptions class for options. |
| */ |
| public class Sqoop extends Configured implements Tool { |
| |
| public static final Log SQOOP_LOG = LogFactory.getLog("com.cloudera.sqoop"); |
| public static final Log LOG = LogFactory.getLog(Sqoop.class.getName()); |
| |
| /** |
| * If this System property is set, always throw an exception, do not just |
| * exit with status 1. |
| */ |
| public static final String SQOOP_RETHROW_PROPERTY = "sqoop.throwOnError"; |
| |
| /** |
| * The option to specify an options file from which other options to the |
| * tool are read. |
| */ |
| public static final String SQOOP_OPTIONS_FILE_SPECIFIER = "--options-file"; |
| |
| static { |
| Configuration.addDefaultResource("sqoop-site.xml"); |
| } |
| |
| private SqoopTool tool; |
| private SqoopOptions options; |
| private String [] childPrgmArgs; |
| |
| /** |
| * Creates a new instance of Sqoop set to run the supplied SqoopTool |
| * with the default configuration. |
| * @param tool the SqoopTool to run in the main body of Sqoop. |
| */ |
| public Sqoop(SqoopTool tool) { |
| this(tool, (Configuration) null); |
| } |
| |
| /** |
| * Creates a new instance of Sqoop set to run the supplied SqoopTool |
| * with the provided configuration. |
| * @param tool the SqoopTool to run in the main body of Sqoop. |
| * @param conf the Configuration to use (e.g., from ToolRunner). |
| */ |
| public Sqoop(SqoopTool tool, Configuration conf) { |
| this(tool, conf, new SqoopOptions()); |
| } |
| |
| /** |
| * Creates a new instance of Sqoop set to run the supplied SqoopTool |
| * with the provided configuration and SqoopOptions. |
| * @param tool the SqoopTool to run in the main body of Sqoop. |
| * @param conf the Configuration to use (e.g., from ToolRunner). |
| * @param opts the SqoopOptions which control the tool's parameters. |
| */ |
| public Sqoop(SqoopTool tool, Configuration conf, SqoopOptions opts) { |
| LOG.info("Running Sqoop version: " + new SqoopVersion().VERSION); |
| |
| if (null != conf) { |
| setConf(conf); |
| } |
| |
| this.options = opts; |
| this.options.setConf(getConf()); |
| |
| this.tool = tool; |
| } |
| |
| /** |
| * @return the SqoopOptions used in this Sqoop instance. |
| */ |
| public SqoopOptions getOptions() { |
| return this.options; |
| } |
| |
| /** |
| * @return the SqoopTool used in this Sqoop instance. |
| */ |
| public SqoopTool getTool() { |
| return this.tool; |
| } |
| |
| @Override |
| /** |
| * Actual main entry-point for the program |
| */ |
| public int run(String [] args) { |
| if (options.getConf() == null) { |
| // Configuration wasn't initialized until after the ToolRunner |
| // got us to this point. ToolRunner gave Sqoop itself a Conf |
| // though. |
| options.setConf(getConf()); |
| } |
| |
| try { |
| options = tool.parseArguments(args, null, options, false); |
| tool.appendArgs(this.childPrgmArgs); |
| tool.validateOptions(options); |
| } catch (Exception e) { |
| // Couldn't parse arguments. |
| // Log the stack trace for this exception |
| LOG.debug(e.getMessage(), e); |
| // Print exception message. |
| System.err.println(e.getMessage()); |
| return 1; // Exit on exception here. |
| } |
| |
| return tool.run(options); |
| } |
| |
| /** |
| * SqoopTools sometimes pass arguments to a child program (e.g., mysqldump). |
| * Users can specify additional args to these programs by preceeding the |
| * additional arguments with a standalone '--'; but |
| * ToolRunner/GenericOptionsParser will cull out this argument. We remove |
| * the child-program arguments in advance, and store them to be readded |
| * later. |
| * @param argv the argv in to the SqoopTool |
| * @return the argv with a "--" and any subsequent arguments removed. |
| */ |
| private String [] stashChildPrgmArgs(String [] argv) { |
| for (int i = 0; i < argv.length; i++) { |
| if ("--".equals(argv[i])) { |
| this.childPrgmArgs = Arrays.copyOfRange(argv, i, argv.length); |
| return Arrays.copyOfRange(argv, 0, i); |
| } |
| } |
| |
| // Didn't find child-program arguments. |
| return argv; |
| } |
| |
| /** |
| * Given a Sqoop object and a set of arguments to deliver to |
| * its embedded SqoopTool, run the tool, wrapping the call to |
| * ToolRunner. |
| * This entry-point is preferred to ToolRunner.run() because |
| * it has a chance to stash child program arguments before |
| * GenericOptionsParser would remove them. |
| */ |
| public static int runSqoop(Sqoop sqoop, String [] args) { |
| String[] toolArgs = sqoop.stashChildPrgmArgs(args); |
| try { |
| return ToolRunner.run(sqoop.getConf(), sqoop, toolArgs); |
| } catch (Exception e) { |
| LOG.error("Got exception running Sqoop: " + e.toString()); |
| e.printStackTrace(); |
| rethrowIfRequired(toolArgs, e); |
| return 1; |
| } |
| } |
| |
| public static void rethrowIfRequired(String[] toolArgs, Exception ex) { |
| if (!isSqoopRethrowSystemPropertySet() && !ArrayUtils.contains(toolArgs, THROW_ON_ERROR_ARG)) { |
| return; |
| } |
| |
| final RuntimeException exceptionToThrow; |
| if (ex instanceof RuntimeException) { |
| exceptionToThrow = (RuntimeException) ex; |
| } else { |
| exceptionToThrow = new RuntimeException(ex); |
| } |
| |
| throw exceptionToThrow; |
| } |
| |
| /** |
| * Entry-point that parses the correct SqoopTool to use from the args, |
| * but does not call System.exit() as main() will. |
| */ |
| public static int runTool(String [] args, Configuration conf) { |
| // Expand the options |
| String[] expandedArgs = null; |
| try { |
| expandedArgs = OptionsFileUtil.expandArguments(args); |
| } catch (Exception ex) { |
| LOG.error("Error while expanding arguments", ex); |
| System.err.println(ex.getMessage()); |
| System.err.println("Try 'sqoop help' for usage."); |
| return 1; |
| } |
| |
| String toolName = expandedArgs[0]; |
| Configuration pluginConf = SqoopTool.loadPlugins(conf); |
| SqoopTool tool = SqoopTool.getTool(toolName); |
| if (null == tool) { |
| System.err.println("No such sqoop tool: " + toolName |
| + ". See 'sqoop help'."); |
| return 1; |
| } |
| |
| |
| Sqoop sqoop = new Sqoop(tool, pluginConf); |
| return runSqoop(sqoop, |
| Arrays.copyOfRange(expandedArgs, 1, expandedArgs.length)); |
| } |
| |
| /** |
| * Entry-point that parses the correct SqoopTool to use from the args, |
| * but does not call System.exit() as main() will. |
| */ |
| public static int runTool(String [] args) { |
| return runTool(args, new Configuration()); |
| } |
| |
| public static void main(String [] args) { |
| if (args.length == 0) { |
| System.err.println("Try 'sqoop help' for usage."); |
| System.exit(1); |
| } |
| |
| int ret = runTool(args); |
| System.exit(ret); |
| } |
| } |
| |