public static void Test1()
{
var api = new DotqApi();
var mult1 = new MultiplyTask(new Inp {
x = 4, y = 5
});
var mult2 = new MultiplyTask(new Inp {
x = 4, y = 6
});
var res1 = api.Delay(mult1);
var res2 = api.Delay(mult2);
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var m = new RedisTaskQueue(redis);
var resolver = new RedisPromiseServer();
// Thread.Sleep(100);
// for (long i = 0; i < m.Length(); i++)
// {
// var task = m.Dequeue();
// task.Execute();
// resolver.Resolve(task.Promise, task.SerializeResult());
// }
// Thread.Sleep(100);
// if (res1.GetResult() == 20 && res2.GetResult() == 24)
// {
// Console.WriteLine("test is successful");
// }
}
public static void test1()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var proClient = new RedisPromiseClient(redis);
var promise = proClient.Listen("haha");
promise.OnTimeOut = () => { promise.StartRetryThread(); };
promise.OnResolve = (payload) => { Console.WriteLine($"I AM RESOLVED BABEEEE: {payload}"); };
if (promise.Payload != null || promise.IsResolved() == true)
{
throw new Exception();
}
var server = new RedisPromiseServer(redis);
server.Resolve(promise.GetCompositeKey(), "42");
for (int i = 0; i < 10; i++)
{
Thread.Sleep(50);
}
if (promise.Payload == null || promise.IsResolved() == false || (string)promise.Payload != "42")
{
throw new Exception();
}
}
public static void SequentialTest()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var m = new MemoryQueue();
int taskCount = 100;
ITask[] tasks = new ITask[taskCount];
PromiseTaskResultHandle <int>[] handles = new PromiseTaskResultHandle <int> [taskCount];
for (int i = 0; i < taskCount; i++)
{
var add = new AddTask(new (i, i + 1));
tasks[i] = add;
var handle = new PromiseTaskResultHandle <int>(add, redis, (o) => Console.WriteLine($"result is ready: {o}"));
add.BindPromise(handle.GetPromise());
m.Enqueue(add.Serialize());
handles[i] = handle;
}
var resolver = new RedisPromiseServer(redis);
// promises resolved in a sequential manner. like one worker is processing all of them
for (int i = 0; i < taskCount; i++)
{
var task = new DefaultTaskDeserializer().Deserialize((string)m.Dequeue());
task.Execute();
var res = task.SerializeResult();
// thanks to BindPromise each task's instance id is also id of its related promise. So we can directly resolve related promise by using it.
resolver.Resolve(task.GetInstanceIdentifier(), res);
}
Thread.Sleep(1000);
}
public SimpleWorker(IDotQueue <ITask> q, ITaskResultStore <string> r)
{
queue = q;
resultStore = r;
deserializer = new DefaultTaskDeserializer();
promiseResolver = new RedisPromiseServer();
_taskRegistry = TaskRegistry.TaskRegistry.Instance;
_taskRegistry.DiscoverTasks();
}
public static void CreatePromiseTest()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var m = new MemoryQueue();
int taskCount = 100;
ITask[] tasks = new ITask[taskCount];
PromiseTaskResultHandle <int>[] handles = new PromiseTaskResultHandle <int> [taskCount];
for (int i = 0; i < taskCount; i++)
{
var add = new AddTask(new (i, i + 1));
tasks[i] = add;
var client = RedisPromiseClientFactory.GetInstance(redis);
var promise = client.CreatePromise();
add.BindPromise(promise);
var handle = new PromiseTaskResultHandle <int>(add, promise, (o) => Console.WriteLine($"result is ready: {o}"));
//now promise will be ready to resolve
client.Listen(promise);
m.Enqueue(add.Serialize());
handles[i] = handle;
}
var resolver = new RedisPromiseServer(redis);
// this is simulating many workers are resolving promises. (executing tasks in this context)
Parallel.ForEach(handles, ((handle) =>
{
var task = new DefaultTaskDeserializer().Deserialize((string)m.Dequeue());
task.Execute();
var res = task.SerializeResult();
// thanks to BindPromise each task's instance id is also id of its related promise. So we can directly resolve related promise by using it.
resolver.Resolve(task.GetInstanceIdentifier(), res);
}));
for (int i = 0; i < taskCount; i++)
{
int correctResult = i + i + 1;
while (!handles[i].IsResolved())
{
// it might not come from redis yet
Thread.Sleep(10);
}
var calculatedResult = (int)handles[i].GetObjectResult();
if (correctResult != calculatedResult)
{
throw new Exception("wrong result");
}
}
Console.WriteLine("ParallelTest is Successful");
Thread.Sleep(1000);
}
public DotqApi(ConnectionMultiplexer redis = null)
{
_redis = redis ?? LocalRedis.Instance;
_taskQueue = new RedisTaskQueue(_redis);
_resultStore = new SimpleRedisTaskResultStore(_redis);
_taskRegistry = TaskRegistry.TaskRegistry.Instance;
_redisPromiseClient = PromiseClientProvider.GetInstance(_redis);
_redisPromiseServer = PromiseServerProvider.GetInstance();
}
public static void StressTest()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var proClient = new RedisPromiseClient(redis);
var clientguid = proClient.GetId().ToString();
var promises = new List <Promise>();
int promiseCount = 1000;
for (int i = 0; i < promiseCount; i++)
{
var promise = proClient.Listen(i.ToString());
promise.OnResolve = (payload) =>
{
Console.WriteLine($"Promise({promise.GetCompositeKey().ToString()}) is resolved. Payload: {payload}");
};
if (promise.Payload != null || promise.IsResolved() == true)
{
throw new Exception();
}
promises.Add(promise);
}
var server = new RedisPromiseServer(redis);
for (int i = 0; i < promiseCount; i++)
{
//server.Resolve(new PromiseIdChannelIdDto(){ChannelId = clientguid, PromiseId = i.ToString()}, i.ToString()); // or;
server.Resolve(promises[i].GetCompositeKey(), i.ToString());
}
Thread.Sleep(100);
for (int i = 0; i < promiseCount; i++)
{
var promise = promises[i];
while (promise.IsResolved() == false)
{
Console.WriteLine("waiting");
Thread.Sleep(100);
}
if (promise.Payload == null || promise.IsResolved() == false || (string)promise.Payload != i.ToString())
{
throw new Exception();
}
}
Console.WriteLine("Stress test is successful");
}
public void ParallelUnitTest()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var m = new MemoryQueue();
RedisPromiseClient promiseClient = new RedisPromiseClient(redis);
int taskCount = 100;
ITask[] tasks = new ITask[taskCount];
PromiseTaskResultHandle <int>[] handles = new PromiseTaskResultHandle <int> [taskCount];
for (int i = 0; i < taskCount; i++)
{
var add = new AddTask(new (i, i + 1));
tasks[i] = add;
var handle = new PromiseTaskResultHandle <int>(add, redis);
handle.Listen(promiseClient);
m.Enqueue(add.Serialize());
handles[i] = handle;
}
var resolver = new RedisPromiseServer(redis);
// this is simulating many workers are resolving promises. (executing tasks in this context)
Parallel.ForEach(handles, ((handle) =>
{
var task = new DefaultTaskDeserializer().Deserialize((string)m.Dequeue());
task.Execute();
var res = task.SerializeResult();
// thanks to BindPromise each task's instance id is also id of its related promise. So we can directly resolve related promise by using it.
resolver.Resolve(task.GetInstanceIdentifier(), res);
}));
for (int i = 0; i < taskCount; i++)
{
int correctResult = i + i + 1;
while (!handles[i].IsResolved())
{
// it might not come from redis yet
Thread.Sleep(10);
}
var calculatedResult = (int)handles[i].GetObjectResult();
Assert.Equal(correctResult, calculatedResult);
}
}
public static void testRetry()
{
ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("localhost");
var proClient = new RedisPromiseClient(redis);
var promise = proClient.Listen("haha");
promise.OnTimeOut = () => { promise.StartRetryThread(); };
promise.OnResolve = (payload) => { Console.WriteLine($"I AM RESOLVED BABEEEE: {payload}"); };
if (promise.Payload != null || promise.IsResolved() == true)
{
throw new Exception();
}
var server = new RedisPromiseServer(redis);
server.ResolveWithoutPublishing(promise.GetCompositeKey().ToString(), "42");
Thread.Sleep(100);
if (promise.Payload != null || promise.IsResolved() == true)
{
throw new Exception();
}
promise.Retry();
Thread.Sleep(100);
if (promise.Payload == null || promise.IsResolved() == false || ((string)promise.Payload) != "42")
{
throw new Exception();
}
Console.WriteLine("Retry test is successful. Except that close thread is still running :(");
// Problem here is that when a promise is resolved with ResolveWithoutPublishing and using retry then client does not know anything about promise resolving hence do not unsubscribe.
// Probable Solution is to call clients onmessage from promise by making promise and client more coupled.
}
public void PersistentRedisPromiseClientPoolTest()
{
int promiseCount = 20;
var redis = ConnectionMultiplexer.Connect("localhost");
var server = new RedisPromiseServer(redis);
var output = new List <string>();
var pool = new PersistentRedisPromiseClientPool(redis);
for (int i = 0; i < promiseCount; i++)
{
/* when a new instance is created here each time instead of getting from pool
* this test takes more than a minute for 20 promises. Although base RedisPromiseClient is really
* cheap to construct it is really expensive to call SetupPubSubServer for the
* first time since it sets up pubsub channel with redis. Hence creating a new instance
* of RedisPromiseClient and consume it quickly is a really slow way of using it.
* Client instances should be taken from the pool when that is the case. (Using the
* pool at all times might be a good solution as well since it is not harmful
* or does not have performance penalties for other use cases too. Just no performance
* gain from pooling.) */
var proClient = pool.Borrow();
var promise = proClient.Listen(i.ToString());
promise.OnResolve = (payload) =>
{
//_testOutputHelper.WriteLine("hello");
output.Add("hello");
pool.Return(proClient);
//Assert.Equal((string)payload, i.ToString());
};
if (i == 1)
{
var xas = 1;
}
server.Resolve(promise.GetCompositeKey(), i.ToString());
}
Console.WriteLine("Stress test is successful");
}
