Java tutorial
/* * 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.lealone.cluster.streaming; import java.io.BufferedOutputStream; import java.io.IOException; import java.net.Socket; import java.net.SocketException; import java.nio.ByteBuffer; import java.nio.channels.Channels; import java.nio.channels.ReadableByteChannel; import java.util.Collection; import java.util.Comparator; import java.util.concurrent.PriorityBlockingQueue; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; import org.lealone.cluster.io.DataOutputStreamPlus; import org.lealone.cluster.streaming.messages.StreamInitMessage; import org.lealone.cluster.streaming.messages.StreamMessage; import org.lealone.cluster.utils.JVMStabilityInspector; import org.lealone.cluster.utils.Utils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import com.google.common.util.concurrent.SettableFuture; /** * ConnectionHandler manages incoming/outgoing message exchange for the {@link StreamSession}. * * <p> * Internally, ConnectionHandler manages thread to receive incoming {@link StreamMessage} and thread to * send outgoing message. Messages are encoded/decoded on those thread and handed to * {@link StreamSession#messageReceived(org.lealone.cluster.streaming.messages.StreamMessage)}. */ public class ConnectionHandler { private static final Logger logger = LoggerFactory.getLogger(ConnectionHandler.class); private final StreamSession session; private final IncomingMessageHandler incoming; private final OutgoingMessageHandler outgoing; ConnectionHandler(StreamSession session) { this.session = session; this.incoming = new IncomingMessageHandler(session); this.outgoing = new OutgoingMessageHandler(session); } /** * Set up incoming message handler and initiate streaming. * * This method is called once on initiator. * * @throws IOException */ @SuppressWarnings("resource") public void initiate() throws IOException { logger.debug("[Stream #{}] Sending stream init for incoming stream", session.planId()); Socket incomingSocket = session.createConnection(); incoming.start(incomingSocket, StreamMessage.CURRENT_VERSION); incoming.sendInitMessage(incomingSocket, true); logger.debug("[Stream #{}] Sending stream init for outgoing stream", session.planId()); Socket outgoingSocket = session.createConnection(); outgoing.start(outgoingSocket, StreamMessage.CURRENT_VERSION); outgoing.sendInitMessage(outgoingSocket, false); } /** * Set up outgoing message handler on receiving side. * * @param socket socket to use for {@link org.lealone.cluster.streaming.ConnectionHandler.OutgoingMessageHandler}. * @param version Streaming message version * @throws IOException */ public void initiateOnReceivingSide(Socket socket, boolean isForOutgoing, int version) throws IOException { if (isForOutgoing) outgoing.start(socket, version); else incoming.start(socket, version); } @SuppressWarnings("unchecked") public ListenableFuture<?> close() { logger.debug("[Stream #{}] Closing stream connection handler on {}", session.planId(), session.peer); ListenableFuture<?> inClosed = incoming == null ? Futures.immediateFuture(null) : incoming.close(); ListenableFuture<?> outClosed = outgoing == null ? Futures.immediateFuture(null) : outgoing.close(); return Futures.allAsList(inClosed, outClosed); } /** * Enqueue messages to be sent. * * @param messages messages to send */ public void sendMessages(Collection<? extends StreamMessage> messages) { for (StreamMessage message : messages) sendMessage(message); } public void sendMessage(StreamMessage message) { if (outgoing.isClosed()) throw new RuntimeException("Outgoing stream handler has been closed"); outgoing.enqueue(message); } /** * @return true if outgoing connection is opened and ready to send messages */ public boolean isOutgoingConnected() { return outgoing != null && !outgoing.isClosed(); } abstract static class MessageHandler implements Runnable { protected final StreamSession session; protected int protocolVersion; protected Socket socket; private final AtomicReference<SettableFuture<?>> closeFuture = new AtomicReference<>(); protected MessageHandler(StreamSession session) { this.session = session; } protected abstract String name(); @SuppressWarnings("resource") protected static DataOutputStreamPlus getWriteChannel(Socket socket) throws IOException { return new DataOutputStreamPlus(new BufferedOutputStream(socket.getOutputStream())); // WritableByteChannel out = socket.getChannel(); // // socket channel is null when encrypted(SSL) // if (out == null) // return new DataOutputStreamPlus(new BufferedOutputStream(socket.getOutputStream())); // return new DataOutputStreamPlus(out); } protected static ReadableByteChannel getReadChannel(Socket socket) throws IOException { ReadableByteChannel in = socket.getChannel(); // socket channel is null when encrypted(SSL) return in == null ? Channels.newChannel(socket.getInputStream()) : in; } @SuppressWarnings("resource") public void sendInitMessage(Socket socket, boolean isForOutgoing) throws IOException { StreamInitMessage message = new StreamInitMessage(Utils.getBroadcastAddress(), session.sessionIndex(), session.planId(), session.description(), isForOutgoing); ByteBuffer messageBuf = message.createMessage(false, protocolVersion); DataOutputStreamPlus out = getWriteChannel(socket); out.write(messageBuf); out.flush(); } public void start(Socket socket, int protocolVersion) { this.socket = socket; this.protocolVersion = protocolVersion; new Thread(this, name() + "-" + session.peer).start(); } public ListenableFuture<?> close() { // Assume it wasn't closed. Not a huge deal if we create a future on a race SettableFuture<?> future = SettableFuture.create(); return closeFuture.compareAndSet(null, future) ? future : closeFuture.get(); } public boolean isClosed() { return closeFuture.get() != null; } protected void signalCloseDone() { closeFuture.get().set(null); // We can now close the socket try { socket.close(); } catch (IOException e) { // Erroring out while closing shouldn't happen but is not really a big deal, so just log // it at DEBUG and ignore otherwise. logger.debug("Unexpected error while closing streaming connection", e); } } } /** * Incoming streaming message handler */ static class IncomingMessageHandler extends MessageHandler { IncomingMessageHandler(StreamSession session) { super(session); } @Override protected String name() { return "STREAM-IN"; } @Override @SuppressWarnings("resource") public void run() { try { ReadableByteChannel in = getReadChannel(socket); while (!isClosed()) { // receive message StreamMessage message = StreamMessage.deserialize(in, protocolVersion, session); // Might be null if there is an error during streaming (see FileMessage.deserialize). It's ok // to ignore here since we'll have asked for a retry. if (message != null) { logger.debug("[Stream #{}] Received {}", session.planId(), message); session.messageReceived(message); } } } catch (SocketException e) { // socket is closed close(); } catch (Throwable t) { JVMStabilityInspector.inspectThrowable(t); session.onError(t); } finally { signalCloseDone(); } } } /** * Outgoing file transfer thread */ static class OutgoingMessageHandler extends MessageHandler { /* * All out going messages are queued up into messageQueue. * The size will grow when received streaming request. * * Queue is also PriorityQueue so that prior messages can go out fast. */ private final PriorityBlockingQueue<StreamMessage> messageQueue = new PriorityBlockingQueue<>(64, new Comparator<StreamMessage>() { @Override public int compare(StreamMessage o1, StreamMessage o2) { return o2.getPriority() - o1.getPriority(); } }); OutgoingMessageHandler(StreamSession session) { super(session); } @Override protected String name() { return "STREAM-OUT"; } public void enqueue(StreamMessage message) { messageQueue.put(message); } @Override @SuppressWarnings("resource") public void run() { try { DataOutputStreamPlus out = getWriteChannel(socket); StreamMessage next; while (!isClosed()) { if ((next = messageQueue.poll(1, TimeUnit.SECONDS)) != null) { logger.debug("[Stream #{}] Sending {}", session.planId(), next); sendMessage(out, next); if (next.type == StreamMessage.Type.SESSION_FAILED) close(); } } // Sends the last messages on the queue while ((next = messageQueue.poll()) != null) sendMessage(out, next); } catch (InterruptedException e) { throw new AssertionError(e); } catch (Throwable e) { session.onError(e); } finally { signalCloseDone(); } } private void sendMessage(DataOutputStreamPlus out, StreamMessage message) { try { StreamMessage.serialize(message, out, protocolVersion, session); out.flush(); } catch (SocketException e) { session.onError(e); close(); } catch (IOException e) { session.onError(e); } } } }