Пример #1
0
        public static async Task <bool> Deploy(ILogger log, Context context)
        {
            var stack    = Build();
            var template = context.JsonStackSerializer.Serialize(stack);
            var cwd      = Path.Combine(context.Config.BuildPath, "src", Namespace);

            var baseStack = await Cloudformation.GetExistingStackAsync(context.Cloudformation, BaseStack.Name(context.Config)).ConfigureAwait(false);

            if (baseStack == null)
            {
                log.Error("Deploy the {stackName} stack first.", BaseStack.Name(context.Config));
                return(false);
            }

            var bucket = baseStack.GetStackOutput("DeploymentsBucket");
            var role   = baseStack.GetStackOutput("CloudFormationServiceRole");

            var parameters = new Dictionary <string, string>
            {
                ["Environment"]       = context.Config.Env,
                ["DeploymentsBucket"] = bucket
            };

            return(await LambdaDeployer.DeployStackAsync(log, context, Name(context.Config), template, cwd, parameters, bucket, role).ConfigureAwait(false));
        }
Пример #2
0
        static async Task <int> SquirtAsync(SquirtOptions options)
        {
            options.Validate();
            var ctrlC = new CancellationTokenSource();

            Console.CancelKeyPress += (sender, args) =>
            {
                Console.WriteLine("Beetles, abort!");
                args.Cancel = true;
                ctrlC.Cancel();
            };
            var verbose = options.Verbose ? (Action <object>)WriteVerbose : o => { };

            var timestamp = DateTimeOffset.UtcNow.ToString("yyyy-MM-dd_HHmmss");

            Console.WriteLine("Preparing battle plan...");
            var packagePath = options.PackagePath ?? GetDefaultPackagePath(options);

            var settings = LoadTypeInfo(options.Configuration, options.Framework, options.Name);

            var deployer = new LambdaDeployer(
                timestamp: timestamp,
                packagePath: packagePath,
                configurationType: settings.ConfigurationType,
                verbose: verbose);

            var rps      = options.RequestsPerSecond;
            var duration = Parser.Duration(options.Duration);

            Console.WriteLine($"Load testing at {rps}rps for {duration} using lambda {packagePath}");

            try
            {
                Console.WriteLine("Beetles, assemble!");
                await deployer.Deploy(options.MemorySize, settings.Name, ctrlC.Token);

                Console.WriteLine("Beetles, attack!");

                var lambdaControlPlane = new LambdaControlPlane(deployer.Topic, 600, detailsLog: verbose);

                var nullLoadTest = new LoadTest(
                    rps,
                    duration,
                    options.WarmUpTime != null ? Parser.Duration(options.WarmUpTime) : TimeSpan.Zero,
                    settings.StoryTeller,
                    lambdaControlPlane,
                    PrintLoadStep);

                var result = await nullLoadTest.RunAsync(ctrlC.Token);

                Console.WriteLine($"Beetles have returned in {result.Elapsed}.");
            }
            catch (TaskCanceledException)
            {
            }
            catch (Exception e)
            {
                WriteError($"An error occured - {e.Message}");

                WriteVerbose(e.ToString());
            }
            finally
            {
                Console.WriteLine("Calling back the beetles...");
                await deployer.Shutdown();
            }

            Console.WriteLine("It's goodbye from them, and it's goodbye from me!");
            return(0);
        }