Inheritance: IConsole
コード例 #1
0
 public SafeCakeLog(CakeConsole c)
 {
     _logger = new Cake.Diagnostics.CakeBuildLog(c);
 }
コード例 #2
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()));
        }
コード例 #3
0
 public SafeCakeLog( CakeConsole c )
 {
     _logger = new CakeBuildLog( c );
 }
コード例 #4
0
        /// <summary>
        /// Runs the application.
        /// </summary>
        /// <param name="args">Arguments.</param>
        /// <returns>0 on success.</returns>
        public int Run( string[] args )
        {
            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 );
            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.RunTarget( context, strategy, context.Arguments.GetArgument( "target" ) ?? "Default" );
                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;
        }
コード例 #5
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);
        }