public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
var wb = new FrameWriter(stream, serializer);
wb.WriteFrameHeader(0x00, streamId, OpCode);
wb.WriteBytes(_token);
return wb.Close();
}
public int WriteFrame(short streamId, MemoryStream stream, ISerializer serializer)
{
var wb = new FrameWriter(stream, serializer);
wb.WriteFrameHeader((byte)_headerFlags, streamId, OpCode);
var protocolVersion = serializer.ProtocolVersion;
if (_payload != null)
{
wb.WriteBytesMap(_payload);
}
wb.WriteLongString(Query);
if (protocolVersion.SupportsKeyspaceInRequest())
{
wb.WriteInt32((int)_prepareFlags);
if (Keyspace != null)
{
wb.WriteString(Keyspace);
}
}
return(wb.Close());
}
public void WriteMessage(QueueDelete message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
writer.WriteOctet(RabbitMQConstants.FrameMethod);
writer.WriteShortInt(_channelId);
var reserved = writer.Reserve(4);
var checkpoint = writer.Written;
FrameWriter.WriteMethodFrame(50, 40, ref writer);
writer.WriteShortInt(0); //reserved-1
writer.WriteShortStr(message.Name);
writer.WriteBit(message.IfUnused);
writer.WriteBit(message.IfEmpty);
writer.WriteBit(message.NoWait);
writer.BitFlush();
var payloadSize = writer.Written - checkpoint;
writer.WriteOctet(RabbitMQConstants.FrameEnd);
Span <byte> span = stackalloc byte[4];
BinaryPrimitives.WriteInt32BigEndian(span, payloadSize);
reserved.Write(span);
writer.Commit();
}
// Test a wide row consisting of a ByteBuffer
private static void TestByteRows(ISession session, string tableName)
{
session.Execute(String.Format("CREATE TABLE {0} (k INT, i {1}, PRIMARY KEY(k,i))", tableName, "BLOB"));
// Build small ByteBuffer sample
var bw = new FrameWriter(new MemoryStream(), new Serializer(ProtocolVersion.V1));
for (int i = 0; i < 56; i++)
{
bw.WriteByte(0);
}
bw.WriteUInt16(0xCAFE);
var bb = new byte[58];
Array.Copy(bw.GetBuffer(), bb, 58);
// Write data
for (int i = 0; i < 1024; ++i)
{
session.Execute(string.Format("INSERT INTO {0}(k,i) values({1},0x{2})", tableName, Key, CqlQueryTools.ToHex(bb)),
ConsistencyLevel.Quorum);
}
// Read data
var rs = session.Execute("SELECT i FROM " + tableName + " WHERE k = " + Key, ConsistencyLevel.Quorum);
// Verify data
foreach (var row in rs)
{
Assert.AreEqual((byte[])row["i"], bb);
}
}
public void WriteMessage(QueueBind message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
writer.WriteOctet(1);
writer.WriteShortInt(_channelId);
var reserved = writer.Reserve(4);
var checkpoint = writer.Written;
FrameWriter.WriteMethodFrame(50, 20, ref writer);
writer.WriteShortInt(0); //reserved-1
writer.WriteShortStr(message.QueueName);
writer.WriteShortStr(message.ExchangeName);
writer.WriteShortStr(message.RoutingKey);
writer.WriteBit(message.NoWait);
writer.WriteTable(message.Arguments);
var payloadSize = writer.Written - checkpoint;
writer.WriteOctet(RabbitMQConstants.FrameEnd);
Span <byte> span = stackalloc byte[4];
BinaryPrimitives.WriteInt32BigEndian(span, payloadSize);
reserved.Write(span);
writer.Commit();
}
public void WriteMessage(ExchangeDeclare message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
writer.WriteOctet(1);
writer.WriteShortInt(_channelId);
var reserved = writer.Reserve(4);
var checkpoint = writer.Written;
FrameWriter.WriteMethodFrame(40, 10, ref writer);
writer.WriteShortInt(0); //reseved-1
writer.WriteShortStr(message.Name);
writer.WriteShortStr(message.Type);
writer.WriteBit(message.Passive);
writer.WriteBit(message.Durable);
writer.WriteBit(message.AutoDelete);
writer.WriteBit(message.Internal);
writer.WriteBit(message.NoWait);
writer.WriteTable(message.Arguments);
var size = writer.Written - checkpoint;
writer.WriteOctet(RabbitMQConstants.FrameEnd);
Span <byte> sizeSpan = stackalloc byte[4];
BinaryPrimitives.WriteInt32BigEndian(sizeSpan, size);
reserved.Write(sizeSpan);
writer.Commit();
}
private byte[] serializeForDynamicType(params object[] vals)
{
var elt = new FrameWriter(new MemoryStream());
foreach (object p in vals)
{
if (p is int)
{
elt.WriteUInt16(0x8000 | 'i');
elt.WriteUInt16(4);
elt.WriteInt32((int)p);
elt.WriteByte(0);
}
else if (p is String)
{
elt.WriteUInt16(0x8000 | 's');
elt.WriteString(p as string);
elt.WriteByte(0);
}
else
{
throw new InvalidOperationException();
}
}
var ret = new byte[elt.Length];
Buffer.BlockCopy(elt.GetBuffer(), 0, ret, 0, (int)elt.Length);
return ret;
}
public void WriteMessage(QueueInfo message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
writer.WriteOctet(1);
writer.WriteShortInt(ChannelId);
var reseved = writer.Reserve(4);
var checkpoint = writer.Written;
FrameWriter.WriteMethodFrame(50, 10, ref writer);
writer.WriteShortInt(0); //reserved-1
writer.WriteShortStr(message.Name);
writer.WriteBit(message.Passive);
writer.WriteBit(message.Durable);
writer.WriteBit(message.Exclusive);
writer.WriteBit(message.AutoDelete);
writer.WriteBit(message.NoWait);
writer.WriteTable(message.Arguments);
var payloadSize = writer.Written - checkpoint;
writer.WriteOctet(Constants.FrameEnd);
Span <byte> span = stackalloc byte[4];
BinaryPrimitives.WriteInt32BigEndian(span, payloadSize);
reseved.Write(span);
writer.Commit();
}
public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
var wb = new FrameWriter(stream, serializer);
wb.WriteFrameHeader(0x00, streamId, OpCode);
return(wb.Close());
}
public int WriteFrame(short streamId, MemoryStream stream)
{
var wb = new FrameWriter(stream);
wb.WriteFrameHeader((byte)ProtocolVersion, 0x00, streamId, OpCode);
wb.WriteStringList(_eventTypes);
return wb.Close();
}
private byte[] serializeForDynamicType(params object[] vals)
{
var elt = new FrameWriter(new MemoryStream(), new Serializer(ProtocolVersion.V1));
foreach (object p in vals)
{
if (p is int)
{
elt.WriteUInt16(0x8000 | 'i');
elt.WriteUInt16(4);
elt.WriteInt32((int)p);
elt.WriteByte(0);
}
else if (p is String)
{
elt.WriteUInt16(0x8000 | 's');
elt.WriteString(p as string);
elt.WriteByte(0);
}
else
{
throw new InvalidOperationException();
}
}
var ret = new byte[elt.Length];
Buffer.BlockCopy(elt.GetBuffer(), 0, ret, 0, (int)elt.Length);
return(ret);
}
internal void WriteMessage(ReadOnlyMemory <byte> message, ref ValueWriter writer)
{
FrameWriter.WriteFrameHeader(RabbitMQConstants.FrameBody, _channelId, message.Length, ref writer);
writer.WriteBytes(message.Span);
writer.WriteOctet(RabbitMQConstants.FrameEnd);
writer.Commit();
}
public void BeBinaryWriter_Close_Sets_Frame_Body_Length()
{
const int frameLength = 10;
const int iterations = 8;
const byte protocolVersion = 2;
var bufferPool = new RecyclableMemoryStreamManager();
using (var stream = bufferPool.GetStream("test"))
{
for (var i = 0; i < iterations; i++)
{
var writer = new FrameWriter(stream, new Serializer(protocolVersion));
writer.WriteFrameHeader(0, 127, 8);
writer.WriteInt16(Convert.ToInt16(0x0900 + i));
var length = writer.Close();
Assert.AreEqual(frameLength, length);
}
Assert.AreEqual(frameLength * iterations, stream.Length);
for (byte i = 0; i < iterations; i++)
{
var buffer = new byte[frameLength];
stream.Position = i * frameLength;
stream.Read(buffer, 0, frameLength);
CollectionAssert.AreEqual(new byte[] { 2, 0, 127, 8, 0, 0, 0, 2, 9, i }, buffer);
}
}
}
public int WriteFrame(short streamId, MemoryStream stream)
{
var wb = new FrameWriter(stream);
wb.WriteFrameHeader((byte)ProtocolVersion, 0x00, streamId, OpCode);
return(wb.Close());
}
public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
var wb = new FrameWriter(stream, serializer);
wb.WriteFrameHeader(0x00, streamId, OpCode);
wb.WriteStringList(_eventTypes);
return wb.Close();
}
public int WriteFrame(short streamId, MemoryStream stream)
{
var wb = new FrameWriter(stream);
wb.WriteFrameHeader((byte)ProtocolVersion, 0x00, streamId, OpCode);
wb.WriteBytes(_token);
return wb.Close();
}
public int WriteFrame(short streamId, MemoryStream stream, ISerializer serializer)
{
var wb = new FrameWriter(stream, serializer);
var protocolVersion = serializer.ProtocolVersion;
if (Payload != null)
{
_headerFlags |= FrameHeader.HeaderFlag.CustomPayload;
}
wb.WriteFrameHeader((byte)_headerFlags, streamId, OpCode);
if (Payload != null)
{
//A custom payload for this request
wb.WriteBytesMap(Payload);
}
wb.WriteShortBytes(_id);
if (protocolVersion.SupportsResultMetadataId())
{
wb.WriteShortBytes(_resultMetadataId);
}
_queryOptions.Write(wb, true);
return(wb.Close());
}
public int Write(FrameWriter writer)
{
var count = writer.WriteUInt16(Major);
count += writer.WriteUInt16(Minor);
return(count);
}
protected override void WriteBody(FrameWriter wb)
{
wb.WriteUInt16((ushort)_options.Count);
foreach (var kv in _options)
{
wb.WriteString(kv.Key);
wb.WriteString(kv.Value);
}
}
public void WriteMessage(byte[] message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
FrameWriter.WriteFrameHeader(Constants.FrameBody, _channelId, message.Length, ref writer);
writer.WriteBytes(message);
writer.WriteOctet(Constants.FrameEnd);
writer.Commit();
}
public void WriteMessage(NoPaylodMethodInfo message, IBufferWriter <byte> output)
{
var writer = new ValueWriter(output);
FrameWriter.WriteFrameHeader(message.FrameType, message.Channel, 4, ref writer);
FrameWriter.WriteMethodFrame(message.ClassId, message.MethodId, ref writer);
writer.WriteOctet(RabbitMQConstants.FrameEnd);
writer.Commit();
}
public void WriteMessage(ushort message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
FrameWriter.WriteFrameHeader(1, message, 5, ref writer);
FrameWriter.WriteMethodFrame(20, 10, ref writer);
writer.WriteOctet(0);
writer.WriteOctet(206);
writer.Commit();
}
public MessageBroker(IDuplexStream stream)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
_reader = new FrameReader(stream);
_writer = new FrameWriter(stream);
}
public void WriteMessage(RejectInfo message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
FrameWriter.WriteFrameHeader(Constants.FrameMethod, _channel, 13, ref writer);
FrameWriter.WriteMethodFrame(60, 90, ref writer);
writer.WriteLongLong(message.DeliveryTag);
writer.WriteBit(message.Requeue);
writer.WriteOctet(Constants.FrameEnd);
}
private void WriteFrame(Frame frame, Stream stream, ID3v2MajorVersion version, EncodingScheme encoding)
{
FrameWriter writer = frame.CreateWriter(version, encoding);
if (writer == null)
{
throw new NoFrameWriterProvidedException(frame, version);
}
writer.WriteToStream(stream);
}
public ZlibWriter(
Stream outputStream,
byte[] dictionary)
{
_frameWriter = new FrameWriter(_pipe.Writer.AsStream());
_outputStream = outputStream;
_dictionary = dictionary;
_backgroundTask = RunZlibCompress();
}
public void WriteToBatch(FrameWriter wb)
{
wb.WriteByte(1); //prepared query
wb.WriteShortBytes(_id);
wb.WriteUInt16((ushort)_queryOptions.Values.Length);
foreach (var queryParameter in _queryOptions.Values)
{
wb.WriteAsBytes(queryParameter);
}
}
private void WriteFrameHeader(FrameWriter writer, short streamId)
{
var flags = _headerFlags;
if (writer.Serializer.ProtocolVersion.IsBeta())
{
flags |= HeaderFlags.UseBeta;
}
writer.WriteFrameHeader((byte)flags, streamId, OpCode);
}
public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
var wb = new FrameWriter(stream, serializer);
wb.WriteFrameHeader((byte)_headerFlags, streamId, OpCode);
if (Payload != null)
{
wb.WriteBytesMap(Payload);
}
wb.WriteLongString(Query);
return wb.Close();
}
public void WriteToBatch(byte protocolVersion, FrameWriter wb)
{
wb.WriteByte(1); //prepared query
wb.WriteShortBytes(_id);
wb.WriteUInt16((ushort)_queryOptions.Values.Length);
for (int i = 0; i < _metadata.Columns.Length; i++)
{
byte[] bytes = TypeCodec.Encode(protocolVersion, _queryOptions.Values[i]);
wb.WriteBytes(bytes);
}
}
public void WriteMessage(RabbitMQMainInfo message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
FrameWriter.WriteFrameHeader(1, 0, 12, ref writer);
FrameWriter.WriteMethodFrame(10, 31, ref writer);
writer.WriteShortInt(message.ChannelMax);
writer.WriteLong(message.FrameMax);
writer.WriteShortInt(message.Heartbeat);
writer.WriteOctet(206);
writer.Commit();
}
public int WriteFrame(short streamId, MemoryStream stream)
{
var wb = new FrameWriter(stream);
wb.WriteFrameHeader((byte)ProtocolVersion, 0x00, streamId, OpCode);
wb.WriteUInt16((ushort) _options.Count);
foreach (var kv in _options)
{
wb.WriteString(kv.Key);
wb.WriteString(kv.Value);
}
return wb.Close();
}
public void WriteMessage(AckInfo message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
FrameWriter.WriteFrameHeader(Constants.FrameMethod, _channelId, 13, ref writer);
FrameWriter.WriteMethodFrame(60, 80, ref writer);
writer.WriteLongLong(message.DeliveryTag);
writer.WriteBit(message.Multiple);
writer.BitFlush();
writer.WriteOctet(Constants.FrameEnd);
writer.Commit();
}
public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
var wb = new FrameWriter(stream, serializer);
wb.WriteFrameHeader((byte)_headerFlags, streamId, OpCode);
if (Payload != null)
{
wb.WriteBytesMap(Payload);
}
wb.WriteLongString(Query);
return(wb.Close());
}
public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
var wb = new FrameWriter(stream, serializer);
wb.WriteFrameHeader(0x00, streamId, StartupRequest.OpCode);
wb.WriteUInt16((ushort)_options.Count);
foreach (var kv in _options)
{
wb.WriteString(kv.Key);
wb.WriteString(kv.Value);
}
return(wb.Close());
}
public void WriteMessage(QoSInfo message, IBufferWriter <byte> output)
{
ValueWriter writer = new ValueWriter(output);
FrameWriter.WriteFrameHeader(1, _channel, 11, ref writer);
FrameWriter.WriteMethodFrame(60, 10, ref writer);
writer.WriteLong(message.PrefetchSize);
writer.WriteShortInt(message.PrefetchCount);
writer.WriteBool(message.Global);
writer.WriteOctet(RabbitMQConstants.FrameEnd);
writer.Commit();
}
public void WriteMessage(ReadOnlyMemory <byte> message, IBufferWriter <byte> output)
{
if (message.IsEmpty)
{
return;
}
var writer = new ValueWriter(output);
FrameWriter.WriteFrameHeader(RabbitMQConstants.FrameBody, _channelId, message.Length, ref writer);
writer.WriteBytes(message.Span);
writer.WriteOctet(RabbitMQConstants.FrameEnd);
writer.Commit();
}
public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
var wb = new FrameWriter(stream, serializer);
if (Payload != null)
{
_headerFlags |= FrameHeader.HeaderFlag.CustomPayload;
}
wb.WriteFrameHeader((byte)_headerFlags, streamId, OpCode);
if (Payload != null)
{
//A custom payload for this request
wb.WriteBytesMap(Payload);
}
wb.WriteShortBytes(_id);
_queryOptions.Write(wb, true);
return wb.Close();
}
public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
if (serializer.ProtocolVersion > 1)
{
throw new NotSupportedException("Credentials request is only supported in C* = 1.2.x");
}
var wb = new FrameWriter(stream, serializer);
wb.WriteFrameHeader(0x00, streamId, OpCode);
wb.WriteUInt16((ushort) _credentials.Count);
foreach (var kv in _credentials)
{
wb.WriteString(kv.Key);
wb.WriteString(kv.Value);
}
return wb.Close();
}
public int WriteFrame(short streamId, MemoryStream stream, Serializer serializer)
{
//protocol v2: <type><n><query_1>...<query_n><consistency>
//protocol v3: <type><n><query_1>...<query_n><consistency><flags>[<serial_consistency>][<timestamp>]
var protocolVersion = serializer.ProtocolVersion;
var wb = new FrameWriter(stream, serializer);
if (Payload != null)
{
_headerFlags |= FrameHeader.HeaderFlag.CustomPayload;
}
wb.WriteFrameHeader((byte)_headerFlags, streamId, OpCode);
if (Payload != null)
{
//A custom payload for this request
wb.WriteBytesMap(Payload);
}
wb.WriteByte((byte) _type);
wb.WriteInt16((short) _requests.Count);
foreach (var br in _requests)
{
br.WriteToBatch(wb);
}
wb.WriteInt16((short) Consistency);
if (protocolVersion >= 3)
{
wb.WriteByte((byte)_batchFlags);
}
if (_serialConsistency != null)
{
wb.WriteInt16((short)_serialConsistency.Value);
}
if (_timestamp != null)
{
//Expressed in microseconds
wb.WriteLong(TypeSerializer.SinceUnixEpoch(_timestamp.Value).Ticks / 10);
}
return wb.Close();
}
// Test a wide row consisting of a ByteBuffer
private static void TestByteRows(ISession session, string tableName)
{
session.Execute(String.Format("CREATE TABLE {0} (k INT, i {1}, PRIMARY KEY(k,i))", tableName, "BLOB"));
// Build small ByteBuffer sample
var bw = new FrameWriter(new MemoryStream());
for (int i = 0; i < 56; i++)
bw.WriteByte(0);
bw.WriteUInt16(0xCAFE);
var bb = new byte[58];
Array.Copy(bw.GetBuffer(), bb, 58);
// Write data
for (int i = 0; i < 1024; ++i)
session.Execute(string.Format("INSERT INTO {0}(k,i) values({1},0x{2})", tableName, Key, CqlQueryTools.ToHex(bb)),
ConsistencyLevel.Quorum);
// Read data
var rs = session.Execute("SELECT i FROM " + tableName + " WHERE k = " + Key, ConsistencyLevel.Quorum);
// Verify data
foreach (var row in rs)
Assert.AreEqual((byte[])row["i"], bb);
}
public void WriteToBatch(byte protocolVersion, FrameWriter wb)
{
wb.WriteByte(1); //prepared query
wb.WriteShortBytes(_id);
wb.WriteUInt16((ushort) _queryOptions.Values.Length);
for (int i = 0; i < _metadata.Columns.Length; i++)
{
byte[] bytes = TypeCodec.Encode(protocolVersion, _queryOptions.Values[i]);
wb.WriteBytes(bytes);
}
}
public void WriteToBatch(FrameWriter wb)
{
wb.WriteByte(1); //prepared query
wb.WriteShortBytes(_id);
wb.WriteUInt16((ushort)_queryOptions.Values.Length);
foreach (var queryParameter in _queryOptions.Values)
{
wb.WriteAsBytes(queryParameter);
}
}
public void WriteToBatch(FrameWriter wb)
{
//not a prepared query
wb.WriteByte(0);
wb.WriteLongString(_cqlQuery);
if (_queryOptions.Values == null || _queryOptions.Values.Length == 0)
{
//not values
wb.WriteInt16(0);
}
else
{
wb.WriteUInt16((ushort) _queryOptions.Values.Length);
foreach (var queryParameter in _queryOptions.Values)
{
wb.WriteAsBytes(queryParameter);
}
}
}
public int WriteFrame(short streamId, MemoryStream stream)
{
var wb = new FrameWriter(stream);
if (Payload != null)
{
_headerFlags |= FrameHeader.HeaderFlag.CustomPayload;
}
wb.WriteFrameHeader((byte)ProtocolVersion, (byte)_headerFlags, streamId, OpCode);
if (Payload != null)
{
//A custom payload for this request
wb.WriteBytesMap(Payload);
}
wb.WriteLongString(_cqlQuery);
_queryOptions.Write(wb, (byte)ProtocolVersion, false);
return wb.Close();
}
public void WriteToBatch(byte protocolVersion, FrameWriter wb)
{
//not a prepared query
wb.WriteByte(0);
wb.WriteLongString(_cqlQuery);
if (_queryOptions.Values == null || _queryOptions.Values.Length == 0)
{
//not values
wb.WriteInt16(0);
}
else
{
wb.WriteUInt16((ushort) _queryOptions.Values.Length);
for (var i = 0; i < _queryOptions.Values.Length; i++)
{
var bytes = TypeCodec.Encode(protocolVersion, _queryOptions.Values[i]);
wb.WriteBytes(bytes);
}
}
}
public FramingMessageProtocol()
{
this.frameCollector = new FrameCollector();
this.frameWriter = new FrameWriter();
this.frameReader = new FrameReader();
}
public void BeBinaryWriter_Close_Sets_Frame_Body_Length()
{
const int frameLength = 10;
const int iterations = 8;
var bufferPool = new RecyclableMemoryStreamManager();
using (var stream = bufferPool.GetStream("test"))
{
for (var i = 0; i < iterations; i++)
{
var writer = new FrameWriter(stream);
writer.WriteFrameHeader(2, 0, 127, 8);
writer.WriteInt16(Convert.ToInt16(0x0900 + i));
var length = writer.Close();
Assert.AreEqual(frameLength, length);
}
Assert.AreEqual(frameLength * iterations, stream.Length);
for (byte i = 0; i < iterations; i++)
{
var buffer = new byte[frameLength];
stream.Position = i * frameLength;
stream.Read(buffer, 0, frameLength);
CollectionAssert.AreEqual(new byte[] { 2, 0, 127, 8, 0, 0, 0, 2, 9, i}, buffer);
}
}
}
