Subversion Repositories SmartDukaan

/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 * Contains some contributions under the Thrift Software License.
 * Please see doc/old-thrift-license.txt in the Thrift distribution for
 * details.
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using Microsoft.Build.Tasks;
using System.IO;
using System.Diagnostics;

namespace ThriftMSBuildTask
{
        /// <summary>
        /// MSBuild Task to generate csharp from .thrift files, and compile the code into a library: ThriftImpl.dll
        /// </summary>
        public class ThriftBuild : Task
        {
                /// <summary>
                /// The full path to the thrift.exe compiler
                /// </summary>
                [Required]
                public ITaskItem ThriftExecutable
                {
                        get;
                        set;
                }

                /// <summary>
                /// The full path to a thrift.dll C# library
                /// </summary>
                [Required]
                public ITaskItem ThriftLibrary
                {
                        get;
                        set;
                }

                /// <summary>
                /// A direcotry containing .thrift files
                /// </summary>
                [Required]
                public ITaskItem ThriftDefinitionDir
                {
                        get;
                        set;
                }

                /// <summary>
                /// The name of the auto-gen and compiled thrift library. It will placed in
                /// the same directory as ThriftLibrary
                /// </summary>
                [Required]
                public ITaskItem OutputName
                {
                        get;
                        set;
                }

                /// <summary>
                /// The full path to the compiled ThriftLibrary. This allows msbuild tasks to use this
                /// output as a variable for use elsewhere.
                /// </summary>
                [Output]
                public ITaskItem ThriftImplementation
                {
                        get { return thriftImpl; }
                }

                private ITaskItem thriftImpl;
                private const string lastCompilationName = "LAST_COMP_TIMESTAMP";

                //use the Message Build Task to write something to build log
                private void LogMessage(string text, MessageImportance importance)
                {
                        Message m = new Message();
                        m.Text = text;
                        m.Importance = importance.ToString();
                        m.BuildEngine = this.BuildEngine;
                        m.Execute();
                }

                //recursively find .cs files in srcDir, paths should initially be non-null and empty
                private void FindSourcesHelper(string srcDir, List<string> paths)
                {
                        string[] files = Directory.GetFiles(srcDir, "*.cs");
                        foreach (string f in files)
                        {
                                paths.Add(f);
                        }
                        string[] dirs = Directory.GetDirectories(srcDir);
                        foreach (string dir in dirs)
                        {
                                FindSourcesHelper(dir, paths);
                        }
                }

                /// <summary>
                /// Quote paths with spaces
                /// </summary>
                private string SafePath(string path)
                {
                        if (path.Contains(' ') && !path.StartsWith("\""))
                        {
                                return "\"" + path + "\"";
                        }
                        return path;
                }

                private ITaskItem[] FindSources(string srcDir)
                {
                        List<string> files = new List<string>();
                        FindSourcesHelper(srcDir, files);
                        ITaskItem[] items = new ITaskItem[files.Count];
                        for (int i = 0; i < items.Length; i++)
                        {
                                items[i] = new TaskItem(files[i]);
                        }
                        return items;
                }

                private string LastWriteTime(string defDir)
                {
                        string[] files = Directory.GetFiles(defDir, "*.thrift");
                        DateTime d = (new DirectoryInfo(defDir)).LastWriteTime;
                        foreach(string file in files)
                        {
                                FileInfo f = new FileInfo(file);
                                DateTime curr = f.LastWriteTime;
                                if (DateTime.Compare(curr, d) > 0)
                                {
                                        d = curr;
                                }
                        }
                        return d.ToFileTimeUtc().ToString();
                }

                public override bool Execute()
                {
                        string defDir = SafePath(ThriftDefinitionDir.ItemSpec);
                        //look for last compilation timestamp
                        string lastBuildPath = Path.Combine(defDir, lastCompilationName);
                        DirectoryInfo defDirInfo = new DirectoryInfo(defDir);
                        string lastWrite = LastWriteTime(defDir);
                        if (File.Exists(lastBuildPath))
                        {
                                string lastComp = File.ReadAllText(lastBuildPath);
                                //don't recompile if the thrift library has been updated since lastComp
                                FileInfo f = new FileInfo(ThriftLibrary.ItemSpec);
                                string thriftLibTime = f.LastWriteTimeUtc.ToFileTimeUtc().ToString();
                                if (lastComp.CompareTo(thriftLibTime) < 0)
                                {
                                        //new thrift library, do a compile
                                        lastWrite = thriftLibTime;
                                }
                                else if (lastComp == lastWrite || (lastComp == thriftLibTime && lastComp.CompareTo(lastWrite) > 0))
                                {
                                        //the .thrift dir hasn't been written to since last compilation, don't need to do anything
                                        LogMessage("ThriftImpl up-to-date", MessageImportance.High);
                                        return true;
                                }
                        }

                        //find the directory of the thriftlibrary (that's where output will go)
                        FileInfo thriftLibInfo = new FileInfo(SafePath(ThriftLibrary.ItemSpec));
                        string thriftDir = thriftLibInfo.Directory.FullName;

                        string genDir = Path.Combine(thriftDir, "gen-csharp");
                        if (Directory.Exists(genDir))
                        {
                                try
                                {
                                        Directory.Delete(genDir, true);
                                }
                                catch { /*eh i tried, just over-write now*/}
                        }

                        //run the thrift executable to generate C#
                        foreach (string thriftFile in Directory.GetFiles(defDir, "*.thrift"))
                        {
                                LogMessage("Generating code for: " + thriftFile, MessageImportance.Normal);
                                Process p = new Process();
                                p.StartInfo.FileName = SafePath(ThriftExecutable.ItemSpec);
                                p.StartInfo.Arguments = "--gen csharp -o " + SafePath(thriftDir) + " -r " + thriftFile;
                                p.StartInfo.UseShellExecute = false;
                                p.StartInfo.CreateNoWindow = true;
                                p.StartInfo.RedirectStandardOutput = false;
                                p.Start();
                                p.WaitForExit();
                                if (p.ExitCode != 0)
                                {
                                        LogMessage("thrift.exe failed to compile " + thriftFile, MessageImportance.High);
                                        return false;
                                }
                                if (p.ExitCode != 0)
                                {
                                        LogMessage("thrift.exe failed to compile " + thriftFile, MessageImportance.High);
                                        return false;
                                }
                        }

                        Csc csc = new Csc();
                        csc.TargetType = "library";
                        csc.References = new ITaskItem[] { new TaskItem(ThriftLibrary.ItemSpec) };
                        csc.EmitDebugInformation = true;
                        string outputPath = Path.Combine(thriftDir, OutputName.ItemSpec);
                        csc.OutputAssembly = new TaskItem(outputPath);
                        csc.Sources = FindSources(Path.Combine(thriftDir, "gen-csharp"));
                        csc.BuildEngine = this.BuildEngine;
                        LogMessage("Compiling generated cs...", MessageImportance.Normal);
                        if (!csc.Execute())
                        {
                                return false;
                        }

                        //write file to defDir to indicate a build was successfully completed
                        File.WriteAllText(lastBuildPath, lastWrite);

                        thriftImpl = new TaskItem(outputPath);

                        return true;
                }
        }
}