public async Task OpenAsyncTwoCallersOnlyOneOpenCalled()
        {
            var contextMock      = Substitute.For <IPipelineContext>();
            var tcs              = new TaskCompletionSource();
            var innerHandlerMock = Substitute.For <IDelegatingHandler>();
            int callCounter      = 0;

            innerHandlerMock.OpenAsync(true, Arg.Any <CancellationToken>()).Returns(t =>
            {
                callCounter++;
                return(tcs.Task);
            });

            var sut = new GateKeeperDelegatingHandler(contextMock);

            sut.ContinuationFactory = c => innerHandlerMock;
            var  cancellationToken = new CancellationToken();
            Task firstOpen         = sut.OpenAsync(cancellationToken);
            Task secondOpen        = sut.OpenAsync(cancellationToken);

            tcs.Complete();
            await Task.WhenAll(firstOpen, secondOpen).ConfigureAwait(false);

            Assert.AreEqual(1, callCounter);
        }
Example #2
0
 public override void ChannelActive(IChannelHandlerContext context)
 {
     Log.Info("Connected to the server");
     _connectedPromise.Complete();
     _connected = true;
     _context   = context;
 }
Example #3
0
        /// <summary>
        ///   Starts a validation asynchronously and returns a Task for the operation.
        /// </summary>
        /// <typeparam name="TTarget"> The type of the object to validate. </typeparam>
        /// <param name="plan"> The validation plan to execute asynchronously. </param>
        /// <param name="target"> The type of the object to validate. </param>
        /// <returns> </returns>
        public static Task <ValidationReport> ExecuteAsync <TTarget>(
            this ValidationPlan <TTarget> plan,
            TTarget target)
        {
            var tcs   = new TaskCompletionSource <ValidationReport>(target);
            var scope = new ValidationScope(enter: false);

            Task.Factory.StartNew(() =>
            {
                var taskDictionary =
                    new ConcurrentDictionary <IValidationRule <TTarget>, Task <bool> >();

                // create and start a task for each rule
                plan.Select(
                    rule => taskDictionary.GetOrAdd(rule,
                                                    rule.ToTask(target,
                                                                taskDictionary,
                                                                scope,
                                                                TaskCreationOptions.AttachedToParent)))
                .ForEach(t => t.TryStart());
            })
            .ContinueWith(t =>
            {
                try
                {
                    tcs.Complete(t, () => ValidationReport.FromScope(scope));
                }
                finally
                {
                    scope.Dispose();
                }
            });
            return(tcs.Task);
        }
Example #4
0
        public void Rules_within_a_ValidationPlan_can_use_APM_signatures_and_run_synchronously()
        {
            var hasAwesomeTag = Validate.Async <string>(
                setup: url =>
            {
                var request = new ApmOperation <string, string>(s =>
                                                                Task <string> .Factory.StartNew(() => "<div>" + s + "</div>"));
                var tcs = new TaskCompletionSource <string>();
                Task <string> .Factory
                .FromAsync(request.BeginInvoke,
                           request.EndInvoke,
                           url,
                           state: null)
                .ContinueWith(
                    t => tcs.Complete(t, () => t.Result));
                return(tcs.Task);
            },
                validate: html => html.As("page").Contains("<awesome>"))
                                .WithErrorMessage("{page} is missing the <awesome> tag!");

            var plan = new ValidationPlan <string>
            {
                isValidHttpUrl,
                hasAwesomeTag.When(isValidHttpUrl)
            };

            var result = plan.Execute("http://microsoft.com");

            Console.WriteLine(result);

            // TODO: (Rules_within_a_ValidationPlan_can_use_APM_signatures_and_run_synchronously)
            Assert.Fail("Test not written");
        }
Example #5
0
        public async Task ScheduledTaskFiresOnTime(bool scheduleFromExecutor)
        {
            var         scheduler    = new SingleThreadEventExecutor(null, TimeSpan.FromMinutes(1));
            var         promise      = new TaskCompletionSource();
            Func <Task> scheduleFunc = () => scheduler.ScheduleAsync(() => promise.Complete(), TimeSpan.FromMilliseconds(100));
            Task        task         = scheduleFromExecutor ? await scheduler.SubmitAsync(scheduleFunc) : scheduleFunc();

            await Task.WhenAny(task, Task.Delay(TimeSpan.FromMilliseconds(300)));

            Assert.True(task.IsCompleted);
        }
Example #6
0
 void ShutdownOutput0(TaskCompletionSource promise)
 {
     try
     {
         this.Socket.Shutdown(SocketShutdown.Send);
         promise.Complete();
     }
     catch (Exception ex)
     {
         promise.SetException(ex);
     }
 }
Example #7
0
 public override void ChannelActive(IChannelHandlerContext context)
 {
     // Ensure the promise was completed before the handler method was triggered.
     if (_promise.Task.IsCompleted)
     {
         _assertPromise.Complete();
     }
     else
     {
         _assertPromise.SetException(new ApplicationException("connect promise should be done"));
     }
 }
Example #8
0
        public static Task <Socket> AcceptAsync(this Socket socket, SocketAsyncEventArgs args, SocketFlags flags)
        {
            var tcs = new TaskCompletionSource <Socket>();

            args.UserToken = tcs;
            if (!socket.AcceptAsync(args))
            {
                tcs.Complete(args, a => a.AcceptSocket);
            }

            return(tcs.Task);
        }
Example #9
0
        public static Task <int> ReceiveAsync(this Socket socket, SocketAsyncEventArgs args, byte[] buffer, int offset, int count)
        {
            var tcs = new TaskCompletionSource <int>();

            args.SetBuffer(buffer, offset, count);
            args.UserToken = tcs;
            if (!socket.ReceiveAsync(args))
            {
                tcs.Complete <int>(args, a => a.BytesTransferred);
            }

            return(tcs.Task);
        }
Example #10
0
        public static Task ConnectAsync(this Socket socket, IPAddress addr, int port)
        {
            var tcs  = new TaskCompletionSource <int>();
            var args = new SocketAsyncEventArgs();

            args.RemoteEndPoint = new IPEndPoint(addr, port);
            args.UserToken      = tcs;
            args.Completed     += (s, a) => { ((TaskCompletionSource <int>)a.UserToken).Complete(a, _ => 0); a.Dispose(); };
            if (!socket.ConnectAsync(args))
            {
                tcs.Complete(args, _ => 0);
                args.Dispose();
            }

            return(tcs.Task);
        }
Example #11
0
        void DoLeaveGroup(IPEndPoint multicastAddress, NetworkInterface networkInterface, IPEndPoint source, TaskCompletionSource promise)
        {
            try
            {
                this.Socket.SetSocketOption(
                    this.config.AddressFamilyOptionLevel,
                    SocketOptionName.DropMembership,
                    this.CreateMulticastOption(multicastAddress, networkInterface, source));

                promise.Complete();
            }
            catch (Exception exception)
            {
                Util.SafeSetFailure(promise, exception, Logger);
            }
        }
Example #12
0
 private Func <TTarget, ValidationScope, Task <bool> > CreateTask(Func <TTarget, Task <TTarget> > setup, Func <TTarget, bool> validate) =>
 (target, parentScope) =>
 {
     var tcs  = new TaskCompletionSource <bool>();
     var task = setup(target);
     task.ContinueWith(
         t => tcs.Complete(t,
                           () =>
     {
         using (var scope = new ValidationScope(parentScope))
         {
             var result = validate(t.Result);
             RecordResult(scope, result, target);
             return(result);
         }
     }));
     return(tcs.Task);
 };
Example #13
0
        public async Task ScheduledTaskFiresOnTimeWhileBusy()
        {
            var    scheduler       = new SingleThreadEventExecutor(null, TimeSpan.FromMilliseconds(10));
            var    promise         = new TaskCompletionSource();
            Action selfQueueAction = null;

            selfQueueAction = () =>
            {
                if (!promise.Task.IsCompleted)
                {
                    scheduler.Execute(selfQueueAction);
                }
            };

            scheduler.Execute(selfQueueAction);
            Task task = scheduler.ScheduleAsync(() => promise.Complete(), TimeSpan.FromMilliseconds(100));
            await Task.WhenAny(task, Task.Delay(TimeSpan.FromMilliseconds(300)));

            Assert.True(task.IsCompleted);
        }
Example #14
0
        public async Task OpenAsync_TwoCallers_OnlyOneOpenCalled()
        {
            var tcs = new TaskCompletionSource();
            var innerHandlerMock = Substitute.For <IDelegatingHandler>();
            int callCounter      = 0;

            innerHandlerMock.OpenAsync(true).Returns(t =>
            {
                callCounter++;
                return(tcs.Task);
            });

            var  sut        = new GateKeeperDelegatingHandler(innerHandlerMock);
            Task firstOpen  = sut.OpenAsync();
            Task secondOpen = sut.OpenAsync();

            tcs.Complete();
            await Task.WhenAll(firstOpen, secondOpen);

            Assert.AreEqual(1, callCounter);
        }
Example #15
0
        public void Rules_within_a_ValidationPlan_can_use_APM_signatures_and_run_asynchronously()
        {
            var hasAwesomeTag = Validate.Async <string>(
                setup: url =>
            {
                var request = new ApmOperation <string, string>(s =>
                                                                Task <string> .Factory.StartNew(() => "<div>" + s + "</div>"));
                var tcs = new TaskCompletionSource <string>();
                Task <string> .Factory
                .FromAsync(request.BeginInvoke,
                           request.EndInvoke,
                           url,
                           state: null,
                           creationOptions: TaskCreationOptions.AttachedToParent)
                .ContinueWith(
                    t => tcs.Complete(t, () => t.Result));
                return(tcs.Task);
            },
                validate: html => html.As("page").Contains("<awesome>"))
                                .WithErrorMessage("{page} is missing the <awesome> tag!");

            var plan = new ValidationPlan <string>
            {
                isValidHttpUrl,
                hasAwesomeTag.When(isValidHttpUrl)
            };

            var task = plan.ExecuteAsync("http://google.com");

            task.Wait();
            var result = task.Result;

            Console.WriteLine(result);
            // TODO: (Rules_within_a_ValidationPlan_can_use_APM_signatures_and_run_asynchronously)

            Assert.That(result.Failures.Any(f => f.Message == "http://google.com is missing the <awesome> tag!"));
        }
        public async Task OpenAsyncTwoCallersOnlyOneOpenCalled()
        {
            var contextMock      = Substitute.For <IPipelineContext>();
            var tcs              = new TaskCompletionSource();
            var innerHandlerMock = Substitute.For <IDelegatingHandler>();
            int callCounter      = 0;

            innerHandlerMock.OpenAsync(Arg.Any <CancellationToken>()).Returns(t =>
            {
                callCounter++;
                return(tcs.Task);
            });
            innerHandlerMock.WaitForTransportClosedAsync().Returns(Task.Delay(TimeSpan.FromSeconds(10)));

            var  sut = new RetryDelegatingHandler(contextMock, innerHandlerMock);
            var  cancellationToken = new CancellationToken();
            Task firstOpen         = sut.OpenAsync(cancellationToken);
            Task secondOpen        = sut.OpenAsync(cancellationToken);

            tcs.Complete();
            await Task.WhenAll(firstOpen, secondOpen).ConfigureAwait(false);

            Assert.AreEqual(1, callCounter);
        }
Example #17
0
 void ShutdownOutput0(TaskCompletionSource promise)
 {
     try
     {
         this.Socket.Shutdown(SocketShutdown.Send);
         promise.Complete();
     }
     catch (Exception ex)
     {
         promise.SetException(ex);
     }
 }
        public async Task OpenAsync_TwoCallers_OnlyOneOpenCalled()
        {
            var tcs = new TaskCompletionSource();
            var innerHandlerMock = Substitute.For<IDelegatingHandler>();
            int callCounter = 0;
            innerHandlerMock.OpenAsync(true).Returns(t =>
            {
                callCounter++;
                return tcs.Task;
            });

            var sut = new GateKeeperDelegatingHandler(innerHandlerMock);
            Task firstOpen = sut.OpenAsync();
            Task secondOpen = sut.OpenAsync();
            tcs.Complete();
            await Task.WhenAll(firstOpen, secondOpen);

            Assert.AreEqual(1, callCounter);
        }