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"); }