io.netty.util.AttributeMap Java Examples

@BeforeEach
void setUp() {
    counter = new AtomicInteger();
    listener = new ConnectionPoolListener() {
        @Override
        public void connectionOpen(SessionProtocol protocol, InetSocketAddress remoteAddr,
                                   InetSocketAddress localAddr, AttributeMap attrs) throws Exception {
            counter.incrementAndGet();
        }

        @Override
        public void connectionClosed(SessionProtocol protocol, InetSocketAddress remoteAddr,
                                     InetSocketAddress localAddr, AttributeMap attrs) throws Exception {
            counter.decrementAndGet();
        }
    };
}
 

@BeforeEach
void setUp() {
    opened = new AtomicInteger();
    closed = new AtomicInteger();
    connectionPoolListener = new ConnectionPoolListener() {
        @Override
        public void connectionOpen(SessionProtocol protocol, InetSocketAddress remoteAddr,
                                   InetSocketAddress localAddr, AttributeMap attrs) throws Exception {
            opened.incrementAndGet();
        }

        @Override
        public void connectionClosed(SessionProtocol protocol, InetSocketAddress remoteAddr,
                                     InetSocketAddress localAddr, AttributeMap attrs) throws Exception {
            closed.incrementAndGet();
        }
    };
}
 

@Override
public void connectionOpen(SessionProtocol protocol,
                           InetSocketAddress remoteAddr,
                           InetSocketAddress localAddr,
                           AttributeMap attrs) throws Exception {
    final int activeChannels = this.activeChannels.incrementAndGet();
    if (logger.isInfoEnabled()) {
        attrs.attr(OPEN_NANOS).set(ticker.read());
        logger.info("[L:{} - R:{}][{}] OPEN (active channels: {})",
                    localAddr, remoteAddr, protocol.uriText(), activeChannels);
    }
}
 

@Override
public void connectionClosed(SessionProtocol protocol,
                             InetSocketAddress remoteAddr,
                             InetSocketAddress localAddr,
                             AttributeMap attrs) throws Exception {
    final int activeChannels = this.activeChannels.decrementAndGet();
    if (logger.isInfoEnabled() && attrs.hasAttr(OPEN_NANOS)) {
        final long closeNanos = ticker.read();
        final long elapsedNanos = closeNanos - attrs.attr(OPEN_NANOS).get();
        logger.info("[L:{} ! R:{}][{}] CLOSED (lasted for: {}, active channels: {})",
                    localAddr, remoteAddr, protocol.uriText(),
                    TextFormatter.elapsed(elapsedNanos), activeChannels);
    }
}
 

@Override
public void onChannelInactive(AttributeMap attMap) {
  C connection = attMap.attr(this.connection).getAndRemove();
  if (connection != null) {
    connection.close();
  }
}
 

@Override
public void onChannelActive(AttributeMap attMap) {
  C newConnection = safeRequestProcessor.openConnection();
  Connection oldConnection = attMap.attr(connection).setIfAbsent(
      newConnection
  );
  if (oldConnection != null) {
    throw new IllegalArgumentException("A connection with id "
        + oldConnection.getConnectionId() + " was stored before "
        + "channel became active!");
  }
}
 

@Override
public void connectionOpen(SessionProtocol protocol,
                           InetSocketAddress remoteAddr,
                           InetSocketAddress localAddr,
                           AttributeMap attrs) throws Exception {
    delegate().connectionOpen(protocol, remoteAddr, localAddr, attrs);
}
 

@Override
public void connectionClosed(SessionProtocol protocol,
                             InetSocketAddress remoteAddr,
                             InetSocketAddress localAddr,
                             AttributeMap attrs) throws Exception {
    delegate().connectionClosed(protocol, remoteAddr, localAddr, attrs);
}
 

@Override
public void connectionOpen(SessionProtocol protocol, InetSocketAddress remoteAddr,
                           InetSocketAddress localAddr, AttributeMap attrs) throws Exception {
    final ConnectionPoolListener connectionPoolListener =
            HttpClientMaxConcurrentStreamTest.this.connectionPoolListener;
    if (connectionPoolListener != null) {
        connectionPoolListener.connectionOpen(protocol, remoteAddr, localAddr, attrs);
    }
}
 

@Override
public void connectionClosed(SessionProtocol protocol, InetSocketAddress remoteAddr,
                             InetSocketAddress localAddr, AttributeMap attrs) throws Exception {
    final ConnectionPoolListener connectionPoolListener =
            HttpClientMaxConcurrentStreamTest.this.connectionPoolListener;
    if (connectionPoolListener != null) {
        connectionPoolListener.connectionClosed(protocol, remoteAddr, localAddr, attrs);
    }
}
 

/**
 * Invoked when a new connection is open and ready to send a request.
 */
void connectionOpen(SessionProtocol protocol,
                    InetSocketAddress remoteAddr,
                    InetSocketAddress localAddr,
                    AttributeMap attrs) throws Exception;
 

@Override
public AttributeMap getAttributeMap() {
  return attributeMap;
}
 

public PojoMessageReplier(int requestId, AttributeMap attributeMap) {
  this.requestId = requestId;
  this.attributeMap = attributeMap;
}
 

@Nonnull
protected Connection getConnection(AttributeMap attMap) {
  return attMap.attr(connection).get();
}
 

@Override
public AttributeMap getAttributeMap() {
  return channelHandlerContext;
}
 

@Override
protected void channelRead0(final ChannelHandlerContext channelHandlerContext, final ResponseMessage response) throws Exception {
    // We are only interested in AUTHENTICATE responses here. Everything else can
    // get passed down the pipeline
    if (response.getStatus().getCode() == ResponseStatusCode.AUTHENTICATE) {
        final Attribute<SaslClient> saslClient = ((AttributeMap) channelHandlerContext).attr(saslClientKey);
        final Attribute<Subject> subject = ((AttributeMap) channelHandlerContext).attr(subjectKey);
        final RequestMessage.Builder messageBuilder = RequestMessage.build(Tokens.OPS_AUTHENTICATION);
        // First time through we don't have a sasl client
        if (saslClient.get() == null) {
            subject.set(login());
            try {
                saslClient.set(saslClient(getHostName(channelHandlerContext)));
            } catch (SaslException saslException) {
                // push the sasl error into a failure response from the server. this ensures that standard
                // processing for the ResultQueue is kept. without this SaslException trap and subsequent
                // conversion to an authentication failure, the close() of the connection might not
                // succeed as it will appear as though pending messages remain present in the queue on the
                // connection and the shutdown won't proceed
                final ResponseMessage clientSideError = ResponseMessage.build(response.getRequestId())
                        .code(ResponseStatusCode.FORBIDDEN).statusMessage(saslException.getMessage()).create();
                channelHandlerContext.fireChannelRead(clientSideError);
                return;
            }

            messageBuilder.addArg(Tokens.ARGS_SASL_MECHANISM, getMechanism());
            messageBuilder.addArg(Tokens.ARGS_SASL, saslClient.get().hasInitialResponse() ?
                    BASE64_ENCODER.encodeToString(evaluateChallenge(subject, saslClient, NULL_CHALLENGE)) : null);
        } else {
            // the server sends base64 encoded sasl as well as the byte array. the byte array will eventually be
            // phased out, but is present now for backward compatibility in 3.2.x
            final String base64sasl = response.getStatus().getAttributes().containsKey(Tokens.ARGS_SASL) ?
                response.getStatus().getAttributes().get(Tokens.ARGS_SASL).toString() :
                BASE64_ENCODER.encodeToString((byte[]) response.getResult().getData());

            messageBuilder.addArg(Tokens.ARGS_SASL, BASE64_ENCODER.encodeToString(
                evaluateChallenge(subject, saslClient, BASE64_DECODER.decode(base64sasl))));
        }
        channelHandlerContext.writeAndFlush(messageBuilder.create());
    } else {
        channelHandlerContext.fireChannelRead(response);
    }
}
 

@Override
public void connectionClosed(SessionProtocol protocol,
                             InetSocketAddress remoteAddr,
                             InetSocketAddress localAddr,
                             AttributeMap attrs) throws Exception {}
 

@Override
public void connectionOpen(SessionProtocol protocol,
                           InetSocketAddress remoteAddr,
                           InetSocketAddress localAddr,
                           AttributeMap attrs) throws Exception {}
 

/**
 * Invoked when a connection in the connection pool has been closed.
 */
void connectionClosed(SessionProtocol protocol,
                      InetSocketAddress remoteAddr,
                      InetSocketAddress localAddr,
                      AttributeMap attrs) throws Exception;
 

public AttributeMap getAttribute() {
    return attribute;
}
 

public abstract AttributeMap getAttributeMap(); 

public void onChannelActive(@Nonnull AttributeMap attributeMap); 

public void onChannelInactive(@Nonnull AttributeMap attributeMap);