src/org/apache/pig/tools/ToolsPigServer.java

/*
 * 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.pig.tools;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.StringReader;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.apache.pig.ExecType;
import org.apache.pig.PigServer;
import org.apache.pig.backend.executionengine.ExecException;
import org.apache.pig.backend.executionengine.ExecJob;
import org.apache.pig.classification.InterfaceAudience;
import org.apache.pig.classification.InterfaceStability;
import org.apache.pig.impl.PigContext;
import org.apache.pig.impl.logicalLayer.FrontendException;
import org.apache.pig.newplan.logical.relational.LogicalPlan;
import org.apache.pig.tools.grunt.GruntParser;
import org.apache.pig.tools.pigstats.PigStats;

/**
 * ToolsPigServer is a subclass of PigServer intended only for Pig tools.  Users
 * should not use this interface, as we make no promises about its stability or
 * continued existence.
 */
@InterfaceAudience.LimitedPrivate({"Penny"})
@InterfaceStability.Unstable
public class ToolsPigServer extends PigServer {

    private PigPlans plans = null;

    /**
     * @param execTypeString can be 'mapreduce' or 'local'.  Local mode will 
     * use Hadoop's local job runner to execute the job on the local machine.
     * Mapreduce mode will connect to a cluster to execute the job.
     * @throws ExecException if throws by PigServer
     * @throws IOException if throws by PigServer
     */
    public ToolsPigServer(String execTypeString) throws ExecException, IOException {
        super(execTypeString);
    }

    /**
     * @param ctx the context to use to construct the PigServer
     * @throws ExecException if throws by PigServer
     * @throws IOException if throws by PigServer
     */
    public ToolsPigServer(PigContext ctx) throws ExecException, IOException {
        super(ctx);
    }

    /**
     * @param execType execution type to start the engine in.
     * @param properties to use for this run
     * @throws ExecException if throws by PigServer
     */
    public ToolsPigServer(ExecType execType, Properties properties) throws ExecException {
        super(execType, properties);
    }

    /**
     * Register a script without running it.  This method is not compatible with
     * {@link #registerQuery(String)}, {@link #registerScript(String)}, 
     * {@link #store(String, String)} or {@link #openIterator(String)}.  It can be
     * used with {@link #getPlans()} and {@link #runPlan(LogicalPlan, String)} in this class 
     * only. The proper control flow is for the caller to call registerNoRun() and then
     * getPlans() to get a copy of the plans.  The user can then modify the
     * logical plan.  It can then be returned via runPlan(), which will execute
     * the plan.
     * @param fileName File containing Pig Latin script to register.
     * @param params  the key is the parameter name, and the value is the parameter value
     * @param paramFiles   files which have the parameter setting
     * @throws IOException if it encounters problems reading the script
     * @throws FrontendException if it encounters problems parsing the script
     */
    public void registerNoRun(String fileName,
                              Map<String, String> params,
                              List<String> paramFiles) throws IOException, FrontendException {

        // Do parameter substitution
        String substituted = null;
        FileInputStream fis = null;
        try{
            fis = new FileInputStream(fileName);
            substituted = pigContext.doParamSubstitution(fis, paramMapToList(params), paramFiles);
        }catch (FileNotFoundException e){
            log.error(e.getLocalizedMessage());
            throw new IOException(e);
        } finally {
            if (fis != null) {
                fis.close();
            }
        }

        // Parse in grunt so that register commands are recognized
        try {
            GruntParser grunt = new GruntParser(new StringReader(substituted), this);
            grunt.setInteractive(false);
            setBatchOn();
            //grunt.setLoadOnly(true);
            grunt.parseOnly();
        } catch (org.apache.pig.tools.pigscript.parser.ParseException e) {
            log.error(e.getLocalizedMessage());
            throw new IOException(e);
        }

        Graph g = getClonedGraph();
        LogicalPlan lp = g.getPlan(null);
        plans = new PigPlans(lp);
    }

    /**
     * Get a class containing the Pig plans.  For now it just contains
     * the new logical plan.  At some point in the future it should contain
     * the MR plan as well.
     * @return the pig plans.
     */
    public PigPlans getPlans() {
        return plans;
    }

    /**
     * Given a (modified) new logical plan, run the script.
     * @param newPlan plan to run
     * @param jobName name to give the MR jobs associated with this run
     * @return list of exec jobs describing the jobs that were run.
     * @throws FrontendException if plan translation fails.
     * @throws ExecException if running the job fails.
     */
    public List<ExecJob> runPlan(LogicalPlan newPlan,
                                 String jobName) throws FrontendException, ExecException {
        PigStats stats = launchPlan(newPlan, jobName);
        return getJobs(stats);
    }

    public static class PigPlans {

        public LogicalPlan lp;

        public PigPlans(LogicalPlan lp) {
            this.lp = lp;
        }
    };
}