public long _2_0_2_AddJob_Async_TimeToLive_Wait_Dead(Disquuun disquuun)
{
WaitUntil("_2_0_2_AddJob_Async_TimeToLive_Wait_Dead", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
var jobId = string.Empty;
disquuun.AddJob(queueId, data_10, 0, "TTL", 1).Async(
(command, result) =>
{
jobId = DisquuunDeserializer.AddJob(result);
}
);
WaitUntil("_2_0_2_AddJob_Async_TimeToLive_Wait_Dead", () => !string.IsNullOrEmpty(jobId), 5);
// wait 2 sec.
Wait("_2_0_2_AddJob_Async_TimeToLive_Wait_Dead", 2);
// get queue len.
var len = DisquuunDeserializer.Qlen(disquuun.Qlen(queueId).DEPRICATED_Sync());
Assert("_2_0_2_AddJob_Async_TimeToLive_Wait_Dead", len == 0, "not match, len:" + len);
return(0);
}
public long _2_8_Qlen_Async(Disquuun disquuun)
{
WaitUntil("_2_8_Qlen_Async", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
var jobId = DisquuunDeserializer.AddJob(
disquuun.AddJob(queueId, data_10).DEPRICATED_Sync()
);
var w = new Stopwatch();
w.Start();
var qlen = 0;
disquuun.Qlen(queueId).Async(
(c, data) =>
{
qlen = DisquuunDeserializer.Qlen(data);
w.Stop();
}
);
WaitUntil("_2_8_Qlen_Async", () => (qlen == 1), 5);
var result = disquuun.FastAck(new string[] { jobId }).DEPRICATED_Sync();
var ackCount = DisquuunDeserializer.FastAck(result);
return(w.ElapsedMilliseconds);
}
public long _2_9_Qstat_Async(Disquuun disquuun)
{
WaitUntil("_2_9_Qstat_Async", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
var jobId = DisquuunDeserializer.AddJob(disquuun.AddJob(queueId, data_10).DEPRICATED_Sync());
var w = new Stopwatch();
w.Start();
var qstatLen = 0;
disquuun.Qstat(queueId).Async(
(command, data) =>
{
qstatLen = DisquuunDeserializer.Qstat(data).len;
w.Stop();
}
);
WaitUntil("_2_9_Qstat_Async", () => (qstatLen == 1), 5);
disquuun.FastAck(new string[] { jobId }).DEPRICATED_Sync();
return(w.ElapsedMilliseconds);
}
public long _2_0_1_AddJob_Async_TimeToLive(Disquuun disquuun)
{
WaitUntil("_2_0_1_AddJob_Async_TimeToLive", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
var jobId = string.Empty;
var w = new Stopwatch();
w.Start();
disquuun.AddJob(queueId, data_10, 0, "TTL", 100).Async(
(command, result) =>
{
jobId = DisquuunDeserializer.AddJob(result);
w.Stop();
}
);
WaitUntil("_2_0_1_AddJob_Async_TimeToLive", () => !string.IsNullOrEmpty(jobId), 5);
// ack in.
disquuun.FastAck(new string[] { jobId }).DEPRICATED_Sync();
return(w.ElapsedMilliseconds);
}
public long _2_2_AckJob_Async(Disquuun disquuun)
{
WaitUntil("_2_2_AckJob_Async", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
var jobId = DisquuunDeserializer.AddJob(
disquuun.AddJob(queueId, data_10).DEPRICATED_Sync()
);
var w = new Stopwatch();
w.Start();
var ackCount = 0;
disquuun.AckJob(new string[] { jobId }).Async(
(command, result) =>
{
ackCount = DisquuunDeserializer.AckJob(result);
w.Stop();
}
);
WaitUntil("_2_2_AckJob_Async", () => (ackCount == 1), 5);
return(w.ElapsedMilliseconds);
}
public long _2_1_4_GetJobWithCounters_Async(Disquuun disquuun)
{
WaitUntil("_2_1_4_GetJobWithCounters_Async", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
disquuun.AddJob(queueId, data_100).DEPRICATED_Sync();
var ackCount = -1;
var w = new Stopwatch();
w.Start();
disquuun.GetJob(new string[] { queueId }, "withcounters").Async(
(command, result) =>
{
var jobDatas = DisquuunDeserializer.GetJob(result);
ackCount = jobDatas[0].additionalDeliveriesCount;
w.Stop();
disquuun.FastAck(new string[] { jobDatas[0].jobId }).Async(
(c, d) => { }
);
}
);
WaitUntil("_2_1_4_GetJobWithCounters_Async", () => (ackCount == 0), 5);
return(w.ElapsedMilliseconds);
}
public void _0_0_4_ReadmeSamplePipeline(Disquuun disquuun)
{
WaitUntil("_0_0_4_ReadmeSamplePipeline", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var fastacked = false;
disquuun.Pipeline(
disquuun.AddJob("my queue name", new byte[100]),
disquuun.GetJob(new string[] { "my queue name" })
).Execute(
(command, data) => {
if (command != DisqueCommand.GETJOB)
{
return;
}
var jobs = DisquuunDeserializer.GetJob(data);
var jobIds = jobs.Select(jobData => jobData.jobId).ToArray();
var jobDatas = jobs.Select(jobData => jobData.jobData).ToList();
/*
* fast ack all.
*/
disquuun.FastAck(jobIds).Async(
(command2, data2) => {
fastacked = true;
}
);
}
);
WaitUntil("_0_0_4_ReadmeSamplePipeline", () => fastacked, 5);
}
public long _5_1_ConnectionFailedMultiple(Disquuun disquuun)
{
WaitUntil("_5_1_ConnectionFailedMultiple", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
List <Exception> errors = new List <Exception>();
var disquuun2 = new Disquuun(
DisquuunTests.TestDisqueHostStr,
DisquuunTests.TestDisqueDummyPortNum,// fake port number.
1,
5,
(conId) => { },
(info, e) =>
{
lock (_5_1_ConnectionFailedMultipleLockObject)
{
errors.Add(e);
}
},
(currentSocketCount, addSocket) =>
{
return;
}
);
WaitUntil("_5_1_ConnectionFailedMultiple", () => (errors.Count == 5), 10);
disquuun2.Disconnect();
return(0);
}
public void _2_1_2_GetJobFromMultiQueue_Async(Disquuun disquuun)
{
WaitUntil("_2_1_2_GetJobFromMultiQueue_Async", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId1 = Guid.NewGuid().ToString();
disquuun.AddJob(queueId1, new byte[10]).DEPRICATED_Sync();
var queueId2 = Guid.NewGuid().ToString();
disquuun.AddJob(queueId2, new byte[10]).DEPRICATED_Sync();
DisquuunDeserializer.JobData[] jobDatas = new DisquuunDeserializer.JobData[] {};
disquuun.GetJob(new string[] { queueId1, queueId2 }, "count", 2).Async(
(command, result) => {
jobDatas = DisquuunDeserializer.GetJob(result);
}
);
WaitUntil("_2_1_2_GetJobFromMultiQueue_Async", () => (jobDatas.Length == 2), 5);
// ack in.
var jobIds = jobDatas.Select(job => job.jobId).ToArray();
disquuun.FastAck(jobIds).DEPRICATED_Sync();
}
public long _1_0_2_AddJob_Sync_TimeToLive_Wait_Dead(Disquuun disquuun)
{
WaitUntil("_1_0_2_AddJob_Sync_TimeToLive_Wait_Dead", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var w = new Stopwatch();
w.Start();
var queueId = Guid.NewGuid().ToString();
var result = disquuun.AddJob(queueId, data_10, 0, "TTL", 1).DEPRICATED_Sync();
var jobId = DisquuunDeserializer.AddJob(result);
WaitUntil("_1_0_2_AddJob_Sync_TimeToLive_Wait_Dead", () => !string.IsNullOrEmpty(jobId), 5);
// wait 2 sec.
Wait("_1_0_2_AddJob_Sync_TimeToLive_Wait_Dead", 2);
// get queue len.
var len = DisquuunDeserializer.Qlen(disquuun.Qlen(queueId).DEPRICATED_Sync());
Assert("_1_0_2_AddJob_Sync_TimeToLive_Wait_Dead", len == 0, "not match, len:" + len);
w.Stop();
return(w.ElapsedMilliseconds);
}
public long _1_1_1_GetJobWithCount_Sync(Disquuun disquuun)
{
WaitUntil("_1_1_1_GetJobWithCount_Sync", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var w = new Stopwatch();
w.Start();
var queueId = Guid.NewGuid().ToString();
var addJobCount = 10000;
for (var i = 0; i < addJobCount; i++)
{
disquuun.AddJob(queueId, data_100).DEPRICATED_Sync();
}
var result = disquuun.GetJob(new string[] { queueId }, "COUNT", addJobCount).DEPRICATED_Sync();
var jobDatas = DisquuunDeserializer.GetJob(result);
Assert("_1_1_1_GetJobWithCount_Sync", addJobCount, jobDatas.Length, "not match.");
// ack in.
var jobIds = jobDatas.Select(job => job.jobId).ToArray();
disquuun.FastAck(jobIds).DEPRICATED_Sync();
w.Stop();
return(w.ElapsedMilliseconds);
}
public long _1_1_2_GetJobFromMultiQueue_Sync(Disquuun disquuun)
{
WaitUntil("_1_1_2_GetJobFromMultiQueue_Sync", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var w = new Stopwatch();
w.Start();
var queueId1 = Guid.NewGuid().ToString();
disquuun.AddJob(queueId1, data_10).DEPRICATED_Sync();
var queueId2 = Guid.NewGuid().ToString();
disquuun.AddJob(queueId2, data_10).DEPRICATED_Sync();
var result = disquuun.GetJob(new string[] { queueId1, queueId2 }, "count", 2).DEPRICATED_Sync();
var jobDatas = DisquuunDeserializer.GetJob(result);
Assert("_1_1_2_GetJobFromMultiQueue_Sync", 2, jobDatas.Length, "not match.");
// ack in.
var jobIds = jobDatas.Select(job => job.jobId).ToArray();
disquuun.FastAck(jobIds).DEPRICATED_Sync();
w.Stop();
return(w.ElapsedMilliseconds);
}
public long _5_0_ConnectionFailed(Disquuun disquuun)
{
WaitUntil("_5_0_ConnectionFailed", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
Exception error = null;
var disquuun2 = new Disquuun(
DisquuunTests.TestDisqueHostStr,
DisquuunTests.TestDisqueDummyPortNum,// fake port number.
1,
1,
(conId) => { },
(info, e) =>
{
error = e;
},
(currentSocketCount, addSocket) =>
{
return;
}
);
WaitUntil("_5_0_ConnectionFailed", () => (error != null), 5);
disquuun2.Disconnect();
return(0);
}
public long _2_1_3_GetJobWithNoHang_Async(Disquuun disquuun)
{
WaitUntil("_2_1_3_GetJobWithNoHang_Async", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
bool received = false;
var w = new Stopwatch();
w.Start();
disquuun.GetJob(new string[] { queueId }, "NOHANG").Async(
(command, result) =>
{
var jobDatas = DisquuunDeserializer.GetJob(result);
Assert("_2_1_3_GetJobWithNoHang_Async", jobDatas.Length == 0, "not match.");
received = true;
w.Stop();
}
);
WaitUntil("_2_1_3_GetJobWithNoHang_Async", () => received, 5);
return(w.ElapsedMilliseconds);
}
public ConnectionServerTransformLayer(string contextQueueIdentity)
{
disquuun = new Disquuun(
"127.0.0.1", 7711, 1024 * 100, 3,
conId => {
// enable adding job to Disque by swapping publisher method.
context.Setup(Publish);
// start getting job from disque then fastack all automatically.
disquuun.GetJob(new string[] { contextQueueIdentity }, "count", 1000).Loop(
(command, data) => {
var jobs = DisquuunDeserializer.GetJob(data);
var jobIds = jobs.Select(jobData => jobData.jobId).ToArray();
var jobDatas = jobs.Select(jobData => jobData.jobData).ToList();
/*
* fast ack all.
*/
disquuun.FastAck(jobIds).Async((command2, data2) => {});
InputDatasToContext(jobDatas);
return(true);
}
);
}
);
}
public long _6_2_ExceededSocketShouldStacked(Disquuun disquuun)
{
WaitUntil("_6_2_ExceededSocketShouldStacked", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
var infoCount = 0;
var connectCount = 1000;
var w = new Stopwatch();
w.Start();
for (var i = 0; i < connectCount; i++)
{
disquuun.Info().Async(
(command, data) =>
{
lock (_6_2_ExceededSocketShouldStackedLockObject) infoCount++;
}
);
}
var stackedCommandCount = disquuun.StackedCommandCount();
// this assert "maybe" hit. not hit if sockets can run so fast.
Assert("_6_2_ExceededSocketShouldStacked", 0 < stackedCommandCount, "not match, " + stackedCommandCount);
WaitUntil("_6_2_ExceededSocketShouldStacked", () => (infoCount == connectCount), 5);
w.Stop();
return(w.ElapsedMilliseconds);
}
public long _6_1_ExceededSocketNo100In2(Disquuun disquuun)
{
WaitUntil("_6_1_ExceededSocketNo100In2", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
var infoCount = 0;
var connectCount = 1000;
var w = new Stopwatch();
w.Start();
for (var i = 0; i < connectCount; i++)
{
disquuun.Info().Async(
(command, data) =>
{
lock (_6_1_ExceededSocketNo100In2LockObject) infoCount++;
}
);
}
WaitUntil("_6_1_ExceededSocketNo100In2", () => (infoCount == connectCount), 5);
w.Stop();
return(w.ElapsedMilliseconds);
}
public void _0_0_2_ReadmeSampleSync(Disquuun disquuun)
{
bool overed = false;
disquuun = new Disquuun(DisquuunTests.TestDisqueHostStr, DisquuunTests.TestDisquePortNum, 1024, 1,
disquuunId => {
var queueId = Guid.NewGuid().ToString();
// addjob. add 10bytes job to Disque.
disquuun.AddJob(queueId, new byte[10]).DEPRICATED_Sync();
// getjob. get job from Disque.
var result = disquuun.GetJob(new string[] { queueId }).DEPRICATED_Sync();
var jobDatas = DisquuunDeserializer.GetJob(result);
Assert("_0_0_2_ReadmeSampleSync", 1, jobDatas.Length, "not match.");
// fastack.
var jobId = jobDatas[0].jobId;
disquuun.FastAck(new string[] { jobId }).DEPRICATED_Sync();
overed = true;
}
);
WaitUntil("", () => overed, 5);
disquuun.Disconnect();
}
public long _4_5_ByfferOverWithSokcetOverSyncGetJob_Async(Disquuun disquuun)
{
WaitUntil("_4_5_ByfferOverWithSokcetOverSyncGetJob_Async", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
var addJobCount = 10001;
for (var i = 0; i < addJobCount; i++)
{
disquuun.AddJob(queueId, data_100).DEPRICATED_Sync();
}
DisquuunDeserializer.JobData[] jobDatas = new DisquuunDeserializer.JobData[] { };
disquuun.GetJob(new string[] { queueId }, "COUNT", addJobCount).Async(
(command, result) =>
{
jobDatas = DisquuunDeserializer.GetJob(result);
}
);
WaitUntil("_4_5_ByfferOverWithSokcetOverSyncGetJob_Async", () => (jobDatas.Length == addJobCount), 5);
// ack in.
var jobIds = jobDatas.Select(job => job.jobId).ToArray();
disquuun.FastAck(jobIds).DEPRICATED_Sync();
return(0);
}
public long _2_1_GetJob_Async(Disquuun disquuun)
{
WaitUntil("_2_1_GetJob_Async", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
disquuun.AddJob(queueId, data_10).DEPRICATED_Sync();
DisquuunDeserializer.JobData[] jobDatas = new DisquuunDeserializer.JobData[] { };
var w = new Stopwatch();
w.Start();
disquuun.GetJob(new string[] { queueId }).Async(
(command, result) =>
{
jobDatas = DisquuunDeserializer.GetJob(result);
w.Stop();
}
);
WaitUntil("_2_1_GetJob_Async", () => (jobDatas.Length == 1), 5);
// ack in.
var jobId = jobDatas[0].jobId;
disquuun.FastAck(new string[] { jobId }).DEPRICATED_Sync();
return(w.ElapsedMilliseconds);
}
public long _0_0_1_WaitOnOpen2Connection(Disquuun disquuun)
{
var w = new Stopwatch();
w.Start();
var conId = string.Empty;
var disquuun2 = new Disquuun(DisquuunTests.TestDisqueHostStr, DisquuunTests.TestDisquePortNum, 1, 1,
connectionId =>
{
conId = connectionId;
},
(info, e) =>
{
},
(currentSocketCount, addSocket) =>
{
return;
}
);
WaitUntil("_0_0_1_WaitOnOpen2Connection", () => !string.IsNullOrEmpty(conId), 5);
disquuun2.Disconnect();
w.Stop();
return(w.ElapsedMilliseconds);
}
public void _2_1_1_GetJobWithCount_Async(Disquuun disquuun)
{
WaitUntil("_2_1_1_GetJobWithCount_Async", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var queueId = Guid.NewGuid().ToString();
var addJobCount = 10000;
for (var i = 0; i < addJobCount; i++)
{
disquuun.AddJob(queueId, new byte[100]).DEPRICATED_Sync();
}
DisquuunDeserializer.JobData[] jobDatas = new DisquuunDeserializer.JobData[] {};
disquuun.GetJob(new string[] { queueId }, "COUNT", addJobCount).Async(
(command, result) => {
jobDatas = DisquuunDeserializer.GetJob(result);
}
);
WaitUntil("_2_1_1_GetJobWithCount_Async", () => (jobDatas.Length == addJobCount), 5);
// ack in.
var jobIds = jobDatas.Select(job => job.jobId).ToArray();
disquuun.FastAck(jobIds).DEPRICATED_Sync();
}
public long _0_7_LoopInfo_100(Disquuun disquuun)
{
WaitUntil("_0_7_LoopInfo_100", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var infos = new List <string>();
var w = new Stopwatch();
w.Start();
disquuun.Info().Loop(
(DisqueCommand command, DisquuunResult[] datas) =>
{
var infoStr = DisquuunDeserializer.Info(datas).rawString;
lock (_0_7_LoopInfo_100Object) infos.Add(infoStr);
if (infos.Count < 100)
{
return(true);
}
return(false);
}
);
WaitUntil("_0_7_LoopInfo_100", () => (infos.Count == 100), 5);
w.Stop();
return(w.ElapsedMilliseconds);
}
public long _0_1_ConnectionFailedWithNoDisqueServer(Disquuun disquuun)
{
WaitUntil("_0_1_ConnectionFailedWithNoDisqueServer", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
Exception e = null;
var w = new Stopwatch();
w.Start();
var disquuun2 = new Disquuun(DisquuunTests.TestDisqueHostStr, DisquuunTests.TestDisqueDummyPortNum, 1024, 1,
conId => { },
(info, e2) =>
{
// set error to param,
lock (_0_1_ConnectionFailedWithNoDisqueServerObject) e = e2;
// TestLogger.Log("e:" + e);
},
(currentSocketCount, addSocket) =>
{
return;
}
);
WaitUntil("_0_1_ConnectionFailedWithNoDisqueServer", () => (e != null), 1);
w.Stop();
return(w.ElapsedMilliseconds);
}
public long _0_1_ConnectedShouldCallOnce(Disquuun disquuun)
{
int connectedCount = 0;
var w = new Stopwatch();
w.Start();
disquuun = new Disquuun(DisquuunTests.TestDisqueHostStr, DisquuunTests.TestDisquePortNum, 1024, 100,
disquuunId =>
{
lock (_0_1_ConnectedShouldCallOnceObject)
{
Assert("_0_1_ConnectedShouldCallOnce", 0, connectedCount, "not match.");
connectedCount++;
}
},
(i, e) => { },
(currentSocketCount, addSocket) =>
{
return;
}
);
WaitUntil("_0_1_ConnectedShouldCallOnce", () => (connectedCount == 1), 5);
disquuun.Disconnect();
w.Stop();
return(w.ElapsedMilliseconds);
}
public DisquuunBench()
{
{
var waitHandle = new ManualResetEvent(false);
disquuun2 = new Disquuun(
"127.0.0.1", 7711, 1024, 2, id =>
{
waitHandle.Set();
// Console.WriteLine("ready2");
},
(conId, e) =>
{
Console.WriteLine("socket e:" + e);
},
(currentSocketCount, addSocket) =>
{
addSocket(true, 1);
}
);
waitHandle.WaitOne(Timeout.Infinite);
}
{
var waitHandle = new ManualResetEvent(false);
disquuun10 = new Disquuun(
"127.0.0.1", 7711, 1024, 10, id =>
{
waitHandle.Set();
// Console.WriteLine("ready10");
},
(conId, e) =>
{
Console.WriteLine("socket e:" + e);
},
(currentSocketCount, addSocket) =>
{
addSocket(true, 1);
}
);
waitHandle.WaitOne(Timeout.Infinite);
}
{
var waitHandle = new ManualResetEvent(false);
disquuun30 = new Disquuun(
"127.0.0.1", 7711, 1024, 30, id =>
{
waitHandle.Set();
// Console.WriteLine("ready30");
},
(conId, e) =>
{
Console.WriteLine("socket e:" + e);
},
(currentSocketCount, addSocket) =>
{
addSocket(true, 1);
}
);
waitHandle.WaitOne(Timeout.Infinite);
}
}
public long _0_0_3_ReadmeSampleAsync(Disquuun disquuun)
{
var w = new Stopwatch();
w.Start();
int fastAckedJobCount = 0;
disquuun = new Disquuun(DisquuunTests.TestDisqueHostStr, DisquuunTests.TestDisquePortNum, 1024, 3,
disquuunId =>
{
var queueId = Guid.NewGuid().ToString();
// addjob. add 10bytes job to Disque.
disquuun.AddJob(queueId, data_10).Async(
(addJobCommand, addJobData) =>
{
// job added to queueId @ Disque.
// getjob. get job from Disque.
disquuun.GetJob(new string[] { queueId }).Async(
(getJobCommand, getJobData) =>
{
// got job from queueId @ Disque.
var jobDatas = DisquuunDeserializer.GetJob(getJobData);
Assert("_0_0_3_ReadmeSampleAsync", 1, jobDatas.Length, "not match.");
// get jobId from got job data.
var gotJobId = jobDatas[0].jobId;
// fastack it.
disquuun.FastAck(new string[] { gotJobId }).Async(
(fastAckCommand, fastAckData) =>
{
// fastack succeded or not.
fastAckedJobCount = DisquuunDeserializer.FastAck(fastAckData);
Assert("_0_0_3_ReadmeSampleAsync", 1, fastAckedJobCount, "not match.");
}
);
}
);
}
);
},
(i, e) => { },
(currentSocketCount, addSocket) =>
{
return;
}
);
WaitUntil("_0_0_3_ReadmeSampleAsync", () => (fastAckedJobCount == 1), 5);
disquuun.Disconnect();
w.Stop();
return(w.ElapsedMilliseconds);
}
public void _0_2_SyncInfo(Disquuun disquuun)
{
WaitUntil("", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var data = disquuun.Info().DEPRICATED_Sync();
var infoStr = DisquuunDeserializer.Info(data).rawString;
Assert("_0_2_SyncInfo", !string.IsNullOrEmpty(infoStr), "empty.");
}
public void _7_2_GetJob1000byLoop(Disquuun disquuun)
{
WaitUntil("_7_2_GetJob1000byLoop", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
var addingJobCount = 1000 * loadLevel;
var queueId = Guid.NewGuid().ToString();
var addedCount = 0;
for (var i = 0; i < addingJobCount; i++)
{
disquuun.AddJob(queueId, new byte[10]).Async(
(command, data) => {
lock (_7_2_GetJob1000byLoopLockObject) addedCount++;
}
);
}
WaitUntil("_7_2_GetJob1000byLoop", () => (addedCount == addingJobCount), 5);
var gotJobDataIds = new List <string>();
var w = new Stopwatch();
w.Start();
disquuun.GetJob(new string[] { queueId }).Loop(
(command, data) => {
lock (_7_2_GetJob1000byLoopLockObject) {
var jobDatas = DisquuunDeserializer.GetJob(data);
var jobIds = jobDatas.Select(j => j.jobId).ToList();
gotJobDataIds.AddRange(jobIds);
if (gotJobDataIds.Count == addingJobCount)
{
w.Stop();
return(false);
}
return(true);
}
}
);
WaitUntil("_7_2_GetJob1000byLoop 1", () => (gotJobDataIds.Count == addingJobCount), 20);
WaitUntil("_7_2_GetJob1000byLoop 2", () => (0 < disquuun.AvailableSocketNum()), 1);
TestLogger.Log("_7_2_GetJob1000byLoop w:" + w.ElapsedMilliseconds + " tick:" + w.ElapsedTicks);
var fastackedCount = 0;
disquuun.FastAck(gotJobDataIds.ToArray()).Async(
(c, data) => {
fastackedCount = DisquuunDeserializer.FastAck(data);
}
);
WaitUntil("_7_2_GetJob1000byLoop 3", () => (addingJobCount == fastackedCount), 10);
}
public long _0_0_InitWith2Connection(Disquuun disquuun)
{
var w = new Stopwatch();
w.Start();
WaitUntil("_0_0_InitWith2Connection", () => (disquuun.State() == Disquuun.ConnectionState.OPENED), 5);
w.Stop();
return(w.ElapsedMilliseconds);
}
