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 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 RedisPromiseClient GetInstance(ConnectionMultiplexer redis)
{
lock (lck)
{
if (_instances.Exists((client => client.GetRedisInstance() == redis)))
{
return(_instances.First(d => d.GetRedisInstance() == redis));
}
var client = new RedisPromiseClient(redis);
_instances.Add(client);
return(client);
}
}
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 void Listen(RedisPromiseClient promiseClient)
{
var promise = promiseClient.CreatePromise();
_task.BindPromise(promise);
promiseClient.Listen(promise);
if (_onResolve != null)
{
promise.OnResolve = promise.OnResolve = (o =>
{
string message = (string)o;
TResult res = JsonConvert.DeserializeObject <TResult>(message);
_onResolve(res);
});
}
_promise = promise;
}
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.
}
