Example usage for org.apache.hadoop.io IOUtils closeSocket

List of usage examples for org.apache.hadoop.io IOUtils closeSocket

  1. HOME
  2. Java
  3. org.apache.hadoop
  4. org.apache.hadoop.io.*
  5. IOUtils
  6. closeSocket

Introduction

In this page you can find the example usage for org.apache.hadoop.io IOUtils closeSocket.

Prototype

public static void closeSocket(Socket sock)

Source Link

Document

Closes the socket ignoring IOException

Usage

From source file:com.cloudera.hadoop.hdfs.nfs.rpc.ClientInputHandler.java

License:Apache License

@Override
public void run() {
    InputStream in = null;/*  w  ww.  j  ava  2  s  .  co  m*/
    OutputStream out = null;
    RPCRequest request = null;
    try {
        mClient.setTcpNoDelay(true);
        mClient.setPerformancePreferences(0, 1, 0);
        in = mClient.getInputStream();
        out = mClient.getOutputStream();
        mOutputHandler = new ClientOutputHandler(out, mOutputBufferQueue, mClientName);
        mOutputHandler.setDaemon(true);
        mOutputHandler.start();
        while (true) {
            // request is used to indicate if we should send
            // a failure packet in case of an error
            request = null;
            RPCBuffer requestBuffer = RPCBuffer.from(in);
            mHandler.incrementMetric(CLIENT_BYTES_READ, requestBuffer.length());
            request = new RPCRequest();
            request.read(requestBuffer);
            AccessPrivilege accessPrivilege = mSecurityHandlerFactory
                    .getAccessPrivilege(mClient.getInetAddress());
            if (request.getRpcVersion() != RPC_VERSION) {
                LOGGER.info(mSessionID + " Denying client due to bad RPC version " + request.getRpcVersion()
                        + " for " + mClientName);
                throw new RPCDeniedException(RPC_REJECT_MISMATCH);
            } else if (accessPrivilege == AccessPrivilege.NONE) {
                throw new RPCAuthException(RPC_AUTH_STATUS_BADCRED);
            } else if (request.getCredentials() == null) {
                LOGGER.info(mSessionID + " Denying client due to null credentials for " + mClientName);
                throw new RPCAuthException(RPC_AUTH_STATUS_TOOWEAK);
            } else if (request.getProcedure() == NFS_PROC_NULL) {
                writeRPCBuffer(mSecurityHandlerFactory.handleNullRequest(mSessionID, mClientName, request,
                        requestBuffer));
            } else if (!(request.getCredentials() instanceof AuthenticatedCredentials)) {
                LOGGER.info(mSessionID + " Denying client due to non-authenticated " + "credentials for "
                        + mClientName);
                throw new RPCAuthException(RPC_AUTH_STATUS_TOOWEAK);
            } else if (request.getProcedure() != NFS_PROC_COMPOUND) {
                throw new RPCAcceptedException(RPC_ACCEPT_PROC_UNAVAIL);
            } else {
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug(mSessionID + " Handling NFS Compound for " + mClientName);
                }
                SessionSecurityHandler<? extends Verifier> securityHandler = mSecurityHandlerFactory
                        .getSecurityHandler(request.getCredentials());
                if (!securityHandler.shouldSilentlyDrop(request)) {
                    if (securityHandler.isUnwrapRequired()) {
                        byte[] encryptedData = requestBuffer.readBytes();
                        requestBuffer = securityHandler.unwrap(request, encryptedData);
                    }
                    // if putIfAbsent returns non-null then the request is already in progress
                    boolean inProgress = mRequestsInProgress.putIfAbsent(request.getXid(),
                            System.currentTimeMillis()) != null;
                    if (inProgress) {
                        mHandler.incrementMetric(RESTRANSMITS, 1);
                        LOGGER.info(mSessionID + " ignoring retransmit of " + request.getXidAsHexString());
                    } else {
                        /*
                         * TODO ensure credentials are the same for request/cached
                         * response.
                         */
                        MessageBase applicationResponse = mResponseCache.get(request.getXid());
                        if (applicationResponse != null) {
                            writeApplicationResponse(securityHandler, request, applicationResponse);
                            LOGGER.info(
                                    mSessionID + " serving cached response to " + request.getXidAsHexString());
                        } else {
                            execute(securityHandler, accessPrivilege, request, requestBuffer);
                        }
                    }
                }
            }
        }
    } catch (EOFException e) {
        LOGGER.info(mSessionID + " Shutdown worker for client " + mClientName);
    } catch (RPCException e) {
        handleRPCException(request, e);
    } catch (Exception e) {
        LOGGER.error(mSessionID + " Error from client " + mClientName, e);
        if (request != null) {
            try {
                RPCResponse response = new RPCResponse(request.getXid(), RPC_VERSION);
                response.setReplyState(RPC_REPLY_STATE_ACCEPT);
                response.setAcceptState(RPC_ACCEPT_SYSTEM_ERR);
                response.setVerifier(new VerifierNone());
                writeRPCResponse(response);
            } catch (Exception x) {
                LOGGER.error(mSessionID + " Error writing failure packet", x);
            }
        }
    } finally {
        if (mOutputHandler != null) {
            mOutputHandler.close();
        }
        // pause for output handler drain it's queue
        try {
            Thread.sleep(1500L);
        } catch (InterruptedException e) {
            LOGGER.info("Interrupted while pausing for output handler");
        }
        IOUtils.closeSocket(mClient);
        Map<Socket, ClientInputHandler<REQUEST, RESPONSE>> clients = mRPCServer.getClients();
        clients.remove(mClient);
    }
}

From source file:com.cloudera.hadoop.hdfs.nfs.rpc.ClientWorker.java

License:Apache License

public void run() {
    InputStream in = null;//w  ww  . j a  v  a  2  s.  c o m
    OutputStream out = null;
    RPCRequest request = null;
    try {
        mClient.setTcpNoDelay(true);
        mClient.setPerformancePreferences(0, 1, 0);
        in = mClient.getInputStream();
        out = mClient.getOutputStream();
        mOutputHandler = new OutputStreamHandler(out, mOutputBufferQueue, mClientName);
        mOutputHandler.setDaemon(true);
        mOutputHandler.start();
        while (true) {
            // request is used to indicate if we should send
            // a failure packet in case of an error
            request = null;
            if (mRetransmits >= mRestransmitPenaltyThreshold) {
                mRetransmits = 0L;
                mHandler.incrementMetric("RETRANSMIT_PENALTY_BOX", 1);
                Thread.sleep(RETRANSMIT_PENALTY_TIME);
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug(
                            mSessionID + " Client " + mClientName + " is going in the penalty box (SLOWDOWN)");
                }
            }
            mRetransmits = mRetransmits > 0 ? mRetransmits : 0;

            // Some requests will burn a thread while waiting for a
            // condition. For example close waits for writes to finish
            // and rename waits for a few ms for the file to close
            // if open. We should have an async return path.
            int count = 0;
            while (getRequestsInProgress().size() > mMaxPendingRequests && count++ < mMaxPendingRequestWaits) {
                mHandler.incrementMetric("TOO_MANY_PENDING_REQUESTS", 1);
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug(mSessionID + " Client " + mClientName
                            + " is waiting for pending requests to finish (SLOWDOWN)");
                }
                Thread.sleep(TOO_MANY_PENDING_REQUESTS_PAUSE);
            }

            RPCBuffer requestBuffer = RPCBuffer.from(in);
            LOGGER.info(mSessionID + " got request");
            mHandler.incrementMetric("CLIENT_BYTES_READ", requestBuffer.length());
            request = new RPCRequest();
            request.read(requestBuffer);
            if (request.getRpcVersion() != RPC_VERSION) {
                LOGGER.info(mSessionID + " Denying client due to bad RPC version " + request.getRpcVersion()
                        + " for " + mClientName);
                RPCResponse response = new RPCResponse(request.getXid(), RPC_VERSION);
                response.setReplyState(RPC_REPLY_STATE_DENIED);
                response.setAcceptState(RPC_REJECT_MISMATCH);
                response.setVerifier(new VerifierNone());
                writeRPCResponse(response);
            } else if (request.getCredentials() == null) {
                LOGGER.info(mSessionID + " Denying client due to null credentials for " + mClientName);
                RPCResponse response = new RPCResponse(request.getXid(), RPC_VERSION);
                response.setReplyState(RPC_REPLY_STATE_DENIED);
                response.setAcceptState(RPC_REJECT_AUTH_ERROR);
                response.setAuthState(RPC_AUTH_STATUS_TOOWEAK);
                response.setVerifier(new VerifierNone());
                writeRPCResponse(response);
            } else if (request.getProcedure() == NFS_PROC_NULL) {
                // RPCGSS uses the NULL proc to setup
                if (request.getCredentials() instanceof CredentialsGSS) {
                    Pair<? extends Verifier, RPCBuffer> security = mSecurityHandler.initializeContext(request,
                            requestBuffer);
                    LOGGER.info(mSessionID + " Handling NFS NULL for GSS Procedure for " + mClientName);
                    RPCResponse response = new RPCResponse(request.getXid(), RPC_VERSION);
                    response.setReplyState(RPC_REPLY_STATE_ACCEPT);
                    response.setAcceptState(RPC_ACCEPT_SUCCESS);
                    response.setVerifier(security.getFirst());
                    writeRPCResponse(response, security.getSecond());
                } else {
                    LOGGER.info(mSessionID + " Handling NFS NULL Procedure for " + mClientName);
                    RPCResponse response = new RPCResponse(request.getXid(), RPC_VERSION);
                    response.setReplyState(RPC_REPLY_STATE_ACCEPT);
                    response.setAcceptState(RPC_ACCEPT_SUCCESS);
                    response.setVerifier(new VerifierNone());
                    writeRPCResponse(response);
                }
            } else if (!(request.getCredentials() instanceof AuthenticatedCredentials)) {
                LOGGER.info(
                        mSessionID + " Denying client due to non-authenticated credentials for " + mClientName);
                RPCResponse response = new RPCResponse(request.getXid(), RPC_VERSION);
                response.setReplyState(RPC_REPLY_STATE_DENIED);
                response.setAcceptState(RPC_REJECT_AUTH_ERROR);
                response.setAuthState(RPC_AUTH_STATUS_TOOWEAK);
                response.setVerifier(new VerifierNone());
                writeRPCResponse(response);
            } else if (!mSecurityHandler.hasAcceptableSecurity(request)) {
                LOGGER.info(mSessionID + " Denying client due to unacceptable credentials for " + mClientName);
                RPCResponse response = new RPCResponse(request.getXid(), RPC_VERSION);
                response.setReplyState(RPC_REPLY_STATE_DENIED);
                response.setAcceptState(RPC_REJECT_AUTH_ERROR);
                response.setAuthState(RPC_AUTH_STATUS_TOOWEAK);
                response.setVerifier(new VerifierNone());
                writeRPCResponse(response);
            } else if (request.getProcedure() == NFS_PROC_COMPOUND) {

                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug(mSessionID + " Handling NFS Compound for " + mClientName);
                }

                if (mSecurityHandler.isUnwrapRequired()) {
                    byte[] encryptedData = requestBuffer.readBytes();
                    byte[] plainData = mSecurityHandler.unwrap(encryptedData);
                    requestBuffer = new RPCBuffer(plainData);
                }

                Set<Integer> requestsInProgress = getRequestsInProgress();
                synchronized (requestsInProgress) {
                    if (requestsInProgress.contains(request.getXid())) {
                        mRetransmits++;
                        mHandler.incrementMetric("RESTRANSMITS", 1);
                        LOGGER.info(mSessionID + " ignoring request " + request.getXid());
                    } else {
                        mRetransmits--;
                        requestsInProgress.add(request.getXid());
                        ClientTask<REQUEST, RESPONSE> task = new ClientTask<REQUEST, RESPONSE>(
                                mClient.getInetAddress(), mSessionID, this, mHandler, request, requestBuffer);
                        this.schedule(task);
                        if (LOGGER.isDebugEnabled()) {
                            LOGGER.debug(mSessionID + " scheduling request " + request.getXid());
                        }
                    }
                }
            } else {
                throw new UnsupportedOperationException("Unknown Proc " + request.getProcedure());
            }
        }
    } catch (EOFException e) {
        LOGGER.info(mSessionID + " Shutdown worker for client " + mClientName);
    } catch (Exception e) {
        LOGGER.error(mSessionID + " Error from client " + mClientName, e);
        if (request != null) {
            try {
                RPCResponse response = new RPCResponse(request.getXid(), RPC_VERSION);
                response.setReplyState(RPC_REPLY_STATE_DENIED);
                response.setAcceptState(RPC_ACCEPT_SYSTEM_ERR);
                writeRPCResponse(response);
            } catch (Exception x) {
                LOGGER.error(mSessionID + " Error writing failure packet", x);
            }
        }
    } finally {
        if (mOutputHandler != null) {
            mOutputHandler.close();
        }
        IOUtils.closeSocket(mClient);
        Map<Socket, ClientWorker<REQUEST, RESPONSE>> clients = mRPCServer.getClients();
        clients.remove(mClient);
    }
}

From source file:com.cloudera.hadoop.hdfs.nfs.rpc.RPCServer.java

License:Apache License

public void shutdown() {
    // first close clients
    for (Socket client : mClients.keySet()) {
        ClientWorker<REQUEST, RESPONSE> worker = mClients.get(client);
        if (worker != null && worker.isAlive()) {
            worker.shutdown();/* w w  w .  java2s  .  co m*/
        }
        IOUtils.closeSocket(client);
    }
    // then server
    if (mServer != null) {
        try {
            mServer.close();
        } catch (Exception e) {
        }
    }
}

From source file:com.endgame.binarypig.loaders.av.ClamScanDaemonLoader.java

License:Apache License

@Override
public Tuple processFile(Text key, BytesWritable value, File binaryFile) throws IOException {
    boolean timedOut = false;
    Socket sock = null;//from w w w . j a  va  2 s. co  m
    BufferedReader in = null;
    OutputStream out = null;
    String result = "";
    try {
        sock = new Socket();
        if (getTimeoutMS() < (long) Integer.MAX_VALUE) {
            sock.setSoTimeout((int) getTimeoutMS());
        }

        sock.connect(clamdEndoint);

        out = sock.getOutputStream();
        in = new BufferedReader(new InputStreamReader(sock.getInputStream()));

        out.write(("nSCAN " + binaryFile.getAbsolutePath() + "\n").getBytes());
        String data = in.readLine();
        if (data != null) {
            result = data.substring(data.indexOf(':') + 1). // "remove the /path/to/file: "
                    replace(" FOUND", ""). // no need for the "FOUND" string
                    replaceAll("\\([a-f0-9:]+\\)$", "").trim(); // on some versions of clamscan, it adds (MD5:NUM)
        }
    } catch (SocketTimeoutException e) {
        result = "";
        timedOut = true;
    } finally {
        IOUtils.closeSocket(sock);
        IOUtils.closeStream(in);
        IOUtils.closeStream(out);
    }

    getProtoTuple().clear();
    getProtoTuple().add(key.toString());
    getProtoTuple().add(timedOut);
    getProtoTuple().add(result);
    return getTupleFactory().newTuple(getProtoTuple());
}

From source file:com.endgame.binarypig.loaders.TextDaemonLoader.java

License:Apache License

private void close() {
    IOUtils.closeSocket(sock);
    IOUtils.closeStream(in);
    IOUtils.closeStream(out);
}

From source file:com.mellanox.r4h.DFSClient.java

License:Apache License

/**
 * Connect to the given datanode's datantrasfer port, and return
 * the resulting IOStreamPair. This includes encryption wrapping, etc.
 *//*from   ww w. ja v  a  2 s  . co m*/
private IOStreamPair connectToDN(DatanodeInfo dn, int timeout, LocatedBlock lb) throws IOException {
    boolean success = false;
    Socket sock = null;
    try {
        sock = socketFactory.createSocket();
        String dnAddr = dn.getXferAddr(getConf().getConnectToDnViaHostname());
        if (LOG.isDebugEnabled()) {
            LOG.debug("Connecting to datanode " + dnAddr);
        }
        NetUtils.connect(sock, NetUtils.createSocketAddr(dnAddr), timeout);
        sock.setSoTimeout(timeout);

        OutputStream unbufOut = NetUtils.getOutputStream(sock);
        InputStream unbufIn = NetUtils.getInputStream(sock);
        IOStreamPair ret = saslClient.newSocketSend(sock, unbufOut, unbufIn, this, lb.getBlockToken(), dn);
        success = true;
        return ret;
    } finally {
        if (!success) {
            IOUtils.closeSocket(sock);
        }
    }
}

From source file:com.mellanox.r4h.DFSClient.java

License:Apache License

@Override
// RemotePeerFactory
public Peer newConnectedPeer(InetSocketAddress addr, Token<BlockTokenIdentifier> blockToken,
        DatanodeID datanodeId) throws IOException {
    Peer peer = null;/*from  w w  w. j a  v  a  2 s.  co  m*/
    boolean success = false;
    Socket sock = null;
    try {
        sock = socketFactory.createSocket();
        NetUtils.connect(sock, addr, getRandomLocalInterfaceAddr(), dfsClientConf.getSocketTimeout());
        peer = TcpPeerServer.peerFromSocketAndKey(saslClient, sock, this, blockToken, datanodeId);
        peer.setReadTimeout(dfsClientConf.socketTimeout());
        success = true;
        return peer;
    } finally {
        if (!success) {
            IOUtils.cleanup(LOG, peer);
            IOUtils.closeSocket(sock);
        }
    }
}

From source file:org.apache.ambari.servicemonitor.probes.PortProbe.java

License:Apache License

/**
 * Try to connect to the (host,port); a failure to connect within
 * the specified timeout is a failure/*  w ww. j  a  v  a 2  s  . c  o m*/
 * @param livePing is the ping live: true for live; false for boot time
 * @return the outcome
 */
@Override
public ProbeStatus ping(boolean livePing) {
    ProbeStatus status = new ProbeStatus();
    InetSocketAddress sockAddr = new InetSocketAddress(host, port);
    Socket socket = new Socket();
    try {
        if (LOG.isDebugEnabled()) {
            LOG.debug("Connecting to " + sockAddr.toString() + " connection-timeout="
                    + MonitorUtils.millisToHumanTime(timeout));
        }
        socket.connect(sockAddr, timeout);
        status.succeed(this);
    } catch (IOException e) {
        String error = "Probe " + sockAddr + " failed: " + e;
        LOG.debug(error, e);
        status.fail(this, new IOException(error, e));
    } finally {
        IOUtils.closeSocket(socket);
    }
    return status;

}

From source file:org.apache.hoya.servicemonitor.PortProbe.java

License:Apache License

/**
 * Try to connect to the (host,port); a failure to connect within
 * the specified timeout is a failure//from w w  w.  j  a  v a  2 s.com
 * @param livePing is the ping live: true for live; false for boot time
 * @return the outcome
 */
@Override
public ProbeStatus ping(boolean livePing) {
    ProbeStatus status = new ProbeStatus();
    InetSocketAddress sockAddr = new InetSocketAddress(host, port);
    Socket socket = new Socket();
    try {
        if (log.isDebugEnabled()) {
            log.debug("Connecting to " + sockAddr.toString() + " connection-timeout="
                    + MonitorUtils.millisToHumanTime(timeout));
        }
        socket.connect(sockAddr, timeout);
        status.succeed(this);
    } catch (IOException e) {
        String error = "Probe " + sockAddr + " failed: " + e;
        log.debug(error, e);
        status.fail(this, new IOException(error, e));
    } finally {
        IOUtils.closeSocket(socket);
    }
    return status;

}

From source file:org.apache.hoya.tools.HoyaUtils.java

License:Apache License

@SuppressWarnings("SocketOpenedButNotSafelyClosed")
public static void checkPort(String name, InetSocketAddress address, int connectTimeout) throws IOException {
    Socket socket = null;//from w  w w  .j a v a 2 s.c  om
    try {
        socket = new Socket();
        socket.connect(address, connectTimeout);
    } catch (Exception e) {
        throw new IOException("Failed to connect to " + name + " at " + address + " after " + connectTimeout
                + "millisconds" + ": " + e, e);
    } finally {
        IOUtils.closeSocket(socket);
    }
}