Example #1
0
 /// <summary>
 /// Creates a build script that attempts to run the build script <paramref name="s"/>,
 /// always returning a successful exit code.
 /// </summary>
 public static BuildScript Try(BuildScript s) => s | Success;
Example #2
0
        public BuildScript Analyse(Autobuilder builder, bool auto)
        {
            if (!builder.ProjectsOrSolutionsToBuild.Any())
            {
                return(BuildScript.Failure);
            }

            if (auto)
            {
                builder.Log(Severity.Info, "Attempting to build using MSBuild");
            }

            var vsTools = GetVcVarsBatFile(builder);

            if (vsTools == null && builder.ProjectsOrSolutionsToBuild.Any())
            {
                var firstSolution = builder.ProjectsOrSolutionsToBuild.OfType <ISolution>().FirstOrDefault();
                vsTools = firstSolution != null
                                ? BuildTools.FindCompatibleVcVars(builder.Actions, firstSolution)
                                : BuildTools.VcVarsAllBatFiles(builder.Actions).OrderByDescending(b => b.ToolsVersion).FirstOrDefault();
            }

            if (vsTools == null && builder.Actions.IsWindows())
            {
                builder.Log(Severity.Warning, "Could not find a suitable version of vcvarsall.bat");
            }

            var nuget =
                builder.SemmlePlatformTools != null?
                builder.Actions.PathCombine(builder.SemmlePlatformTools, "csharp", "nuget", "nuget.exe") :
                    "nuget";

            var ret = BuildScript.Success;

            foreach (var projectOrSolution in builder.ProjectsOrSolutionsToBuild)
            {
                if (builder.Options.NugetRestore)
                {
                    var nugetCommand = new CommandBuilder(builder.Actions).
                                       RunCommand(nuget).
                                       Argument("restore").
                                       QuoteArgument(projectOrSolution.FullPath);
                    ret &= BuildScript.Try(nugetCommand.Script);
                }

                var command = new CommandBuilder(builder.Actions);

                if (vsTools != null)
                {
                    command.CallBatFile(vsTools.Path);
                }

                builder.MaybeIndex(command, MsBuild);
                command.QuoteArgument(projectOrSolution.FullPath);

                command.Argument("/p:UseSharedCompilation=false");

                string target = builder.Options.MsBuildTarget != null
                                       ? builder.Options.MsBuildTarget
                                       : "rebuild";
                string platform = builder.Options.MsBuildPlatform != null
                                         ? builder.Options.MsBuildPlatform
                                         : projectOrSolution is ISolution s1 ? s1.DefaultPlatformName : null;
                string configuration = builder.Options.MsBuildConfiguration != null
                                              ? builder.Options.MsBuildConfiguration
                                              : projectOrSolution is ISolution s2 ? s2.DefaultConfigurationName : null;

                command.Argument("/t:" + target);
                if (platform != null)
                {
                    command.Argument(string.Format("/p:Platform=\"{0}\"", platform));
                }
                if (configuration != null)
                {
                    command.Argument(string.Format("/p:Configuration=\"{0}\"", configuration));
                }
                command.Argument("/p:MvcBuildViews=true");

                command.Argument(builder.Options.MsBuildArguments);

                ret &= command.Script;
            }

            return(ret);
        }
Example #3
0
 /// <summary>
 /// Creates a build script that runs <paramref name="s1"/>, followed by running the script
 /// produced by <paramref name="s2"/> on the exit code and standard output from
 /// <paramref name="s1"/>.
 /// </summary>
 public static BuildScript Bind(BuildScript s1, Func <IList <string>, int, BuildScript> s2) =>
 new BindBuildScript(s1, s2);
Example #4
0
 /// <summary>
 /// Creates a build script that runs <paramref name="s1"/>, followed by running the script
 /// produced by <paramref name="s2"/> on the exit code from <paramref name="s1"/>.
 /// </summary>
 public static BuildScript Bind(BuildScript s1, Func <int, BuildScript> s2) =>
 new BindBuildScript(s1, s2);
Example #5
0
 public BindBuildScript(BuildScript s1, Func <int, BuildScript> s2)
 {
     this.s1  = s1;
     this.s2b = s2;
 }
Example #6
0
 public BindBuildScript(BuildScript s1, Func <IList <string>, int, BuildScript> s2)
 {
     this.s1  = s1;
     this.s2a = s2;
 }
        /// <summary>
        /// Returns a script for downloading a specific .NET Core SDK version, if the
        /// version is not already installed.
        ///
        /// See https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script.
        /// </summary>
        static BuildScript DownloadDotNetVersion(Autobuilder builder, string path, string version)
        {
            return(BuildScript.Bind(GetInstalledSdksScript(builder.Actions), (sdks, sdksRet) =>
            {
                if (sdksRet == 0 && sdks.Count() == 1 && sdks[0].StartsWith(version + " ", StringComparison.Ordinal))
                {
                    // The requested SDK is already installed (and no other SDKs are installed), so
                    // no need to reinstall
                    return BuildScript.Failure;
                }

                builder.Log(Severity.Info, "Attempting to download .NET Core {0}", version);

                if (builder.Actions.IsWindows())
                {
                    var psScript = @"param([string]$Version, [string]$InstallDir)

add-type @""
using System.Net;
using System.Security.Cryptography.X509Certificates;
public class TrustAllCertsPolicy : ICertificatePolicy
{
    public bool CheckValidationResult(ServicePoint srvPoint, X509Certificate certificate, WebRequest request, int certificateProblem)
    {
        return true;
    }
}
""@
$AllProtocols = [System.Net.SecurityProtocolType]'Ssl3,Tls,Tls11,Tls12'
[System.Net.ServicePointManager]::SecurityProtocol = $AllProtocols
[System.Net.ServicePointManager]::CertificatePolicy = New-Object TrustAllCertsPolicy
$Script = Invoke-WebRequest -useb 'https://dot.net/v1/dotnet-install.ps1'

$arguments = @{
  Channel = 'release'
  Version = $Version
  InstallDir = $InstallDir
}

$ScriptBlock = [scriptblock]::create("".{$($Script)} $(&{$args} @arguments)"")

Invoke-Command -ScriptBlock $ScriptBlock";
                    var psScriptFile = builder.Actions.PathCombine(builder.Options.RootDirectory, "install-dotnet.ps1");
                    builder.Actions.WriteAllText(psScriptFile, psScript);

                    var install = new CommandBuilder(builder.Actions).
                                  RunCommand("powershell").
                                  Argument("-NoProfile").
                                  Argument("-ExecutionPolicy").
                                  Argument("unrestricted").
                                  Argument("-file").
                                  Argument(psScriptFile).
                                  Argument("-Version").
                                  Argument(version).
                                  Argument("-InstallDir").
                                  Argument(path);

                    var removeScript = new CommandBuilder(builder.Actions).
                                       RunCommand("del").
                                       Argument(psScriptFile);

                    return install.Script & BuildScript.Try(removeScript.Script);
                }
                else
                {
                    var curl = new CommandBuilder(builder.Actions).
                               RunCommand("curl").
                               Argument("-L").
                               Argument("-sO").
                               Argument("https://dot.net/v1/dotnet-install.sh");

                    var chmod = new CommandBuilder(builder.Actions).
                                RunCommand("chmod").
                                Argument("u+x").
                                Argument("dotnet-install.sh");

                    var install = new CommandBuilder(builder.Actions).
                                  RunCommand("./dotnet-install.sh").
                                  Argument("--channel").
                                  Argument("release").
                                  Argument("--version").
                                  Argument(version).
                                  Argument("--install-dir").
                                  Argument(path);

                    var removeScript = new CommandBuilder(builder.Actions).
                                       RunCommand("rm").
                                       Argument("dotnet-install.sh");

                    return curl.Script & chmod.Script & install.Script & BuildScript.Try(removeScript.Script);
                }
            }));
        }