Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
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.ql.session;
 
 import java.io.File;
 import java.net.URI;
 import java.net.URL;
 import java.util.List;
 import java.util.Set;
 
 import  org.apache.hadoop.conf.Configuration;
 import  org.apache.hadoop.fs.FileSystem;
 import  org.apache.hadoop.fs.Path;
SessionState encapsulates common data associated with a session. Also provides support for a thread static session object that can be accessed from any point in the code to interact with the user and to retrieve configuration information
 
 public class SessionState {

  
current configuration.
 
   protected HiveConf conf;

  
silent mode.
 
   protected boolean isSilent;

  
verbose mode
 
   protected boolean isVerbose;
 
   /*
    * HiveHistory Object
    */
   protected HiveHistory hiveHist;
  
Streams to read/write from.
 
   public InputStream in;
   public PrintStream out;
   public PrintStream err;
  
Standard output from any child process(es).
 
   public PrintStream childOut;
  
Error output from any child process(es).
 
   public PrintStream childErr;

  
type of the command.
 
   private HiveOperation commandType;
   
  
  
Lineage state.
Get the lineage state stored in this session.

Returns:
LineageState
    return ;
  }
  public HiveConf getConf() {
    return ;
  }
  public void setConf(HiveConf conf) {
    this. = conf;
  }
  public boolean getIsSilent() {
    if( != null) {
    } else {
      return ;
    }
  }
  public void setIsSilent(boolean isSilent) {
    if( != null) {
    }
    this. = isSilent;
  }
  public boolean getIsVerbose() {
    return ;
  }
  public void setIsVerbose(boolean isVerbose) {
    this. = isVerbose;
  }
  public SessionState() {
    this(null);
  }
  public SessionState(HiveConf conf) {
    this. = conf;
     = new LineageState();
  }
  public void setCmd(String cmdString) {
  }
  public String getCmd() {
  }
  public String getQueryId() {
  }
  public String getSessionId() {
  }

  
Singleton Session object per thread.
  private static ThreadLocal<SessionStatetss = new ThreadLocal<SessionState>();

  
start a new session and set it to current session.

Throws:
HiveException
  public static SessionState start(HiveConf confthrows HiveException {
    SessionState ss = new SessionState(conf);
    ss.hiveHist = new HiveHistory(ss);
    ss.authenticator = HiveUtils.getAuthenticator(conf);
    ss.authorizer = HiveUtils.getAuthorizeProviderManager(
        confss.authenticator);
    ss.createTableGrants = CreateTableAutomaticGrant.create(conf);
    .set(ss);
    return (ss);
  }

  
set current session to existing session object if a thread is running multiple sessions - it must call this method with the new session object when switching from one session to another.

Throws:
HiveException
  public static SessionState start(SessionState startSs) {
    .set(startSs);
    if (StringUtils.isEmpty(startSs.getConf().getVar(
        ..))) {
      startSs.getConf()
    }
    if (startSs.hiveHist == null) {
      startSs.hiveHist = new HiveHistory(startSs);
    }
    
    try {
      startSs.authenticator = HiveUtils.getAuthenticator(startSs
          .getConf());
      startSs.authorizer = HiveUtils.getAuthorizeProviderManager(startSs
          .getConf(), startSs.authenticator);
      startSs.createTableGrants = CreateTableAutomaticGrant.create(startSs
          .getConf());
    } catch (HiveException e) {
      throw new RuntimeException(e);
    }
    
    return startSs;
  }

  
get the current session.
  public static SessionState get() {
    return .get();
  }

  
get hiveHitsory object which does structured logging.

Returns:
The hive history object
  public HiveHistory getHiveHistory() {
    return ;
  }
  private static String makeSessionId() {
    GregorianCalendar gc = new GregorianCalendar();
    String userid = System.getProperty("user.name");
    return userid
        + "_"
        + String.format("%1$4d%2$02d%3$02d%4$02d%5$02d"gc.get(.),
        gc.get(.) + 1, gc.get(.), gc
        .get(.), gc.get(.));
  }
  public static final String HIVE_L4J = "hive-log4j.properties";
  public static final String HIVE_EXEC_L4J = "hive-exec-log4j.properties";
  public static void initHiveLog4j() {
    // allow hive log4j to override any normal initialized one
    URL hive_l4j = SessionState.class.getClassLoader().getResource();
    if (hive_l4j == null) {
      ..println( + " not found");
    } else {
      LogManager.resetConfiguration();
      PropertyConfigurator.configure(hive_l4j);
    }
  }

  
This class provides helper routines to emit informational and error messages to the user and log4j files while obeying the current session's verbosity levels. NEVER write directly to the SessionStates standard output other than to emit result data DO use printInfo and printError provided by LogHelper to emit non result data strings. It is perfectly acceptable to have global static LogHelper objects (for example - once per module) LogHelper always emits info/error to current session as required.
  public static class LogHelper {
    protected Log LOG;
    protected boolean isSilent;
    public LogHelper(Log LOG) {
      this(LOGfalse);
    }
    public LogHelper(Log LOGboolean isSilent) {
      this. = LOG;
      this. = isSilent;
    }
    public PrintStream getOutStream() {
      SessionState ss = SessionState.get();
      return ((ss != null) && (ss.out != null)) ? ss.out : .;
    }
    public PrintStream getErrStream() {
      SessionState ss = SessionState.get();
      return ((ss != null) && (ss.err != null)) ? ss.err : .;
    }
    public PrintStream getChildOutStream() {
      SessionState ss = SessionState.get();
      return ((ss != null) && (ss.childOut != null)) ? ss.childOut : .;
    }
    public PrintStream getChildErrStream() {
      SessionState ss = SessionState.get();
      return ((ss != null) && (ss.childErr != null)) ? ss.childErr : .;
    }
    public boolean getIsSilent() {
      SessionState ss = SessionState.get();
      // use the session or the one supplied in constructor
      return (ss != null) ? ss.getIsSilent() : ;
    }
    public void printInfo(String info) {
      printInfo(infonull);
    }
    public void printInfo(String infoString detail) {
      if (!getIsSilent()) {
        getErrStream().println(info);
      }
      .info(info + StringUtils.defaultString(detail));
    }
    public void printError(String error) {
      printError(errornull);
    }
    public void printError(String errorString detail) {
      getErrStream().println(error);
      .error(error + StringUtils.defaultString(detail));
    }
  }
  private static LogHelper _console;

  
initialize or retrieve console object for SessionState.
  public static LogHelper getConsole() {
    if ( == null) {
      Log LOG = LogFactory.getLog("SessionState");
       = new LogHelper(LOG);
    }
    return ;
  }
  public static String validateFile(Set<StringcurFilesString newFile) {
    SessionState ss = SessionState.get();
    LogHelper console = getConsole();
    Configuration conf = (ss == null) ? new Configuration() : ss.getConf();
    try {
      if (Utilities.realFile(newFileconf) != null) {
        return newFile;
      } else {
        console.printError(newFile + " does not exist");
        return null;
      }
    } catch (IOException e) {
      console.printError("Unable to validate " + newFile + "\nException: "
          + e.getMessage(), "\n"
          + org.apache.hadoop.util.StringUtils.stringifyException(e));
      return null;
    }
  }
  public static boolean registerJar(String newJar) {
    LogHelper console = getConsole();
    try {
      ClassLoader loader = Thread.currentThread().getContextClassLoader();
          Utilities.addToClassPath(loader, StringUtils.split(newJar",")));
      console.printInfo("Added " + newJar + " to class path");
      return true;
    } catch (Exception e) {
      console.printError("Unable to register " + newJar + "\nException: "
          + e.getMessage(), "\n"
          + org.apache.hadoop.util.StringUtils.stringifyException(e));
      return false;
    }
  }
  public static boolean unregisterJar(String jarsToUnregister) {
    LogHelper console = getConsole();
    try {
      Utilities.removeFromClassPath(StringUtils.split(jarsToUnregister","));
      console.printInfo("Deleted " + jarsToUnregister + " from class path");
      return true;
    } catch (Exception e) {
      console.printError("Unable to unregister " + jarsToUnregister
          + "\nException: " + e.getMessage(), "\n"
          + org.apache.hadoop.util.StringUtils.stringifyException(e));
      return false;
    }
  }

  
ResourceHook.
  public static interface ResourceHook {
    String preHook(Set<StringcurString s);
    boolean postHook(Set<StringcurString s);
  }

  
ResourceType.
  public static enum ResourceType {
    FILE(new ResourceHook() {
      public String preHook(Set<StringcurString s) {
        return validateFile(curs);
      }
      public boolean postHook(Set<StringcurString s) {
        return true;
      }
    }),
    JAR(new ResourceHook() {
      public String preHook(Set<StringcurString s) {
        String newJar = validateFile(curs);
        if (newJar != null) {
          return (registerJar(newJar) ? newJar : null);
        } else {
          return null;
        }
      }
      public boolean postHook(Set<StringcurString s) {
        return unregisterJar(s);
      }
    }),
    ARCHIVE(new ResourceHook() {
      public String preHook(Set<StringcurString s) {
        return validateFile(curs);
      }
      public boolean postHook(Set<StringcurString s) {
        return true;
      }
    });
    public ResourceHook hook;
    ResourceType(ResourceHook hook) {
      this. = hook;
    }
  };
  public static ResourceType find_resource_type(String s) {
    s = s.trim().toUpperCase();
    try {
      return ResourceType.valueOf(s);
    } catch (IllegalArgumentException e) {
    }
    // try singular
    if (s.endsWith("S")) {
      s = s.substring(0, s.length() - 1);
    } else {
      return null;
    }
    try {
      return ResourceType.valueOf(s);
    } catch (IllegalArgumentException e) {
    }
    return null;
  }
  private final HashMap<ResourceTypeHashSet<String>> resource_map =
  public void add_resource(ResourceType tString value) {
    // By default don't convert to unix
    add_resource(tvaluefalse);
  }
  public String add_resource(ResourceType tString valueboolean convertToUnix) {
    try {
      value = downloadResource(valueconvertToUnix);
    } catch (Exception e) {
      getConsole().printError(e.getMessage());
      return null;
    }
    if (.get(t) == null) {
      .put(tnew HashSet<String>());
    }
    String fnlVal = value;
    if (t.hook != null) {
      fnlVal = t.hook.preHook(.get(t), value);
      if (fnlVal == null) {
        return fnlVal;
      }
    }
    getConsole().printInfo("Added resource: " + fnlVal);
    .get(t).add(fnlVal);
    return fnlVal;
  }

  
Returns the list of filesystem schemas as regex which are permissible for download as a resource.
  public static String getMatchingSchemaAsRegex() {
    String[] matchingSchema = {"s3""s3n""hdfs"};
    return StringUtils.join(matchingSchema"|");
  }
  private String downloadResource(String valueboolean convertToUnix) {
    if (value.matches("("getMatchingSchemaAsRegex() +")://.*")) {
      getConsole().printInfo("converting to local " + value);
      File resourceDir = new File(getConf().getVar(..));
      String destinationName = new Path(value).getName();
      File destinationFile = new File(resourceDirdestinationName);
      if ( resourceDir.exists() && ! resourceDir.isDirectory() ) {
        throw new RuntimeException("The resource directory is not a directory, resourceDir is set to" + resourceDir);
      }
      if ( ! resourceDir.exists() && ! resourceDir.mkdirs() ) {
        throw new RuntimeException("Couldn't create directory " + resourceDir);
      }
      try {
        FileSystem fs = FileSystem.get(new URI(value), );
        fs.copyToLocalFile(new Path(value), new Path(destinationFile.getCanonicalPath()));
        value = destinationFile.getCanonicalPath();
        if (convertToUnix && DosToUnix.isWindowsScript(destinationFile)) {
          try {
            DosToUnix.convertWindowsScriptToUnix(destinationFile);
          } catch (Exception e) {
            throw new RuntimeException("Caught exception while converting to unix line endings"e);
          }
        }
      } catch (Exception e) {
        throw new RuntimeException("Failed to read external resource " + valuee);
      }
    }
    return value;
  }
  public boolean delete_resource(ResourceType tString value) {
    if (.get(t) == null) {
      return false;
    }
    if (t.hook != null) {
      if (!t.hook.postHook(.get(t), value)) {
        return false;
      }
    }
    return (.get(t).remove(value));
  }
  public Set<Stringlist_resource(ResourceType tList<Stringfilter) {
    if (.get(t) == null) {
      return null;
    }
    Set<Stringorig = .get(t);
    if (filter == null) {
      return orig;
    } else {
      Set<Stringfnl = new HashSet<String>();
      for (String one : orig) {
        if (filter.contains(one)) {
          fnl.add(one);
        }
      }
      return fnl;
    }
  }
  public void delete_resource(ResourceType t) {
    if (.get(t) != null) {
      for (String value : .get(t)) {
        delete_resource(tvalue);
      }
      .remove(t);
    }
  }
  public String getCommandType() {
    if ( == null) {
      return null;
    }
    return .getOperationName();
  }
  
    return ;
  }
  public void setCommandType(HiveOperation commandType) {
    this. = commandType;
  }
  
    return ;
  }
  public void setAuthorizer(HiveAuthorizationProvider authorizer) {
    this. = authorizer;
  }
    return ;
  }
  public void setAuthenticator(HiveAuthenticationProvider authenticator) {
    this. = authenticator;
  }
  
    return ;
  }
  public void setCreateTableGrants(CreateTableAutomaticGrant createTableGrants) {
    this. = createTableGrants;
  }
New to GrepCode? Check out our FAQ X