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);
                }
            }
        }