Пример #1
0
        public override bool Execute() {
            int buildId;

            try {
                dynamic buildEngine = BuildEngine.AccessPrivate();

                var host = buildEngine.host;
                dynamic pHost = new AccessPrivateWrapper(host);
                var bp = pHost.buildParameters;
                dynamic pBp = new AccessPrivateWrapper(bp);

                buildId = pBp.buildId;

                lock (typeof(InvokeBuild)) {
                    if (buildId <= MaxBuildId) {
                        // this happens when we build a solution, and it wants to build each project
                        return true;
                    }
                    MaxBuildId = buildId;
                }
            }
            catch {
            
            }

            using (new PushDirectory(Environment.CurrentDirectory)) {
                try {
                    if (Location.Is()) {
                        Environment.CurrentDirectory = Location.GetFullPath();
                    }

                    if (string.IsNullOrWhiteSpace(ScriptFile)) {
                        // search for it.
                        ScriptFile = new[] {
                            @"copkg\.buildinfo", @"contrib\.buildinfo", @"contrib\coapp\.buildinfo", @".buildinfo"
                        }.WalkUpPaths();

                        if (string.IsNullOrEmpty(ScriptFile)) {
                            throw new ClrPlusException(@"Unable to find .buildinfo file anywhere in the current directory structure.");
                        }
                    }

                    if (!File.Exists(ScriptFile)) {
                        throw new ClrPlusException(@"Unable to find Invoke-build script file '{0}'.".format(ScriptFile));
                    }

                    string[] defines = Defines.IsNullOrEmpty() ? new string[0] : Defines.Select(each => each.ItemSpec).ToArray();

                    using (var buildScript = new BuildScript(ScriptFile)) {

                        buildScript.BuildMessage += message => {
                            try {
                                switch (message.EventType) {
                                    case "BuildWarning":
                                        Log.LogWarning(message.Subcategory, message.Code, message.HelpKeyword, message.File, message.LineNumber, message.ColumnNumber, message.EndLineNumber, message.EndColumnNumber, message.Message);
                                        break;
                                    case "BuildError":
                                        Log.LogError(message.Subcategory, message.Code, message.HelpKeyword, message.File, message.LineNumber, message.ColumnNumber, message.EndLineNumber, message.EndColumnNumber, message.Message);
                                        break;
                                    case "ProjectStarted":
                                        Log.LogExternalProjectStarted(message.Message, message.HelpKeyword, message.ProjectFile, message.TargetNames);
                                        break;
                                    case "ProjectFinished":
                                        Log.LogExternalProjectFinished(message.Message, message.HelpKeyword, message.ProjectFile, message.Succeeded);
                                        break;
                                    case "TaskStarted":
                                        Log.LogMessage(MessageImportance.Low, message.Message);
                                        break;
                                    case "TaskFinished":
                                        Log.LogMessage(MessageImportance.Low, message.Message);
                                        break;
                                    case "TargetStarted":
                                        Log.LogMessage(MessageImportance.Low, message.Message);
                                        break;
                                    case "TargetFinished":
                                        Log.LogMessage(MessageImportance.Low, message.Message);
                                        break;
                                    case "BuildStarted":
                                        Log.LogMessage(MessageImportance.Low, message.Message);
                                        break;
                                    case "BuildFinished":
                                        Log.LogMessage(MessageImportance.Low, message.Message);
                                        break;
                                    case "BuildMessage":
                                        Log.LogMessage((MessageImportance)message.Importance, message.Message);
                                        break;
                                    default:
                                        Log.LogMessage(MessageImportance.Low, message.Message);
                                        break;
                                }
                                
                            }
                            catch (Exception e) {
                                LogError("{0}/{1}/{2}", e.GetType().Name, e.Message, e.StackTrace );
                            }
                            return false;
                        };

                        foreach (var i in defines) {
                            var p = i.IndexOf("=");
                            var k = p > -1 ? i.Substring(0, p) : i;
                            var v = p > -1 ? i.Substring(p + 1) : "";
                            buildScript.AddMacro(k, v);
                        }

                        var targets = Targets.IsNullOrEmpty() ? new string[0] : Targets.Select(each => each.ItemSpec).ToArray();

                        if (Targets.IsNullOrEmpty()) {
                            targets = new string[] {
                                "default"
                            };
                        }

                        Environment.SetEnvironmentVariable("MaxThreads", "" + MaxThreads);
                        Environment.SetEnvironmentVariable("HIDE_THREADS", "true");

                        buildScript.MaxThreads = MaxThreads;
                        return buildScript.Execute(targets);
                    }

                } catch (Exception e) {
                    LogError("{0}/{1}/{2}".format(e.GetType().Name, e.Message, e.StackTrace));
                    return false;
                } finally {
                    Environment.SetEnvironmentVariable("HIDE_THREADS", null);
                    Environment.SetEnvironmentVariable("MaxThreads", null);
                }
            }

        }
Пример #2
0
        protected override void BeginProcessing()
        {
#if USING_RESTABLE_CMDLET
            if (Remote)
            {
                ProcessRecordViaRest();
                return;
            }
#endif
            using (new PushDirectory(Path.Combine(SessionState.Drive.Current.Root, SessionState.Drive.Current.CurrentLocation))) {
                // Invoking a ptk script.
                if (string.IsNullOrWhiteSpace(ScriptFile))
                {
                    // search for it.
                    ScriptFile = new[] {
                        @"copkg\.buildinfo", @"contrib\.buildinfo", @"contrib\coapp\.buildinfo", @".buildinfo"
                    }.WalkUpPaths();

                    if (string.IsNullOrEmpty(ScriptFile))
                    {
                        throw new ClrPlusException(@"Unable to find .buildinfo file anywhere in the current directory structure.");
                    }
                }

                using (var local = LocalEventSource) {
                    local.Events += new SourceError((code, location, message, objects) => {
                        location = location.IsNullOrEmpty() ? SourceLocation.Unknowns : location;
                        Host.UI.WriteErrorLine("{0}:{1}:{2}".format(location.FirstOrDefault(), code, message.format(objects)));
                        return(true);
                    });

                    if (!NoWarnings)
                    {
                        local.Events += new SourceWarning((code, location, message, objects) => {
                            WriteWarning(message);
                            return(false);
                        });
                    }

                    local.Events += new SourceDebug((code, location, message, objects) => {
                        WriteVerbose(message);
                        return(false);
                    });

                    local.Events += new MSBuildMessage((obj) => {
                        switch (obj.EventType)
                        {
                        case "BuildWarning":
                            if (!NoWarnings)
                            {
                                Host.UI.WriteLine("{0}:{1}:{2}".format(obj.File, obj.Code, obj.Message));
                            }
                            break;

                        case "BuildError":
                            Host.UI.WriteErrorLine("{0}:{1}:{2}".format(obj.File, obj.Code, obj.Message));

                            break;

                        case "ProjectStarted":
                        case "ProjectFinished":
                        case "TaskStarted":
                        case "TaskFinished":
                        case "TargetStarted":
                        case "TargetFinished":
                        case "BuildStarted":
                        case "BuildFinished":
                            WriteVerbose(obj.Message);
                            break;

                        case "BuildMessage":
                            if (filterMessages.Any(each => obj.Message.IndexOf(each) > -1))
                            {
                                WriteVerbose(obj.Message);
                            }
                            else
                            {
                                Host.UI.WriteLine(obj.Message);
                            }

                            break;

                        default:
                            WriteVerbose(obj.Message);
                            break;
                        }
                        return(false);
                    });

                    using (buildScript = new BuildScript(ScriptFile)) {
                        if (Defines != null)
                        {
                            foreach (var i in Defines)
                            {
                                var p = i.IndexOf("=");
                                var k = p > -1 ? i.Substring(0, p) : i;
                                var v = p > -1 ? i.Substring(p + 1) : "";
                                buildScript.AddMacro(k, v);
                            }
                        }
                        if (Define != null)
                        {
                            foreach (var i in Define)
                            {
                                var p = i.IndexOf("=");
                                var k = p > -1 ? i.Substring(0, p) : i;
                                var v = p > -1 ? i.Substring(p + 1) : "";
                                buildScript.AddMacro(k, v);
                            }
                        }
                        if (Targets.IsNullOrEmpty())
                        {
                            Targets = new string[] {
                                "default"
                            };
                        }

                        if (SaveScript)
                        {
                            WriteObject("Script Saved To: {0}".format(buildScript.EmitScript()));
                            return;
                        }

                        if (DumpScript)
                        {
                            WriteObject(buildScript.ScriptText());
                            return;
                        }

                        Environment.SetEnvironmentVariable("MaxThreads", "" + MaxThreads);
                        buildScript.MaxThreads = MaxThreads;
                        buildScript.Execute(Targets);
                    }
                }
            }
        }
Пример #3
0
        public static BuildResultCode BuildLocal(BuilderOptions options)
        {
            string inputFile = options.InputFiles[0];
            string sdkDir    = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "../../..");

            BuildScript buildScript = BuildScript.LoadFromFile(sdkDir, inputFile);

            buildScript.Compile(options.Plugins);

            if (buildScript.GetWarnings().FirstOrDefault() != null)
            {
                foreach (string warning in buildScript.GetWarnings())
                {
                    options.Logger.Warning(warning);
                }
            }

            if (buildScript.HasErrors)
            {
                foreach (string error in buildScript.GetErrors())
                {
                    options.Logger.Error(error);
                }
                throw new InvalidOperationException("Can't compile the provided build script.");
            }

            string inputDir = Path.GetDirectoryName(inputFile) ?? Environment.CurrentDirectory;

            options.SourceBaseDirectory       = options.SourceBaseDirectory ?? Path.Combine(inputDir, buildScript.SourceBaseDirectory ?? "");
            options.BuildDirectory            = options.BuildDirectory ?? Path.Combine(inputDir, buildScript.BuildDirectory ?? "");
            options.OutputDirectory           = options.OutputDirectory ?? (buildScript.OutputDirectory != null ? Path.Combine(inputDir, buildScript.OutputDirectory) : "");
            options.MetadataDatabaseDirectory = options.MetadataDatabaseDirectory ?? (buildScript.MetadataDatabaseDirectory != null ? Path.Combine(inputDir, buildScript.MetadataDatabaseDirectory) : "");
            if (!string.IsNullOrWhiteSpace(options.SourceBaseDirectory))
            {
                if (!Directory.Exists(options.SourceBaseDirectory))
                {
                    string error = string.Format("Source base directory \"{0}\" does not exists.", options.SourceBaseDirectory);
                    options.Logger.Error(error);
                    throw new OptionException(error, "sourcebase");
                }
                Environment.CurrentDirectory = options.SourceBaseDirectory;
            }

            if (string.IsNullOrWhiteSpace(options.BuildDirectory))
            {
                throw new OptionException("This tool requires a build path.", "build-path");
            }

            // Mount build path
            ((FileSystemProvider)VirtualFileSystem.ApplicationData).ChangeBasePath(options.BuildDirectory);

            options.ValidateOptionsForMaster();

            // assets is always added by default
            //options.Databases.Add(new DatabaseMountInfo("/assets"));
            PrepareDatabases(options);

            try
            {
                VirtualFileSystem.CreateDirectory("/data/");
                VirtualFileSystem.CreateDirectory("/data/db/");
            }
            catch (Exception)
            {
                throw new OptionException("Invalid Build database path", "database");
            }

            // Create builder
            LogMessageType logLevel = options.Debug ? LogMessageType.Debug : (options.Verbose ? LogMessageType.Verbose : LogMessageType.Info);
            var            logger   = Logger.GetLogger("builder");

            logger.ActivateLog(logLevel);
            var builder = new Builder("builder", options.BuildDirectory, options.BuilderMode, logger)
            {
                ThreadCount = options.ThreadCount
            };

            builder.MonitorPipeNames.AddRange(options.MonitorPipeNames);
            builder.ActivateConfiguration(options.Configuration);
            foreach (var sourceFolder in buildScript.SourceFolders)
            {
                builder.InitialVariables.Add(("SourceFolder:" + sourceFolder.Key).ToUpperInvariant(), sourceFolder.Value);
            }
            Console.CancelKeyPress += (sender, e) => Cancel(builder, e);

            buildScript.Execute(builder);

            // Run builder
            return(builder.Run(options.Append == false));
        }
Пример #4
0
        public override bool Execute()
        {
            int buildId;

            try {
                dynamic buildEngine = BuildEngine.AccessPrivate();

                var     host  = buildEngine.host;
                dynamic pHost = new AccessPrivateWrapper(host);
                var     bp    = pHost.buildParameters;
                dynamic pBp   = new AccessPrivateWrapper(bp);

                buildId = pBp.buildId;

                lock (typeof(InvokeBuild)) {
                    if (buildId <= MaxBuildId)
                    {
                        // this happens when we build a solution, and it wants to build each project
                        return(true);
                    }
                    MaxBuildId = buildId;
                }
            }
            catch {
            }

            using (new PushDirectory(Environment.CurrentDirectory)) {
                try {
                    if (Location.Is())
                    {
                        Environment.CurrentDirectory = Location.GetFullPath();
                    }

                    if (string.IsNullOrWhiteSpace(ScriptFile))
                    {
                        // search for it.
                        ScriptFile = new[] {
                            @"copkg\.buildinfo", @"contrib\.buildinfo", @"contrib\coapp\.buildinfo", @".buildinfo"
                        }.WalkUpPaths();

                        if (string.IsNullOrEmpty(ScriptFile))
                        {
                            throw new ClrPlusException(@"Unable to find .buildinfo file anywhere in the current directory structure.");
                        }
                    }

                    if (!File.Exists(ScriptFile))
                    {
                        throw new ClrPlusException(@"Unable to find Invoke-build script file '{0}'.".format(ScriptFile));
                    }

                    string[] defines = Defines.IsNullOrEmpty() ? new string[0] : Defines.Select(each => each.ItemSpec).ToArray();

                    using (var buildScript = new BuildScript(ScriptFile)) {
                        buildScript.BuildMessage += message => {
                            try {
                                switch (message.EventType)
                                {
                                case "BuildWarning":
                                    Log.LogWarning(message.Subcategory, message.Code, message.HelpKeyword, message.File, message.LineNumber, message.ColumnNumber, message.EndLineNumber, message.EndColumnNumber, message.Message);
                                    break;

                                case "BuildError":
                                    Log.LogError(message.Subcategory, message.Code, message.HelpKeyword, message.File, message.LineNumber, message.ColumnNumber, message.EndLineNumber, message.EndColumnNumber, message.Message);
                                    break;

                                case "ProjectStarted":
                                    Log.LogExternalProjectStarted(message.Message, message.HelpKeyword, message.ProjectFile, message.TargetNames);
                                    break;

                                case "ProjectFinished":
                                    Log.LogExternalProjectFinished(message.Message, message.HelpKeyword, message.ProjectFile, message.Succeeded);
                                    break;

                                case "TaskStarted":
                                    Log.LogMessage(MessageImportance.Low, message.Message);
                                    break;

                                case "TaskFinished":
                                    Log.LogMessage(MessageImportance.Low, message.Message);
                                    break;

                                case "TargetStarted":
                                    Log.LogMessage(MessageImportance.Low, message.Message);
                                    break;

                                case "TargetFinished":
                                    Log.LogMessage(MessageImportance.Low, message.Message);
                                    break;

                                case "BuildStarted":
                                    Log.LogMessage(MessageImportance.Low, message.Message);
                                    break;

                                case "BuildFinished":
                                    Log.LogMessage(MessageImportance.Low, message.Message);
                                    break;

                                case "BuildMessage":
                                    Log.LogMessage((MessageImportance)message.Importance, message.Message);
                                    break;

                                default:
                                    Log.LogMessage(MessageImportance.Low, message.Message);
                                    break;
                                }
                            }
                            catch (Exception e) {
                                LogError("{0}/{1}/{2}", e.GetType().Name, e.Message, e.StackTrace);
                            }
                            return(false);
                        };

                        foreach (var i in defines)
                        {
                            var p = i.IndexOf("=");
                            var k = p > -1 ? i.Substring(0, p) : i;
                            var v = p > -1 ? i.Substring(p + 1) : "";
                            buildScript.AddMacro(k, v);
                        }

                        var targets = Targets.IsNullOrEmpty() ? new string[0] : Targets.Select(each => each.ItemSpec).ToArray();

                        if (Targets.IsNullOrEmpty())
                        {
                            targets = new string[] {
                                "default"
                            };
                        }

                        Environment.SetEnvironmentVariable("MaxThreads", "" + MaxThreads);
                        Environment.SetEnvironmentVariable("HIDE_THREADS", "true");

                        buildScript.MaxThreads = MaxThreads;
                        return(buildScript.Execute(targets));
                    }
                } catch (Exception e) {
                    LogError("{0}/{1}/{2}".format(e.GetType().Name, e.Message, e.StackTrace));
                    return(false);
                } finally {
                    Environment.SetEnvironmentVariable("HIDE_THREADS", null);
                    Environment.SetEnvironmentVariable("MaxThreads", null);
                }
            }
        }
Пример #5
0
        private void Start(string[] args)
        {
            CurrentTask.Events += new SourceError((code, location, message, objects) => {
                location = location ?? SourceLocation.Unknowns;
                Console.WriteLine("{0}:Error {1}:{2}", location.FirstOrDefault(), code, message.format(objects));
                return(true);
            });

            CurrentTask.Events += new SourceWarning((code, location, message, objects) => {
                location = location ?? SourceLocation.Unknowns;
                Console.WriteLine("{0}:Warning {1}:{2}", location.FirstOrDefault(), message.format(objects));
                return(false);
            });

            CurrentTask.Events += new SourceDebug((code, location, message, objects) => {
                location = location ?? SourceLocation.Unknowns;
                Console.WriteLine("{0}:DebugMessage {1}:{2}", location.FirstOrDefault(), code, message.format(objects));
                return(false);
            });

            CurrentTask.Events += new Error((code, message, objects) => {
                Console.WriteLine("{0}:Error {1}", code, message.format(objects));
                return(true);
            });

            CurrentTask.Events += new Warning((code, message, objects) => {
                Console.WriteLine("{0}:Warning {1}", code, message.format(objects));
                return(false);
            });

            CurrentTask.Events += new Debug((code, message, objects) => {
                Console.WriteLine("{0}:DebugMessage {1}", code, message.format(objects));
                return(false);
            });

            CurrentTask.Events += new Verbose((code, message, objects) => {
                Console.WriteLine("{0}:Verbose {1}", code, message.format(objects));
                return(false);
            });
            CurrentTask.Events += new Message((code, message, objects) => {
                Console.WriteLine("{0}:Message {1}", code, message.format(objects));
                return(false);
            });

#if true
            try {
                Environment.CurrentDirectory = @"C:\root\V2\coapp-packages\openssl\copkg";
                Console.WriteLine("Package script");
                using (var script = new PackageScript("openssl.autopkg")) {
                    IEnumerable <string> overlayFiles;
                    var pkgFile = script.Save(PackageTypes.NuGet, false, false, out overlayFiles);
                }
                Console.WriteLine();
            } catch (Exception e) {
                Console.WriteLine("{0} =>\r\n\r\nat {1}", e.Message, e.StackTrace.Replace("at ClrPlus.Scripting.Languages.PropertySheetV3.PropertySheetParser", "PropertySheetParser"));
            }
#else
            try {
                // Environment.CurrentDirectory = @"C:\project";
                Console.WriteLine("Build script");
                using (var script = new BuildScript("test.buildinfo")) {
                    script.Execute();
                }
            } catch (Exception e) {
                Console.WriteLine("{0} =>\r\n\r\nat {1}", e.Message, e.StackTrace.Replace("at ClrPlus.Scripting.Languages.PropertySheetV3.PropertySheetParser", "PropertySheetParser"));
            }
#endif
            return;
            //
        }