private static byte[] ToBytes(DisqueCommand commandEnum, params object[] args)
{
int length = 1 + args.Length;
var command = commandEnum.ToString();
string strCommand;
{
StringBuilder sb = new StringBuilder();
sb.Append(CharMultiBulk).Append(length).Append(CharEOL);
sb.Append(CharBulk).Append(Encoding.UTF8.GetByteCount(command)).Append(CharEOL).Append(command).Append(CharEOL);
foreach (var arg in args)
{
var str = String.Format(CultureInfo.InvariantCulture, "{0}", arg);
sb.Append(CharBulk)
.Append(Encoding.UTF8.GetByteCount(str))
.Append(CharEOL)
.Append(str)
.Append(CharEOL);
}
strCommand = sb.ToString();
}
byte[] bytes = Encoding.UTF8.GetBytes(strCommand.ToCharArray());
return(bytes);
}
public static void Loop(this DisquuunInput input, Func <DisqueCommand, DisquuunResult[], bool> Callback)
{
var socket = input.socketPool.ChooseAvailableSocket();
var commands = new DisqueCommand[] { input.command };
socket.Loop(commands, input.data, Callback);
}
public StackCommandData(DisquuunExecuteType executeType, DisqueCommand command, byte[] dataSource, Func <DisqueCommand, DisquuunResult[], bool> Callback)
{
this.executeType = executeType;
this.command = command;
this.data = dataSource;
this.Callback = Callback;
}
/*
* Core methods of Disquuun.
*/
/**
* method for Sync execution of specific Disque command.
* DEPRECATED. only use for testing.
*/
public override DisquuunResult[] DEPRECATED_Sync(DisqueCommand command, byte[] data)
{
#if LOGIC_BENCH
{
socketToken.socketState = SocketState.OPENED;
return(new DisquuunResult[0]);
}
#endif
try
{
socketToken.socket.Send(data);
var currentLength = 0;
var scanResult = new DisquuunAPI.ScanResult(false);
while (true)
{
// waiting for head of transferring data or rest of data.
socketToken.socket.Receive(socketToken.receiveBuffer, currentLength, 1, SocketFlags.None);
currentLength = currentLength + 1;
var available = socketToken.socket.Available;
var readableLength = currentLength + available;
{
if (socketToken.receiveBuffer.Length < readableLength)
{
Array.Resize(ref socketToken.receiveBuffer, readableLength);
}
}
// read rest.
socketToken.socket.Receive(socketToken.receiveBuffer, currentLength, available, SocketFlags.None);
currentLength = currentLength + available;
scanResult = DisquuunAPI.ScanBuffer(command, socketToken.receiveBuffer, 0, currentLength, socketId);
if (scanResult.isDone)
{
break;
}
// continue reading data from socket.
// if need, prepare for next 1 byte.
if (socketToken.receiveBuffer.Length == readableLength)
{
Array.Resize(ref socketToken.receiveBuffer, socketToken.receiveBuffer.Length + 1);
}
}
socketToken.socketState = SocketState.OPENED;
return(scanResult.data);
}
catch (Exception e)
{
throw e;
}
}
public virtual void Async(DisqueCommand command, byte[] data, Func <DisqueCommand, DisquuunResult[], bool> Callback)
{
lock (stackLockObject) {
try {
this.stackedDataQueue.Enqueue(new StackCommandData(DisquuunExecuteType.ASYNC, command, data, Callback));
} catch (Exception e) {
Disquuun.Log("failed to start async:" + e);
}
}
}
/**
* method for start Looping of specific Disque command.
*/
public override void Loop(DisqueCommand command, byte[] data, Func <DisqueCommand, DisquuunResult[], bool> Callback)
{
switch (socketToken.socketState)
{
case SocketState.BUSY: {
StartReceiveAndSendDataAsync(command, data, Callback);
break;
}
}
}
public static void Execute(this List <List <DisquuunInput> > inputs, Action <DisqueCommand, DisquuunResult[]> Callback)
{
if (!inputs.Any())
{
return;
}
if (!inputs[0].Any())
{
return;
}
var socketPool = inputs[0][0].socketPool;
for (var i = 0; i < inputs.Count; i++)
{
var currentSlotInputs = inputs[i];
var socket = socketPool.ChooseAvailableSocket();
var commands = new DisqueCommand[currentSlotInputs.Count];
for (var j = 0; j < currentSlotInputs.Count; j++)
{
commands[j] = currentSlotInputs[j].command;
}
using (var memStream = new MemoryStream())
{
for (var j = 0; j < currentSlotInputs.Count; j++)
{
var input = currentSlotInputs[j];
memStream.Write(input.data, 0, input.data.Length);
}
var wholeData = memStream.ToArray();
socket.Execute(
commands,
wholeData,
(command, resultBytes) =>
{
Callback(command, resultBytes);
return(false);
}
);
}
}
inputs.Clear();
}
public static void Async(this DisquuunInput input, Action <DisqueCommand, DisquuunResult[]> Callback)
{
var socket = input.socketPool.ChooseAvailableSocket();
var commands = new DisqueCommand[] { input.command };
socket.Async(
commands,
input.data,
(command, resultBytes) =>
{
Callback(command, resultBytes);
return(false);
}
);
}
private void Bench_LoopOrAsyncReceive(DisqueCommand command)
{
// ここで、コマンドの結果内容を精査する場合、結果を生成する必要があるが、どうするかな、、
var result = new DisquuunResult[0];
socketToken.continuation = socketToken.AsyncCallback(command, result);
if (socketToken.continuation)
{
System.Threading.Tasks.Task.Run(() =>
{
Bench_LoopOrAsyncReceive(command);
});
}
else
{
socketToken.socketState = SocketState.OPENED;
SocketReloaded(this);
}
}
/*
* default pooled socket + disposable socket shared
*/
private void StartReceiveAndSendDataAsync(DisqueCommand command, byte[] data, Func <DisqueCommand, DisquuunResult[], bool> Callback)
{
try {
// ready for receive.
socketToken.readableDataLength = 0;
socketToken.receiveArgs.SetBuffer(socketToken.receiveBuffer, 0, socketToken.receiveBuffer.Length);
if (!socketToken.socket.ReceiveAsync(socketToken.receiveArgs))
{
OnReceived(socketToken.socket, socketToken.receiveArgs);
}
socketToken.currentCommand = command;
socketToken.currentSendingBytes = data;
socketToken.AsyncCallback = Callback;
try {
socketToken.sendArgs.SetBuffer(data, 0, data.Length);
} catch (Exception e) {
Disquuun.Log("StartReceiveAndSendDataAsync before error,", true);
Disquuun.Log("sendArgs setBuffer error:" + e.Message);
// renew. potential error is exists and should avoid this error.
var endPoint = socketToken.sendArgs.RemoteEndPoint;
socketToken.sendArgs = new SocketAsyncEventArgs();
socketToken.sendArgs.RemoteEndPoint = endPoint;
socketToken.sendArgs.Completed += new EventHandler <SocketAsyncEventArgs>(OnSend);
}
if (!socketToken.socket.SendAsync(socketToken.sendArgs))
{
OnSend(socketToken.socket, socketToken.sendArgs);
}
} catch (Exception e1) {
Disquuun.Log("StartReceiveAndSendDataAsync error:" + e1.Message, true);
}
}
public static ScanResult ScanBuffer(DisqueCommand command, byte[] sourceBuffer, int fromCursor, long length, string socketId)
{
var cursor = fromCursor;
switch (command)
{
case DisqueCommand.ADDJOB:
{
switch (sourceBuffer[cursor])
{
// case ByteError: {
// -
// var lineEndCursor = ReadLine(sourceBuffer, cursor);
// cursor = cursor + 1;// add header byte size = 1.
// if (Failed != null) {
// var errorStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
// // Disquuun.Log("errorStr:" + errorStr);
// Failed(currentCommand, errorStr);
// }
// cursor = lineEndCursor + 2;// CR + LF
// break;
// }
case ByteStatus:
{
// + count
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countBuffer = new ArraySegment <byte>(sourceBuffer, cursor, lineEndCursor - cursor);
cursor = lineEndCursor + 2; // CR + LF
return(new ScanResult(cursor, true, new DisquuunResult[] { new DisquuunResult(countBuffer) }));
}
}
break;
}
case DisqueCommand.GETJOB:
{
switch (sourceBuffer[cursor])
{
case ByteMultiBulk:
{
DisquuunResult[] jobDatas = null;
{
// * count.
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var bulkCountStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
// TestLogger.Log("bulkCountStr:" + bulkCountStr);
var bulkCountNum = Convert.ToInt32(bulkCountStr);
cursor = lineEndCursor + 2; // CR + LF
// trigger when GETJOB NOHANG
if (bulkCountNum < 0)
{
return(new ScanResult(cursor, true, new DisquuunResult[] { }));
}
jobDatas = new DisquuunResult[bulkCountNum];
for (var i = 0; i < bulkCountNum; i++)
{
var itemCount = 0;
{
// * count.
var lineEndCursor2 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor2 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var bulkCountStr2 = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor2 - cursor);
itemCount = Convert.ToInt32(bulkCountStr2);
// Disquuun.Log("itemCount:" + itemCount);
cursor = lineEndCursor2 + 2; // CR + LF
}
// queueName
{
// $ count.
var lineEndCursor3 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor3 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor3 - cursor);
var strNum = Convert.ToInt32(countStr);
cursor = lineEndCursor3 + 2; // CR + LF
// $ bulk.
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
// var nameStr = Encoding.UTF8.GetString(sourceBuffer, cursor, strNum);
// Disquuun.Log("nameStr:" + nameStr);
cursor = cursor + strNum + 2; // CR + LF
}
// jobId
ArraySegment <byte> jobIdBytes;
{
// $ count.
var lineEndCursor3 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor3 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor3 - cursor);
var strNum = Convert.ToInt32(countStr);
// Disquuun.Log("id strNum:" + strNum);
cursor = lineEndCursor3 + 2; // CR + LF
// $ bulk.
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
jobIdBytes = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
// var jobIdStr = Encoding.UTF8.GetString(jobIdBytes);
// Disquuun.Log("jobIdStr:" + jobIdStr);
cursor = cursor + strNum + 2; // CR + LF
}
// jobData
ArraySegment <byte> dataBytes;
{
// $ count.
var lineEndCursor3 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor3 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor3 - cursor);
var strNum = Convert.ToInt32(countStr);
cursor = lineEndCursor3 + 2; // CR + LF
// $ bulk.
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
dataBytes = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
cursor = cursor + strNum + 2; // CR + LF
}
// no withcounters response.
if (itemCount == 3)
{
jobDatas[i] = new DisquuunResult(jobIdBytes, dataBytes);
// cursor = cursor + 2;// CR + LF
continue;
}
// withcounters response.
if (itemCount == 7)
{
ArraySegment <byte> nackCountBytes;
{
// $
var lineEndCursor3 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor3 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor3 - cursor);
var strNum = Convert.ToInt32(countStr);
// Disquuun.Log("data strNum:" + strNum);
cursor = lineEndCursor3 + 2; // CR + LF
// ignore params.
cursor = cursor + strNum + 2; // CR + LF
// :
var lineEndCursor4 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor4 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
nackCountBytes = new ArraySegment <byte>(sourceBuffer, cursor, lineEndCursor4 - cursor);
cursor = lineEndCursor4 + 2; // CR + LF
}
ArraySegment <byte> additionalDeliveriesCountBytes;
{
// $
var lineEndCursor3 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor3 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor3 - cursor);
var strNum = Convert.ToInt32(countStr);
// Disquuun.Log("data strNum:" + strNum);
cursor = lineEndCursor3 + 2; // CR + LF
// ignore params.
cursor = cursor + strNum + 2; // CR + LF
// :
var lineEndCursor4 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor4 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
additionalDeliveriesCountBytes = new ArraySegment <byte>(sourceBuffer, cursor, lineEndCursor4 - cursor);
jobDatas[i] = new DisquuunResult(jobIdBytes, dataBytes, nackCountBytes, additionalDeliveriesCountBytes);
cursor = lineEndCursor4 + 2; // CR + LF
}
}
}
}
if (jobDatas != null && 0 < jobDatas.Length)
{
return(new ScanResult(cursor, true, jobDatas));
}
break;
}
// case ByteError: {
// // -
// Disquuun.Log("-");
// throw new Exception("GetJob error.");
// // var lineEndCursor = ReadLine2(sourceBuffer, cursor, length);
// // cursor = cursor + 1;// add header byte size = 1.
// // if (Failed != null) {
// // var errorStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
// // // Disquuun.Log("errorStr:" + errorStr);
// // Failed(currentCommand, errorStr);
// // }
// // cursor = lineEndCursor + 2;// CR + LF
// break;
// }
}
break;
}
case DisqueCommand.ACKJOB:
case DisqueCommand.FASTACK:
{
switch (sourceBuffer[cursor])
{
case ByteInt:
{
// : count.
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
// var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
// Disquuun.Log("countStr:" + countStr);
var countBuffer = new ArraySegment <byte>(sourceBuffer, cursor, lineEndCursor - cursor);
var byteData = new DisquuunResult(countBuffer);
cursor = lineEndCursor + 2; // CR + LF
return(new ScanResult(cursor, true, new DisquuunResult[] { byteData }));
}
// case ByteError: {
// // -
// var lineEndCursor = ReadLine(sourceBuffer, cursor);
// cursor = cursor + 1;// add header byte size = 1.
// if (Failed != null) {
// var errorStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
// // Disquuun.Log("errorStr:" + errorStr);
// Failed(currentCommand, errorStr);
// }
// cursor = lineEndCursor + 2;// CR + LF
// break;
// }
}
break;
}
case DisqueCommand.INFO:
{
switch (sourceBuffer[cursor])
{
case ByteBulk:
{
var countNum = 0;
{ // readbulk count.
// $
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
countNum = Convert.ToInt32(countStr);
cursor = lineEndCursor + 2; // CR + LF
}
{ // readbulk string.
if (ShortageOfReadableLength(sourceBuffer, cursor, countNum))
{
return(new ScanResult(false));
}
var newBuffer = new ArraySegment <byte>(sourceBuffer, cursor, countNum);
cursor = cursor + countNum + 2; // CR + LF
return(new ScanResult(cursor, true, new DisquuunResult[] { new DisquuunResult(newBuffer) }));
}
}
}
break;
}
case DisqueCommand.HELLO:
{
switch (sourceBuffer[cursor])
{
case ByteMultiBulk:
{
ArraySegment <byte> version;
ArraySegment <byte> thisNodeId;
List <ArraySegment <byte> > nodeIdsAndInfos = new List <ArraySegment <byte> >();
/*
* :*3
* :1 version [0][0]
*
* $40 this node ID [0][1]
* 002698920b158ba29ff8d41d3e5303ceaf0e8d45
*
* 4 [1~n][0~3]
* $40
* 002698920b158ba29ff8d41d3e5303ceaf0e8d45
*
* $0
* ""
*
* $4
* 7711
*
* $1
* 1
*/
{
// *
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
// var bulkCountStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
// Disquuun.Log("bulkCountStr:" + bulkCountStr);
cursor = lineEndCursor + 2; // CR + LF
}
{
// : format version
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
version = new ArraySegment <byte>(sourceBuffer, cursor, lineEndCursor - cursor);
// Disquuun.Log(":version:" + version);
cursor = lineEndCursor + 2; // CR + LF
}
{
// $ this node id
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
var strNum = Convert.ToInt32(countStr);
// Disquuun.Log("id strNum:" + strNum);
cursor = lineEndCursor + 2; // CR + LF
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
thisNodeId = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
// Disquuun.Log("thisNodeId:" + thisNodeId);
cursor = cursor + strNum + 2; // CR + LF
}
{
// * node ids
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
cursor = cursor + 1; // add header byte size = 1.
var bulkCountStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
var bulkCountNum = Convert.ToInt32(bulkCountStr);
// Disquuun.Log("bulkCountNum:" + bulkCountNum);
cursor = lineEndCursor + 2; // CR + LF
// nodeId, ip, port, priority.
for (var i = 0; i < bulkCountNum / 4; i++)
{
ArraySegment <byte> idStr;
// $ nodeId
{
var lineEndCursor2 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor2 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor2 - cursor);
var strNum = Convert.ToInt32(countStr);
cursor = lineEndCursor2 + 2; // CR + LF
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
idStr = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
nodeIdsAndInfos.Add(idStr);
cursor = cursor + strNum + 2; // CR + LF
}
{
var lineEndCursor2 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor2 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor2 - cursor);
var strNum = Convert.ToInt32(countStr);
cursor = lineEndCursor2 + 2; // CR + LF
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
var ipStr = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
nodeIdsAndInfos.Add(ipStr);
cursor = cursor + strNum + 2; // CR + LF
}
{
var lineEndCursor2 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor2 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor2 - cursor);
var strNum = Convert.ToInt32(countStr);
cursor = lineEndCursor2 + 2; // CR + LF
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
var portStr = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
nodeIdsAndInfos.Add(portStr);
cursor = cursor + strNum + 2; // CR + LF
}
{
var lineEndCursor2 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor2 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor2 - cursor);
var strNum = Convert.ToInt32(countStr);
cursor = lineEndCursor2 + 2; // CR + LF
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
var priorityStr = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
nodeIdsAndInfos.Add(priorityStr);
cursor = cursor + strNum + 2; // CR + LF
}
}
}
var byteDatas = new DisquuunResult[1 + nodeIdsAndInfos.Count / 4];
byteDatas[0] = new DisquuunResult(version, thisNodeId);
for (var index = 0; index < nodeIdsAndInfos.Count / 4; index++)
{
var nodeId = nodeIdsAndInfos[index * 4 + 0];
var ip = nodeIdsAndInfos[index * 4 + 1];
var port = nodeIdsAndInfos[index * 4 + 2];
var priority = nodeIdsAndInfos[index * 4 + 3];
byteDatas[index + 1] = new DisquuunResult(nodeId, ip, port, priority);
}
return(new ScanResult(cursor, true, byteDatas));
}
}
break;
}
case DisqueCommand.QLEN:
{
switch (sourceBuffer[cursor])
{
case ByteInt:
{
// : format version
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countBuffer = new ArraySegment <byte>(sourceBuffer, cursor, lineEndCursor - cursor);
var byteData = new DisquuunResult(countBuffer);
cursor = lineEndCursor + 2; // CR + LF
return(new ScanResult(cursor, true, new DisquuunResult[] { byteData }));
}
}
break;
}
case DisqueCommand.QSTAT:
{
// * count of item.
var bulkCountNum = 0;
{
var lineEndCursor = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var bulkCountStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor - cursor);
bulkCountNum = Convert.ToInt32(bulkCountStr);
cursor = lineEndCursor + 2; // CR + LF
}
// items are key & value pair(maybe "import-from" will not match..)
var itemCount = bulkCountNum / 2;
var results = new DisquuunResult[itemCount];
for (var i = 0; i < itemCount; i++)
{
ArraySegment <byte> keyBytes;
{ // key ($)
var lineEndCursor2 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor2 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor2 - cursor);
var strNum = Convert.ToInt32(countStr);
cursor = lineEndCursor2 + 2; // CR + LF
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
keyBytes = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
cursor = cursor + strNum + 2; // CR + LF
}
{ // value ($ or * or :)
ArraySegment <byte> valBytes;
var type = sourceBuffer[cursor];
/*
* check next parameter = value parameter's type.
* $ or * or : is expected.
*/
switch (type)
{
case ByteBulk:
{
// $ have string value.
var lineEndCursor3 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor3 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor3 - cursor);
var strNum = Convert.ToInt32(countStr);
cursor = lineEndCursor3 + 2; // CR + LF
if (ShortageOfReadableLength(sourceBuffer, cursor, strNum))
{
return(new ScanResult(false));
}
valBytes = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
cursor = cursor + strNum + 2; // CR + LF
break;
}
case ByteMultiBulk:
case ByteInt:
{
// * or : have number value.
var lineEndCursor3 = ReadLine(sourceBuffer, cursor, length);
if (lineEndCursor3 == -1)
{
return(new ScanResult(false));
}
cursor = cursor + 1; // add header byte size = 1.
var countStr = Encoding.UTF8.GetString(sourceBuffer, cursor, lineEndCursor3 - cursor);
var strNum = countStr.Length;
valBytes = new ArraySegment <byte>(sourceBuffer, cursor, strNum);
cursor = lineEndCursor3 + 2; // CR + LF
break;
}
default:
{
throw new Exception("qstat unexpected type:" + type);
}
}
results[i] = new DisquuunResult(keyBytes, valBytes);
}
}
return(new ScanResult(cursor, true, results));
}
default:
{
throw new Exception("error command:" + command + " unhandled:" + sourceBuffer[cursor] + " data:" + Encoding.UTF8.GetString(sourceBuffer));
}
}
return(new ScanResult(false));
}
public virtual DisquuunResult[] DEPRECATED_Sync(DisqueCommand command, byte[] data)
{
throw new Exception("deprecated & all sockets are using.");
}
public DisquuunInput(DisqueCommand command, byte[] data, DisquuunSocketPool socketPool)
{
this.command = command;
this.data = data;
this.socketPool = socketPool;
}
public virtual void Loop(DisqueCommand command, byte[] data, Func <DisqueCommand, DisquuunResult[], bool> Callback)
{
lock (stackLockObject) this.stackedDataQueue.Enqueue(new StackCommandData(DisquuunExecuteType.LOOP, command, data, Callback));
}
public DisquuunInput(DisqueCommand command, byte[] data, StackSocket socket)
{
this.command = command;
this.data = data;
this.socket = socket;
}
