def __init__(self, host=None, port=10000, authMechanism=None, user=None, password=None, database=None, configuration=None): super(Connection, self).__init__(authMechanism) #Must set a password for thrift, even if it doesn't need one #Open issue with python-sasl password = self._check_password(authMechanism, password) socket = TSocket(host, port) if authMechanism == 'NOSASL': transport = TBufferedTransport(socket) else: saslc, sasl_mech = self._get_sasl_client(host, authMechanism, user, password, configuration) transport = TSaslClientTransport(saslc, sasl_mech, socket) self.client = TCLIService.Client(TBinaryProtocol(transport)) transport.open() res = self.client.OpenSession( TOpenSessionReq(configuration=configuration)) self.session = res.sessionHandle if database is not None: with self.cursor() as cur: query = "USE {0}".format(database) cur.execute(query)
def open_session(self, user): kwargs = { 'username': user. username, # If SASL, it gets the username from the authentication mechanism" since it dependents on it. 'configuration': {}, } if self.impersonation_enabled: kwargs.update({'username': '******'}) if self.query_server['server_name'] == 'impala': kwargs['configuration'].update( {'impala.doas.user': user.username}) else: kwargs['configuration'].update( {'hive.server2.proxy.user': user.username}) req = TOpenSessionReq(**kwargs) res = self._client.OpenSession(req) sessionId = res.sessionHandle.sessionId LOG.info('Opening session %s' % sessionId) encoded_status, encoded_guid = HiveServerQueryHandle( secret=sessionId.secret, guid=sessionId.guid).get() return Session.objects.create( owner=user, application=self.query_server['server_name'], status_code=res.status.statusCode, secret=encoded_status, guid=encoded_guid, server_protocol_version=res.serverProtocolVersion)
def __init__(self, host=None, port=10000, authMechanism=None, user=None, password=None, database=None, cursorclass=Cursor): authMechanisms = set(['NOSASL', 'PLAIN', 'KERBEROS', 'LDAP']) if authMechanism not in authMechanisms or authMechanism == 'KERBEROS': raise NotImplementedError( 'authMechanism is either not supported or not implemented') #Must set a password for thrift, even if it doesn't need one #Open issue with python-sasl if authMechanism == 'PLAIN' and (password is None or len(password) == 0): password = '******' socket = TSocket(host, port) self.cursorclass = cursorclass if authMechanism == 'NOSASL': transport = TBufferedTransport(socket) else: saslc = sasl.Client() saslc.setAttr("username", user) saslc.setAttr("password", password) saslc.init() transport = TSaslClientTransport(saslc, "PLAIN", socket) self.client = TCLIService.Client(TBinaryProtocol(transport)) transport.open() res = self.client.OpenSession(TOpenSessionReq()) self.session = res.sessionHandle if database is not None: with self.cursor() as cur: query = "USE {0}".format(database) cur.execute(query)
def open_session(self, user): if self.hiveserver2_impersonation_enabled: kerberos_principal_short_name = KERBEROS.HUE_PRINCIPAL.get().split( '/', 1)[0] kwargs = { 'username': kerberos_principal_short_name, 'configuration': { 'hive.server2.proxy.user': user.username } } else: kwargs = {'username': user.username, 'configuration': {}} req = TOpenSessionReq(**kwargs) res = self._client.OpenSession(req) sessionId = res.sessionHandle.sessionId LOG.info('Opening session %s' % sessionId) encoded_status, encoded_guid = HiveServerQueryHandle( secret=sessionId.secret, guid=sessionId.guid).get() return Session.objects.create( owner=user, application=self.query_server['server_name'], status_code=res.status.statusCode, secret=encoded_status, guid=encoded_guid, server_protocol_version=res.serverProtocolVersion)
def open_session(self, user): self.user = user kwargs = { 'client_protocol': beeswax_conf.THRIFT_VERSION.get() - 1, 'username': user.username, # If SASL or LDAP, it gets the username from the authentication mechanism" since it dependents on it. 'configuration': {}, } if self.impersonation_enabled: kwargs.update({'username': DEFAULT_USER}) if self.query_server['server_name'] == 'impala': # Only when Impala accepts it kwargs['configuration'].update({'impala.doas.user': user.username}) if self.query_server['server_name'] == 'beeswax': # All the time kwargs['configuration'].update({'hive.server2.proxy.user': user.username}) if self.query_server['server_name'] == 'sparksql': # All the time kwargs['configuration'].update({'hive.server2.proxy.user': user.username}) if self.query_server['server_name'] == 'impala' and self.query_server['SESSION_TIMEOUT_S'] > 0: kwargs['configuration'].update({'idle_session_timeout': str(self.query_server['SESSION_TIMEOUT_S'])}) LOG.info('Opening %s thrift session for user %s' % (self.query_server['server_name'], user.username)) req = TOpenSessionReq(**kwargs) res = self._client.OpenSession(req) self.coordinator_host = self._client.get_coordinator_host() if res.status is not None and res.status.statusCode not in (TStatusCode.SUCCESS_STATUS,): if hasattr(res.status, 'errorMessage') and res.status.errorMessage: message = res.status.errorMessage else: message = '' raise QueryServerException(Exception('Bad status for request %s:\n%s' % (req, res)), message=message) sessionId = res.sessionHandle.sessionId LOG.info('Session %s opened' % repr(sessionId.guid)) encoded_status, encoded_guid = HiveServerQueryHandle(secret=sessionId.secret, guid=sessionId.guid).get() properties = json.dumps(res.configuration) session = Session.objects.create(owner=user, application=self.query_server['server_name'], status_code=res.status.statusCode, secret=encoded_status, guid=encoded_guid, server_protocol_version=res.serverProtocolVersion, properties=properties) # HS2 does not return properties in TOpenSessionResp if not session.get_properties(): session.properties = json.dumps(self.get_configuration()) session.save() return session
def __init__(self, unix_socket=None, host=None, port=10000, authMechanism=None, user=None, password=None, database=None, configuration=None, timeout=None): authMechanisms = set(['NOSASL', 'PLAIN', 'KERBEROS', 'LDAP']) if authMechanism not in authMechanisms: raise NotImplementedError( 'authMechanism is either not supported or not implemented') #Must set a password for thrift, even if it doesn't need one #Open issue with python-sasl if authMechanism == 'PLAIN' and (password is None or len(password) == 0): password = '******' if unix_socket is not None: socket = TSocket(unix_socket=unix_socket) else: socket = TSocket(host, port) socket.setTimeout(timeout) if authMechanism == 'NOSASL': transport = TBufferedTransport(socket) else: sasl_mech = 'PLAIN' saslc = sasl.Client() saslc.setAttr("username", user) saslc.setAttr("password", password) if authMechanism == 'KERBEROS': krb_host, krb_service = self._get_krb_settings( host, configuration) sasl_mech = 'GSSAPI' saslc.setAttr("host", krb_host) saslc.setAttr("service", krb_service) saslc.init() transport = TSaslClientTransport(saslc, sasl_mech, socket) self.client = TCLIService.Client(TBinaryProtocol(transport)) transport.open() res = self.client.OpenSession( TOpenSessionReq(username=user, password=password, configuration=configuration)) self.session = res.sessionHandle if database is not None: with self.cursor() as cur: query = "USE {0}".format(database) cur.execute(query)
def open_session(self, user): kwargs = { 'client_protocol': 4, ##TODO: support latest column protocol 'username': user. username, # If SASL, it gets the username from the authentication mechanism" since it dependents on it. 'configuration': {}, } if self.impersonation_enabled: kwargs.update({'username': '******'}) if self.query_server[ 'server_name'] == 'impala': # Only when Impala accepts it kwargs['configuration'].update( {'impala.doas.user': user.username}) if self.query_server['server_name'] == 'beeswax': # All the time kwargs['configuration'].update( {'hive.server2.proxy.user': user.username}) if LDAP_PASSWORD.get( ): # HiveServer2 supports pass-through LDAP authentication. kwargs['username'] = LDAP_USERNAME.get() kwargs['password'] = LDAP_PASSWORD.get() req = TOpenSessionReq(**kwargs) res = self._client.OpenSession(req) if res.status is not None and res.status.statusCode not in ( TStatusCode.SUCCESS_STATUS, ): if hasattr(res.status, 'errorMessage') and res.status.errorMessage: message = res.status.errorMessage else: message = '' raise QueryServerException(Exception( 'Bad status for request %s:\n%s' % (req, res)), message=message) sessionId = res.sessionHandle.sessionId LOG.info('Opening session %s' % sessionId) encoded_status, encoded_guid = HiveServerQueryHandle( secret=sessionId.secret, guid=sessionId.guid).get() return Session.objects.create( owner=user, application=self.query_server['server_name'], status_code=res.status.statusCode, secret=encoded_status, guid=encoded_guid, server_protocol_version=res.serverProtocolVersion)
def open_session(self, user): req = TOpenSessionReq(username=user.username, configuration={}) res = self._client.OpenSession(req) sessionId = res.sessionHandle.sessionId LOG.info('Opening session %s' % sessionId) encoded_status, encoded_guid = HiveServerQueryHandle(secret=sessionId.secret, guid=sessionId.guid).get() return Session.objects.create(owner=user, application=self.query_server['server_name'], status_code=res.status.statusCode, secret=encoded_status, guid=encoded_guid, server_protocol_version=res.serverProtocolVersion)
def open_session(self, username): req = TOpenSessionReq(username=username, configuration={}) res = self._client.OpenSession(req) session_handle = res.sessionHandle return session_handle
from thrift import Thrift from thrift.transport import TSocket from thrift.transport import TTransport from thrift.protocol import TBinaryProtocol from TCLIService import TCLIService from TCLIService.ttypes import TOpenSessionReq, TFetchResultsReq,\ TExecuteStatementReq, TFetchOrientation try: transport = TSocket.TSocket( sys.argv[1], int(sys.argv[2])) transport = TTransport.TBufferedTransport(transport) protocol = TBinaryProtocol.TBinaryProtocol(transport) client = TCLIService.Client(protocol) transport.open() openReq = TOpenSessionReq() openResp = client.OpenSession(openReq) m_sessHandle = openResp.sessionHandle execReq = TExecuteStatementReq() execReq.sessionHandle = m_sessHandle execReq.statement = "create external table IF NOT EXISTS AdventureWorks_Person_Contact(contactid int,fullname string,age int,emailaddress string,phoneno string,modifieddate string) ROW FORMAT DELIMITED FIELDS TERMINATED BY ',' LOCATION '/Data/AdventureWorks'" execResp = client.ExecuteStatement(execReq) execReq.statement = 'select * from AdventureWorks_Person_Contact' execResp = client.ExecuteStatement(execReq) stmtHandle = execResp.operationHandle fetchReq = TFetchResultsReq() fetchReq.operationHandle = stmtHandle fetchReq.orientation = TFetchOrientation.FETCH_NEXT fetchReq.maxRows = 100 resultsResp = client.FetchResults(fetchReq) resultsSet = resultsResp.results
try: print "1) Preparing the connection..." sock = TSocket(host, port) if auth == 'NOSASL': transport = TBufferedTransport(sock) else: transport = TSaslClientTransport(sasl_factory, "PLAIN", sock) client = TCLIService.Client(TBinaryProtocol(transport)) transport.open() print "\n2) Opening Session..." res = client.OpenSession( TOpenSessionReq(username=username, password=password)) session = res.sessionHandle print('Session opened. ( %s )' % session.sessionId) ## 3) Show tables print "\n3) Try fetching table list..." query = TExecuteStatementReq(session, statement="show tables", confOverlay={}) response = client.ExecuteStatement(query) opHandle = response.operationHandle fetchReq = TFetchResultsReq(operationHandle=opHandle, orientation=TFetchOrientation.FETCH_NEXT, maxRows=100) resultsRes = client.FetchResults(fetchReq)