Пример #1
0
        public async Task <CosmosDbDestroyResponse> DestroyCosmosDbAsync(CosmosDbDestroyRequest request)
        {
            var collectionResponse = await _documentClient.DeleteDocumentCollectionAsync(_collectionUri);

            var databaseResponse = await _documentClient.DeleteDatabaseAsync(_databaseUri);

            var requestCharge = databaseResponse.RequestCharge + collectionResponse.RequestCharge;

            return(new CosmosDbDestroyResponse(requestCharge));
        }
Пример #2
0
        public async Task <CosmosDbDestroyResponse> DestroyCosmosDbAsync(CosmosDbDestroyRequest request)
        {
            var containerResponse = await Container.DeleteContainerAsync();

            var databaseResponse = await Database.DeleteAsync();

            var requestCharge = databaseResponse.RequestCharge + containerResponse.RequestCharge;

            return(new CosmosDbDestroyResponse(requestCharge));
        }
Пример #3
0
        public async Task LaunchAsync(string[] args)
        {
            var environment = Environment.GetEnvironmentVariable("ENVIRONMENT") ?? DefaultEnvironmentToUse;

            var configuration = new ConfigurationBuilder()
                                .SetBasePath(Directory.GetCurrentDirectory())
                                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                                .AddJsonFile($"appsettings.{environment}.json", optional: true, reloadOnChange: true)
                                .AddEnvironmentVariables()
                                .Build();

            var services = new ServiceCollection();

            services.Configure <CosmosDbQueries>(configuration.GetSection(nameof(CosmosDbQueries)));
            services.Configure <CosmosDbSettings>(configuration.GetSection(nameof(CosmosDbSettings)));
            services.Configure <CosmosDbDocuments>(configuration.GetSection(nameof(CosmosDbDocuments)));
            services.AddSingleton <ICosmosDbPrinter, CosmosDbPrinter>();
            services.AddSingleton <ICosmosDbRepository>(provider =>
            {
                var cosmosDbSettings = provider.GetService <IOptions <CosmosDbSettings> >().Value;
                return(new CosmosDbRepository(cosmosDbSettings));
            });

            var serviceProvider = services.BuildServiceProvider();

            var targets = new Targets();

            targets.Add(nameof(LauncherTargets.Create), async() =>
            {
                LauncherTargets.Create.WaitForConfirmation();
                var printer          = serviceProvider.GetRequiredService <ICosmosDbPrinter>();
                var repository       = serviceProvider.GetRequiredService <ICosmosDbRepository>();
                var cosmosDbSettings = serviceProvider.GetService <IOptions <CosmosDbSettings> >().Value;
                var request          = new CosmosDbCreateRequest(cosmosDbSettings);
                var response         = await repository.CreateCosmosDbAsync(request);
                printer.Print(request, response);
            });

            targets.Add(nameof(LauncherTargets.Insert), new List <string> {
                nameof(LauncherTargets.Create)
            }, async() =>
            {
                LauncherTargets.Insert.WaitForConfirmation();
                var printer           = serviceProvider.GetRequiredService <ICosmosDbPrinter>();
                var repository        = serviceProvider.GetRequiredService <ICosmosDbRepository>();
                var cosmosDbSettings  = serviceProvider.GetService <IOptions <CosmosDbSettings> >().Value;
                var cosmosDbDocuments = serviceProvider.GetService <IOptions <CosmosDbDocuments> >().Value;
                var cosmosDbRequests  = cosmosDbDocuments.Select(x => new CosmosDbInsertRequest(x, cosmosDbSettings));
                foreach (var request in cosmosDbRequests)
                {
                    var response = await repository.InsertCosmosDbAsync(request);
                    printer.Print(request, response);
                }
            });

            targets.Add(nameof(LauncherTargets.Query), new List <string> {
                nameof(LauncherTargets.Insert)
            }, async() =>
            {
                LauncherTargets.Query.WaitForConfirmation();
                var printer          = serviceProvider.GetRequiredService <ICosmosDbPrinter>();
                var repository       = serviceProvider.GetRequiredService <ICosmosDbRepository>();
                var cosmosDbQueries  = serviceProvider.GetService <IOptions <CosmosDbQueries> >().Value;
                var cosmosDbRequests = cosmosDbQueries.Select(x => new CosmosDbQueryRequest(x));
                foreach (var request in cosmosDbRequests)
                {
                    var response = await repository.QueryCosmosDbAsync(request);
                    printer.Print(request, response);
                }
            });

            targets.Add(nameof(LauncherTargets.Delete), new List <string> {
                nameof(LauncherTargets.Query)
            }, async() =>
            {
                LauncherTargets.Delete.WaitForConfirmation();
                var printer           = serviceProvider.GetRequiredService <ICosmosDbPrinter>();
                var repository        = serviceProvider.GetRequiredService <ICosmosDbRepository>();
                var cosmosDbSettings  = serviceProvider.GetService <IOptions <CosmosDbSettings> >().Value;
                var cosmosDbDocuments = serviceProvider.GetService <IOptions <CosmosDbDocuments> >().Value;
                var cosmosDbRequests  = cosmosDbDocuments.Select(x => new CosmosDbDeleteRequest(x, cosmosDbSettings));
                foreach (var request in cosmosDbRequests)
                {
                    var response = await repository.DeleteCosmosDbAsync(request);
                    printer.Print(request, response);
                }
            });

            targets.Add(nameof(LauncherTargets.Destroy), new List <string> {
                nameof(LauncherTargets.Delete)
            }, async() =>
            {
                LauncherTargets.Destroy.WaitForConfirmation();
                var printer          = serviceProvider.GetRequiredService <ICosmosDbPrinter>();
                var repository       = serviceProvider.GetRequiredService <ICosmosDbRepository>();
                var cosmosDbSettings = serviceProvider.GetService <IOptions <CosmosDbSettings> >().Value;
                var request          = new CosmosDbDestroyRequest(cosmosDbSettings);
                var response         = await repository.DestroyCosmosDbAsync(request);
                printer.Print(request, response);
            });

            targets.Add(nameof(LauncherTargets.Default), new List <string> {
                nameof(LauncherTargets.Destroy)
            });

            await targets.RunWithoutExitingAsync(args);
        }
Пример #4
0
 public void Print(CosmosDbDestroyRequest request, CosmosDbDestroyResponse response)
 {
     Console.WriteLine($"DatabaseName: {request.DatabaseName}");
     Console.WriteLine($"ContainerName: {request.ContainerName}");
     Console.WriteLine($"RequestUnits: {response.RequestUnits} RU");
 }