Examples with ByteBufInputStream io.netty.buffer.ByteBufInputStream used on opensource projects

Example 41 with ByteBufInputStream

use of io.netty.buffer.ByteBufInputStream in project Almura by AlmuraDev.

the class ClientboundBiomeInformationPacket method readFrom.

@Override
public void readFrom(final ChannelBuf buf) {
    final int size = buf.readInteger();
    this.biomes = new HashMap<>(size);
    if (size > 0) {
        for (int i = 0; i < size; i++) {
            final int length = buf.readInteger();
            ByteBufInputStream byteBufInputStream = null;
            ObjectInputStream objectInputStream = null;
            try {
                final ByteBuf buffer = Unpooled.buffer(length);
                buffer.writeBytes(buf.readBytes(length));
                byteBufInputStream = new ByteBufInputStream(buffer, length);
                objectInputStream = new ObjectInputStream(byteBufInputStream);
                final BiomeConfig biomeConfig = (BiomeConfig) objectInputStream.readObject();
                this.biomes.put(biomeConfig.getServerBiomeId(), biomeConfig);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
                if (byteBufInputStream != null) {
                    try {
                        byteBufInputStream.close();
                    } catch (IOException ignored) {
                    }
                }
                if (objectInputStream != null) {
                    try {
                        objectInputStream.close();
                    } catch (IOException ignored) {
                    }
                }
            }
        }
    }
}

Example 42 with ByteBufInputStream

use of io.netty.buffer.ByteBufInputStream in project pravega by pravega.

the class CommandDecoder method parseCommand.

@VisibleForTesting
public static WireCommand parseCommand(ByteBuf in) throws IOException {
    @Cleanup ByteBufInputStream is = new ByteBufInputStream(in);
    int readableBytes = in.readableBytes();
    if (readableBytes < WireCommands.TYPE_PLUS_LENGTH_SIZE) {
        throw new InvalidMessageException("Not enough bytes to read.");
    }
    WireCommandType type = readType(is);
    int length = readLength(is, readableBytes);
    WireCommand command = type.readFrom(is, length);
    return command;
}

Example 43 with ByteBufInputStream

use of io.netty.buffer.ByteBufInputStream in project pravega by pravega.

the class WireCommandsTest method testCommandFromByteArray.

private void testCommandFromByteArray(byte[] bytes, WireCommand compatibleCommand) throws IOException {
    WireCommand read = compatibleCommand.getType().readFrom(new ByteBufInputStream(Unpooled.wrappedBuffer(bytes)), bytes.length);
    assertEquals(compatibleCommand, read);
}

Example 44 with ByteBufInputStream

use of io.netty.buffer.ByteBufInputStream in project pravega by pravega.

the class WireCommandsTest method testCommand.

private void testCommand(WireCommand command) throws IOException {
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    command.writeFields(new DataOutputStream(bout));
    byte[] array = bout.toByteArray();
    WireCommand read = command.getType().readFrom(new ByteBufInputStream(Unpooled.wrappedBuffer(array)), array.length);
    assertEquals(command, read);
}

Example 45 with ByteBufInputStream

use of io.netty.buffer.ByteBufInputStream in project drill by axbaretto.

the class UserServerRequestHandler method handle.

@Override
public void handle(BitToUserConnection connection, int rpcType, ByteBuf pBody, ByteBuf dBody, ResponseSender responseSender) throws RpcException {
    switch(rpcType) {
        case RpcType.RUN_QUERY_VALUE:
            logger.debug("Received query to run.  Returning query handle.");
            try {
                final RunQuery query = RunQuery.PARSER.parseFrom(new ByteBufInputStream(pBody));
                final QueryId queryId = worker.submitWork(connection, query);
                responseSender.send(new Response(RpcType.QUERY_HANDLE, queryId));
                break;
            } catch (InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding RunQuery body.", e);
            }
        case RpcType.CANCEL_QUERY_VALUE:
            try {
                final QueryId queryId = QueryId.PARSER.parseFrom(new ByteBufInputStream(pBody));
                final Ack ack = worker.cancelQuery(queryId);
                responseSender.send(new Response(RpcType.ACK, ack));
                break;
            } catch (InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding QueryId body.", e);
            }
        case RpcType.RESUME_PAUSED_QUERY_VALUE:
            try {
                final QueryId queryId = QueryId.PARSER.parseFrom(new ByteBufInputStream(pBody));
                final Ack ack = worker.resumeQuery(queryId);
                responseSender.send(new Response(RpcType.ACK, ack));
                break;
            } catch (final InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding QueryId body.", e);
            }
        case RpcType.GET_QUERY_PLAN_FRAGMENTS_VALUE:
            try {
                final GetQueryPlanFragments req = GetQueryPlanFragments.PARSER.parseFrom(new ByteBufInputStream(pBody));
                responseSender.send(new Response(RpcType.QUERY_PLAN_FRAGMENTS, worker.getQueryPlan(connection, req)));
                break;
            } catch (final InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding GetQueryPlanFragments body.", e);
            }
        case RpcType.GET_CATALOGS_VALUE:
            try {
                final GetCatalogsReq req = GetCatalogsReq.PARSER.parseFrom(new ByteBufInputStream(pBody));
                worker.submitCatalogMetadataWork(connection.getSession(), req, responseSender);
                break;
            } catch (final InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding GetCatalogsReq body.", e);
            }
        case RpcType.GET_SCHEMAS_VALUE:
            try {
                final GetSchemasReq req = GetSchemasReq.PARSER.parseFrom(new ByteBufInputStream(pBody));
                worker.submitSchemasMetadataWork(connection.getSession(), req, responseSender);
                break;
            } catch (final InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding GetSchemasReq body.", e);
            }
        case RpcType.GET_TABLES_VALUE:
            try {
                final GetTablesReq req = GetTablesReq.PARSER.parseFrom(new ByteBufInputStream(pBody));
                worker.submitTablesMetadataWork(connection.getSession(), req, responseSender);
                break;
            } catch (final InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding GetTablesReq body.", e);
            }
        case RpcType.GET_COLUMNS_VALUE:
            try {
                final GetColumnsReq req = GetColumnsReq.PARSER.parseFrom(new ByteBufInputStream(pBody));
                worker.submitColumnsMetadataWork(connection.getSession(), req, responseSender);
                break;
            } catch (final InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding GetColumnsReq body.", e);
            }
        case RpcType.CREATE_PREPARED_STATEMENT_VALUE:
            try {
                final CreatePreparedStatementReq req = CreatePreparedStatementReq.PARSER.parseFrom(new ByteBufInputStream(pBody));
                worker.submitPreparedStatementWork(connection, req, responseSender);
                break;
            } catch (final InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding CreatePreparedStatementReq body.", e);
            }
        case RpcType.GET_SERVER_META_VALUE:
            try {
                final GetServerMetaReq req = GetServerMetaReq.PARSER.parseFrom(new ByteBufInputStream(pBody));
                worker.submitServerMetadataWork(connection.getSession(), req, responseSender);
                break;
            } catch (final InvalidProtocolBufferException e) {
                throw new RpcException("Failure while decoding CreatePreparedStatementReq body.", e);
            }
        default:
            throw new UnsupportedOperationException(String.format("UserServerRequestHandler received rpc of unknown type. Type was %d.", rpcType));
    }
}