makefile.shade

var PROJECT='AspNet'
var VERSION='0.2.1'

use namespace='System'
use namespace='System.IO'
use namespace='System.Collections.Generic'
use namespace='System.Net'
use namespace='System.Linq'
use namespace='System.Text.RegularExpressions'
use import="BuildEnv"

functions
    @{
        static string BASE_DIR = Directory.GetCurrentDirectory();
        static string TARGET_DIR = Path.Combine(BASE_DIR, "artifacts", "build");
        static Dictionary<string, string> sources = new Dictionary<string, string>(){
            // The repos list is topologically sorted based on build order
            {"Configuration","1.0.0-alpha3"},
            {"Caching","1.0.0-alpha3"},
            {"DataCommon","1.0.0-alpha3"},
            {"DataCommon.SQLite","1.0.0-alpha3"},
            {"DataProtection","1.0.0-alpha3"},
            {"DependencyInjection","1.0.0-alpha3"},
            {"Options","1.0.0-alpha3"},
            {"Logging","1.0.0-alpha3"},
            {"Testing","1.0.0-alpha3"},
            {"Diagnostics","1.0.0-alpha3"},
            {"EntityFramework","7.0.0-alpha3"},
            {"FileSystem","1.0.0-alpha3"},
            {"WebSocketAbstractions","1.0.0-alpha3"},
            {"HttpAbstractions","1.0.0-alpha3"},
            {"Hosting","1.0.0-alpha3"},
            /*{"Helios","1.0.0-alpha3"},*/
            {"Identity","3.0.0-alpha3"},
            {"Razor","4.0.0-alpha3"},
            {"Routing","1.0.0-alpha3"},
            {"Mvc","6.0.0-alpha3"},
            {"Scaffolding","1.0.0-alpha3"},
            {"Security","1.0.0-alpha3"},
            {"SignalR-Server","3.0.0-alpha3"},
            {"StaticFiles","1.0.0-alpha3"},
            /*{"WebListener","1.0.0-alpha3"},*/
            {"KestrelHttpServer","1.0.0-alpha3"},
            {"WebSockets","1.0.0-alpha3"},
            {"Entropy","1.0.0-alpha3"},
        };
        static string[] repos = sources.Keys.ToArray();
        static string[] tags = sources.Values.ToArray();
        static bool useHttps = UseHttps(BASE_DIR);
        static string gitHubUriPrefix = useHttps ? "https://github.com/aspnet/" : "git@github.com:aspnet/";
    }

@{
    var kBuildVersion = Environment.GetEnvironmentVariable("K_BUILD_VERSION");
    if (!string.IsNullOrEmpty(kBuildVersion))
    {
        VERSION += "-" + kBuildVersion;
    }
    else
    {
        VERSION += "-" + BuildNumber;
    }
}

#default .compile

#pull .checkout
#compile .pull
#install .pull
#checkout

#pack
    directory create='${TARGET_DIR}'
    nuget-pack nuspecFile='${Path.Combine(BASE_DIR, "KoreBuild.nuspec")}' packageVersion='${VERSION}' outputDir='${TARGET_DIR}'

#pack-install .pack
    nuget-local-publish sourcePackagesDir='${TARGET_DIR}' 

#git-checkout target='checkout' 
    @{
        foreach (var source in sources)
        {
            var repo = source.Key;
            var tag = source.Value;

            if(false == Directory.Exists(repo))
            {
                continue;
            }

            try
            {
                GitCommand(repo, "checkout " + tag);
            }
            catch
            {
                // If the release branch does not exist, create a new branch and reset origin/dev to it.
                GitCommand(repo, "checkout " + "master");
            }
        }
    }

#git-pull target='pull' 
    @{
        foreach(var repo in repos) 
        {
            CloneOrUpdate(repo);
        }
    }

#init
    @{
        var templatePath = Path.Combine(BASE_DIR, "build-template");
        var templateFiles = Files.Include(templatePath + Path.DirectorySeparatorChar + "*.*").Select(Path.GetFileName).ToList();

        foreach(var repo in repos)
        {
            foreach (string fileName in templateFiles)
            {
                var targetFile = Path.Combine(Directory.GetCurrentDirectory(), repo, fileName);
                var sourceFile = Path.Combine(Directory.GetCurrentDirectory(), templatePath, fileName);

                // Don't update the makefile
                if(fileName.Equals("makefile.shake", StringComparison.OrdinalIgnoreCase) && File.Exists(targetFile))
                {
                    continue;
                }

                if(!File.Exists(sourceFile) || 
                   (File.ReadAllText(sourceFile) != File.ReadAllText(targetFile)))
                {
                    Log.Info("Updating " + fileName + " to " + repo);
                    File.Copy(sourceFile, targetFile, true);
                }
            }
        }
    }

#update-release
    -// Merge dev branch to release
    @{
        foreach (var repo in GetAllRepos())
        {
            CloneOrUpdate(repo);
            try
            {
                GitCommand(repo, "checkout release");
            }
            catch
            {
                // If the release branch does not exist, create a new branch and reset origin/dev to it.
                GitCommand(repo, "checkout origin/dev -b release");
            }

            GitCommand(repo, "merge origin/dev");
            GitCommand(repo, "push origin release");
        }
    }

#reset-master
    -// Resets master branch to release
    for each='var repo in GetAllRepos()'
        -CloneOrUpdate(repo);

        var gitFolder = '${repo}'
        git gitCommand='fetch origin'
        git gitCommand='checkout origin/release -B master'

#push-master
    -// Resets master branch to release
    for each='var repo in GetAllRepos()'
        var gitFolder = '${repo}'
        git gitCommand='push origin master:master -f'

#only-compile target='compile'
    @{
        var failed = new Dictionary<string, Exception>();
        foreach(var repo in repos) 
        {
            try
            {
                Log.Info(string.Format("Building {0}", repo));
                if (IsMono)
                {
                    Exec("build.sh", "compile", repo);
                }
                else
                {
                    Exec("build.cmd", "compile", repo);
                }
                Log.Info(string.Format("Build {0} succeeded", repo));
            }
            catch(Exception ex)
            {
                Log.Warn(string.Format("Build {0} failed: {1}", repo, ex.Message));
                failed[repo] = ex;
            }
        }
        foreach(var repo in repos)
        {
            Exception ex;
            if (failed.TryGetValue(repo, out ex))
            {
                Log.Warn(string.Format("Build {0} failed: {1}", repo, ex.Message));
            }
            else
            {
                Log.Info(string.Format("Build {0} succeeded", repo));
            }
        }
    }

#only-install target='install'
    @{
        foreach(var repo in repos) 
        {
            if (IsMono)
            {
                Exec("build.sh", "install", repo);
            }
            else
            {
                Exec("build.cmd", "install", repo);
            }
        }
    }
    
#run-snapshot-manager
    @{
        Exec(@".nuget\nuget.exe", @"restore -out packages tools\TCDependencyManager\packages.config", "");
        var programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);
        var msbuildPath = Path.Combine(programFiles, "MSBuild", "12.0", "Bin", "MsBuild.exe");
        Exec(msbuildPath, "TCDependencyManager.csproj", @"tools\TCDependencyManager");
        Exec(@"tools\TCDependencyManager\bin\Debug\TCDependencyManager.exe", "", "");
    }

#git-status decription='Show status of repos known by Universe'
    @{
        foreach(var repo in repos) 
        {
            GitStatus(repo);
        }
    }

#git-clean decription='REMOVE ALL CHANGES to the working directory'
    @{
        Console.WriteLine("This runs `git clean -xfd` in all non-Universe repos.");
        Console.WriteLine("This should REMOVE ALL CHANGES to the working directory.");
        Console.Write("***** Are you sure? ***** (Y or anything else)? ");
        if (Console.ReadLine() != "Y")
        {
            throw new Exception("git-clean cancelled");
        }
        foreach(var repo in repos) 
        {
            GitClean(repo);
        }
    }

macro name='GitCheckout' gitTag='string'
    git-checkout

macro name='GitPull' gitUri='string' gitBranch='string' gitFolder='string'
    git-pull

macro name='GitClone' gitUri='string' gitBranch='string'
    git-clone

macro name='GitConfig' gitOptionName='string' gitOptionValue='string' gitFolder='string'
    git-config

macro name='GitStatus' gitFolder='string'
    git gitCommand='status'

macro name='GitClean' gitFolder='string'
    git gitCommand='clean -xdf'

macro name='GitCommand' gitFolder='string' gitCommand='string'
    git

macro name='Exec' program='string' commandline='string' workingdir='string'
    exec

functions
    @{
        static bool UseHttps(string directory)
        {
            var filename = Path.Combine(directory, ".git", "config");
            if (!File.Exists(filename))
            {
                Console.WriteLine("Unable to find '{0}' file", filename);
                return false;
            }

            var url = ReadOriginUrl(filename);
            return IsHttpsUrl(url);
        }

        // Perform equivalent of `git config remote.origin.url` but directly
        // read config file to get value.
        static string ReadOriginUrl(string filename)
        {
            // Subsection portion of configuration name is case-sensitive; rest
            // of name is case-insensitive.
            var beginOriginSection = new Regex(@"^\[(?i:remote) ""origin""\]\s*$");
            var beginSection = new Regex(@"^\[");
            var urlLine = new Regex(@"^\s+url = (\S+)\s*$", RegexOptions.IgnoreCase);

            var inRemoteOriginSection = false;
            foreach (var line in File.ReadAllLines(filename))
            {
                if (beginOriginSection.IsMatch(line))
                {
                    inRemoteOriginSection = true;
                    continue;
                }

                if (inRemoteOriginSection)
                {
                    if (beginSection.IsMatch(line))
                    {
                        // Read through the section without finding URL line.
                        break;
                    }

                    var match = urlLine.Match(line);
                    if (match.Success && match.Groups.Count == 2 && match.Groups[1].Success)
                    {
                        return match.Groups[1].Value;
                    }
                }
            }

            Console.WriteLine("Unable to parse '{0}' file", filename);
            return null;
        }

        static bool IsHttpsUrl(string url)
        {
            if (string.IsNullOrEmpty(url))
            {
                return false;
            }

            return url.StartsWith("https://", System.StringComparison.OrdinalIgnoreCase);
        }
        
        static bool IsAccessible(string key)
        {
            var req = WebRequest.CreateHttp("https://github.com/aspnet/" + key);
            req.Method = "HEAD";
            try
            {
                using (req.GetResponse());
            }
            catch (WebException ex)
            {
                if (ex.Response != null && 
                    ((HttpWebResponse)ex.Response).StatusCode == HttpStatusCode.NotFound)
                {
                    return false;
                }
                
                // Ignore any other exception. They should surface as part of git clone with well-known messages.
            }
            return true;
        }

        IEnumerable<string> GetAllRepos()
        {
            var nonDefaultRepos = new[]
            {
              "KRuntime",
              "Claims",
              "DataAnnotations",
              "SqlClient",
              "MusicStore"
            };
            return Enumerable.Concat(repos, nonDefaultRepos);
        }

        void CloneOrUpdate(string repo)
        {
            var repoUrl = gitHubUriPrefix + repo + ".git";

            if(Directory.Exists(repo))
            {
                GitPull(repoUrl, "dev", repo);
            }
            else
            {
                if (useHttps &&
                    !IsAccessible(repo))
                {
                    Log.Warn(string.Format("The repo at '{0}' is not accessible. If you do not have access to this repository, skip the git prompt" +
                                           " for credentials to skip cloning this repository. To avoid this prompt, re-clone the Universe repository over ssh.",
                                           repoUrl));
                }

                try
                {
                    GitClone(repoUrl, "dev");
                }
                catch (Exception ex)
                {
                    Log.Warn(string.Format("Unable to clone repository at '{0}': {1}", repoUrl, ex.Message));
                    return;
                }
                GitConfig("bugtraq.url", "http://github.com/aspnet/" + repo + "/issues/%BUGID%", repo);
                GitConfig("bugtraq.logregex", @"#(\d+)", repo);
            }
        }        
    }