public Server() throws TTransportException { try { realUgi = UserGroupInformation.getCurrentUser(); clientValidationUGI = UserGroupInformation.getCurrentUser(); } catch (IOException ioe) { throw new TTransportException(ioe); } } /**
@Override public int readAll(byte[] buf, int off, int len) throws TTransportException { final int bytesRemaining = this.buf.readableBytes(); if (len > bytesRemaining) { throw new TTransportException("unexpected end of frame"); } this.buf.readBytes(buf, off, len); return len; }
private static TTransportException rewriteException(TTransportException e, HostAndPort address) { return new TTransportException(e.getType(), String.format("%s: %s", address, e.getMessage()), e); }
private static Exception decodeException(Throwable cause, @Nullable Class<?>[] declaredThrowableExceptions) { if (cause instanceof RuntimeException || cause instanceof TException) { return (Exception) cause; } final boolean isDeclaredException; if (declaredThrowableExceptions != null) { isDeclaredException = Arrays.stream(declaredThrowableExceptions).anyMatch(v -> v.isInstance(cause)); } else { isDeclaredException = false; } if (isDeclaredException) { return (Exception) cause; } else if (cause instanceof Error) { return new RuntimeException(cause); } else { return new TTransportException(cause); } } }
@Override public HiveMetastoreClient create(HostAndPort address) throws TTransportException { checkState(!clients.isEmpty(), "mock not given enough clients"); HiveMetastoreClient client = clients.remove(0); if (client == null) { throw new TTransportException(TTransportException.TIMED_OUT); } return client; } }
@Override public void writeMessageEnd() throws TException { try { getCurrentWriter().writeEndObject(); getCurrentWriter().flush(); } catch (IOException e) { throw new TTransportException(e); } }
@Override protected TSocket acceptImpl() throws TTransportException { TSocket ts = super.acceptImpl(); try { ts.getSocket().setKeepAlive(true); } catch (SocketException e) { throw new TTransportException(e); } return ts; } }
private static TTransport createRaw(HostAndPort address, Optional<SSLContext> sslContext, Optional<HostAndPort> socksProxy, int timeoutMillis) throws TTransportException { Proxy proxy = socksProxy .map(socksAddress -> new Proxy(SOCKS, InetSocketAddress.createUnresolved(socksAddress.getHost(), socksAddress.getPort()))) .orElse(Proxy.NO_PROXY); Socket socket = new Socket(proxy); try { socket.connect(new InetSocketAddress(address.getHost(), address.getPort()), timeoutMillis); socket.setSoTimeout(timeoutMillis); if (sslContext.isPresent()) { // SSL will connect to the SOCKS address when present HostAndPort sslConnectAddress = socksProxy.orElse(address); socket = sslContext.get().getSocketFactory().createSocket(socket, sslConnectAddress.getHost(), sslConnectAddress.getPort(), true); } return new TSocket(socket); } catch (Throwable t) { // something went wrong, close the socket and rethrow try { socket.close(); } catch (IOException e) { t.addSuppressed(e); } throw new TTransportException(t); } }
/** * Helper shared by write{List/Set}End. */ private void writeSequenceEnd() throws TException { try { getCurrentWriter().writeEndArray(); } catch (IOException ex) { throw new TTransportException(ex); } popContext(); }
@Override protected TSocket acceptImpl() throws TTransportException { ServerSocket serverSocket = getServerSocket(); if (serverSocket == null) { throw new TTransportException( TTransportException.NOT_OPEN, "No underlying server socket." ); } try { Socket result = serverSocket.accept(); TSocketWrapper result2 = new TSocketWrapper(result); result2.setTimeout(0); openedSockets.add(result2); return result2; } catch (IOException iox) { throw new TTransportException(iox); } } };
throws TTransportException { if (keytabFile == null || keytabFile.isEmpty()) { throw new TTransportException("No keytab specified"); throw new TTransportException("No principal specified"); assert realUgi.isFromKeytab(); } catch (IOException ioe) { throw new TTransportException(ioe);
/** * I believe these two messages are called for a thrift service * interface. We don't plan on storing any text objects of that * type on disk. */ @Override public void writeMessageBegin(TMessage message) throws TException { try { getCurrentWriter().writeStartObject(); getCurrentWriter().writeFieldName("method"); getCurrentWriter().writeString(message.name); getCurrentWriter().writeFieldName("type"); TypedParser.TMESSAGE_TYPE.writeValue(getCurrentWriter(), message.type); getCurrentWriter().writeFieldName("seqid"); getCurrentWriter().writeNumber(message.seqid); getCurrentWriter().writeFieldName("args"); } catch (IOException e) { throw new TTransportException(e); } }
private void checkException(int type, String loc) { BeeLine testBeeLine = new TestBeeline(loc); TTransportException tTransportException = new TTransportException(type); SQLException sqlException = new SQLException(tTransportException); testBeeLine.handleSQLException(sqlException); } }
client.login(new AuthenticationRequest(credentials)); } catch (Exception e) { // TTransportException will propagate authentication/authorization failure throw new TTransportException(e);
/** * Helper shared by write{List/Set}Begin. */ private void writeSequenceBegin(int size) throws TException { getCurrentContext().write(); if (getCurrentContext().isMapKey()) { throw new TException(SEQUENCE_AS_KEY_ILLEGAL); } pushContext(new SequenceContext(null)); try { getCurrentWriter().writeStartArray(); } catch (IOException ex) { throw new TTransportException(ex); } }
/** * Create a TSaslServerTransport.Factory that, upon connection of a client * socket, negotiates a Kerberized SASL transport. * * @param saslProps Map of SASL properties */ public TSaslServerTransport.Factory createSaslServerTransportFactory( Map<String, String> saslProps) throws TTransportException { // Parse out the kerberos principal, host, realm. String kerberosName = clientValidationUGI.getUserName(); final String names[] = SaslRpcServer.splitKerberosName(kerberosName); if (names.length != 3) { throw new TTransportException("Kerberos principal should have 3 parts: " + kerberosName); } TSaslServerTransport.Factory transFactory = new TSaslServerTransport.Factory(); transFactory.addServerDefinition( AuthMethod.KERBEROS.getMechanismName(), names[0], names[1], // two parts of kerberos principal saslProps, new SaslRpcServer.SaslGssCallbackHandler()); transFactory.addServerDefinition(AuthMethod.DIGEST.getMechanismName(), null, SaslRpcServer.SASL_DEFAULT_REALM, saslProps, new SaslDigestCallbackHandler(secretManager)); return transFactory; }
@Override protected TTransport newTransport(String uri, HttpHeaders headers) throws TTransportException { final SSLContext sslContext; try { sslContext = SSLContextBuilder.create() .loadTrustMaterial((TrustStrategy) (chain, authType) -> true) .build(); } catch (GeneralSecurityException e) { throw new TTransportException("failed to initialize an SSL context", e); } final THttpClient client = new THttpClient( uri, HttpClientBuilder.create() .setSSLHostnameVerifier((hostname, session) -> true) .setSSLContext(sslContext) .build()); client.setCustomHeaders( headers.names().stream() .collect(toImmutableMap(AsciiString::toString, name -> String.join(", ", headers.getAll(name))))); return client; }
@Override public int readI32() throws TException { final Class<?> fieldClass = getCurrentFieldClassIfIs(TEnum.class); if (fieldClass != null) { // Enum fields may be set by string, even though they represent integers. getCurrentContext().read(); final JsonNode elem = getCurrentContext().getCurrentChild(); if (elem.isInt()) { return TypedParser.INTEGER.readFromJsonElement(elem); } else if (elem.isTextual()) { // All TEnum are enums @SuppressWarnings({ "unchecked", "rawtypes" }) final TEnum tEnum = (TEnum) Enum.valueOf((Class<Enum>) fieldClass, TypedParser.STRING.readFromJsonElement(elem)); return tEnum.getValue(); } else { throw new TTransportException("invalid value type for enum field: " + elem.getNodeType() + " (" + elem + ')'); } } else { return readNameOrValue(TypedParser.INTEGER); } }
response.release(); } catch (Exception e) { throw new TTransportException(TTransportException.UNKNOWN, e); } finally { if (ch != null) {
throw new TTransportException("Failed to start token manager", e);