@Override
 public void incomingMessage(ChannelHandlerContext ctx, MessageEvent event) throws Exception {
   if (event.getMessage() instanceof MappingHttpRequest) {
     MappingHttpRequest httpRequest = (MappingHttpRequest) event.getMessage();
     if (httpRequest.getMessage() instanceof WalrusRequestType) {
       WalrusRequestType request = (WalrusRequestType) httpRequest.getMessage();
       BucketLogData logData = request.getLogData();
       if (logData != null) {
         long currentTime = System.currentTimeMillis();
         logData.setTotalTime(currentTime);
         logData.setTurnAroundTime(currentTime);
         logData.setUri(httpRequest.getUri());
         String referrer = httpRequest.getHeader(HttpHeaders.Names.REFERER);
         if (referrer != null) logData.setReferrer(referrer);
         String userAgent = httpRequest.getHeader(HttpHeaders.Names.USER_AGENT);
         if (userAgent != null) logData.setUserAgent(userAgent);
         logData.setTimestamp(
             String.format("[%1$td/%1$tb/%1$tY:%1$tH:%1$tM:%1$tS %1$tz]", Calendar.getInstance()));
         User user = Contexts.lookup(httpRequest.getCorrelationId()).getUser();
         if (user != null) logData.setAccessorId(user.getUserId());
         if (request.getBucket() != null) logData.setBucketName(request.getBucket());
         if (request.getKey() != null) logData.setKey(request.getKey());
         if (ctx.getChannel().getRemoteAddress() instanceof InetSocketAddress) {
           InetSocketAddress sockAddress = (InetSocketAddress) ctx.getChannel().getRemoteAddress();
           logData.setSourceAddress(sockAddress.getAddress().getHostAddress());
         }
       }
     }
   }
 }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent e, XmlDocument d) {

    MessageEvent s = e;

    // Convert to a String first.
    XmlDocument doc = d; // new XmlDocument();
    // doc.LoadXml((String)message);

    // String cAction = doc.DocumentElement.ChildNodes[0].Attributes["action"].Value;

    String cAction =
        doc.getDocumentElement().getChildren().get(0).getAttribute("action").getValue();

    InetSocketAddress remoteAddress = (InetSocketAddress) s.getChannel().getRemoteAddress();
    String strIpPort =
        remoteAddress.getAddress().getHostAddress() + ":" + String.valueOf(remoteAddress.getPort());

    //
    //        //create item
    SessionMessage item = new SessionMessage(e, doc, false, true);
    //
    //        //save
    ChChessLPU.getInstance().getmsgList().Opp(QueueMethod.Add, item);
    //
    //        //
    if (cAction.equals(ClientAction.heartBeat)) {
      // 不打印
    } else {
      // log
      Log.WriteStrByRecv(cAction, strIpPort);
    }
  }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {

    Object m = e.getMessage();
    if (!(m instanceof ChannelBuffer)) {
      ctx.sendUpstream(e);
      return;
    }

    ChannelBuffer input = (ChannelBuffer) m;
    if (!input.readable()) {
      return;
    }

    ChannelBuffer cumulation = cumulation(ctx);
    if (cumulation.readable()) {
      cumulation.discardReadBytes();
      cumulation.writeBytes(input);
      callDecode(ctx, e.getChannel(), cumulation, e.getRemoteAddress());
    } else {
      callDecode(ctx, e.getChannel(), input, e.getRemoteAddress());
      if (input.readable()) {
        cumulation.writeBytes(input);
      }
    }
  }
  /* (non-Javadoc)
   * @see org.jboss.netty.channel.SimpleChannelDownstreamHandler#writeRequested(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.MessageEvent)
   */
  public synchronized void writeRequested(ChannelHandlerContext ctx, MessageEvent e)
      throws Exception {
    Object msg = e.getMessage();
    if (msg instanceof FlushRequestMessage) {
      hOut.flush(e.getFuture());
      e.getFuture().await(5000);
      return;
    }

    try {
      //				if (e.getMessage() instanceof Integer)
      //				{
      //					hOut.flush();
      //					return;
      //				}
      HessianRPCReplyMessage message = (HessianRPCReplyMessage) e.getMessage();
      // Constants.ahessianLogger.warn("encode reply for
      // #"+message.getHeaders().get(Constants.CALL_ID_STRING));

      hOut.resetReferences();
      hOut.writeReply(message);
      // hOut.flush();
      // e.getFuture().setSuccess();
    } catch (Exception ex) {
      Constants.ahessianLogger.warn("", ex);
      e.getFuture().setFailure(ex);
    }
  }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent event) throws Exception {
    if (event.getMessage() instanceof MappingHttpRequest) {
      MappingHttpRequest httpRequest = (MappingHttpRequest) event.getMessage();

      if (httpRequest.getMessage() instanceof ObjectStorageDataRequestType) {
        if (httpRequest.isChunked()) {
          // Chunked request, and beginning, setup map etc.
          initializeNewPut(ctx, (ObjectStorageDataRequestType) httpRequest.getMessage());
        }
      }
    } else if (event.getMessage() instanceof HttpChunk) {
      // Add the chunk to the current streams channel buffer.
      HttpChunk chunk = (HttpChunk) event.getMessage();
      appendChunk(chunk.getContent(), ctx.getChannel());

      if (chunk.isLast()) {
        // Remove from the map
        Logs.extreme()
            .debug(
                "Removing data map due to last chunk processed event for channel: "
                    + ctx.getChannel().getId());
        dataMap.remove(ctx.getChannel());
      }
    }
    // Always pass it on
    ctx.sendUpstream(event);
  }
  /* (non-Javadoc)
   * @see org.jboss.netty.channel.SimpleChannelHandler#messageReceived(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.MessageEvent)
   */
  @Override
  public void messageReceived(final ChannelHandlerContext context, final MessageEvent e)
      throws Exception {
    String decoded;
    synchronized (stringWriter) {

      // extract the buffer from the message event
      final Object message = e.getMessage();
      if (!(message instanceof ChannelBuffer)) {
        context.sendUpstream(e);
        return;
      }
      final ChannelBuffer buffer = (ChannelBuffer) message;
      if (!buffer.readable()) {
        return;
      }

      // read all bytes from the buffer to the decoder stream
      final byte[] bytes = new byte[buffer.readableBytes()];
      buffer.readBytes(bytes);
      writerOutputStream.write(bytes);
      writerOutputStream.flush();
      decoded = stringWriter.toString();
      stringWriter.getBuffer().setLength(0);
    }

    // push all successfully decoded characters upstream
    Channels.fireMessageReceived(context, decoded, e.getRemoteAddress());
  }
Example #7
0
 /**
  * {@inheritDoc}
  *
  * @see
  *     org.jboss.netty.channel.SimpleChannelUpstreamHandler#messageReceived(org.jboss.netty.channel.ChannelHandlerContext,
  *     org.jboss.netty.channel.MessageEvent)
  */
 public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
   final SocketAddress remote = e.getRemoteAddress();
   ChannelBuffer buff = (ChannelBuffer) e.getMessage();
   if (buff.equals(BYE_BUFF)) {
     e.getChannel()
         .write(BYE_MSG, remote)
         .addListener(
             new ChannelFutureListener() {
               @Override
               public void operationComplete(ChannelFuture future) throws Exception {
                 future.getChannel().close();
               }
             });
     return;
   }
   e.getChannel()
       .write(e.getMessage(), remote)
       .addListener(
           new ChannelFutureListener() {
             @Override
             public void operationComplete(ChannelFuture future) throws Exception {
               if (future.isSuccess()) {
                 logger.info(" S:OK");
               } else {
                 logger.info(" S:FAILED");
               }
             }
           });
 }
 @Override
 public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
   // Функция принимает уже готовые AbstractPacket'ы от игрока, поэтому их можно сразу посылать в
   // worker. За их формирование отвечает другой обработчик.
   // log.info("messageReceived");
   if (e.getChannel().isOpen()) worker.acceptPacket((AbstractPacket) e.getMessage());
 }
  @Override
  public void messageReceived(final ChannelHandlerContext ctx, final MessageEvent e)
      throws Exception {

    if (!chunked) {
      final HttpRequest request = (HttpRequest) e.getMessage();

      final ChannelBuffer buffer = request.getContent();
      receivedData.write(buffer.array());
      // System.out.println("received "+buffer.array() );
      // System.out.println(buffer.array().length);
      if (!request.isChunked()) {
        processRequest(e);
      } else {
        chunked = true;
      }
      // final boolean keepAlive = isKeepAlive(request);
    } else {
      final HttpChunk chunk = (HttpChunk) e.getMessage();
      final ChannelBuffer buffer = chunk.getContent();
      receivedData.write(buffer.array());
      if (chunk.isLast()) {
        processRequest(e);
      }
    }
  }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {

    // Cast to a String first.
    // We know it is a String because we put some codec in TelnetPipelineFactory.
    String request = (String) e.getMessage();

    // Generate and write a response.
    String response;
    boolean close = false;
    if (request.length() == 0) {
      response = "Please type something.\r\n";
    } else if (request.toLowerCase().equals("bye")) {
      response = "Have a good day!\r\n";
      close = true;
    } else {
      response = "Did you say '" + request + "'?\r\n";
    }

    // We do not need to write a ChannelBuffer here.
    // We know the encoder inserted at TelnetPipelineFactory will do the conversion.
    ChannelFuture future = e.getChannel().write(response);

    // Close the connection after sending 'Have a good day!'
    // if the client has sent 'bye'.
    if (close) {
      future.addListener(ChannelFutureListener.CLOSE);
    }
  }
 @Override
 public void writeRequested(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
   if (e.getMessage() instanceof KafkaRequest) {
     ctx.setAttachment(((KafkaRequest) e.getMessage()).getResponseHandler());
   }
   super.writeRequested(ctx, e);
 }
  private void handleIncomingConfirmableCoapResponse(ChannelHandlerContext ctx, MessageEvent me) {
    InetSocketAddress remoteEndpoint = (InetSocketAddress) me.getRemoteAddress();
    CoapResponse coapResponse = (CoapResponse) me.getMessage();

    writeEmptyAcknowledgement(remoteEndpoint, coapResponse.getMessageID());

    ctx.sendUpstream(me);
  }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {

    // Send back the received message to the remote peer.
    transferredBytes.addAndGet(((ChannelBuffer) e.getMessage()).readableBytes());
    e.getChannel().write(e.getMessage());
    System.out.println("Server: " + e.getMessage());
  }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent me) throws Exception {
    if (!(me.getMessage() instanceof HttpRequest)) {
      ctx.sendUpstream(me);
      return;
    }

    HttpRequest request = (HttpRequest) me.getMessage();
    Object response;

    // Look up resource
    String path = request.getUri();
    String host = request.getHeader("host");
    log.debug("Received request for path:" + path);

    boolean showHtml = false;
    if (path.endsWith("?html")) {
      showHtml = true;
      path = path.replace("?html", "");
    }

    for (String service : resources.keySet()) {
      log.debug("Available Service: " + service);
    }

    Model model = resources.get(path);

    if (model != null) {
      if (request.getMethod() == HttpMethod.GET) {
        if (showHtml) {
          String html = HtmlCreator.createModelPage(model, new URI(path), host);
          response = ChannelBuffers.wrappedBuffer(html.getBytes(Charset.forName("UTF-8")));

          log.debug("Returned html page for resource: " + path);
        } else {
          response = new SelfDescription(model, new URI(request.getUri()));

          log.debug("Resource found: " + path);
        }
      } else {
        response =
            new DefaultHttpResponse(
                request.getProtocolVersion(), HttpResponseStatus.METHOD_NOT_ALLOWED);

        log.debug("Method not allowed: " + request.getMethod());
      }
    } else {
      response =
          HttpResponseFactory.createHttpResponse(
              request.getProtocolVersion(), HttpResponseStatus.NOT_FOUND);

      log.debug("Resource not found: " + path);
    }

    // Send response
    ChannelFuture future = Channels.write(ctx.getChannel(), response);
    future.addListener(ChannelFutureListener.CLOSE);
  }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
    if (handshakeComplete) {
      super.messageReceived(ctx, e);
    } else {
      if (e.getMessage() instanceof ChannelBuffer) {
        ChannelBuffer newBuffer = (ChannelBuffer) e.getMessage();
        buffered = ChannelBuffers.copiedBuffer(buffered, newBuffer);

        if (buffered.readableBytes() < 8) {
          return;
        }
        int payloadLength = buffered.getInt(0);
        int revision = buffered.getInt(4);

        boolean handshakeSuccessful = false;

        if (revision == 1 || revision == -1) {
          if (buffered.readableBytes() < payloadLength + 4) {
            return;
          }
          buffered.skipBytes(8);

          if (revision == 1) {
            handshakeSuccessful = handleRevision1Response(ctx, payloadLength);
          } else {
            handshakeSuccessful = handleGenericResponse(ctx, payloadLength);
          }
        } else {
          handshakeSuccessful = handleUnknownRevisionResponse(ctx);
        }

        if (!handshakeSuccessful) {
          ctx.getChannel().close();
        }

        if (keepAliveInterval.millis() > 0) {
          ctx.getPipeline()
              .addBefore(
                  ctx.getName(),
                  "found-connection-keep-alive",
                  new ConnectionKeepAliveHandler(scheduler, keepAliveInterval));
        }

        handshakeComplete = true;

        ChannelBuffer remaining = buffered.slice();
        if (remaining.readableBytes() > 0) {
          ctx.sendUpstream(
              new UpstreamMessageEvent(
                  ctx.getChannel(), remaining, ctx.getChannel().getRemoteAddress()));
        }

        ctx.getPipeline().remove(this);
      }
    }
  }
Example #16
0
 @Override
 public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
   Channel ch = e.getChannel();
   DefaultNetSocket sock = socketMap.get(ch);
   if (sock != null) {
     ChannelBuffer buff = (ChannelBuffer) e.getMessage();
     sock.handleDataReceived(new Buffer(buff.slice()));
   }
 }
Example #17
0
  @Override
  public void writeRequested(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
    UnixTime time = (UnixTime) e.getMessage();

    ChannelBuffer buf = buffer(4);
    buf.writeInt(time.getValue());

    Channels.write(ctx, e.getFuture(), buf);
  }
  /**
   * If the message to be written is a {@link CoapResponse} this method decides whether the message
   * type is {@link MessageType.Name#ACK} (if there wasn't an empty acknowledgement sent yet) or
   * {@link MessageType.Name#CON} (if there was already an empty acknowledgement sent). In the
   * latter case it additionally cancels the sending of an empty acknowledgement (which was
   * scheduled by the <code>messageReceived</code> method when the request was received).
   *
   * @param ctx The {@link ChannelHandlerContext} connecting relating this class (which implements
   *     the {@link ChannelUpstreamHandler} interface) to the datagramChannel that received the
   *     message.
   * @param me the {@link MessageEvent} containing the actual message
   * @throws Exception if an error occurred
   */
  @Override
  public void writeRequested(ChannelHandlerContext ctx, MessageEvent me) throws Exception {
    if (isShutdown()) return;

    if (me.getMessage() instanceof CoapResponse) handleOutgoingCoapResponse(ctx, me);
    else if (me.getMessage() instanceof InternalApplicationShutdownMessage)
      handleApplicationShutdown(ctx, me);
    else ctx.sendDownstream(me);
  }
 @Override
 public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
   Object attachment = ctx.getAttachment();
   if (e.getMessage() instanceof KafkaResponse && attachment instanceof ResponseHandler) {
     ((ResponseHandler) attachment).received((KafkaResponse) e.getMessage());
   } else {
     super.messageReceived(ctx, e);
   }
 }
Example #20
0
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
    Object message = e.getMessage();

    if (message instanceof HttpRequest) {
      eventBus.post(message);
      httpRequestReceived((HttpRequest) message, e.getChannel());
    }
  }
Example #21
0
 @Override
 public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
   Object message = e.getMessage();
   if (message instanceof OperatorMessage) {
     System.out.println("Server --------------Message is: " + message.toString());
     OperatorMessage om = (OperatorMessage) message;
     // e.getChannel().write(excMethod(om));//执行用户方法
     e.getChannel().write("TEST is over!");
   }
 }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
    Object message = e.getMessage();

    if (message instanceof SubscribeChannelRequest) {
      String channelName = ((SubscribeChannelRequest) message).channelName();
      this.channelSubscriptions.subscribe(e.getChannel(), channelName);
    } else {
      ctx.sendUpstream(e);
    }
  }
  @Override
  public void writeRequested(ChannelHandlerContext ctx, MessageEvent e) {

    // logger.info("Mongo message encoding...");

    Message message = (Message) e.getMessage();

    ChannelBuffer buf = message.encode(null);

    Channels.write(ctx, e.getFuture(), buf);
  }
Example #24
0
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
    // Cast to a String first.
    // We know it is a String because we put some codec in TelnetPipelineFactory.
    String requestJson = (String) e.getMessage();
    System.out.println("received Message:\n " + requestJson);
    if (this.jsonStrings != null) {
      this.jsonStrings.offer(requestJson);
    }
    Message info = null;
    try {
      info = new Message(requestJson);
    } catch (JSONException e2) {
      // TODO Auto-generated catch block
      e2.printStackTrace();
    }
    int resFlag = 0;
    long receiveTime = new Date().getTime();
    try {
      List<TableMap> maps = this.tableMaps.getTableMapsBySourceInfo(info.getSourceInfo());
      if (maps == null || maps.size() == 0) System.out.println("maps is null");
      System.out.println(info.getSourceInfo());
      for (TableMap tableMap : maps) {

        Message msg = DataTranslator.transData(info, tableMap);
        SourceInfo sourceInfo = tableMap.getToTable().getSourceInfo();
        Tenant tanent =
            this.tanentPool.getTanentByOthers(
                sourceInfo.getIp(),
                sourceInfo.getPort(),
                sourceInfo.getDBName(),
                sourceInfo.getUserName());
        resFlag =
            new OperateDB(
                    msg,
                    tableMap,
                    this.conPool.getCon(
                        tanent.getUrl(), tanent.getUserName(), tanent.getPassword()))
                .synData();
      }
    } catch (SQLException e1) {
      // TODO Auto-generated catch block
      e1.printStackTrace();
    }
    // Generate and write a response.
    String response = "";
    ReturnMsg returnMsg = new ReturnMsg();
    returnMsg.setStatus(resFlag);
    returnMsg.setRecordId(info.getRecordId());
    returnMsg.setReceiveTime(receiveTime);
    response = returnMsg.toString();
    e.getChannel().write(response + "\r\n");
    System.out.println("sendReturnMsg:" + response);
  }
  @Override
  public void handleUpstream(ChannelHandlerContext ctx, ChannelEvent ce) throws Exception {
    if (!(ce instanceof MessageEvent)) {
      ctx.sendUpstream(ce);
      return;
    }
    MessageEvent e = (MessageEvent) ce;
    RedisConnection conn = (RedisConnection) e.getChannel().getAttachment();
    ChannelBuffer cb = (ChannelBuffer) e.getMessage();
    conn.replyFromBackend(cb.copy());

    ctx.sendUpstream(ce);
  }
 @Override
 public void messageReceived(ChannelHandlerContext ctx, final MessageEvent e) throws Exception {
   ChannelBuffer msg = (ChannelBuffer) e.getMessage();
   // System.out.println(">>> " + ChannelBuffers.hexDump(msg));
   synchronized (trafficLock) {
     outboundChannel.write(msg);
     // If outboundChannel is saturated, do not read until notified in
     // OutboundHandler.channelInterestChanged().
     if (!outboundChannel.isWritable()) {
       e.getChannel().setReadable(false);
     }
   }
 }
  public static void send(MessageEvent event, Integer transactionId, Long connectionId)
      throws Exception {
    logger.debug("ConnectionResponse::send to " + event.getRemoteAddress());

    ChannelBuffer responseBuffer = ChannelBuffers.buffer(4 + 4 + 8);
    responseBuffer.writeInt(Action.CONNECT.getId());
    responseBuffer.writeInt(transactionId);
    responseBuffer.writeLong(connectionId);

    logger.debug("ConnectionResponse DUMP: " + Utils.getHexString(responseBuffer.array()));

    event.getChannel().write(responseBuffer, event.getRemoteAddress());
  }
  private void handleIncomingConfirmableCoapRequest(ChannelHandlerContext ctx, MessageEvent me) {
    InetSocketAddress remoteEndpoint = (InetSocketAddress) me.getRemoteAddress();
    CoapMessage coapMessage = (CoapMessage) me.getMessage();

    IncomingReliableMessageExchange newMessageExchange =
        new IncomingReliableMessageExchange(remoteEndpoint, coapMessage.getMessageID());

    IncomingMessageExchange oldMessageExchange =
        ongoingMessageExchanges.get(remoteEndpoint, coapMessage.getMessageID());

    // Check if there is an ongoing
    if (oldMessageExchange != null) {

      if (oldMessageExchange instanceof IncomingReliableMessageExchange) {

        // if the old message exchange is reliable and the empty ACK was already sent send another
        // empty ACK
        if (((IncomingReliableMessageExchange) oldMessageExchange).isAcknowledgementSent())
          writeEmptyAcknowledgement(remoteEndpoint, coapMessage.getMessageID());

      }

      // if the old message was unreliable and the duplicate message is confirmable send empty ACK
      else writeEmptyAcknowledgement(remoteEndpoint, coapMessage.getMessageID());

      // As the message is already being processed there is nothing more to do
      return;
    }

    // try to add new reliable message exchange
    boolean added = false;
    synchronized (monitor) {
      Long time = System.currentTimeMillis() + MIN_EMPTY_ACK_DELAY_MILLIS;

      // Add message exchange to set of ongoing exchanges to detect duplicates
      if (!ongoingMessageExchanges.contains(remoteEndpoint, coapMessage.getMessageID())) {
        ongoingMessageExchanges.put(remoteEndpoint, coapMessage.getMessageID(), newMessageExchange);
        added = true;
      }

      // If the scheduling of the empty ACK does not work then it was already scheduled
      if (!emptyAcknowledgementSchedule.put(time, newMessageExchange)) {
        log.error("Could not schedule empty ACK for message: {}", coapMessage);
        ongoingMessageExchanges.remove(remoteEndpoint, coapMessage.getMessageID());
        added = false;
      }
    }

    // everything is fine, so further process message
    if (added) ctx.sendUpstream(me);
  }
Example #29
0
  public void handleDownstream(final ChannelHandlerContext context, final ChannelEvent evt)
      throws Exception {
    if (evt instanceof ChannelStateEvent) {
      ChannelStateEvent e = (ChannelStateEvent) evt;
      switch (e.getState()) {
        case OPEN:
        case CONNECTED:
        case BOUND:
          if (Boolean.FALSE.equals(e.getValue()) || e.getValue() == null) {
            closeOutboundAndChannel(context, e);
            return;
          }
      }
    }
    if (!(evt instanceof MessageEvent)) {
      context.sendDownstream(evt);
      return;
    }

    MessageEvent e = (MessageEvent) evt;
    if (!(e.getMessage() instanceof ChannelBuffer)) {
      context.sendDownstream(evt);
      return;
    }

    // Do not encrypt the first write request if this handler is
    // created with startTLS flag turned on.
    if (startTls && sentFirstMessage.compareAndSet(false, true)) {
      context.sendDownstream(evt);
      return;
    }

    // Otherwise, all messages are encrypted.
    ChannelBuffer msg = (ChannelBuffer) e.getMessage();
    PendingWrite pendingWrite;

    if (msg.readable()) {
      pendingWrite =
          new PendingWrite(
              evt.getFuture(), msg.toByteBuffer(msg.readerIndex(), msg.readableBytes()));
    } else {
      pendingWrite = new PendingWrite(evt.getFuture(), null);
    }
    synchronized (pendingUnencryptedWrites) {
      boolean offered = pendingUnencryptedWrites.offer(pendingWrite);
      assert offered;
    }

    wrap(context, evt.getChannel());
  }
  @Override
  public void messageReceived(ChannelHandlerContext ctx, MessageEvent event) {
    LOG.debug("Got Message: {}", event.getMessage().toString());
    Object evm = event.getMessage();

    if (evm instanceof ControlMessage) {
      LOG.debug("Got control message: {}", evm.toString());
      return;
    } else if (evm instanceof HBMessage) {
      client.gotMessage((HBMessage) evm);
    } else {
      LOG.warn("Got unexpected message: {} from server.", evm);
    }
  }