~ubuntu-branches/ubuntu/saucy/monodevelop/saucy-proposed

using System.IO;

using System.Linq;

 

                static FilePath GenericLogFile {

                        get { return "MonoDevelop.log"; }

                }

 

                static string FormattedGenericLogFile (int value)

                {

                        return string.Format ("MonoDevelop-{0}.log", value);

                }

 

                static string FormattedUniqueFileName (DateTime timestamp)

                {

                        return string.Format ("MonoDevelop.{0}.log", timestamp.ToString ("yyyy-MM-dd__HH-mm-ss"));

                }

                

                public static void Initialize (bool redirectOutput)

                {

                        PurgeOldLogs ();

                        

                        if (Platform.IsWindows || redirectOutput)

                                RedirectOutputToLogFile ();

                }

                

                static void PurgeOldLogs ()

                {

                        // Delete all logs older than 30 days

                        if (!Directory.Exists (UserProfile.Current.LogDir))

                                return;

 

                        var files = Directory.EnumerateFiles (UserProfile.Current.LogDir, "MonoDevelop.*.log")

                                .Select (f => new FileInfo (f))

                                .Where (f => f.CreationTimeUtc < DateTime.UtcNow.Subtract (TimeSpan.FromDays (30)));

 

                        foreach (var v in files)

                                v.Delete ();

                }

                

                static void RedirectOutputToLogFile ()

                {

                        FilePath logDir = UserProfile.Current.LogDir;

                        if (!Directory.Exists (logDir))

                                Directory.CreateDirectory (logDir);

                

                        try {

                                if (Platform.IsWindows) {

                                        //TODO: redirect the file descriptors on Windows, just plugging in a textwriter won't get everything

                                        RedirectOutputToFileWindows (logDir);

                                } else {

                                        RedirectOutputToFileUnix (logDir);

                                }

                        } catch {

                        }

                }

 

                static IEnumerable<string> GetGenericLogFiles (FilePath logDirectory)

                {

                        // Look for MonoDevelop.log and also MonoDevelop-XXX.log and move them to MonoDevelop.{timestamp}.log files

                        // as we cannot symlink on windows and we want 'MonoDevelop.log' to be the newest log file

                        string additonalGenericLogs = Path.GetFileNameWithoutExtension (GenericLogFile) + "-";

                        return Directory.GetFiles (logDirectory)

                                .Where (f => f == GenericLogFile || f.StartsWith (additonalGenericLogs))

                                .OrderBy (f => f);

                }

 

                static void RedirectOutputToFileWindows (FilePath logDirectory)

                {

                        // First try to move any generic MonoDevelop.log files to a timestamped filename

                        foreach (var path in GetGenericLogFiles (logDirectory)) {

                                try {

                                        var creationTime = File.GetCreationTime (path);

                                        var destination = logDirectory.Combine (FormattedUniqueFileName (creationTime));

                                        File.Copy (path, destination, true);

                                        File.Delete (path);

                                } catch {}

                        }

 

                        // Find the first free filename, try MonoDevelop.log first and then MonoDevelop-{0}.log

                        int count = 0;

                        var newLogFileName = GenericLogFile;

                        var existingFiles = GetGenericLogFiles (logDirectory).Select (f => Path.GetFileName (f)).ToList ();

                        while (existingFiles.Contains (newLogFileName))

                                newLogFileName = FormattedGenericLogFile (count ++);

 

                        var logFile = new StreamWriter (logDirectory.Combine (newLogFileName));

                        logFile.AutoFlush = true;

                        Console.SetOut (logFile);

                        Console.SetError (logFile);

                }

                

                static void RedirectOutputToFileUnix (FilePath logDirectory)

                {

                        const int STDOUT_FILENO = 1;

                        const int STDERR_FILENO = 2;

                        

                        Mono.Unix.Native.OpenFlags flags = Mono.Unix.Native.OpenFlags.O_WRONLY

                                | Mono.Unix.Native.OpenFlags.O_CREAT | Mono.Unix.Native.OpenFlags.O_TRUNC;

                        var mode = Mono.Unix.Native.FilePermissions.S_IFREG

                                | Mono.Unix.Native.FilePermissions.S_IRUSR | Mono.Unix.Native.FilePermissions.S_IWUSR

                                | Mono.Unix.Native.FilePermissions.S_IRGRP | Mono.Unix.Native.FilePermissions.S_IWGRP;

                        

                        var file = logDirectory.Combine (FormattedUniqueFileName (DateTime.Now));

                        int fd = Mono.Unix.Native.Syscall.open (file, flags, mode);

                        if (fd < 0)

                                //error

                                return;

                        try {

                                int res = Mono.Unix.Native.Syscall.dup2 (fd, STDOUT_FILENO);

                                if (res < 0)

                                        //error

                                        return;

                                

                                res = Mono.Unix.Native.Syscall.dup2 (fd, STDERR_FILENO);

                                if (res < 0)

                                        //error

                                        return;

 

                                var genericLog = logDirectory.Combine (GenericLogFile);

                                File.Delete (genericLog);

                                Mono.Unix.Native.Syscall.symlink (file, genericLog);

                        } finally {

                                Mono.Unix.Native.Syscall.close (fd);

                        }

                }