Beispiel #1
0
 public HeartbeatExtension(byte mode)
 {
     if (!HeartbeatMode.IsValid(mode))
     {
         throw new ArgumentException("not a valid HeartbeatMode value", "mode");
     }
     mMode = mode;
 }
Beispiel #2
0
            public async Task <HeartbeatResult> RunAsync(HeartbeatMode mode)
            {
                var stub = Workflow.NewActivityStub <IActivityHeartbeat>(new ActivityOptions()
                {
                    HeartbeatTimeout = TimeSpan.FromSeconds(10)
                });

                return(await stub.RunAsync(mode));
            }
Beispiel #3
0
    public static HeartbeatExtension Parse(Stream input)
    {
        byte b = TlsUtilities.ReadUint8(input);

        if (!HeartbeatMode.IsValid(b))
        {
            throw new TlsFatalAlert(47);
        }
        return(new HeartbeatExtension(b));
    }
Beispiel #4
0
            public async Task <HeartbeatResult> RunAsync(HeartbeatMode mode)
            {
                switch (mode)
                {
                case HeartbeatMode.SendHeartbeat:

                    await Activity.SendHeartbeatAsync(new byte[] { 0, 1, 2, 3, 4 });

                    break;

                case HeartbeatMode.HeartbeatWithDefaults:

                    // The first heartbeat should always be recorded.

                    if (!await Activity.HeartbeatAsync())
                    {
                        return(HeartbeatResult.Error1);
                    }

                    // The next (immediate) heartbeat should not be recorded.

                    if (await Activity.HeartbeatAsync())
                    {
                        return(HeartbeatResult.Error2);
                    }

                    // Sleep for 1/2 the heartbeat timeout (plus a bit) and verify that the
                    // next heartbeat is recorded afterwards.

                    await Task.Delay(TimeSpan.FromTicks(Activity.Task.HeartbeatTimeout.Ticks / 2) + TimeSpan.FromMilliseconds(50));

                    if (!await Activity.HeartbeatAsync())
                    {
                        return(HeartbeatResult.Error3);
                    }
                    break;

                case HeartbeatMode.HeartbeatWithDetails:

                    var detailsRetrieved = false;

                    if (!await Activity.HeartbeatAsync(
                            () =>
                    {
                        detailsRetrieved = true;
                        return(new byte[] { 0, 1, 2, 3, 4 });
                    }))
                    {
                        return(HeartbeatResult.Error4);
                    }

                    if (!detailsRetrieved)
                    {
                        return(HeartbeatResult.Error5);
                    }
                    break;

                case HeartbeatMode.HeartbeatWithInterval:

                    // The first heartbeat should always be recorded.

                    if (!await Activity.HeartbeatAsync(interval: TimeSpan.FromSeconds(1)))
                    {
                        return(HeartbeatResult.Error6);
                    }

                    // The next (immediate) heartbeat should not be recorded.

                    if (await Activity.HeartbeatAsync())
                    {
                        return(HeartbeatResult.Error7);
                    }

                    // Sleep long enough such that we'll definitely exceed the heart minimum
                    // and verify that next heartbeat is recorded.

                    await Task.Delay(TimeSpan.FromTicks(Activity.Task.HeartbeatTimeout.Ticks / 2) + TimeSpan.FromMilliseconds(50));

                    if (!await Activity.HeartbeatAsync())
                    {
                        return(HeartbeatResult.Error8);
                    }
                    break;
                }

                return(HeartbeatResult.OK);
            }