io.netty.channel.ChannelHandlerContext#connect ( )源码实例Demo

/**
 * Intercept the connect phase and store the original promise.
 */
@Override
public void connect(final ChannelHandlerContext ctx, final SocketAddress remoteAddress,
                    final SocketAddress localAddress, final ChannelPromise promise) throws Exception {
  originalPromise = promise;
  ChannelPromise inboundPromise = ctx.newPromise();
  inboundPromise.addListener(new GenericFutureListener<Future<Void>>() {
    @Override
    public void operationComplete(Future<Void> future) throws Exception {
      if (!future.isSuccess() && !originalPromise.isDone()) {
        originalPromise.setFailure(future.cause());
      }
    }
  });
  ctx.connect(remoteAddress, localAddress, inboundPromise);
}
 

@Override
public void connect(final ChannelHandlerContext ctx, final SocketAddress remoteAddress,
                    final SocketAddress localAddress, final ChannelPromise promise) throws Exception {
  ctx.connect(remoteAddress, localAddress, promise);
  ctx.pipeline().remove(this);

  final Runnable fireDeadlineEvent = new Runnable() {
    /**
     * If there is a {@link ConnectInterceptingHandler} remaining in the pipeline,
     * it will respond to this event by failing the connection. If there are none
     * in the pipeline, the handshake is complete and this event is ignored.
     */
    @Override
    public void run() {
      LOGGER.debug("Firing handshake deadline event.");
      ctx.fireUserEventTriggered(HANDSHAKE_DEADLINE_EVENT);
    }
  };

  LOGGER.debug("Handshake timeout is {} {}.", timeout, timeoutUnit);
  ctx.executor().schedule(fireDeadlineEvent, timeout, timeoutUnit);
}
 

@Override
public void connect(
    ChannelHandlerContext ctx,
    SocketAddress remoteAddress,
    SocketAddress localAddress,
    ChannelPromise promise) {
  ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
    ChannelPromise promise) throws Exception {
    originalPromise = promise;
    ChannelPromise downPromise = ctx.newPromise();
    downPromise.addListener(new GenericFutureListener<Future<Void>>() {
        @Override
        public void operationComplete(Future<Void> future) throws Exception {
            if (!future.isSuccess() && !originalPromise.isDone()) {
                originalPromise.setFailure(future.cause());
            }
        }
    });
    ctx.connect(remoteAddress, localAddress, downPromise);
}
 

@Override
public final void connect(
        ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
        ChannelPromise promise) throws Exception {

    if (destinationAddress != null) {
        promise.setFailure(new ConnectionPendingException());
        return;
    }

    destinationAddress = remoteAddress;
    ctx.connect(proxyAddress, localAddress, promise);
}
 

@Override
public void connect(
        ChannelHandlerContext ctx,
        SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) throws Exception {
    if (logger.isEnabled(internalLevel)) {
        logger.log(internalLevel, format(ctx, "CONNECT", remoteAddress, localAddress));
    }
    ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
                    ChannelPromise promise) throws Exception {
    originalPromise = promise;
    ChannelPromise downPromise = ctx.newPromise();
    downPromise.addListener(new GenericFutureListener<Future<Void>>() {
        @Override
        public void operationComplete(Future<Void> future) throws Exception {
            if (!future.isSuccess() && !originalPromise.isDone()) {
                originalPromise.setFailure(future.cause());
            }
        }
    });
    ctx.connect(remoteAddress, localAddress, downPromise);
}
 

@SuppressWarnings("FutureReturnValueIgnored")
@Override
public void connect(
    ChannelHandlerContext ctx,
    SocketAddress remoteAddress,
    SocketAddress localAddress,
    ChannelPromise promise) {
  ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(
        ChannelHandlerContext ctx,
        SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) throws Exception {
    if (logger.isEnabled(internalLevel)) {
        logger.log(internalLevel, format(ctx, "CONNECT", remoteAddress, localAddress));
    }
    ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(
    ChannelHandlerContext ctx,
    SocketAddress remoteAddress,
    SocketAddress localAddress,
    ChannelPromise promise) {
  ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
                    ChannelPromise promise) throws Exception {
    originalPromise = promise;
    ChannelPromise downPromise = ctx.newPromise();
    downPromise.addListener(new GenericFutureListener<Future<Void>>() {
        @Override
        public void operationComplete(Future<Void> future) throws Exception {
            if (!future.isSuccess() && !originalPromise.isDone()) {
                originalPromise.setFailure(future.cause());
            }
        }
    });
    ctx.connect(remoteAddress, localAddress, downPromise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
                    ChannelPromise promise) throws Exception {

    // Remember the requested remote address for later use.
    final InetSocketAddress inetRemoteAddr = (InetSocketAddress) remoteAddress;
    this.remoteAddress = inetRemoteAddr;

    // Configure the pipeline.
    final Channel ch = ctx.channel();
    ChannelUtil.disableWriterBufferWatermark(ch);

    final ChannelPipeline p = ch.pipeline();
    p.addLast(new FlushConsolidationHandler());
    p.addLast(ReadSuppressingAndChannelDeactivatingHandler.INSTANCE);

    try {
        if (sslCtx != null) {
            configureAsHttps(ch, inetRemoteAddr);
        } else {
            configureAsHttp(ch);
        }
    } catch (Throwable t) {
        promise.tryFailure(t);
        ctx.close();
    } finally {
        if (p.context(this) != null) {
            p.remove(this);
        }
    }

    ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext nettyctx, SocketAddress remoteAddress,
        SocketAddress localAddress, ChannelPromise promise)
        throws Exception {
    nettyctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
                    ChannelPromise promise) throws Exception {
    ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
                    ChannelPromise promise) throws Exception {
    ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
                    ChannelPromise promise) throws Exception {
    ctx.connect(remoteAddress, localAddress, promise);
}
 

public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) {
    ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress,
                    ChannelPromise promise) throws Exception {
    ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) throws Exception {
  if (DEBUG_CALLS) Gdx.app.debug(TAG, "connect");
  ctx.connect(remoteAddress, localAddress, promise);
}
 

@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) throws Exception {
  if (DEBUG_CALLS) Gdx.app.debug(TAG, "connect");
  ctx.connect(remoteAddress, localAddress, promise);
}