@Override
 public void fromBytes(ByteBuf buf) {
   int elementNameLength = buf.readInt();
   this.elementName = new String(buf.readBytes(elementNameLength).array());
   int elementTextLength = buf.readInt();
   this.elementText = new String(buf.readBytes(elementTextLength).array());
 }
 @Override
 public void fromBytes(ByteBuf buffer) {
   int ownerLength = buffer.readInt();
   this.owner = new String(buffer.readBytes(ownerLength).array());
   int notifierLength = buffer.readInt();
   this.notifier = new String(buffer.readBytes(notifierLength).array());
 }
 @Override
 public void decodeFrom(ChannelHandlerContext ctx, ByteBuf buffer) throws IOException {
   data = new byte[buffer.readInt()];
   signature = new byte[buffer.readInt()];
   buffer.readBytes(data);
   buffer.readBytes(signature);
 }
Ejemplo n.º 4
0
 /**
  * Deserialize an object from a given byte buffer.
  *
  * @param b The bytebuf to deserialize.
  * @return The deserialized object.
  */
 @Override
 public Object deserialize(ByteBuf b, CorfuRuntime rt) {
   int classNameLength = b.readShort();
   byte[] classNameBytes = new byte[classNameLength];
   b.readBytes(classNameBytes, 0, classNameLength);
   String className = new String(classNameBytes);
   if (className.equals("null")) {
     return null;
   } else if (className.equals("CorfuObject")) {
     int SMRClassNameLength = b.readShort();
     byte[] SMRClassNameBytes = new byte[SMRClassNameLength];
     b.readBytes(SMRClassNameBytes, 0, SMRClassNameLength);
     String SMRClassName = new String(SMRClassNameBytes);
     try {
       return rt.getObjectsView()
           .build()
           .setStreamID(new UUID(b.readLong(), b.readLong()))
           .setType(Class.forName(SMRClassName))
           .open();
     } catch (ClassNotFoundException cnfe) {
       log.error("Exception during deserialization!", cnfe);
       throw new RuntimeException(cnfe);
     }
   } else {
     try (ByteBufInputStream bbis = new ByteBufInputStream(b)) {
       try (InputStreamReader r = new InputStreamReader(bbis)) {
         return gson.fromJson(r, Class.forName(className));
       }
     } catch (IOException | ClassNotFoundException ie) {
       log.error("Exception during deserialization!", ie);
       throw new RuntimeException(ie);
     }
   }
 }
Ejemplo n.º 5
0
 protected void internalReceive(HttpResponseStatus status, HttpHeaders headers, ByteBuf content) {
   try {
     if (status.code() > 399) {
       byte[] b = new byte[content.readableBytes()];
       content.readBytes(b);
       onErrorResponse(status, headers, new String(b, CharsetUtil.UTF_8));
       return;
     }
     if (type == ByteBuf.class) {
       _doReceive(status, headers, type.cast(content));
     } else if (type == String.class || type == CharSequence.class) {
       byte[] b = new byte[content.readableBytes()];
       content.readBytes(b);
       _doReceive(status, headers, type.cast(new String(b, CharsetUtil.UTF_8)));
     } else if (type == byte[].class) {
       byte[] b = new byte[content.readableBytes()];
       content.readBytes(b);
       _doReceive(status, headers, type.cast(b));
     } else {
       ObjectMapper mapper = new ObjectMapper();
       byte[] b = new byte[content.readableBytes()];
       content.readBytes(b);
       try {
         Object o = mapper.readValue(b, type);
         _doReceive(status, headers, type.cast(o));
       } catch (Exception ex) {
         Exceptions.chuck(ex);
       }
     }
   } finally {
     latch.countDown();
   }
 }
  public EncryptionKeyResponseMessage decode(ByteBuf buffer) throws IOException {
    byte[] sharedSecret = new byte[ByteBufUtils.readVarInt(buffer)];
    buffer.readBytes(sharedSecret);

    byte[] verifyToken = new byte[ByteBufUtils.readVarInt(buffer)];
    buffer.readBytes(verifyToken);

    return new EncryptionKeyResponseMessage(sharedSecret, verifyToken);
  }
 @Override
 public SignatureCodec read(ByteBuf buf) {
   byte[] me = new byte[Number160.BYTE_ARRAY_SIZE];
   buf.readBytes(me);
   number1 = new Number160(me);
   buf.readBytes(me);
   number2 = new Number160(me);
   return this;
 }
 @Override
 public void fromBytes(ByteBuf buf) {
   this.x = buf.readInt();
   this.y = buf.readInt();
   this.z = buf.readInt();
   this.orientation = buf.readByte();
   this.state = buf.readByte();
   int customNameLength = buf.readInt();
   this.customName = new String(buf.readBytes(customNameLength).array());
   int ownerLength = buf.readInt();
   this.owner = new String(buf.readBytes(ownerLength).array());
 }
Ejemplo n.º 9
0
 @Override
 public void readFrom(ByteBuf fromBuffer) {
   short length = fromBuffer.readShort();
   byte[] array = new byte[length];
   fromBuffer.readBytes(array);
   this.command = new String(array, PROTOCOL_ENCODING);
 }
Ejemplo n.º 10
0
  @Override
  protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
    // System.out.println("decode:" + in.readableBytes());
    if (in.readableBytes() > 4) {
      in.markReaderIndex();
      int needBytes = in.readInt();
      // System.out.println("needBytes:" + needBytes);
      if (in.readableBytes() >= needBytes) {
        byte[] content = new byte[in.readableBytes()];
        in.readBytes(content);
        // byte[] data= ZLipHelper.decompress(content);
        // System.out.println("data:" + new String(data));

        Amf3Input amf3Input = new Amf3Input(SerializationContext.getSerializationContext());
        //				amf3Input = new Amf3Input(SerializationContext.getSerializationContext());
        InputStream bais = new ByteArrayInputStream(content);
        amf3Input.setInputStream(bais);
        try {
          Object decoded = amf3Input.readObject();
          if (decoded != null) {
            out.add(decoded);
            // System.out.println("decoded:" + decoded);
          }
        } catch (Exception e) {
        }
        //				amf3Input.close();
      } else {
        in.resetReaderIndex();
      }
    }
  }
Ejemplo n.º 11
0
  /**
   * This test makes sure that even when the decoder is confronted with various chunk sizes in the
   * middle of decoding, it can recover and decode all the time eventually.
   */
  @Test
  public void shouldHandleNonUniformNetworkBatches() {
    ByteBuf incoming = Unpooled.copiedBuffer(SET_REQUEST_WITH_CONTENT);
    while (incoming.isReadable()) {
      channel.writeInbound(incoming.readBytes(5));
    }

    BinaryMemcacheRequest request = (BinaryMemcacheRequest) channel.readInbound();

    assertThat(request, notNullValue());
    assertThat(request.getHeader(), notNullValue());
    assertThat(request.getKey(), notNullValue());
    assertThat(request.getExtras(), nullValue());

    request.release();

    MemcacheContent content1 = (MemcacheContent) channel.readInbound();
    MemcacheContent content2 = (MemcacheContent) channel.readInbound();

    assertThat(content1, instanceOf(MemcacheContent.class));
    assertThat(content2, instanceOf(LastMemcacheContent.class));

    assertThat(content1.content().readableBytes(), is(3));
    assertThat(content2.content().readableBytes(), is(5));

    content1.release();
    content2.release();
  }
Ejemplo n.º 12
0
 @Override
 public byte[] allBytes() {
   ByteBuf dup = buf.duplicate().resetReaderIndex();
   byte[] res = new byte[dup.readableBytes()];
   dup.readBytes(res);
   return res;
 }
Ejemplo n.º 13
0
  public NettyMessage decode(ByteBuf in) throws Exception {
    NettyMessage message = new NettyMessage();
    Header header = new Header();
    header.setCrcCode(in.readInt());
    header.setLength(in.readInt());
    header.setSessionID(in.readLong());
    header.setType(in.readByte());
    header.setPriority(in.readByte());

    int size = in.readInt();
    if (size > 0) {
      Map<String, Object> attch = new HashMap<String, Object>(size);
      int keySize = 0;
      byte[] keyArray = null;
      String key = null;
      for (int i = 0; i < size; i++) {
        keySize = in.readInt();
        keyArray = new byte[keySize];
        in.readBytes(keyArray);
        key = new String(keyArray, "UTF-8");
        attch.put(key, marshallingDecoder.decode(in));
      }
      keyArray = null;
      key = null;
      header.setAttachment(attch);
    }
    if (in.readableBytes() > 4) {
      message.setBody(marshallingDecoder.decode(in));
    }
    message.setHeader(header);
    return message;
  }
Ejemplo n.º 14
0
 @Override
 protected void channelRead0(ChannelHandlerContext ctx, FullHttpResponse msg) throws Exception {
   Integer streamId =
       msg.headers().getInt(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text());
   if (streamId == null) {
     logger.error("HttpResponseHandler unexpected message received: " + msg);
     return;
   }
   onResponseReceived(ctx, streamIdUrlMap.get(streamId));
   Map.Entry<ChannelFuture, ChannelPromise> entry = streamIdPromiseMap.get(streamId);
   if (entry == null) {
     logger.error("Message received for unknown stream id " + streamId);
   } else {
     // Do stuff with the message (for now just print it)
     ByteBuf content = msg.content();
     ContentType contentType = ContentType.parse(msg.headers().get(HttpHeaderNames.CONTENT_TYPE));
     if (content.isReadable()) {
       int contentLength = content.readableBytes();
       byte[] arr = new byte[contentLength];
       content.readBytes(arr);
       handleContent(arr, ctx, contentType);
     }
     entry.getValue().setSuccess();
   }
 }
Ejemplo n.º 15
0
 /**
  * @param headerLength
  * @param middleLength
  * @param endLength
  * @param buf
  * @return the new ErrorPacket from buffer
  * @throws OpenR66ProtocolPacketException
  */
 public static ErrorPacket createFromBuffer(
     int headerLength, int middleLength, int endLength, ByteBuf buf)
     throws OpenR66ProtocolPacketException {
   final byte[] bheader = new byte[headerLength - 1];
   final byte[] bmiddle = new byte[middleLength];
   if (headerLength - 1 > 0) {
     buf.readBytes(bheader);
   }
   if (middleLength > 0) {
     buf.readBytes(bmiddle);
   }
   if (endLength != 4) {
     throw new OpenR66ProtocolPacketException("Packet not correct");
   }
   return new ErrorPacket(new String(bheader), new String(bmiddle), buf.readInt());
 }
Ejemplo n.º 16
0
  @Override
  protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {
    // TODO Auto-generated method stub
    ByteBuf frame = (ByteBuf) super.decode(ctx, in);
    if (frame == null) {
      return null;
    }

    Message message = new Message();
    Header header = new Header();

    header.setSrcCode(in.readInt());
    header.setLength(in.readInt());
    header.setSessionId(in.readLong());
    header.setType(in.readByte());
    header.setPriority(in.readByte());
    int size = in.readInt();
    if (size > 0) {
      Map<String, Object> attch = new HashMap<String, Object>(size);
      int keySize = 0;
      byte[] keyArray = null;
      String key = null;
      for (int i = 0; i < size; i++) {
        keySize = in.readInt();
        keyArray = new byte[keySize];
        in.readBytes(keyArray);
        key = new String(keyArray, "UTF-8");
        attch.put(key, nettyMarshallingDecoder.decode(ctx, in));
      }
      keyArray = null;
      key = null;
      header.setAttachment(attch);
    }
    return message;
  }
 private void setInput(ByteBuf decompressed) {
   byte[] in = new byte[decompressed.readableBytes()];
   decompressed.readBytes(in);
   z.next_in = in;
   z.next_in_index = 0;
   z.avail_in = in.length;
 }
  @Override
  public RequestMessage deserializeRequest(final ByteBuf msg) throws SerializationException {
    try {
      final Kryo kryo = kryoThreadLocal.get();
      final byte[] payload = new byte[msg.readableBytes()];
      msg.readBytes(payload);
      try (final Input input = new Input(payload)) {
        // by the time the message gets here, the mime length/type have been already read, so this
        // part just
        // needs to process the payload.
        final UUID id = kryo.readObject(input, UUID.class);
        final String processor = input.readString();
        final String op = input.readString();

        final RequestMessage.Builder builder =
            RequestMessage.build(op).overrideRequestId(id).processor(processor);

        final Map<String, Object> args = kryo.readObject(input, HashMap.class);
        args.forEach(builder::addArg);
        return builder.create();
      }
    } catch (Exception ex) {
      logger.warn(
          "Request [{}] could not be deserialized by {}.",
          msg,
          GryoMessageSerializerV1d0.class.getName());
      throw new SerializationException(ex);
    }
  }
Ejemplo n.º 19
0
 @Override
 public void split(ChannelHandlerContext ctx, ByteBuf input, List<Object> list) throws Exception {
   input.markReaderIndex();
   final byte[] array = new byte[3];
   for (int i = 0; i < array.length; ++i) {
     if (!input.isReadable()) {
       input.resetReaderIndex();
       return;
     }
     array[i] = input.readByte();
     if (array[i] >= 0) {
       final PacketDataSerializer packetDataSerializer =
           new PacketDataSerializer(
               Unpooled.wrappedBuffer(array), ProtocolVersion.MINECRAFT_1_7_10);
       try {
         final int length = packetDataSerializer.readVarInt();
         if (input.readableBytes() < length) {
           input.resetReaderIndex();
           return;
         }
         list.add(input.readBytes(length));
         return;
       } finally {
         packetDataSerializer.release();
       }
     }
   }
   throw new CorruptedFrameException("length wider than 21-bit");
 }
  @Override
  public ResponseMessage deserializeResponse(final ByteBuf msg) throws SerializationException {
    try {
      final Kryo kryo = kryoThreadLocal.get();
      final byte[] payload = new byte[msg.readableBytes()];
      msg.readBytes(payload);
      try (final Input input = new Input(payload)) {
        final UUID requestId = kryo.readObjectOrNull(input, UUID.class);
        final int status = input.readShort();
        final String statusMsg = input.readString();
        final Map<String, Object> statusAttributes =
            (Map<String, Object>) kryo.readClassAndObject(input);
        final Object result = kryo.readClassAndObject(input);
        final Map<String, Object> metaAttributes =
            (Map<String, Object>) kryo.readClassAndObject(input);

        return ResponseMessage.build(requestId)
            .code(ResponseStatusCode.getFromValue(status))
            .statusMessage(statusMsg.intern())
            .statusAttributes(statusAttributes)
            .result(result)
            .responseMetaData(metaAttributes)
            .create();
      }
    } catch (Exception ex) {
      logger.warn(
          "Response [{}] could not be deserialized by {}.",
          msg,
          GryoMessageSerializerV1d0.class.getName());
      throw new SerializationException(ex);
    }
  }
  private boolean handleCompressedFrame(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)
      throws Exception {
    if (!in.isReadable(FRAME_COMPRESS_HEADER_LENGTH)) {
      return false;
    }

    int compressedPayloadLength = in.readInt();
    if (!in.isReadable(compressedPayloadLength)) {
      return false;
    }

    // decompress payload
    Inflater inflater = new Inflater();
    if (in.hasArray()) {
      inflater.setInput(in.array(), in.arrayOffset() + in.readerIndex(), compressedPayloadLength);
      in.skipBytes(compressedPayloadLength);
    } else {
      byte[] array = new byte[compressedPayloadLength];
      in.readBytes(array);
      inflater.setInput(array);
    }

    while (!inflater.finished()) {
      ByteBuf decompressed = ctx.alloc().heapBuffer(1024, 1024);
      byte[] outArray = decompressed.array();
      int count =
          inflater.inflate(outArray, decompressed.arrayOffset(), decompressed.writableBytes());
      decompressed.writerIndex(count);
      // put data in the pipeline
      out.add(decompressed);
    }

    return true;
  }
  @Override
  public void appendMessages(Tpp tpp, Collection<MessageBatchWithRawData> batches)
      throws Exception {
    ByteBuf bodyBuf = Unpooled.buffer();
    KafkaMessageBrokerSender sender = getSender(tpp.getTopic());
    try {
      for (MessageBatchWithRawData batch : batches) {
        List<PartialDecodedMessage> pdmsgs = batch.getMessages();
        for (PartialDecodedMessage pdmsg : pdmsgs) {
          m_messageCodec.encodePartial(pdmsg, bodyBuf);
          byte[] bytes = new byte[bodyBuf.readableBytes()];
          bodyBuf.readBytes(bytes);
          bodyBuf.clear();

          ByteBuf propertiesBuf = pdmsg.getDurableProperties();
          HermesPrimitiveCodec codec = new HermesPrimitiveCodec(propertiesBuf);
          Map<String, String> propertiesMap = codec.readStringStringMap();
          sender.send(tpp.getTopic(), propertiesMap.get("pK"), bytes);
          BrokerStatusMonitor.INSTANCE.kafkaSend(tpp.getTopic());
        }
      }
    } finally {
      bodyBuf.release();
    }
  }
Ejemplo n.º 23
0
 @Override
 public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
   ByteBuf buf = (ByteBuf) msg;
   byte[] req = new byte[buf.readableBytes()];
   buf.readBytes(req);
   String body = new String(req, "UTF-8");
   System.out.println("Now is : " + body);
 }
Ejemplo n.º 24
0
 @Override
 public Object decode(ByteBuf buf, State state) throws IOException {
   byte[] bytes = new byte[buf.readableBytes()];
   buf.readBytes(bytes);
   bytes = Snappy.uncompress(bytes);
   ByteBuf bf = Unpooled.wrappedBuffer(bytes);
   return innerCodec.getValueDecoder().decode(bf, state);
 }
Ejemplo n.º 25
0
  @Override
  public void channelRead0(final ChannelHandlerContext ctx, Object msg) throws Exception {
    ByteBuf in = (ByteBuf) msg;

    byte[] bytes = in.array();
    String sInfo = Hex.encodeHexStr(bytes);

    logger.info(String.format("primary received:%s", sInfo));
    // 接收到包的长度
    int length = in.readableBytes();
    // 终端设备上报到服务器位始 $$
    String head = in.readBytes(2).toString(Charset.defaultCharset());

    if ("$$".equals(head)) {
      // 从包的字段得到包的长度
      short l = in.readShort();
      System.out.println(l);
      if (length == l) {
        // 得到产品id 序列号
        final String serialNumber = byteToArray(in.readBytes(7).array());

        // 得到协议号
        final String agreement = byteToArray(in.readBytes(2).array());

        // 得到数据
        final String content = operation(serialNumber, head, length, l, agreement, in, ctx);
        // 得到校验位 checksum
        String checksum = byteToArray(in.readBytes(2).array());

        // 得到结束符\r\n
        final String end = byteToArray(in.readBytes(2).array());

        executorService.execute(
            new Runnable() {
              public void run() {
                try {
                  serviceHandler(ctx, serialNumber, agreement, content, end);
                } catch (Exception e) {

                  e.printStackTrace();
                }
              }
            });
      }
    }
  }
Ejemplo n.º 26
0
 public static byte[] serialiseAddress(Address addr) {
   ByteBuf buf = Unpooled.buffer();
   AddressSerializer.INSTANCE.toBinary(addr, buf);
   byte[] bytes = new byte[buf.readableBytes()];
   buf.readBytes(bytes);
   buf.release();
   return bytes;
 }
Ejemplo n.º 27
0
 public static byte[] serialiseKey(Key key) {
   ByteBuf buf = Unpooled.buffer();
   serialiseKey(key, buf);
   byte[] bytes = new byte[buf.readableBytes()];
   buf.readBytes(bytes);
   buf.release();
   return bytes;
 }
Ejemplo n.º 28
0
 public void reading(ByteBuf datas) {
   datas.readBytes(temp, datas.readableBytes());
   if (this.temp.writableBytes() != 0) {
     end = false;
   } else {
     end = true;
   }
 }
Ejemplo n.º 29
0
 @Override
 protected void handleData(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) {
   byte[] data = new byte[byteBuf.readableBytes() - 5];
   byteBuf.skipBytes(5);
   byteBuf.readBytes(data);
   String content = new String(data);
   System.out.println(name + " get content: " + content);
 }
Ejemplo n.º 30
0
  @Override
  public void readData(ByteBuf data) {
    super.readData(data);

    state = Unpooled.buffer();
    int length = data.readInt();
    state.writeBytes(data.readBytes(length));
  }