* 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.

*/

* Utilities.

*

*/

  /**

   * The object in the reducer are composed of these top level fields.

   */

  public static String HADOOP_LOCAL_FS = "file:///";

  public static String MAP_PLAN_NAME = "map.xml";

  public static String REDUCE_PLAN_NAME = "reduce.xml";

  public static final String MAPRED_MAPPER_CLASS = "mapred.mapper.class";

  public static final String MAPRED_REDUCER_CLASS = "mapred.reducer.class";

  /**

   * ReduceField:

   * KEY: record key

   * VALUE: record value

   */

  public static enum ReduceField {

    KEY, VALUE

  };

  public static List<String> reduceFieldNameList;

  static {

    reduceFieldNameList = new ArrayList<String>();

    for (ReduceField r : ReduceField.values()) {

      reduceFieldNameList.add(r.toString());

    }

  }

  private Utilities() {

    // prevent instantiation

  }

  private static Map<Path, BaseWork> gWorkMap = Collections

      .synchronizedMap(new HashMap<Path, BaseWork>());

  private static final String CLASS_NAME = Utilities.class.getName();

  private static final Log LOG = LogFactory.getLog(CLASS_NAME);

  public static void clearWork(Configuration conf) {

    Path mapPath = getPlanPath(conf, MAP_PLAN_NAME);

    Path reducePath = getPlanPath(conf, REDUCE_PLAN_NAME);

    // if the plan path hasn't been initialized just return, nothing to clean.

    if (mapPath == null || reducePath == null) {

      return;

    }

    try {

      FileSystem fs = mapPath.getFileSystem(conf);

      if (fs.exists(mapPath)) {

        fs.delete(mapPath, true);

      }

      if (fs.exists(reducePath)) {

        fs.delete(reducePath, true);

      }

    } catch (Exception e) {

      LOG.warn("Failed to clean-up tmp directories.", e);

    } finally {

      // where a single process works with multiple plans - we must clear

      // the cache before working with the next plan.

      if (mapPath != null) {

        gWorkMap.remove(mapPath);

      }

      if (reducePath != null) {

        gWorkMap.remove(reducePath);

      }

    }

  }

  public static MapredWork getMapRedWork(Configuration conf) {

    MapredWork w = new MapredWork();

    w.setMapWork(getMapWork(conf));

    w.setReduceWork(getReduceWork(conf));

    return w;

  }

  public static void setMapWork(Configuration conf, MapWork work) {

    setBaseWork(conf, MAP_PLAN_NAME, work);

  }

  public static MapWork getMapWork(Configuration conf) {

    return (MapWork) getBaseWork(conf, MAP_PLAN_NAME);

  }

  public static void setReduceWork(Configuration conf, ReduceWork work) {

    setBaseWork(conf, REDUCE_PLAN_NAME, work);

  }

  public static ReduceWork getReduceWork(Configuration conf) {

    return (ReduceWork) getBaseWork(conf, REDUCE_PLAN_NAME);

  }

  /**

   * Pushes work into the global work map

   */

  public static void setBaseWork(Configuration conf, String name, BaseWork work) {

    Path path = getPlanPath(conf, name);

    gWorkMap.put(path, work);

  }

  /**

   * Returns the Map or Reduce plan

   * Side effect: the BaseWork returned is also placed in the gWorkMap

   * @param conf

   * @param name

   * @return BaseWork based on the name supplied will return null if name is null

   * @throws RuntimeException if the configuration files are not proper or if plan can not be loaded

   */

  private static BaseWork getBaseWork(Configuration conf, String name) {

    BaseWork gWork = null;

    Path path = null;

    InputStream in = null;

    try {

      path = getPlanPath(conf, name);

      assert path != null;

      if (!gWorkMap.containsKey(path)) {

        Path localPath;

        if (ShimLoader.getHadoopShims().isLocalMode(conf)) {

          localPath = path;

        } else {

          localPath = new Path(name);

        }

        if (HiveConf.getBoolVar(conf, ConfVars.HIVE_RPC_QUERY_PLAN)) {

          LOG.debug("Loading plan from string: "+path.toUri().getPath());

          String planString = conf.get(path.toUri().getPath());

          if (planString == null) {

            LOG.info("Could not find plan string in conf");

            return null;

          }

          byte[] planBytes = Base64.decodeBase64(planString);

          in = new ByteArrayInputStream(planBytes);

          in = new InflaterInputStream(in);

        } else {

          in = new FileInputStream(localPath.toUri().getPath());

        }

        if(MAP_PLAN_NAME.equals(name)){

          if (ExecMapper.class.getName().equals(conf.get(MAPRED_MAPPER_CLASS))){