public async Task ExecuteAsync(
            int bucketNumber,
            int bucketCount,
            CancellationToken token)
        {
            DateTimeOffset?newCursorValue;

            do
            {
                await _cursor.Load(token);

                newCursorValue = await ProcessBatchAsync(bucketNumber, bucketCount, token);

                if (newCursorValue.HasValue)
                {
                    _cursor.Value = newCursorValue.Value;
                    _logger.LogInformation(
                        "Moving cursor {BucketNumber}/{BucketCount} forward to {NewCursorValue}.",
                        bucketNumber,
                        bucketCount,
                        newCursorValue.Value);
                    await _cursor.Save(token);
                }
            }while (newCursorValue.HasValue);
        }
Example #2
0
        public async void CanReadWhatItSaves()
        {
            StorageContent savedContent = null;

            var storageMock = CreateStorageMock();

            storageMock
            .Protected().Setup <Task>("OnSave", ItExpr.IsAny <Uri>(), ItExpr.IsAny <StorageContent>(), ItExpr.IsAny <CancellationToken>())
            .Callback <Uri, StorageContent, CancellationToken>((uri, content, token) => { savedContent = content; })
            .Returns(Task.FromResult(0));

            storageMock
            .Protected().Setup <Task <StorageContent> >("OnLoad", ItExpr.IsAny <Uri>(), ItExpr.IsAny <CancellationToken>())
            .Returns <Uri, CancellationToken>((uri, token) => Task.FromResult(savedContent));

            DateTimeOffset defaultValue       = new DateTimeOffset(2017, 5, 5, 17, 8, 42, TimeSpan.Zero);
            DateTimeOffset actualValue        = new DateTimeOffset(2017, 5, 5, 17, 49, 42, TimeSpan.Zero);
            var            durableCursorSaver = new DurableCursor(new Uri("http://localhost/cursor.json"), storageMock.Object, defaultValue);

            durableCursorSaver.Value = actualValue;
            await durableCursorSaver.Save(CancellationToken.None);

            var durableCursorLoader = new DurableCursor(new Uri("http://localhost/cursor.json"), storageMock.Object, defaultValue);
            await durableCursorLoader.Load(CancellationToken.None);

            Assert.Equal(actualValue, durableCursorLoader.Value);
        }
        public static void CreateNewCursor(string[] args)
        {
            IDictionary <string, string> arguments = GetArguments(args, 0);
            StorageFactory storageFactory          = CreateStorageFactory(arguments, verbose: true);
            Storage        storage = storageFactory.Create();

            DurableCursor cursor = new DurableCursor(storage.ResolveUri("cursor.json"), storage, GetDefaultValue(arguments));

            cursor.Load().Wait();
            cursor.Save().Wait();
        }
Example #4
0
        public async void UsesDefaultValue()
        {
            var storageMock = CreateStorageMock();

            storageMock
            .Protected().Setup <Task>("OnLoad", ItExpr.IsAny <Uri>(), ItExpr.IsAny <CancellationToken>())
            .Returns(Task.FromResult <StorageContent>(null));

            DateTimeOffset defaultValue  = new DateTimeOffset(2017, 5, 5, 17, 8, 42, TimeSpan.Zero);
            var            durableCursor = new DurableCursor(new Uri("http://localhost/cursor.json"), storageMock.Object, defaultValue);
            await durableCursor.Load(CancellationToken.None);

            Assert.Equal(defaultValue, durableCursor.Value);
        }
        public async void LoadsFromStorage()
        {
            var storageMock = CreateStorageMock();

            storageMock
            .Protected().Setup <Task <StorageContent> >("OnLoad", ItExpr.IsAny <Uri>(), ItExpr.IsAny <CancellationToken>())
            .Returns(Task.FromResult <StorageContent>(null))
            .Verifiable();

            var durableCursor = new DurableCursor(new Uri("http://localhost/cursor.json"), storageMock.Object, new DateTimeOffset(2017, 5, 5, 17, 8, 42, TimeSpan.Zero));
            await durableCursor.Load(CancellationToken.None);

            storageMock.Verify();
        }