Examples with ServiceException com.google.protobuf.ServiceException used on opensource projects

Example 76 with ServiceException

use of com.google.protobuf.ServiceException in project hadoop by apache.

the class TraceAdminProtocolServerSideTranslatorPB method listSpanReceivers.

@Override
public ListSpanReceiversResponseProto listSpanReceivers(RpcController controller, ListSpanReceiversRequestProto req) throws ServiceException {
    try {
        SpanReceiverInfo[] descs = server.listSpanReceivers();
        ListSpanReceiversResponseProto.Builder bld = ListSpanReceiversResponseProto.newBuilder();
        for (int i = 0; i < descs.length; ++i) {
            bld.addDescriptions(TraceAdminPB.SpanReceiverListInfo.newBuilder().setId(descs[i].getId()).setClassName(descs[i].getClassName()).build());
        }
        return bld.build();
    } catch (IOException e) {
        throw new ServiceException(e);
    }
}

Example 77 with ServiceException

use of com.google.protobuf.ServiceException in project hadoop by apache.

the class TestSaslRPC method testErrorMessage.

@Test
public void testErrorMessage() throws Exception {
    BadTokenSecretManager sm = new BadTokenSecretManager();
    final Server server = setupTestServer(conf, 5, sm);
    boolean succeeded = false;
    try {
        doDigestRpc(server, sm);
    } catch (ServiceException e) {
        assertTrue(e.getCause() instanceof RemoteException);
        RemoteException re = (RemoteException) e.getCause();
        LOG.info("LOGGING MESSAGE: " + re.getLocalizedMessage());
        assertEquals(ERROR_MESSAGE, re.getLocalizedMessage());
        assertTrue(re.unwrapRemoteException() instanceof InvalidToken);
        succeeded = true;
    }
    assertTrue(succeeded);
}

Example 78 with ServiceException

use of com.google.protobuf.ServiceException in project hadoop by apache.

the class TestSaslRPC method internalGetAuthMethod.

private String internalGetAuthMethod(final AuthMethod clientAuth, final AuthMethod serverAuth, final UseToken tokenType) throws Exception {
    final Configuration serverConf = new Configuration(conf);
    serverConf.set(HADOOP_SECURITY_AUTHENTICATION, serverAuth.toString());
    UserGroupInformation.setConfiguration(serverConf);
    final UserGroupInformation serverUgi = (serverAuth == KERBEROS) ? UserGroupInformation.createRemoteUser("server/localhost@NONE") : UserGroupInformation.createRemoteUser("server");
    serverUgi.setAuthenticationMethod(serverAuth);
    final TestTokenSecretManager sm = new TestTokenSecretManager();
    boolean useSecretManager = (serverAuth != SIMPLE);
    if (enableSecretManager != null) {
        useSecretManager &= enableSecretManager;
    }
    if (forceSecretManager != null) {
        useSecretManager |= forceSecretManager;
    }
    final SecretManager<?> serverSm = useSecretManager ? sm : null;
    Server server = serverUgi.doAs(new PrivilegedExceptionAction<Server>() {

        @Override
        public Server run() throws IOException {
            return setupTestServer(serverConf, 5, serverSm);
        }
    });
    final Configuration clientConf = new Configuration(conf);
    clientConf.set(HADOOP_SECURITY_AUTHENTICATION, clientAuth.toString());
    clientConf.setBoolean(CommonConfigurationKeys.IPC_CLIENT_FALLBACK_TO_SIMPLE_AUTH_ALLOWED_KEY, clientFallBackToSimpleAllowed);
    UserGroupInformation.setConfiguration(clientConf);
    final UserGroupInformation clientUgi = UserGroupInformation.createRemoteUser("client");
    clientUgi.setAuthenticationMethod(clientAuth);
    final InetSocketAddress addr = NetUtils.getConnectAddress(server);
    if (tokenType != UseToken.NONE) {
        TestTokenIdentifier tokenId = new TestTokenIdentifier(new Text(clientUgi.getUserName()));
        Token<TestTokenIdentifier> token = null;
        switch(tokenType) {
            case VALID:
                token = new Token<>(tokenId, sm);
                SecurityUtil.setTokenService(token, addr);
                break;
            case INVALID:
                token = new Token<>(tokenId.getBytes(), "bad-password!".getBytes(), tokenId.getKind(), null);
                SecurityUtil.setTokenService(token, addr);
                break;
            case OTHER:
                token = new Token<>();
                break;
            // won't get here
            case NONE:
        }
        clientUgi.addToken(token);
    }
    try {
        LOG.info("trying ugi:" + clientUgi + " tokens:" + clientUgi.getTokens());
        return clientUgi.doAs(new PrivilegedExceptionAction<String>() {

            @Override
            public String run() throws IOException {
                TestRpcService proxy = null;
                try {
                    proxy = getClient(addr, clientConf);
                    proxy.ping(null, newEmptyRequest());
                    // make sure the other side thinks we are who we said we are!!!
                    assertEquals(clientUgi.getUserName(), proxy.getAuthUser(null, newEmptyRequest()).getUser());
                    AuthMethod authMethod = convert(proxy.getAuthMethod(null, newEmptyRequest()));
                    // verify sasl completed with correct QOP
                    assertEquals((authMethod != SIMPLE) ? expectedQop.saslQop : null, RPC.getConnectionIdForProxy(proxy).getSaslQop());
                    return authMethod != null ? authMethod.toString() : null;
                } catch (ServiceException se) {
                    if (se.getCause() instanceof RemoteException) {
                        throw (RemoteException) se.getCause();
                    } else if (se.getCause() instanceof IOException) {
                        throw (IOException) se.getCause();
                    } else {
                        throw new RuntimeException(se.getCause());
                    }
                } finally {
                    if (proxy != null) {
                        RPC.stopProxy(proxy);
                    }
                }
            }
        });
    } finally {
        server.stop();
    }
}

Example 79 with ServiceException

use of com.google.protobuf.ServiceException in project hadoop by apache.

the class TestRPC method testClientRpcTimeout.

/**
   *  Test RPC timeout.
   */
@Test(timeout = 30000)
public void testClientRpcTimeout() throws Exception {
    Server server;
    TestRpcService proxy = null;
    RPC.Builder builder = newServerBuilder(conf).setQueueSizePerHandler(1).setNumHandlers(1).setVerbose(true);
    server = setupTestServer(builder);
    try {
        // Test RPC timeout with default ipc.client.ping.
        try {
            Configuration c = new Configuration(conf);
            c.setInt(CommonConfigurationKeys.IPC_CLIENT_RPC_TIMEOUT_KEY, 1000);
            proxy = getClient(addr, c);
            proxy.sleep(null, newSleepRequest(3000));
            fail("RPC should time out.");
        } catch (ServiceException e) {
            assertTrue(e.getCause() instanceof SocketTimeoutException);
            LOG.info("got expected timeout.", e);
        }
        // Test RPC timeout when ipc.client.ping is false.
        try {
            Configuration c = new Configuration(conf);
            c.setBoolean(CommonConfigurationKeys.IPC_CLIENT_PING_KEY, false);
            c.setInt(CommonConfigurationKeys.IPC_CLIENT_RPC_TIMEOUT_KEY, 1000);
            proxy = getClient(addr, c);
            proxy.sleep(null, newSleepRequest(3000));
            fail("RPC should time out.");
        } catch (ServiceException e) {
            assertTrue(e.getCause() instanceof SocketTimeoutException);
            LOG.info("got expected timeout.", e);
        }
        // Test negative timeout value.
        try {
            Configuration c = new Configuration(conf);
            c.setInt(CommonConfigurationKeys.IPC_CLIENT_RPC_TIMEOUT_KEY, -1);
            proxy = getClient(addr, c);
            proxy.sleep(null, newSleepRequest(2000));
        } catch (ServiceException e) {
            LOG.info("got unexpected exception.", e);
            fail("RPC should not time out.");
        }
        // Test RPC timeout greater than ipc.ping.interval.
        try {
            Configuration c = new Configuration(conf);
            c.setBoolean(CommonConfigurationKeys.IPC_CLIENT_PING_KEY, true);
            c.setInt(CommonConfigurationKeys.IPC_PING_INTERVAL_KEY, 800);
            c.setInt(CommonConfigurationKeys.IPC_CLIENT_RPC_TIMEOUT_KEY, 1000);
            proxy = getClient(addr, c);
            try {
                // should not time out because effective rpc-timeout is
                // multiple of ping interval: 1600 (= 800 * (1000 / 800 + 1))
                proxy.sleep(null, newSleepRequest(1300));
            } catch (ServiceException e) {
                LOG.info("got unexpected exception.", e);
                fail("RPC should not time out.");
            }
            proxy.sleep(null, newSleepRequest(2000));
            fail("RPC should time out.");
        } catch (ServiceException e) {
            assertTrue(e.getCause() instanceof SocketTimeoutException);
            LOG.info("got expected timeout.", e);
        }
    } finally {
        stop(server, proxy);
    }
}

Example 80 with ServiceException

use of com.google.protobuf.ServiceException in project hadoop by apache.

the class TestRPC method doRPCs.

private void doRPCs(Configuration myConf, boolean expectFailure) throws Exception {
    Server server;
    TestRpcService proxy = null;
    server = setupTestServer(myConf, 5);
    server.refreshServiceAcl(myConf, new TestPolicyProvider());
    TestProtos.EmptyRequestProto emptyRequestProto = TestProtos.EmptyRequestProto.newBuilder().build();
    try {
        proxy = getClient(addr, conf);
        proxy.ping(null, emptyRequestProto);
        if (expectFailure) {
            fail("Expect RPC.getProxy to fail with AuthorizationException!");
        }
    } catch (ServiceException e) {
        if (expectFailure) {
            RemoteException re = (RemoteException) e.getCause();
            assertTrue(re.unwrapRemoteException() instanceof AuthorizationException);
            assertEquals("RPC error code should be UNAUTHORIZED", RpcErrorCodeProto.FATAL_UNAUTHORIZED, re.getErrorCode());
        } else {
            throw e;
        }
    } finally {
        MetricsRecordBuilder rb = getMetrics(server.rpcMetrics.name());
        if (expectFailure) {
            assertCounter("RpcAuthorizationFailures", 1L, rb);
        } else {
            assertCounter("RpcAuthorizationSuccesses", 1L, rb);
        }
        //since we don't have authentication turned ON, we should see 
        // 0 for the authentication successes and 0 for failure
        assertCounter("RpcAuthenticationFailures", 0L, rb);
        assertCounter("RpcAuthenticationSuccesses", 0L, rb);
        stop(server, proxy);
    }
}