Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/**
* 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.exec.tez;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.hive.conf.HiveConf;
import org.apache.hadoop.hive.ql.metadata.HiveException;
import org.apache.hadoop.hive.ql.session.SessionState;
import org.apache.hadoop.hive.shims.Utils;
import org.apache.hadoop.security.UserGroupInformation;
/**
* This class is for managing multiple tez sessions particularly when
* HiveServer2 is being used to submit queries.
*
* In case the user specifies a queue explicitly, a new session is created
* on that queue and assigned to the session state.
*/
public class TezSessionPoolManager {
private static final Log LOG = LogFactory.getLog(TezSessionPoolManager.class);
private BlockingQueue defaultQueuePool;
private int blockingQueueLength = -1;
private HiveConf initConf = null;
private boolean inited = false;
private static TezSessionPoolManager sessionPool = null;
private static List openSessions = Collections
.synchronizedList(new LinkedList());
public static TezSessionPoolManager getInstance()
throws Exception {
if (sessionPool == null) {
sessionPool = new TezSessionPoolManager();
}
return sessionPool;
}
protected TezSessionPoolManager() {
}
public void startPool() throws Exception {
this.inited = true;
for (int i = 0; i < blockingQueueLength; i++) {
HiveConf newConf = new HiveConf(initConf);
TezSessionState sessionState = defaultQueuePool.take();
newConf.set("tez.queue.name", sessionState.getQueueName());
sessionState.open(newConf);
openSessions.add(sessionState);
defaultQueuePool.put(sessionState);
}
}
public void setupPool(HiveConf conf) throws InterruptedException {
String defaultQueues = HiveConf.getVar(conf, HiveConf.ConfVars.HIVE_SERVER2_TEZ_DEFAULT_QUEUES);
int numSessions = conf.getIntVar(HiveConf.ConfVars.HIVE_SERVER2_TEZ_SESSIONS_PER_DEFAULT_QUEUE);
// the list of queues is a comma separated list.
String defaultQueueList[] = defaultQueues.split(",");
defaultQueuePool =
new ArrayBlockingQueue(numSessions * defaultQueueList.length);
this.initConf = conf;
/*
* with this the ordering of sessions in the queue will be (with 2 sessions 3 queues)
* s1q1, s1q2, s1q3, s2q1, s2q2, s2q3 there by ensuring uniform distribution of
* the sessions across queues at least to begin with. Then as sessions get freed up, the list
* may change this ordering.
*/
blockingQueueLength = 0;
for (int i = 0; i < numSessions; i++) {
for (String queue : defaultQueueList) {
if (queue.length() == 0) {
continue;
}
TezSessionState sessionState = createSession(TezSessionState.makeSessionId());
sessionState.setQueueName(queue);
sessionState.setDefault();
LOG.info("Created new tez session for queue: " + queue +
" with session id: " + sessionState.getSessionId());
defaultQueuePool.put(sessionState);
blockingQueueLength++;
}
}
}
private TezSessionState getSession(HiveConf conf, boolean doOpen,
boolean forceCreate)
throws Exception {
String queueName = conf.get("tez.queue.name");
boolean nonDefaultUser = conf.getBoolVar(HiveConf.ConfVars.HIVE_SERVER2_ENABLE_DOAS);
/*
* if the user has specified a queue name themselves, we create a new session.
* also a new session is created if the user tries to submit to a queue using
* their own credentials. We expect that with the new security model, things will
* run as user hive in most cases.
*/
if (forceCreate || !(this.inited)
|| ((queueName != null) && (!queueName.isEmpty()))
|| (nonDefaultUser) || (defaultQueuePool == null) || (blockingQueueLength <= 0)) {
LOG.info("QueueName: " + queueName + " nonDefaultUser: " + nonDefaultUser +
" defaultQueuePool: " + defaultQueuePool +
" blockingQueueLength: " + blockingQueueLength);
return getNewSessionState(conf, queueName, doOpen);
}
LOG.info("Choosing a session from the defaultQueuePool");
return defaultQueuePool.take();
}
/**
* @param conf HiveConf that is used to initialize the session
* @param queueName could be null. Set in the tez session.
* @param doOpen
* @return
* @throws Exception
*/
private TezSessionState getNewSessionState(HiveConf conf,
String queueName, boolean doOpen) throws Exception {
TezSessionState retTezSessionState = createSession(TezSessionState.makeSessionId());
if (queueName != null) {
conf.set("tez.queue.name", queueName);
}
String what = "Created";
if (doOpen) {
retTezSessionState.open(conf);
openSessions.add(retTezSessionState);
what = "Started";
}
LOG.info(what + " a new session for queue: " + queueName +
" session id: " + retTezSessionState.getSessionId());
return retTezSessionState;
}
public void returnSession(TezSessionState tezSessionState)
throws Exception {
if (tezSessionState.isDefault()) {
LOG.info("The session " + tezSessionState.getSessionId()
+ " belongs to the pool. Put it back in");
SessionState sessionState = SessionState.get();
if (sessionState != null) {
sessionState.setTezSession(null);
}
defaultQueuePool.put(tezSessionState);
}
// non default session nothing changes. The user can continue to use the existing
// session in the SessionState
}
public void close(TezSessionState tezSessionState, boolean keepTmpDir) throws Exception {
LOG.info("Closing tez session default? " + tezSessionState.isDefault());
if (!tezSessionState.isDefault()) {
tezSessionState.close(keepTmpDir);
openSessions.remove(tezSessionState);
}
}
public void stop() throws Exception {
if ((sessionPool == null) || (this.inited == false)) {
return;
}
// we can just stop all the sessions
Iterator iter = openSessions.iterator();
while (iter.hasNext()) {
TezSessionState sessionState = iter.next();
if (sessionState.isDefault()) {
sessionState.close(false);
iter.remove();
}
}
}
protected TezSessionState createSession(String sessionId) {
return new TezSessionState(sessionId);
}
public TezSessionState getSession(
TezSessionState session, HiveConf conf, boolean doOpen) throws Exception {
return getSession(session, conf, doOpen, false);
}
/*
* This method helps to re-use a session in case there has been no change in
* the configuration of a session. This will happen only in the case of non-hive-server2
* sessions for e.g. when a CLI session is started. The CLI session could re-use the
* same tez session eliminating the latencies of new AM and containers.
*/
private boolean canWorkWithSameSession(TezSessionState session, HiveConf conf)
throws HiveException {
if (session == null || conf == null) {
return false;
}
try {
UserGroupInformation ugi = Utils.getUGI();
String userName = ugi.getShortUserName();
LOG.info("The current user: " + userName + ", session user: " + session.getUser());
if (userName.equals(session.getUser()) == false) {
LOG.info("Different users incoming: " + userName + " existing: " + session.getUser());
return false;
}
} catch (Exception e) {
throw new HiveException(e);
}
boolean doAsEnabled = conf.getBoolVar(HiveConf.ConfVars.HIVE_SERVER2_ENABLE_DOAS);
// either variables will never be null because a default value is returned in case of absence
if (doAsEnabled != conf.getBoolVar(HiveConf.ConfVars.HIVE_SERVER2_ENABLE_DOAS)) {
return false;
}
if (!session.isDefault()) {
String queueName = session.getQueueName();
LOG.info("Current queue name is " + queueName + " incoming queue name is "
+ conf.get("tez.queue.name"));
if (queueName == null) {
if (conf.get("tez.queue.name") != null) {
// queue names are different
return false;
} else {
return true;
}
}
if (!queueName.equals(conf.get("tez.queue.name"))) {
// the String.equals method handles the case of conf not having the queue name as well.
return false;
}
} else {
// this session should never be a default session unless something has messed up.
throw new HiveException("Default queue should always be returned." +
"Hence we should not be here.");
}
return true;
}
public TezSessionState getSession(TezSessionState session, HiveConf conf,
boolean doOpen, boolean forceCreate) throws Exception {
if (canWorkWithSameSession(session, conf)) {
return session;
}
if (session != null) {
close(session, false);
}
return getSession(conf, doOpen, forceCreate);
}
public void closeAndOpen(TezSessionState sessionState, HiveConf conf, boolean keepTmpDir)
throws Exception {
closeAndOpen(sessionState, conf, null, keepTmpDir);
}
public void closeAndOpen(TezSessionState sessionState, HiveConf conf,
String[] additionalFiles, boolean keepTmpDir) throws Exception {
HiveConf sessionConf = sessionState.getConf();
if (sessionConf != null && sessionConf.get("tez.queue.name") != null) {
conf.set("tez.queue.name", sessionConf.get("tez.queue.name"));
}
close(sessionState, keepTmpDir);
sessionState.open(conf, additionalFiles);
openSessions.add(sessionState);
}
public List getOpenSessions() {
return openSessions;
}
}
