public byte[] GetQueryBuffer()
{
if (RequestOpcode != Opcode.Get && RequestOpcode != Opcode.GetK && RequestOpcode != Opcode.GAT && RequestOpcode != Opcode.ReplicaRead)
{
throw new MemcacheException("Get request only supports Get, GetK, GAT or ReplicaRead opcodes");
}
int extraLength = RequestOpcode == Opcode.GAT ? sizeof(uint) : 0;
var requestHeader = new MemcacheRequestHeader(RequestOpcode)
{
VBucket = VBucket,
KeyLength = (ushort)Key.Length,
ExtraLength = (byte)extraLength,
TotalBodyLength = (uint)(extraLength + Key.Length),
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer);
// in case of Get and Touch, post the new TTL in extra
if (RequestOpcode == Opcode.GAT)
{
buffer.CopyFrom(MemcacheRequestHeader.Size + sizeof(uint), ExpirationTimeUtils.MemcachedTTL(Expire));
}
Key.CopyTo(buffer, extraLength + MemcacheRequestHeader.Size);
return(buffer);
}
public byte[] GetQueryBuffer()
{
var requestHeader = new MemcacheRequestHeader(Opcode.NoOp)
{
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.SIZE];
requestHeader.ToData(buffer, 0);
return(buffer);
}
public byte[] GetQueryBuffer()
{
var requestHeader = new MemcacheRequestHeader(Opcode.NoOp)
{
VBucket = VBucket,
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size];
requestHeader.ToData(buffer);
return buffer;
}
public byte[] GetQueryBuffer()
{
var requestHeader = new MemcacheRequestHeader(Opcode.NoOp)
{
VBucket = VBucket,
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size];
requestHeader.ToData(buffer);
return(buffer);
}
public byte[] GetQueryBuffer()
{
if (RequestOpcode != Opcode.Get && RequestOpcode != Opcode.GetK && RequestOpcode != Opcode.GAT)
{
throw new MemcacheException("Get request only supports Get, GetK or GAT opcodes");
}
var keyAsBytes = UTF8Encoding.Default.GetBytes(Key);
if (keyAsBytes.Length > ushort.MaxValue)
{
throw new ArgumentException("The key is too long for the memcache binary protocol : " + Key);
}
int extraLength = RequestOpcode == Opcode.GAT ?
sizeof(uint) : 0;
var requestHeader = new MemcacheRequestHeader(RequestOpcode)
{
KeyLength = (ushort)keyAsBytes.Length,
ExtraLength = (byte)extraLength,
TotalBodyLength = (uint)(extraLength + keyAsBytes.Length),
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.SIZE + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer, 0);
// in case of Get and Touch, post the new TTL in extra
if (RequestOpcode == Opcode.GAT)
{
uint expire;
if (Expire.CompareTo(TimeSpan.FromDays(30)) < 0)
{
expire = (uint)Expire.TotalSeconds;
}
else
{
expire = (uint)(DateTime.UtcNow.Add(Expire) - Epock).TotalSeconds;
}
buffer.CopyFrom(MemcacheRequestHeader.SIZE + sizeof(uint), expire);
}
keyAsBytes.CopyTo(buffer, extraLength + MemcacheRequestHeader.SIZE);
return(buffer);
}
public byte[] GetQueryBuffer()
{
var requestHeader = new MemcacheRequestHeader(Opcode.Delete)
{
VBucket = VBucket,
KeyLength = (ushort)Key.Length,
ExtraLength = 0,
TotalBodyLength = (uint)Key.Length,
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer);
Key.CopyTo(buffer, MemcacheResponseHeader.Size);
return buffer;
}
public byte[] GetQueryBuffer()
{
var requestHeader = new MemcacheRequestHeader(Opcode.Delete)
{
VBucket = VBucket,
KeyLength = (ushort)Key.Length,
ExtraLength = 0,
TotalBodyLength = (uint)Key.Length,
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer);
Key.CopyTo(buffer, MemcacheResponseHeader.Size);
return(buffer);
}
public byte[] GetQueryBuffer()
{
var keyAsBytes = UTF8Encoding.Default.GetBytes(Key);
if (keyAsBytes.Length > ushort.MaxValue)
{
throw new ArgumentException("The key is too long for the memcache binary protocol : " + Key);
}
var requestHeader = new MemcacheRequestHeader(RequestOpcode)
{
KeyLength = (ushort)keyAsBytes.Length,
ExtraLength = 2 * sizeof(uint),
TotalBodyLength = (uint)(2 * sizeof(uint) + keyAsBytes.Length + (Message == null ? 0 : Message.Length)),
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.SIZE + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer, 0);
buffer.CopyFrom(MemcacheRequestHeader.SIZE, Flags);
uint expire;
if (Expire.CompareTo(TimeSpan.FromDays(30)) < 0)
{
expire = (uint)Expire.TotalSeconds;
}
else
{
expire = (uint)(DateTime.UtcNow.Add(Expire) - Epock).TotalSeconds;
}
buffer.CopyFrom(MemcacheRequestHeader.SIZE + sizeof(uint), expire);
keyAsBytes.CopyTo(buffer, MemcacheRequestHeader.SIZE + requestHeader.ExtraLength);
if (Message != null)
{
Message.CopyTo(buffer, MemcacheRequestHeader.SIZE + requestHeader.ExtraLength + keyAsBytes.Length);
}
return(buffer);
}
public byte[] GetQueryBuffer()
{
var key = UTF8Encoding.Default.GetBytes(Key);
var data = Encoding.UTF8.GetBytes(Zone + "\0" + User + "\0" + Password);
var header = new MemcacheRequestHeader(Opcode.StartAuth)
{
ExtraLength = 0,
KeyLength = (ushort)key.Length,
TotalBodyLength = (uint)(key.Length + data.Length),
};
var message = new byte[MemcacheRequestHeader.SIZE + header.TotalBodyLength];
header.ToData(message);
Array.Copy(key, 0, message, MemcacheRequestHeader.SIZE, key.Length);
Array.Copy(data, 0, message, MemcacheRequestHeader.SIZE + key.Length, data.Length);
return(message);
}
public byte[] GetQueryBuffer()
{
var data = Encoding.UTF8.GetBytes(Zone + "\0" + User + "\0" + Password);
var header = new MemcacheRequestHeader(Opcode.StartAuth)
{
VBucket = VBucket,
ExtraLength = 0,
KeyLength = (ushort)Key.Length,
TotalBodyLength = (uint)(Key.Length + data.Length),
};
var message = new byte[MemcacheRequestHeader.Size + header.TotalBodyLength];
header.ToData(message);
Key.CopyTo(message, MemcacheRequestHeader.Size);
data.CopyTo(message, MemcacheRequestHeader.Size + Key.Length);
return(message);
}
public byte[] GetQueryBuffer()
{
const int extraLength = sizeof(ulong) + sizeof(ulong) + sizeof(uint);
var requestHeader = new MemcacheRequestHeader(RequestOpcode)
{
VBucket = VBucket,
KeyLength = (ushort)Key.Length,
ExtraLength = (byte)extraLength,
TotalBodyLength = (uint)(extraLength + Key.Length),
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer);
buffer.CopyFrom(MemcacheRequestHeader.Size, Delta);
buffer.CopyFrom(MemcacheRequestHeader.Size + sizeof(ulong), Initial);
buffer.CopyFrom(MemcacheRequestHeader.Size + 2 * sizeof(ulong), ExpirationTimeUtils.MemcachedTTL(Expire));
Key.CopyTo(buffer, extraLength + MemcacheRequestHeader.Size);
return buffer;
}
public byte[] GetQueryBuffer()
{
const int extraLength = sizeof(ulong) + sizeof(ulong) + sizeof(uint);
var requestHeader = new MemcacheRequestHeader(RequestOpcode)
{
VBucket = VBucket,
KeyLength = (ushort)Key.Length,
ExtraLength = (byte)extraLength,
TotalBodyLength = (uint)(extraLength + Key.Length),
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer);
buffer.CopyFrom(MemcacheRequestHeader.Size, Delta);
buffer.CopyFrom(MemcacheRequestHeader.Size + sizeof(ulong), Initial);
buffer.CopyFrom(MemcacheRequestHeader.Size + 2 * sizeof(ulong), ExpirationTimeUtils.MemcachedTTL(Expire));
Key.CopyTo(buffer, extraLength + MemcacheRequestHeader.Size);
return(buffer);
}
public byte[] GetQueryBuffer()
{
var keyAsBytes = UTF8Encoding.Default.GetBytes(Key);
if (keyAsBytes.Length > ushort.MaxValue)
{
throw new ArgumentException("The key is too long for the memcache binary protocol : " + Key);
}
var requestHeader = new MemcacheRequestHeader(Opcode.Delete)
{
KeyLength = (ushort)keyAsBytes.Length,
ExtraLength = 0,
TotalBodyLength = (uint)(keyAsBytes.Length),
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.SIZE + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer, 0);
keyAsBytes.CopyTo(buffer, MemcacheResponseHeader.SIZE);
return(buffer);
}
public byte[] GetQueryBuffer()
{
var requestHeader = new MemcacheRequestHeader(RequestOpcode)
{
VBucket = VBucket,
KeyLength = (ushort)Key.Length,
ExtraLength = 2 * sizeof(uint),
TotalBodyLength = (uint)(2 * sizeof(uint) + Key.Length + (Message == null ? 0 : Message.Length)),
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer);
buffer.CopyFrom(MemcacheRequestHeader.Size, Flags);
buffer.CopyFrom(MemcacheRequestHeader.Size + sizeof(uint), ExpirationTimeUtils.MemcachedTTL(Expire));
Key.CopyTo(buffer, MemcacheRequestHeader.Size + requestHeader.ExtraLength);
if (Message != null)
{
Message.CopyTo(buffer, MemcacheRequestHeader.Size + requestHeader.ExtraLength + Key.Length);
}
return(buffer);
}
public byte[] GetQueryBuffer()
{
var data = Encoding.UTF8.GetBytes(Zone + "\0" + User + "\0" + Password);
var header = new MemcacheRequestHeader(Opcode.StartAuth)
{
VBucket = VBucket,
ExtraLength = 0,
KeyLength = (ushort)Key.Length,
TotalBodyLength = (uint)(Key.Length + data.Length),
};
var message = new byte[MemcacheRequestHeader.Size + header.TotalBodyLength];
header.ToData(message);
Key.CopyTo(message, MemcacheRequestHeader.Size);
data.CopyTo(message, MemcacheRequestHeader.Size + Key.Length);
return message;
}
public void MemcacheSocketTest([Values(0, 2, 10)] int maxByteSentByServer)
{
using (var serverMock = new ServerMock())
{
var endPoint = serverMock.ListenEndPoint;
serverMock.MaxSent = maxByteSentByServer;
// random header
var requestHeader = new MemcacheRequestHeader
{
Cas = 1,
DataType = 2,
ExtraLength = 5,
KeyLength = 3,
Opaque = 42,
Opcode = Opcode.Increment,
TotalBodyLength = 12,
};
// body with the size defined in the header
var requestBody = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
// build the request buffer
var requestBuffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(requestBuffer);
Array.Copy(requestBody, 0, requestBuffer, MemcacheRequestHeader.Size, requestHeader.TotalBodyLength);
// build the response header
var responseHeader = new MemcacheResponseHeader
{
Cas = 8,
DataType = 12,
ExtraLength = 3,
KeyLength = 0,
// must be the same or it will crash : TODO add a test to ensure we detect this fail
Opaque = requestHeader.Opaque,
Status = Status.UnknownCommand,
Opcode = Opcode.Prepend,
TotalBodyLength = 15,
};
// body with the size defined in the header
var responseExtra = new byte[] { 1, 2, 3 };
var responseMessage = new byte[] { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
// build the request buffer
var responseBody = new byte[responseHeader.TotalBodyLength];
Array.Copy(responseExtra, 0, responseBody, 0, responseHeader.ExtraLength);
Array.Copy(responseMessage, 0, responseBody, responseHeader.ExtraLength, responseHeader.TotalBodyLength - responseHeader.ExtraLength);
// set the things to answer to the server
serverMock.ResponseBody = responseBody;
responseHeader.ToData(serverMock.ResponseHeader);
var request = new RequestMock
{
QueryBuffer = requestBuffer,
RequestId = requestHeader.Opaque
/*ResponseHeader = responseHeader,
* Message = responseMessage,
* Extra = responseExtra,*/
};
using (var transport = new MemcacheTransport(endPoint, new MemcacheClientConfiguration(), _ => { }, _ => { }, false, null))
{
Assert.IsTrue(transport.TrySend(request));
Assert.IsTrue(request.Mutex.Wait(TimeSpan.FromSeconds(10)), "The request has not been completed on less than 10 sec");
// and now, assert that we sent what we had to send and we received what the server sent
Assert.AreEqual(requestHeader, serverMock.LastReceivedHeader, "Sent header differ from header received by the server");
CollectionAssert.AreEqual(requestBody, serverMock.LastReceivedBody, "Sent body is different than received by the server");
Assert.AreEqual(responseHeader, request.ResponseHeader, "Received header differ from header sent by the server");
CollectionAssert.AreEqual(responseExtra, request.Extra, "Received extra is different than sent by the server");
CollectionAssert.AreEqual(responseMessage, request.Message, "Received message is different than sent by the server");
}
}
}
public byte[] GetQueryBuffer()
{
var requestHeader = new MemcacheRequestHeader(RequestOpcode)
{
VBucket = VBucket,
KeyLength = (ushort)Key.Length,
ExtraLength = 2 * sizeof(uint),
TotalBodyLength = (uint)(2 * sizeof(uint) + Key.Length + (Message == null ? 0 : Message.Length)),
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer);
buffer.CopyFrom(MemcacheRequestHeader.Size, Flags);
buffer.CopyFrom(MemcacheRequestHeader.Size + sizeof(uint), ExpirationTimeUtils.MemcachedTTL(Expire));
Key.CopyTo(buffer, MemcacheRequestHeader.Size + requestHeader.ExtraLength);
if (Message != null)
Message.CopyTo(buffer, MemcacheRequestHeader.Size + requestHeader.ExtraLength + Key.Length);
return buffer;
}
/// <summary>
/// A header is received =>
/// * Read the body if present
/// * Send the response header
/// * Send the body if present
/// * Start receiving again
/// </summary>
/// <param name="sender" />
/// <param name="e" />
void OnReceive(object sender, SocketAsyncEventArgs e)
{
try
{
if (ReceiveMutex != null)
{
ReceiveMutex.Wait();
}
// ends when error occur
if (e.SocketError != SocketError.Success)
{
return;
}
// ends request header transfer
var socket = sender as Socket;
int transfered = e.BytesTransferred;
while (transfered < MemcacheRequestHeader.Size && !_disposed)
{
transfered += socket.Receive(e.Buffer, transfered, MemcacheRequestHeader.Size - transfered, SocketFlags.None);
}
// read the request header
var header = new MemcacheRequestHeader();
header.FromData(e.Buffer);
LastReceivedHeader = header;
// transfer the body is present
if (header.TotalBodyLength > 0)
{
var body = new byte[header.TotalBodyLength];
transfered = 0;
while (transfered < header.TotalBodyLength && !_disposed)
{
transfered += socket.Receive(body, transfered, (int)header.TotalBodyLength - transfered, SocketFlags.None);
}
LastReceivedBody = body;
}
else
{
LastReceivedBody = null;
}
// send the response header
transfered = 0;
while (transfered < MemcacheResponseHeader.Size && !_disposed)
{
var toTransfer = MemcacheResponseHeader.Size - transfered;
if (MaxSent != 0 && MaxSent < toTransfer)
{
toTransfer = MaxSent;
}
transfered += socket.Send(ResponseHeader, transfered, toTransfer, SocketFlags.None);
}
// send the response body if present
if (ResponseBody != null)
{
transfered = 0;
while (transfered < ResponseBody.Length && !_disposed)
{
var toTransfer = ResponseBody.Length - transfered;
if (MaxSent != 0 && MaxSent < toTransfer)
{
toTransfer = MaxSent;
}
transfered += socket.Send(ResponseBody, transfered, toTransfer, SocketFlags.None);
}
}
// start to receive again
if (!_disposed)
{
socket.ReceiveAsync(e);
}
}
catch (Exception ex)
{
Console.WriteLine("Exception raised in ServerMock.OnReceive : " + ex);
LastException = ex;
}
}
public void MemcacheSocketTest([Values(0, 2, 10)]int maxByteSentByServer)
{
using (var serverMock = new ServerMock())
{
var endPoint = serverMock.ListenEndPoint;
serverMock.MaxSent = maxByteSentByServer;
// random header
var requestHeader = new MemcacheRequestHeader
{
Cas = 1,
DataType = 2,
ExtraLength = 5,
KeyLength = 3,
Opaque = 42,
Opcode = Opcode.Increment,
TotalBodyLength = 12,
};
// body with the size defined in the header
var requestBody = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
// build the request buffer
var requestBuffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(requestBuffer);
Array.Copy(requestBody, 0, requestBuffer, MemcacheRequestHeader.Size, requestHeader.TotalBodyLength);
// build the response header
var responseHeader = new MemcacheResponseHeader
{
Cas = 8,
DataType = 12,
ExtraLength = 3,
KeyLength = 0,
// must be the same or it will crash : TODO add a test to ensure we detect this fail
Opaque = requestHeader.Opaque,
Status = Status.UnknownCommand,
Opcode = Opcode.Prepend,
TotalBodyLength = 15,
};
// body with the size defined in the header
var responseExtra = new byte[] { 1, 2, 3 };
var responseMessage = new byte[] { 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
// build the request buffer
var responseBody = new byte[responseHeader.TotalBodyLength];
Array.Copy(responseExtra, 0, responseBody, 0, responseHeader.ExtraLength);
Array.Copy(responseMessage, 0, responseBody, responseHeader.ExtraLength, responseHeader.TotalBodyLength - responseHeader.ExtraLength);
// set the things to answer to the server
serverMock.ResponseBody = responseBody;
responseHeader.ToData(serverMock.ResponseHeader);
var request = new RequestMock
{
QueryBuffer = requestBuffer,
RequestId = requestHeader.Opaque
/*ResponseHeader = responseHeader,
Message = responseMessage,
Extra = responseExtra,*/
};
using (var transport = new MemcacheTransport(endPoint, new MemcacheClientConfiguration(), _ => { }, _ => { }, false, null))
{
Assert.IsTrue(transport.TrySend(request));
Assert.IsTrue(request.Mutex.Wait(TimeSpan.FromSeconds(10)), "The request has not been completed on less than 10 sec");
// and now, assert that we sent what we had to send and we received what the server sent
Assert.AreEqual(requestHeader, serverMock.LastReceivedHeader, "Sent header differ from header received by the server");
CollectionAssert.AreEqual(requestBody, serverMock.LastReceivedBody, "Sent body is different than received by the server");
Assert.AreEqual(responseHeader, request.ResponseHeader, "Received header differ from header sent by the server");
CollectionAssert.AreEqual(responseExtra, request.Extra, "Received extra is different than sent by the server");
CollectionAssert.AreEqual(responseMessage, request.Message, "Received message is different than sent by the server");
}
}
}
/// <summary>
/// A header is received =>
/// * Read the body if present
/// * Send the response header
/// * Send the body if present
/// * Start receiving again
/// </summary>
/// <param name="sender" />
/// <param name="e" />
void OnReceive(object sender, SocketAsyncEventArgs e)
{
try
{
if (ReceiveMutex != null)
{
ReceiveMutex.Wait();
}
// ends when error occur
if (e.SocketError != SocketError.Success)
return;
// ends request header transfer
var socket = sender as Socket;
int transfered = e.BytesTransferred;
while (transfered < MemcacheRequestHeader.Size && !_disposed)
transfered += socket.Receive(e.Buffer, transfered, MemcacheRequestHeader.Size - transfered, SocketFlags.None);
// read the request header
var header = new MemcacheRequestHeader();
header.FromData(e.Buffer);
LastReceivedHeader = header;
// transfer the body is present
if (header.TotalBodyLength > 0)
{
var body = new byte[header.TotalBodyLength];
transfered = 0;
while (transfered < header.TotalBodyLength && !_disposed)
transfered += socket.Receive(body, transfered, (int)header.TotalBodyLength - transfered, SocketFlags.None);
LastReceivedBody = body;
}
else
LastReceivedBody = null;
// send the response header
transfered = 0;
while (transfered < MemcacheResponseHeader.Size && !_disposed)
{
var toTransfer = MemcacheResponseHeader.Size - transfered;
if (MaxSent != 0 && MaxSent < toTransfer)
toTransfer = MaxSent;
transfered += socket.Send(ResponseHeader, transfered, toTransfer, SocketFlags.None);
}
// send the response body if present
if (ResponseBody != null)
{
transfered = 0;
while (transfered < ResponseBody.Length && !_disposed)
{
var toTransfer = ResponseBody.Length - transfered;
if (MaxSent != 0 && MaxSent < toTransfer)
toTransfer = MaxSent;
transfered += socket.Send(ResponseBody, transfered, toTransfer, SocketFlags.None);
}
}
// start to receive again
if (!_disposed)
socket.ReceiveAsync(e);
}
catch (Exception ex)
{
Console.WriteLine("Exception raised in ServerMock.OnReceive : " + ex);
LastException = ex;
}
}
public byte[] GetQueryBuffer()
{
if (RequestOpcode != Opcode.Get && RequestOpcode != Opcode.GetK && RequestOpcode != Opcode.GAT && RequestOpcode != Opcode.ReplicaRead)
throw new MemcacheException("Get request only supports Get, GetK, GAT or ReplicaRead opcodes");
int extraLength = RequestOpcode == Opcode.GAT ? sizeof(uint) : 0;
var requestHeader = new MemcacheRequestHeader(RequestOpcode)
{
VBucket = VBucket,
KeyLength = (ushort)Key.Length,
ExtraLength = (byte)extraLength,
TotalBodyLength = (uint)(extraLength + Key.Length),
Opaque = RequestId,
};
var buffer = new byte[MemcacheRequestHeader.Size + requestHeader.TotalBodyLength];
requestHeader.ToData(buffer);
// in case of Get and Touch, post the new TTL in extra
if (RequestOpcode == Opcode.GAT)
buffer.CopyFrom(MemcacheRequestHeader.Size + sizeof(uint), ExpirationTimeUtils.MemcachedTTL(Expire));
Key.CopyTo(buffer, extraLength + MemcacheRequestHeader.Size);
return buffer;
}
