Java GenericFutureListener类代码示例

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
public synchronized ListenableFuture<Void> connect ()
{
    if ( this.connectFuture != null )
    {
        return this.connectFuture;
    }

    final ChannelFuture channelFuture = this.bootstrap.connect ( this.address );
    this.connectFuture = SettableFuture.create ();

    channelFuture.addListener ( new GenericFutureListener<ChannelFuture> () {

        @Override
        public void operationComplete ( final ChannelFuture future ) throws Exception
        {
            handleOperationComplete ( Client.this.connectFuture, future );
        }
    } );

    return this.connectFuture;
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
/**
 * Establishes a new socket connection with connection test
 */
protected void setupWithTest() {
  ChannelFuture future = boot.connect(uri.host(), port);
  future.addListener(
      new GenericFutureListener<ChannelFuture>() {

        public void operationComplete(ChannelFuture f) {
          if (f.isSuccess()) {
            channel = (HTTPChannel) f.channel();
            testConnection();
            onTestBell.promise(onConnectBell);
          } else {
            onConnectBell.ring(f.cause());
          }
        }
      });
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
/**
 * Kick a player from the server with a reason
 */
public void kickPlayerFromServer(String reason)
{
    final ChatComponentText chatcomponenttext = new ChatComponentText(reason);
    this.netManager.sendPacket(new S40PacketDisconnect(chatcomponenttext), new GenericFutureListener < Future <? super Void >> ()
    {
        public void operationComplete(Future <? super Void > p_operationComplete_1_) throws Exception
        {
            NetHandlerPlayServer.this.netManager.closeChannel(chatcomponenttext);
        }
    }, new GenericFutureListener[0]);
    this.netManager.disableAutoRead();
    Futures.getUnchecked(this.serverController.addScheduledTask(new Runnable()
    {
        public void run()
        {
            NetHandlerPlayServer.this.netManager.checkDisconnected();
        }
    }));
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
public void sendPacket(Packet packetIn)
{
    if (this.isChannelOpen())
    {
        this.flushOutboundQueue();
        this.dispatchPacket(packetIn, (GenericFutureListener <? extends Future <? super Void >> [])null);
    }
    else
    {
        this.field_181680_j.writeLock().lock();

        try
        {
            this.outboundPacketsQueue.add(new NetworkManager.InboundHandlerTuplePacketListener(packetIn, (GenericFutureListener[])null));
        }
        finally
        {
            this.field_181680_j.writeLock().unlock();
        }
    }
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
public RemoteConnection(SocketChannel channel, String name) {
  super();
  this.channel = channel;
  this.clientName = name;
  this.writeManager = new WriteManager();
  channel.pipeline().addLast(new BackPressureHandler());
  channel.closeFuture().addListener(new GenericFutureListener<Future<? super Void>>() {
    public void operationComplete(Future<? super Void> future) throws Exception {
      // this could possibly overrelease but it doesn't matter since we're only going to do this to ensure that we
      // fail out any pending messages
      writeManager.disable();
      writeManager.setWritable(true);
    }
  });

}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
/**
 * Kick a player from the server with a reason
 */
public void kickPlayerFromServer(String reason)
{
    final TextComponentString textcomponentstring = new TextComponentString(reason);
    this.netManager.sendPacket(new SPacketDisconnect(textcomponentstring), new GenericFutureListener < Future <? super Void >> ()
    {
        public void operationComplete(Future <? super Void > p_operationComplete_1_) throws Exception
        {
            NetHandlerPlayServer.this.netManager.closeChannel(textcomponentstring);
        }
    }, new GenericFutureListener[0]);
    this.netManager.disableAutoRead();
    Futures.getUnchecked(this.serverController.addScheduledTask(new Runnable()
    {
        public void run()
        {
            NetHandlerPlayServer.this.netManager.checkDisconnected();
        }
    }));
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
@Override
public void connectionSucceeded(final ServerConnection connection) {
  connection.getChannel().closeFuture().addListener(
      new GenericFutureListener<Future<? super Void>>() {
        @Override
        public void operationComplete(Future<? super Void> future)
            throws Exception {
          for (final UserResultsListener listener : queryIdToResultsListenersMap.values()) {
            listener.submissionFailed(UserException.connectionError()
                .message("Connection %s closed unexpectedly. SabotNode down?",
                    connection.getName())
                .build(logger));
            if (listener instanceof BufferingResultsListener) {
              // the appropriate listener will be failed by SubmissionListener#failed
              logger.warn("Buffering listener failed before results were transferred to the actual listener.");
            }
          }
        }
      });
  parentHandler.connectionSucceeded(connection);
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
private void kickWithMessage(String message)
{
    final TextComponentString TextComponentString = new TextComponentString(message);
    if (side == Side.CLIENT)
    {
        manager.closeChannel(TextComponentString);
    }
    else
    {
        manager.sendPacket(new SPacketDisconnect(TextComponentString), new GenericFutureListener<Future<? super Void>>()
        {
            @Override
            public void operationComplete(Future<? super Void> result)
            {
                manager.closeChannel(TextComponentString);
            }
        }, (GenericFutureListener<? extends Future<? super Void>>[])null);
    }
    manager.channel().config().setAutoRead(false);
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
public void sendPacket(Packet<?> packetIn)
{
    if (this.isChannelOpen())
    {
        this.flushOutboundQueue();
        this.dispatchPacket(packetIn, (GenericFutureListener <? extends Future <? super Void >> [])null);
    }
    else
    {
        this.readWriteLock.writeLock().lock();

        try
        {
            this.outboundPacketsQueue.add(new NetworkManager.InboundHandlerTuplePacketListener(packetIn, (GenericFutureListener[])null));
        }
        finally
        {
            this.readWriteLock.writeLock().unlock();
        }
    }
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
private void kickWithMessage(String message)
{
    final ChatComponentText chatcomponenttext = new ChatComponentText(message);
    if (side == Side.CLIENT)
    {
        manager.func_150718_a(chatcomponenttext);
    }
    else
    {
        manager.func_150725_a(new S40PacketDisconnect(chatcomponenttext), new GenericFutureListener<Future<?>>()
        {
            @Override
            public void operationComplete(Future<?> result)
            {
                manager.func_150718_a(chatcomponenttext);
            }
        });
    }
    manager.channel().config().setAutoRead(false);
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
@Override
public void sendOneWayMessage(Message message, SendResultCallback callback) {
    if (message.getMessageId() == null) {
        message.assignMessageId();
    }
    io.netty.channel.Channel _socket = this.socket;
    if (_socket == null || !_socket.isOpen()) {
        callback.messageSent(message, new Exception(this + " connection is closed"));
        return;
    }
    _socket.writeAndFlush(message).addListener(new GenericFutureListener() {

        @Override
        public void operationComplete(Future future) throws Exception {
            if (future.isSuccess()) {
                callback.messageSent(message, null);
            } else {
                LOGGER.log(Level.SEVERE, this + ": error " + future.cause(), future.cause());
                callback.messageSent(message, future.cause());
                close();
            }
        }

    });
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
@Test
public void finalizeChannelPipeline_should_send_event_to_metricsListener_for_successful_response_and_flush_context() throws Exception {
    // given
    ChannelFuture responseWriterChannelFuture = mock(ChannelFuture.class);
    state.setResponseWriterFinalChunkChannelFuture(responseWriterChannelFuture);
    HttpProcessingState stateSpy = spy(state);
    doReturn(stateSpy).when(stateAttributeMock).get();
    ChannelFuture responseWriteFutureResult = mock(ChannelFuture.class);
    doReturn(true).when(responseWriteFutureResult).isSuccess();
    Assertions.assertThat(stateSpy.isRequestMetricsRecordedOrScheduled()).isFalse();

    // when
    handler.finalizeChannelPipeline(ctxMock, null, stateSpy, null);

    // then
    ArgumentCaptor<GenericFutureListener> channelFutureListenerArgumentCaptor = ArgumentCaptor.forClass(GenericFutureListener.class);
    verify(responseWriterChannelFuture).addListener(channelFutureListenerArgumentCaptor.capture());
    GenericFutureListener futureListener = channelFutureListenerArgumentCaptor.getValue();
    assertThat(futureListener, notNullValue());
    futureListener.operationComplete(responseWriteFutureResult);

    verify(metricsListenerMock).onEvent(eq(ServerMetricsEvent.RESPONSE_SENT), any(HttpProcessingState.class));
    verify(ctxMock).flush();
    Assertions.assertThat(stateSpy.isRequestMetricsRecordedOrScheduled()).isTrue();
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
@Test
public void finalizeChannelPipeline_should_send_event_to_metricsListener_for_failure_response_and_flush_context() throws Exception {
    // given
    ChannelFuture responseWriterChannelFuture = mock(ChannelFuture.class);
    state.setResponseWriterFinalChunkChannelFuture(responseWriterChannelFuture);
    HttpProcessingState stateSpy = spy(state);
    doReturn(stateSpy).when(stateAttributeMock).get();
    ChannelFuture responseWriteFutureResult = mock(ChannelFuture.class);
    doReturn(false).when(responseWriteFutureResult).isSuccess();
    Assertions.assertThat(stateSpy.isRequestMetricsRecordedOrScheduled()).isFalse();

    // when
    handler.finalizeChannelPipeline(ctxMock, null, stateSpy, null);

    // then
    ArgumentCaptor<GenericFutureListener> channelFutureListenerArgumentCaptor = ArgumentCaptor.forClass(GenericFutureListener.class);
    verify(responseWriterChannelFuture).addListener(channelFutureListenerArgumentCaptor.capture());
    GenericFutureListener futureListener = channelFutureListenerArgumentCaptor.getValue();
    assertThat(futureListener, notNullValue());
    futureListener.operationComplete(responseWriteFutureResult);

    verify(metricsListenerMock).onEvent(ServerMetricsEvent.RESPONSE_WRITE_FAILED, null);
    verify(ctxMock).flush();
    Assertions.assertThat(stateSpy.isRequestMetricsRecordedOrScheduled()).isTrue();
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
private void verifyCloseFutureListener(GenericFutureListener closeFutureListener) throws Exception {
    // If the double-check ScheduledFuture is not done then it cancels it.
    reset(doubleCheckScheduledFutureMock);
    doReturn(false).when(doubleCheckScheduledFutureMock).isDone();
    closeFutureListener.operationComplete(null);
    verify(doubleCheckScheduledFutureMock).isDone();
    verify(doubleCheckScheduledFutureMock).cancel(false);
    verifyNoMoreInteractions(doubleCheckScheduledFutureMock);

    // And when the double-check ScheduledFuture is done, then nothing happens.
    reset(doubleCheckScheduledFutureMock);
    doReturn(true).when(doubleCheckScheduledFutureMock).isDone();
    closeFutureListener.operationComplete(null);
    verify(doubleCheckScheduledFutureMock).isDone();
    verifyNoMoreInteractions(doubleCheckScheduledFutureMock);
}
 

import io.netty.util.concurrent.GenericFutureListener; //导入依赖的package包/类
@DataProvider(value = {
    "0",
    "1"
})
@Test
public void doChannelActive_marks_and_schedules_double_check_timeout_if_too_many_open_channels(
    int numOpenChannelsGreaterThanMax
) throws Exception {
    // given
    int actualOpenChannels = maxOpenChannelsThreshold + numOpenChannelsGreaterThanMax;
    setActualOpenChannels(actualOpenChannels);

    // when
    PipelineContinuationBehavior result = handler.doChannelActive(ctxMock);

    // then
    assertThat(result).isEqualTo(CONTINUE);
    Pair<Runnable, GenericFutureListener> futureInfoPair = extractDoubleCheckRunnableAndCloseFutureListener();
    verify(tooManyOpenConnectionsAttributeMock).set(actualOpenChannels);
    verifyDoubleCheckFuture(futureInfoPair.getLeft());
    verifyCloseFutureListener(futureInfoPair.getRight());
    verify(channelGroupMock, never()).add(channelMock);
}