Base class for build objects.
예제 #1
0
        /// <summary>
        /// Runs the application.
        /// </summary>
        /// <param name="args">Arguments.</param>
        /// <param name="appRoot">Application root folder</param>
        /// <returns>The result of the run.</returns>
        public async Task <RunResult> RunAsync(IEnumerable <string> args, string appRoot = null)
        {
            var console = new CakeConsole();
            var logger  = new SafeCakeLog(console);
            ICakeDataService dataService = new CodeCakeDataService();
            var engine = new CakeEngine(dataService, logger);

            ICakePlatform          platform    = new CakePlatform();
            ICakeRuntime           runtime     = new CakeRuntime();
            IFileSystem            fileSystem  = new FileSystem();
            MutableCakeEnvironment environment = new MutableCakeEnvironment(platform, runtime, appRoot);

            console.SupportAnsiEscapeCodes = AnsiDetector.SupportsAnsi(environment);

            IGlobber globber = new Globber(fileSystem, environment);

            IRegistry windowsRegistry = new WindowsRegistry();
            // Parse options.
            var         argumentParser = new ArgumentParser(logger, fileSystem);
            CakeOptions options        = argumentParser.Parse(args);

            Debug.Assert(options != null);
            CakeConfigurationProvider configProvider = new CakeConfigurationProvider(fileSystem, environment);
            ICakeConfiguration        configuration  = configProvider.CreateConfiguration(environment.ApplicationRoot, options.Arguments);
            IToolRepository           toolRepo       = new ToolRepository(environment);
            IToolResolutionStrategy   toolStrategy   = new ToolResolutionStrategy(fileSystem, environment, globber, configuration, logger);
            IToolLocator   locator       = new ToolLocator(environment, toolRepo, toolStrategy);
            IToolLocator   toolLocator   = new ToolLocator(environment, toolRepo, toolStrategy);
            IProcessRunner processRunner = new ProcessRunner(fileSystem, environment, logger, toolLocator, configuration);

            logger.SetVerbosity(options.Verbosity);
            ICakeArguments arguments = new CakeArguments(options.Arguments);
            var            context   = new CakeContext(
                fileSystem,
                environment,
                globber,
                logger,
                arguments,
                processRunner,
                windowsRegistry,
                locator,
                dataService,
                configuration);

            CodeCakeBuildTypeDescriptor choosenBuild;

            if (!AvailableBuilds.TryGetValue(options.Script, out choosenBuild))
            {
                logger.Error("Build script '{0}' not found.", options.Script);
                return(new RunResult(-1, context.InteractiveMode()));
            }

            // Set the working directory: the solution directory.
            logger.Information($"Working in Solution directory: '{_solutionDirectory}'.");
            environment.WorkingDirectory = new DirectoryPath(_solutionDirectory);

            try
            {
                SetEnvironmentVariablesFromCodeCakeBuilderKeyVault(logger, context);

                // Instantiates the script object.
                CodeCakeHost._injectedActualHost = new BuildScriptHost(engine, context);
                CodeCakeHost c = (CodeCakeHost)Activator.CreateInstance(choosenBuild.Type);


                var target                  = context.Arguments.GetArgument("target") ?? "Default";
                var execSettings            = new ExecutionSettings().SetTarget(target);
                var exclusiveTargetOptional = context.Arguments.HasArgument("exclusiveOptional");
                var exclusiveTarget         = exclusiveTargetOptional | context.Arguments.HasArgument("exclusive");
                var strategy                = new CodeCakeExecutionStrategy(logger, exclusiveTarget ? target : null);
                if (exclusiveTargetOptional && !engine.Tasks.Any(t => t.Name == target))
                {
                    logger.Warning($"No task '{target}' defined. Since -exclusiveOptional is specified, nothing is done.");
                    return(new RunResult(0, context.InteractiveMode()));
                }
                var report = await engine.RunTargetAsync(context, strategy, execSettings);

                if (report != null && !report.IsEmpty)
                {
                    var printerReport = new CakeReportPrinter(console);
                    printerReport.Write(report);
                }
            }
            catch (CakeTerminateException ex)
            {
                switch (ex.Option)
                {
                case CakeTerminationOption.Error:
                    logger.Error("Termination with Error: '{0}'.", ex.Message);
                    return(new RunResult(-2, context.InteractiveMode()));

                case CakeTerminationOption.Warning:
                    logger.Warning("Termination with Warning: '{0}'.", ex.Message);
                    break;

                default:
                    Debug.Assert(ex.Option == CakeTerminationOption.Success);
                    logger.Information("Termination with Success: '{0}'.", ex.Message);
                    break;
                }
            }
            catch (TargetInvocationException ex)
            {
                logger.Error("Error occurred: '{0}'.", ex.InnerException?.Message ?? ex.Message);
                return(new RunResult(-3, context.InteractiveMode()));
            }
            catch (AggregateException ex)
            {
                logger.Error("Error occurred: '{0}'.", ex.Message);
                foreach (var e in ex.InnerExceptions)
                {
                    logger.Error("  -> '{0}'.", e.Message);
                }
                return(new RunResult(-4, context.InteractiveMode()));
            }
            catch (Exception ex)
            {
                logger.Error("Error occurred: '{0}'.", ex.Message);
                return(new RunResult(-5, context.InteractiveMode()));
            }
            return(new RunResult(0, context.InteractiveMode()));
        }
예제 #2
0
        /// <summary>
        /// Runs the application.
        /// </summary>
        /// <param name="args">Arguments.</param>
        /// <param name="appRoot">Application root folder</param>
        /// <returns>0 on success.</returns>
        public int Run(string[] args, string appRoot = null)
        {
            var console = new CakeConsole();
            var logger  = new SafeCakeLog(console);
            var engine  = new CakeEngine(logger);

            ICakePlatform          platform    = new CakePlatform();
            ICakeRuntime           runtime     = new CakeRuntime();
            IFileSystem            fileSystem  = new FileSystem();
            MutableCakeEnvironment environment = new MutableCakeEnvironment(platform, runtime, appRoot);
            IGlobber globber = new Globber(fileSystem, environment);

            environment.Initialize(globber);
            IProcessRunner processRunner   = new ProcessRunner(environment, logger);
            IRegistry      windowsRegistry = new WindowsRegistry();
            // Parse options.
            var         argumentParser = new ArgumentParser(logger, fileSystem);
            CakeOptions options        = argumentParser.Parse(args);

            Debug.Assert(options != null);
            CakeConfigurationProvider configProvider = new CakeConfigurationProvider(fileSystem, environment);
            ICakeConfiguration        configuration  = configProvider.CreateConfiguration(environment.ApplicationRoot, options.Arguments);
            IToolRepository           toolRepo       = new ToolRepository(environment);
            IToolResolutionStrategy   toolStrategy   = new ToolResolutionStrategy(fileSystem, environment, globber, configuration);
            IToolLocator locator     = new ToolLocator(environment, toolRepo, toolStrategy);
            IToolLocator toolLocator = new ToolLocator(environment, toolRepo, toolStrategy);

            logger.SetVerbosity(options.Verbosity);
            CodeCakeBuildTypeDescriptor choosenBuild;

            if (!AvailableBuilds.TryGetValue(options.Script, out choosenBuild))
            {
                logger.Error("Build script '{0}' not found.", options.Script);
                return(-1);
            }

            ICakeArguments arguments = new CakeArguments(options.Arguments);

            var context = new CakeContext(fileSystem, environment, globber, logger, arguments, processRunner, windowsRegistry, locator);

            // Copy the arguments from the options.

            // Set the working directory: the solution directory.
            environment.WorkingDirectory = new DirectoryPath(_solutionDirectory);

            // Adds additional paths from chosen build.
            foreach (var p in choosenBuild.AdditionnalPatternPaths)
            {
                environment.AddPath(p);
            }
            logger.Information("Path(s) added: " + string.Join(", ", environment.EnvironmentAddedPaths));
            logger.Information("Dynamic pattern path(s) added: " + string.Join(", ", environment.EnvironmentDynamicPaths));

            try
            {
                // Instanciates the script object.
                CodeCakeHost._injectedActualHost = new BuildScriptHost(engine, context);
                CodeCakeHost c = (CodeCakeHost)Activator.CreateInstance(choosenBuild.Type);

                var strategy = new DefaultExecutionStrategy(logger);
                var report   = engine.RunTargetAsync(context, strategy, context.Arguments.GetArgument("target") ?? "Default").GetAwaiter().GetResult();
                if (report != null && !report.IsEmpty)
                {
                    var printerReport = new CakeReportPrinter(console);
                    printerReport.Write(report);
                }
            }
            catch (CakeTerminateException ex)
            {
                switch (ex.Option)
                {
                case CakeTerminationOption.Error:
                    logger.Error("Termination with Error: '{0}'.", ex.Message);
                    return(-1);

                case CakeTerminationOption.Warning:
                    logger.Warning("Termination with Warning: '{0}'.", ex.Message);
                    break;

                default:
                    Debug.Assert(ex.Option == CakeTerminationOption.Success);
                    logger.Information("Termination with Success: '{0}'.", ex.Message);
                    break;
                }
            }
            catch (TargetInvocationException ex)
            {
                logger.Error("Error occurred: '{0}'.", ex.InnerException?.Message ?? ex.Message);
                return(-1);
            }
            catch (Exception ex)
            {
                logger.Error("Error occurred: '{0}'.", ex.Message);
                return(-1);
            }
            return(0);
        }