@Override public boolean reattachOnNewConnection(RemotingConnection newConnection) throws ActiveMQException { this.remotingConnection = newConnection; sessionChannel.transferConnection((CoreRemotingConnection) newConnection); Packet request = new ReattachSessionMessage(name, sessionChannel.getLastConfirmedCommandID()); Channel channel1 = getCoreConnection().getChannel(1, -1); ReattachSessionResponseMessage response = (ReattachSessionResponseMessage) channel1.sendBlocking(request, PacketImpl.REATTACH_SESSION_RESP); if (response.isReattached()) { ActiveMQClientLogger.LOGGER.replayingCommands(sessionChannel.getID(), response.getLastConfirmedCommandID()); // The session was found on the server - we reattached transparently ok sessionChannel.replayCommands(response.getLastConfirmedCommandID()); return true; } else { ActiveMQClientLogger.LOGGER.reconnectCreatingNewSession(sessionChannel.getID()); sessionChannel.clearCommands(); return false; } }
final int expectedEncodeSize = chunkPacket.expectedEncodeSize(); final CoreRemotingConnection connection = channel.getConnection(); final long blockingCallTimeoutMillis = Math.max(0, connection.getBlockingCallTimeout()); final long startFlowControl = System.nanoTime(); channel.sendBlocking(chunkPacket, PacketImpl.NULL_RESPONSE); } else { channel.send(chunkPacket);
@Override public RemotingConnection connect(Connection transportConnection, long callTimeout, long callFailoverTimeout, List<Interceptor> incomingInterceptors, List<Interceptor> outgoingInterceptors, TopologyResponseHandler topologyResponseHandler) { this.connection = new RemotingConnectionImpl(createPacketDecoder(), transportConnection, callTimeout, callFailoverTimeout, incomingInterceptors, outgoingInterceptors); this.topologyResponseHandler = topologyResponseHandler; getChannel0().setHandler(new Channel0Handler(connection)); sendHandshake(transportConnection); return connection; }
@Override public void cleanup() { sessionChannel.close(); // if the server is sending a disconnect // any pending blocked operation could hang without this sessionChannel.returnBlocking(); }
public ActiveMQSessionContext(String name, RemotingConnection remotingConnection, Channel sessionChannel, int serverVersion, int confirmationWindow) { super(remotingConnection); this.name = name; this.sessionChannel = sessionChannel; this.serverVersion = serverVersion; this.confirmationWindow = confirmationWindow; ChannelHandler handler = new ClientSessionPacketHandler(); sessionChannel.setHandler(handler); if (confirmationWindow >= 0) { sessionChannel.setCommandConfirmationHandler(confirmationHandler); } }
@Override public void createAddress(SimpleString address, EnumSet<RoutingType> routingTypes, final boolean autoCreated) throws ActiveMQException { CreateAddressMessage request = new CreateAddressMessage(address, routingTypes, autoCreated, true); if (!sessionChannel.getConnection().isVersionBeforeAddressChange()) { sessionChannel.sendBlocking(request, PacketImpl.NULL_RESPONSE); } }
private void sendPacketWithoutLock(final Channel parameterChannel, final Packet packet) { packet.setChannelID(parameterChannel.getID()); Connection conn = parameterChannel.getConnection().getTransportConnection(); ActiveMQBuffer buffer = packet.encode(this.getCoreConnection()); conn.write(buffer, false, false); }
@Override public void sendFullMessage(ICoreMessage msgI, boolean sendBlocking, SendAcknowledgementHandler handler, SimpleString defaultAddress) throws ActiveMQException { SessionSendMessage packet; if (sessionChannel.getConnection().isVersionBeforeAddressChange()) { packet = new SessionSendMessage_1X(msgI, sendBlocking, handler); } else { packet = new SessionSendMessage(msgI, sendBlocking, handler); } if (sendBlocking) { sessionChannel.sendBlocking(packet, PacketImpl.NULL_RESPONSE); } else { sessionChannel.sendBatched(packet); } }
@Override public void sessionStart() throws ActiveMQException { sessionChannel.send(new PacketImpl(PacketImpl.SESS_START)); }
private void doConfirmAndResponse(final Packet confirmPacket, final Packet response, final boolean flush, final boolean closeChannel) { // don't confirm if the response is an exception if (confirmPacket != null && (response == null || (response != null && response.getType() != PacketImpl.EXCEPTION))) { channel.confirm(confirmPacket); if (flush) { channel.flushConfirmations(); } } if (response != null) { channel.send(response); } if (closeChannel) { channel.close(); } }
@Override public void disconnect(String scaleDownNodeID, final boolean criticalError) { Channel channel0 = getChannel(ChannelImpl.CHANNEL_ID.PING.id, -1); // And we remove all channels from the connection, this ensures no more packets will be processed after this // method is // complete Set<Channel> allChannels = new HashSet<>(channels.values()); if (!criticalError) { removeAllChannels(); } else { // We can't hold a lock if a critical error is happening... // as other threads will be holding the lock while hanging on IO channels.clear(); } // Now we are 100% sure that no more packets will be processed we can flush then send the disconnect if (!criticalError) { for (Channel channel : allChannels) { channel.flushConfirmations(); } } Packet disconnect; if (channel0.supports(PacketImpl.DISCONNECT_V2)) { disconnect = new DisconnectMessage_V2(nodeID, scaleDownNodeID); } else { disconnect = new DisconnectMessage(nodeID); } channel0.sendAndFlush(disconnect); }
@Override public int recoverSessionTimeout() throws ActiveMQException { SessionXAGetTimeoutResponseMessage response = (SessionXAGetTimeoutResponseMessage) sessionChannel.sendBlocking(new PacketImpl(PacketImpl.SESS_XA_GET_TIMEOUT), PacketImpl.SESS_XA_GET_TIMEOUT_RESP); return response.getTimeoutSeconds(); }
channel.transferConnection(newConnection); remotingConnection.setFailureListeners(failureListeners); int serverLastReceivedCommandID = channel.getLastConfirmedCommandID(); channel.replayCommands(lastReceivedCommandID); channel.setTransferring(false);
@Override public void simpleCommit(boolean block) throws ActiveMQException { if (block) { sessionChannel.sendBlocking(new PacketImpl(PacketImpl.SESS_COMMIT), PacketImpl.NULL_RESPONSE); } else { sessionChannel.sendBatched(new PacketImpl(PacketImpl.SESS_COMMIT)); } }
protected CreateSessionMessage newCreateSession(String username, String password, int minLargeMessageSize, boolean xa, boolean autoCommitSends, boolean autoCommitAcks, boolean preAcknowledge) { return new CreateSessionMessage(name, sessionChannel.getID(), getServerVersion(), username, password, minLargeMessageSize, xa, autoCommitSends, autoCommitAcks, preAcknowledge, confirmationWindow, null); }
@Override public void flush() { synchronized (transferLock) { for (Channel channel : channels.values()) { channel.flushConfirmations(); } } }
@Override public boolean isSupportReconnect() { for (Channel channel : channels.values()) { if (channel.getConfirmationWindowSize() > 0) { return true; } } return false; }
sessionChannel.confirm(packet);
private void internalClose() { // We close the underlying transport connection getTransportConnection().close(); for (Channel channel : channels.values()) { channel.close(); } }
response = new ReattachSessionResponseMessage(-1, false); } else { if (sessionHandler.getChannel().getConfirmationWindowSize() == -1) { channel1.send(response);