public RiakResult Read(IRiakCommand command)
{
bool done = false;
do
{
MessageCode expectedCode = command.ExpectedCode;
Type expectedType = MessageCodeTypeMapBuilder.GetTypeFor(expectedCode);
int size = DoRead(expectedCode, expectedType);
RpbResp response = DeserializeInstance(expectedType, size);
command.OnSuccess(response);
var streamingResponse = response as IRpbStreamingResp;
if (streamingResponse == null)
{
done = true;
}
else
{
done = streamingResponse.done;
}
}while (done == false);
return(RiakResult.Success());
}
public void AllMessageCodesInMessageCodeEnum()
{
var messageMapByName = new Dictionary <string, ushort>();
var currentDir = Environment.CurrentDirectory;
string riak_pb_messages_file =
Path.GetFullPath(Path.Combine(currentDir, "..", "..", "..", "riak_pb", "src", "riak_pb_messages.csv"));
if (!File.Exists(riak_pb_messages_file))
{
Assert.Ignore("Please run 'git submodule update --init' before running this test. Required file is missing: '{0}'", riak_pb_messages_file);
}
string[] msg_csv = File.ReadAllLines(riak_pb_messages_file);
foreach (string line in msg_csv)
{
string[] parts = line.Split(csv_split);
ushort messageCode = UInt16.Parse(parts[0]);
string messageName = parts[1];
messageMapByName.Add(messageName, messageCode);
}
var messageCodeEnumNames = Enum.GetNames(typeof(MessageCode));
foreach (string name in messageMapByName.Keys)
{
Assert.True(messageCodeEnumNames.Contains(name),
string.Format("CSV contains name '{0}' but enum does NOT", name));
ushort messageCodeValue = messageMapByName[name];
MessageCode parsedMessageCode;
Assert.True(Enum.TryParse(messageCodeValue.ToString(), out parsedMessageCode),
string.Format("Can't parse message code '{0}' with value '{1}' as Message Code enum",
name, messageCodeValue));
bool condition =
parsedMessageCode.Equals(MessageCode.RpbPingReq) || // NB: Does not have a protobuf message class
parsedMessageCode.Equals(MessageCode.RpbPingResp) ||
parsedMessageCode.Equals(MessageCode.RpbGetClientIdReq) || // NB: unused
parsedMessageCode.Equals(MessageCode.RpbGetClientIdResp) ||
parsedMessageCode.Equals(MessageCode.RpbGetServerInfoReq) ||
parsedMessageCode.Equals(MessageCode.RpbSetClientIdReq) ||
parsedMessageCode.Equals(MessageCode.RpbSetClientIdResp) ||
parsedMessageCode.Equals(MessageCode.RpbDelResp) ||
parsedMessageCode.Equals(MessageCode.RpbSetBucketResp) ||
parsedMessageCode.Equals(MessageCode.RpbResetBucketResp) ||
parsedMessageCode.Equals(MessageCode.RpbAuthResp) ||
parsedMessageCode.Equals(MessageCode.RpbStartTls) ||
MessageCodeTypeMapBuilder.Contains(parsedMessageCode);
Assert.True(condition, string.Format("MessageCodeTypeMapBuilder does NOT contain '{0}'", parsedMessageCode));
}
foreach (string name in messageCodeEnumNames)
{
Assert.True(messageMapByName.ContainsKey(name),
string.Format("MessageCode enum contains name '{0}' but CSV does NOT", name));
}
}
public T Read <T>() where T : new()
{
Type expectedType = typeof(T);
MessageCode expectedCode = MessageCodeTypeMapBuilder.GetMessageCodeFor(expectedType);
int size = ReadMessageSize(expectedCode);
return(DeserializeInstance <T>(size));
}
public RiakResult Read(IRiakCommand command)
{
MessageCode expectedCode = command.ExpectedCode;
Type expectedType = MessageCodeTypeMapBuilder.GetTypeFor(expectedCode);
int size = DoRead(expectedCode, expectedType);
RpbResp response = DeserializeInstance(expectedType, size);
command.OnSuccess(response);
return(RiakResult.Success());
}
public virtual RiakResp DecodeResponse(byte[] buffer)
{
Type expectedType = MessageCodeTypeMapBuilder.GetTypeFor(ExpectedCode);
if (buffer == null || buffer.Length == 0)
{
return(Activator.CreateInstance(expectedType) as RiakResp);
}
else
{
using (var memStream = new MemoryStream(buffer))
{
return(Serializer.NonGeneric.Deserialize(expectedType, memStream) as RiakResp);
}
}
}
private int ReadMessageSize(MessageCode expectedCode)
{
int size = 0;
MessageCode messageCode = ReceiveHeader(out size);
if (!MessageCodeTypeMapBuilder.Contains(messageCode))
{
throw new RiakInvalidDataException((byte)messageCode);
}
if (expectedCode != messageCode)
{
string errorMessage = string.Format("Expected return code {0} received {1}", expectedCode, messageCode);
throw new RiakException(errorMessage, false);
}
return(size);
}
private RiakResult DoWrite(Action <MemoryStream> serializer, Type messageType)
{
byte[] messageBody;
int messageLength = 0;
using (var memStream = new MemoryStream())
{
// add a buffer to the start of the array to put the size and message code
memStream.Position += PbMsgHeaderSize;
serializer(memStream);
messageBody = memStream.GetBuffer();
messageLength = (int)memStream.Position;
}
// check to make sure something was written, otherwise we'll have to create a new array
if (messageLength == PbMsgHeaderSize)
{
messageBody = new byte[PbMsgHeaderSize];
}
MessageCode messageCode = MessageCodeTypeMapBuilder.GetMessageCodeFor(messageType);
var size = BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)messageLength - PbMsgHeaderSize + 1));
Array.Copy(size, messageBody, SizeOfInt);
messageBody[SizeOfInt] = (byte)messageCode;
if (NetworkStream.CanWrite)
{
NetworkStream.Write(messageBody, 0, messageLength);
}
else
{
string errorMessage = string.Format("Failed to send data to server - Can't write: {0}:{1}", server, port);
throw new RiakException(errorMessage, true);
}
return(RiakResult.Success());
}
private int DoRead(MessageCode expectedCode, Type expectedType)
{
int size = 0;
MessageCode messageCode = ReceiveHeader(out size);
if (!MessageCodeTypeMapBuilder.Contains(messageCode))
{
throw new RiakInvalidDataException((byte)messageCode);
}
if (expectedCode != messageCode)
{
string errorMessage = string.Format("Expected return code {0} received {1}", expectedCode, messageCode);
throw new RiakException(errorMessage, false);
}
/*
* Removed #if DEBUG because this seems like a good check
* This message code validation is here to make sure that the caller
* is getting exactly what they expect.
* TODO: FUTURE - does this check impact performance?
*/
Type typeForMessageCode = MessageCodeTypeMapBuilder.GetTypeFor(messageCode);
if (typeForMessageCode != expectedType)
{
string receivedMessageCodeTypeName = MessageCodeTypeMapBuilder.GetTypeNameFor(messageCode);
throw new InvalidOperationException(
string.Format(
"Attempt to decode message to type '{0}' when received type '{1}'.",
expectedType.Name,
receivedMessageCodeTypeName));
}
return(size);
}
public void Write <T>(T message) where T : class
{
MessageCode messageCode = MessageCodeTypeMapBuilder.GetMessageCodeFor(typeof(T));
DoWrite(s => Serializer.Serialize(s, message), messageCode);
}
