ModStatistics.cs

using JsonFx.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using UnityEngine;

namespace ModStatistics
{
    [KSPAddon(KSPAddon.Startup.Instantly, true)]
    internal class ModStatistics : MonoBehaviour
    {
        // The implementation with the highest version number will be allowed to run.
        private const int version = 7;
        private static int _version = version;

        private static readonly string folder;
        private static readonly string configpath;

        static ModStatistics()
        {
            folder = KSPUtil.ApplicationRootPath + "GameData" + Path.DirectorySeparatorChar + "ModStatistics" + Path.DirectorySeparatorChar;
            configpath = folder + "settings.cfg";
        }

        public void Start()
        {
            // Compatible types are identified by the type name and version field name.
            int highest =
                getAllTypes()
                .Where(t => t.Name == typeof(ModStatistics).Name)
                .Select(t => t.GetField("_version", BindingFlags.Static | BindingFlags.NonPublic))
                .Where(f => f != null)
                .Where(f => f.FieldType == typeof(int))
                .Max(f => (int)f.GetValue(null));

            // Let the latest version execute.
            if (version != highest) { return; }

            Debug.Log(String.Format("[ModStatistics] Running version {0}", _version));

            // Other checkers will see this version and not run.
            // This accomplishes the same as an explicit "ran" flag with fewer moving parts.
            _version = int.MaxValue;

            Directory.CreateDirectory(folder);

            var node = ConfigNode.Load(configpath);

            if (node == null)
            {
                promptUpdatePref();
            }
            else
            {
                var disabledString = node.GetValue("disabled");
                if (disabledString != null && bool.TryParse(disabledString, out disabled) && disabled)
                {
                    Debug.Log("[ModStatistics] Disabled in configuration file");
                    return;
                }

                var idString = node.GetValue("id");
                try
                {
                    id = new Guid(idString);
                }
                catch
                {
                    Debug.LogWarning("[ModStatistics] Could not parse ID");
                }

                var str = node.GetValue("update");
                if (str != null && bool.TryParse(str, out update))
                {
                    writeConfig();
                    checkUpdates();
                }
                else
                {
                    promptUpdatePref();
                }
            }

            running = true;
            DontDestroyOnLoad(this);

            if (File.Exists(folder + "checkpoint.json"))
            {
                File.Move(folder + "checkpoint.json", createReportPath());
            }

            sendReports();
            install();
        }

        private void promptUpdatePref()
        {
            PopupDialog.SpawnPopupDialog(
                new MultiOptionDialog(
                    "You recently installed a mod which uses ModStatistics to report anonymous usage information. Would you like ModStatistics to automatically update when new versions are available?",
                    new Callback(() => { update = GUILayout.Toggle(update, "Automatically install ModStatistics updates"); }),
                    "ModStatistics",
                    HighLogic.Skin,
                    new DialogOption("OK", () => { writeConfig(); checkUpdates(); }, true),
                    new DialogOption("Launch Website", () => { Application.OpenURL(@"http://stats.majiir.net/"); }, false)
                    ),
                true,
                HighLogic.Skin
            );
        }

        private void writeConfig()
        {
            var text = String.Format("// To disable ModStatistics, change the line below to \"disabled = true\"" + Environment.NewLine + "// Do NOT delete the ModStatistics folder. It could be reinstated by another mod." + Environment.NewLine + "disabled = {2}" + Environment.NewLine + "update = {1}" + Environment.NewLine + "id = {0:N}" + Environment.NewLine, id, update.ToString().ToLower(), disabled.ToString().ToLower());
            File.WriteAllText(configpath, text);
        }

        private static IEnumerable<Type> getAllTypes()
        {
            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                Type[] types;
                try
                {
                    types = assembly.GetTypes();
                }
                catch (Exception)
                {
                    types = Type.EmptyTypes;
                }

                foreach (var type in types)
                {
                    yield return type;
                }
            }
        }

        private bool running = false;
        private bool disabled = false;
        private bool update = true;

        private Guid id = Guid.NewGuid();
        private GameScenes? scene = null;
        private DateTime started = DateTime.UtcNow;
        private DateTime sceneStarted = DateTime.UtcNow;
        private Dictionary<GameScenes, TimeSpan> sceneTimes = new Dictionary<GameScenes, TimeSpan>();
        private DateTime nextSave = DateTime.MinValue;

        public void FixedUpdate()
        {
            if (!running) { return; }

            if (scene != HighLogic.LoadedScene)
            {
                updateSceneTimes();
            }

            var now = DateTime.UtcNow;
            if (nextSave < now)
            {
                nextSave = now.AddSeconds(15);

                var report = prepareReport(true);
                File.WriteAllText(folder + "checkpoint.json", report);
            }
        }

        public void OnDestroy()
        {
            if (!running) { return; }

            Debug.Log("[ModStatistics] Saving report");
            File.WriteAllText(createReportPath(), prepareReport(false));

            File.Delete(folder + "checkpoint.json");
        }

        private static string createReportPath()
        {
            int i = 0;
            string path;
            do
            {
                path = folder + "report-" + i + ".json";
                i++;
            } while (File.Exists(path));
            return path;
        }

        private void sendReports()
        {
            var files = Directory.GetFiles(folder, "report-*.json");
            using (var client = new WebClient())
            {
                setUserAgent(client);
                client.Headers.Add(HttpRequestHeader.ContentType, "application/json");

                client.UploadStringCompleted += (s, e) =>
                {
                    var file = (string)e.UserState;
                    if (e.Cancelled)
                    {
                        Debug.LogWarning(String.Format("[ModStatistics] Upload operation for {0} was cancelled", Path.GetFileName(file)));
                    }
                    else if (e.Error != null)
                    {
                        Debug.LogError(String.Format("[ModStatistics] Could not upload {0}:\n{1}", Path.GetFileName(file), e.Error));
                    }
                    else
                    {
                        Debug.Log("[ModStatistics] " + Path.GetFileName(file) + " sent successfully");
                        File.Delete(file);
                    }
                };

                foreach (var file in files)
                {
                    try
                    {
                        client.UploadStringAsync(new Uri(@"http://stats.majiir.net/submit_report"), null, File.ReadAllText(file), file);
                    }
                    catch (Exception e)
                    {
                        Debug.LogWarning(String.Format("[ModStatistics] Error initiating {0) upload:\n{1}", Path.GetFileName(file), e));
                    }
                }
            }
        }

        private static void setUserAgent(WebClient client)
        {
            client.Headers.Add(HttpRequestHeader.UserAgent, String.Format("ModStatistics/{0} ({1})", getInformationalVersion(Assembly.GetExecutingAssembly()), version));
        }

        private class ManifestEntry
        {
            public string url = String.Empty;
            public string path = String.Empty;
        }

        private void checkUpdates()
        {
            if (!update) { return; }

            using (var client = new WebClient())
            {
                client.DownloadStringCompleted += (s, e) =>
                {
                    if (e.Cancelled)
                    {
                        Debug.LogWarning(String.Format("[ModStatistics] Update query operation was cancelled"));
                    }
                    else if (e.Error != null)
                    {
                        Debug.LogError(String.Format("[ModStatistics] Could not query for updates:\n{0}", e.Error));
                    }
                    else
                    {
                        try
                        {
                            var manifest = new JsonReader().Read<ManifestEntry[]>(e.Result);
                            foreach (var entry in manifest)
                            {
                                var dest = folder + Path.DirectorySeparatorChar + entry.path.Replace('/', Path.DirectorySeparatorChar);
                                Directory.CreateDirectory(Path.GetDirectoryName(dest));
                                setUserAgent(client);
                                client.DownloadFileAsync(new Uri(entry.url), dest, entry);
                            }
                        }
                        catch (Exception ex)
                        {
                            Debug.LogError(String.Format("[ModStatistics] Error parsing update manifest:\n{0}", ex));
                        }
                    }
                };

                client.DownloadFileCompleted += (s, e) =>
                {
                    var entry = e.UserState as ManifestEntry;
                    if (e.Cancelled)
                    {
                        Debug.LogWarning(String.Format("[ModStatistics] Update download operation was cancelled"));
                    }
                    else if (e.Error != null)
                    {
                        Debug.LogError(String.Format("[ModStatistics] Could not download update for {0}:\n{1}", entry.path, e.Error));
                    }
                    else
                    {
                        Debug.Log("[ModStatistics] Successfully updated " + entry.path);
                    }
                };

                setUserAgent(client);
                client.DownloadStringAsync(new Uri(@"http://stats.majiir.net/update"));
            }
        }

        private void install()
        {
            var dest = folder + "Plugins" + Path.DirectorySeparatorChar;
            Directory.CreateDirectory(dest);
            if (!File.Exists(dest + "JsonFx.dll"))
            {
                var fxpath = AppDomain.CurrentDomain.GetAssemblies().First(a => a.GetName().Name == "JsonFx").Location;
                File.Copy(fxpath, dest + "JsonFx.dll");
            }
            var mspath = dest + "ModStatistics-" + getInformationalVersion(Assembly.GetExecutingAssembly()) + ".dll";
            if (!File.Exists(mspath))
            {
                File.Copy(Assembly.GetExecutingAssembly().Location, mspath);
            }
        }

        private void updateSceneTimes()
        {
            var lastScene = scene;
            var lastStarted = sceneStarted;
            scene = HighLogic.LoadedScene;
            sceneStarted = DateTime.UtcNow;

            if (lastScene == null) { return; }

            if (!sceneTimes.ContainsKey(lastScene.Value))
            {
                sceneTimes[lastScene.Value] = TimeSpan.Zero;
            }

            sceneTimes[lastScene.Value] += (sceneStarted - lastStarted);
        }

        private object[] assembliesInfo = null;

        private string prepareReport(bool crashed)
        {
            updateSceneTimes();

            if (assembliesInfo == null)
            {
                assembliesInfo = (from assembly in AssemblyLoader.loadedAssemblies.Skip(1)
                                  let fileVersion = assembly.assembly.GetName().Version
                                  select new
                                  {
                                      dllName = assembly.dllName,
                                      name = assembly.name,
                                      title = getAssemblyTitle(assembly.assembly),
                                      url = assembly.url,
                                      sha2 = getAssemblyHash(assembly.assembly),
                                      kspVersionMajor = assembly.versionMajor,
                                      kspVersionMinor = assembly.versionMinor,
                                      fileVersion = new
                                      {
                                          major = fileVersion.Major,
                                          minor = fileVersion.Minor,
                                          revision = fileVersion.Revision,
                                          build = fileVersion.Build,
                                      },
                                      informationalVersion = getInformationalVersion(assembly.assembly),
                                  }).ToArray();
            }

            var report = new
            {
                started = started,
                finished = sceneStarted,
                crashed = crashed,
                statisticsVersion = version,
                platform = getRunningPlatform(),
                id = id.ToString("N"),
                installedWithSteam = installedWithSteam(),
                gameVersion = new
                {
                    build = Versioning.BuildID,
                    major = Versioning.version_major,
                    minor = Versioning.version_minor,
                    revision = Versioning.Revision,
                    experimental = Versioning.Experimental,
                    isBeta = Versioning.isBeta,
                    isSteam = Versioning.IsSteam,
                    is64 = IntPtr.Size == 8,
                },
                scenes = sceneTimes.OrderBy(p => p.Key).ToDictionary(p => p.Key.ToString().ToLower(), p => p.Value.TotalMilliseconds),
                systemInfo = new {
                    cpus = SystemInfo.processorCount,
                    gpuMemory = SystemInfo.graphicsMemorySize,
                    gpuVendorId = SystemInfo.graphicsDeviceVendorID,
                    systemMemory = SystemInfo.systemMemorySize,
                },
                assemblies = assembliesInfo,
            };

            return new JsonWriter().Write(report);
        }

        private static string getInformationalVersion(Assembly assembly)
        {
            return System.Diagnostics.FileVersionInfo.GetVersionInfo(assembly.Location).ProductVersion;
        }

        private static HashSet<String> warnedAssemblies = new HashSet<String>();

        private static string getAssemblyTitle(Assembly assembly)
        {
            try
            {
                var attr = assembly.GetCustomAttributes(typeof(AssemblyTitleAttribute), false).OfType<AssemblyTitleAttribute>().FirstOrDefault();
                if (attr == null) { return String.Empty; }
                return attr.Title;
            }
            catch (TypeLoadException e)
            {
                var name = assembly.GetName().Name;
                if (!warnedAssemblies.Contains(name))
                {
                    warnedAssemblies.Add(name);
                    Debug.LogError(String.Format("[ModStatistics] Error while inspecting assembly {0}. This probably means that {0} is targeting a runtime other than .NET 3.5. Please notify the author of {0} of this error.\n\n{1}", name, e));
                }
                return null;
            }
        }

        private enum Platform
        {
            Windows,
            Linux,
            Mac
        }

        private static Platform getRunningPlatform()
        {
            var platform = Environment.OSVersion.Platform;
            if (platform == PlatformID.Unix)
            {
                if (Directory.Exists("/Applications") && Directory.Exists("/Users") && Directory.Exists("/Volumes") && Directory.Exists("/System"))
                {
                    return Platform.Mac;
                }
                else
                {
                    return Platform.Linux;
                }
            }
            else if (platform == PlatformID.MacOSX)
            {
                return Platform.Mac;
            }
            else
            {
                return Platform.Windows;
            }
        }

        private static string getAssemblyHash(Assembly assembly)
        {
            byte[] hash;
            using (var sha2 = SHA256.Create()) {
                using (var stream = File.OpenRead(assembly.Location)) {
                    hash = sha2.ComputeHash(stream);
                }
            }
            var sb = new StringBuilder();
            foreach (var b in hash)
            {
                sb.Append(b.ToString("X2"));
            }
            return sb.ToString();
        }

        private static bool installedWithSteam()
        {
            var path = KSPUtil.ApplicationRootPath;
            return path.Contains(@"SteamApps\common") || path.Contains(@"SteamApps/common");
        }
    }
}