Java StreamSession类代码示例

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public IncomingFileMessage deserialize(ReadableByteChannel in, int version, StreamSession session) throws IOException
{
    DataInputStream input = new DataInputStream(Channels.newInputStream(in));
    FileMessageHeader header = FileMessageHeader.serializer.deserialize(input, version);
    StreamReader reader = header.compressionInfo == null ? new StreamReader(header, session)
            : new CompressedStreamReader(header, session);

    try
    {
        return new IncomingFileMessage(reader.read(in), header);
    }
    catch (Throwable t)
    {
        JVMStabilityInspector.inspectThrowable(t);
        session.doRetry(header, t);
        return null;
    }
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public static StreamMessage deserialize(ReadableByteChannel in, int version, StreamSession session) throws IOException
{
    ByteBuffer buff = ByteBuffer.allocate(1);
    if (in.read(buff) > 0)
    {
        buff.flip();
        Type type = Type.get(buff.get());
        return type.inSerializer.deserialize(in, version, session);
    }
    else
    {
        // when socket gets closed, there is a chance that buff is empty
        // in that case, just return null
        return null;
    }
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public static StreamMessage deserialize(ReadableByteChannel in, int version, StreamSession session) throws IOException
{
    ByteBuffer buff = ByteBuffer.allocate(1);
    if (in.read(buff) > 0)
    {
        buff.flip();
        Type type = Type.get(buff.get());
        return type.serializer.deserialize(in, version, session);
    }
    else
    {
        // when socket gets closed, there is a chance that buff is empty
        // in that case, just return null
        return null;
    }
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public FileMessage deserialize(ReadableByteChannel in, int version, StreamSession session) throws IOException
{
    DataInputStream input = new DataInputStream(Channels.newInputStream(in));
    FileMessageHeader header = FileMessageHeader.serializer.deserialize(input, version);
    StreamReader reader = header.compressionInfo == null ? new StreamReader(header, session)
                                  : new CompressedStreamReader(header, session);

    try
    {
        return new FileMessage(reader.read(in), header);
    }
    catch (Throwable e)
    {
        session.doRetry(header, e);
        return null;
    }
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
@SuppressWarnings("resource")
public IncomingFileMessage deserialize(ReadableByteChannel in, int version, StreamSession session) throws IOException
{
    DataInputPlus input = new DataInputStreamPlus(Channels.newInputStream(in));
    FileMessageHeader header = FileMessageHeader.serializer.deserialize(input, version);
    StreamReader reader = !header.isCompressed() ? new StreamReader(header, session)
            : new CompressedStreamReader(header, session);

    try
    {
        return new IncomingFileMessage(reader.read(in), header);
    }
    catch (Throwable t)
    {
        JVMStabilityInspector.inspectThrowable(t);
        throw t;
    }
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public synchronized void serialize(DataOutputStreamPlus out, int version, StreamSession session) throws IOException
{
    if (completed)
    {
        return;
    }

    CompressionInfo compressionInfo = FileMessageHeader.serializer.serialize(header, out, version);

    final SSTableReader reader = ref.get();
    StreamWriter writer = compressionInfo == null ?
                                  new StreamWriter(reader, header.sections, session) :
                                  new CompressedStreamWriter(reader, header.sections,
                                                             compressionInfo, session);
    writer.write(out);
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public static StreamMessage deserialize(ReadableByteChannel in, int version, StreamSession session) throws IOException
{
    ByteBuffer buff = ByteBuffer.allocate(1);
    int readBytes = in.read(buff);
    if (readBytes > 0)
    {
        buff.flip();
        Type type = Type.get(buff.get());
        return type.inSerializer.deserialize(in, version, session);
    }
    else if (readBytes == 0)
    {
        // input socket buffer was not filled yet
        return null;
    }
    else
    {
        // possibly socket gets closed
        throw new SocketException("End-of-stream reached");
    }
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public IncomingFileMessage deserialize(ReadableByteChannel in, int version, StreamSession session) throws IOException
{
    DataInputStream input = new DataInputStream(Channels.newInputStream(in));
    FileMessageHeader header = FileMessageHeader.serializer.deserialize(input, version);
    StreamReader reader = header.compressionInfo == null ? new StreamReader(header, session)
            : new CompressedStreamReader(header, session);

    try
    {
        return new IncomingFileMessage(reader.read(in), header);
    }
    catch (Throwable e)
    {
        session.doRetry(header, e);
        return null;
    }
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public void serialize(OutgoingFileMessage message, DataOutputStreamAndChannel out, int version, StreamSession session) throws IOException
{
    FileMessageHeader.serializer.serialize(message.header, out, version);

    final SSTableReader reader = message.sstable;
    StreamWriter writer = message.header.compressionInfo == null ?
            new StreamWriter(reader, message.header.sections, session) :
            new CompressedStreamWriter(reader,
                    message.header.sections,
                    message.header.compressionInfo, session);
    writer.write(out.getChannel());
    session.fileSent(message.header);
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public PrepareMessage deserialize(ReadableByteChannel in, int version, StreamSession session) throws IOException
{
    DataInput input = new DataInputStream(Channels.newInputStream(in));
    PrepareMessage message = new PrepareMessage();
    // requests
    int numRequests = input.readInt();
    for (int i = 0; i < numRequests; i++)
        message.requests.add(StreamRequest.serializer.deserialize(input, version));
    // summaries
    int numSummaries = input.readInt();
    for (int i = 0; i < numSummaries; i++)
        message.summaries.add(StreamSummary.serializer.deserialize(input, version));
    return message;
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public void serialize(PrepareMessage message, DataOutputStreamAndChannel out, int version, StreamSession session) throws IOException
{
    // requests
    out.writeInt(message.requests.size());
    for (StreamRequest request : message.requests)
        StreamRequest.serializer.serialize(request, out, version);
    // summaries
    out.writeInt(message.summaries.size());
    for (StreamSummary summary : message.summaries)
        StreamSummary.serializer.serialize(summary, out, version);
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public static void serialize(StreamMessage message, DataOutputStreamAndChannel out, int version, StreamSession session) throws IOException
{
    ByteBuffer buff = ByteBuffer.allocate(1);
    // message type
    buff.put(message.type.type);
    buff.flip();
    out.write(buff);
    message.type.outSerializer.serialize(message, out, version, session);
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public void serialize(PrepareMessage message, WritableByteChannel out, int version, StreamSession session) throws IOException
{
    DataOutput output = new DataOutputStream(Channels.newOutputStream(out));
    // requests
    output.writeInt(message.requests.size());
    for (StreamRequest request : message.requests)
        StreamRequest.serializer.serialize(request, output, version);
    // summaries
    output.writeInt(message.summaries.size());
    for (StreamSummary summary : message.summaries)
        StreamSummary.serializer.serialize(summary, output, version);
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public static void serialize(StreamMessage message, WritableByteChannel out, int version, StreamSession session) throws IOException
{
    ByteBuffer buff = ByteBuffer.allocate(1);
    // message type
    buff.put(message.type.type);
    buff.flip();
    out.write(buff);
    message.type.serializer.serialize(message, out, version, session);
}
 

import org.apache.cassandra.streaming.StreamSession; //导入依赖的package包/类
public void serialize(FileMessage message, WritableByteChannel out, int version, StreamSession session) throws IOException
{
    DataOutput output = new DataOutputStream(Channels.newOutputStream(out));
    FileMessageHeader.serializer.serialize(message.header, output, version);
    StreamWriter writer = message.header.compressionInfo == null ?
                                  new StreamWriter(message.sstable, message.header.sections, session) :
                                  new CompressedStreamWriter(message.sstable,
                                                             message.header.sections,
                                                             message.header.compressionInfo, session);
    writer.write(out);
    session.fileSent(message.header);
}