FileVersionManager.cs

Go to the documentation of this file.

// Copyright (c) 2014 Silicon Studio Corp. (http://siliconstudio.co.jp)
// This file is distributed under GPL v3. See LICENSE.md for details.
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using SiliconStudio.BuildEngine;
using SiliconStudio.Core.Diagnostics;
using SiliconStudio.Core.IO;
using SiliconStudio.Core.Storage;

namespace SiliconStudio.Assets
{
    public class FileVersionManager
    {
        private static readonly object TrackerLock = new object();
        private static FileVersionManager instance;
        private readonly FileVersionTracker tracker;
        private readonly Thread asyncRunner;
        private readonly AutoResetEvent asyncRequestAvailable;
        private readonly ConcurrentQueue<AsyncRequest> asyncRequests;
        private bool isDisposing;
        private bool isDisposed;

        private FileVersionManager()
        {
            // Environment.SpecialFolder.ApplicationData
            asyncRequestAvailable = new AutoResetEvent(false);
            asyncRequests = new ConcurrentQueue<AsyncRequest>();

            // Loads the file version cache
            tracker = FileVersionTracker.GetDefault();
            asyncRunner = new Thread(SafeAction.Wrap(ComputeFileHashAsyncRunner)) { IsBackground = true };
            asyncRunner.Start();
        }

        public static FileVersionManager Instance
        {
            get
            {
                lock (TrackerLock)
                {
                    if (instance != null)
                        return instance;

                    instance = new FileVersionManager();
                    AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
                    return instance;
                }
            }
        }

        public static void Shutdown()
        {
            lock (TrackerLock)
            {
                if (instance == null)
                    return;
                instance.Dispose();
                instance = null;
            }
        }

        public ObjectId ComputeFileHash(UFile path)
        {
            if (!File.Exists(path))
                return ObjectId.Empty;

            return tracker.ComputeFileHash(path);
        }


        public void ComputeFileHashAsync(UFile path, Action<UFile, ObjectId> fileHashCallback = null, CancellationToken? cancellationToken = null)
        {
            if (path == null) throw new ArgumentNullException("path");

            lock (asyncRequests)
            {
                asyncRequests.Enqueue(new AsyncRequest(path, fileHashCallback, cancellationToken));
            }
            asyncRequestAvailable.Set();
        }

        public void ComputeFileHashAsync(IEnumerable<UFile> paths, Action<UFile, ObjectId> fileHashCallback = null, CancellationToken? cancellationToken = null)
        {
            if (paths == null) throw new ArgumentNullException("paths");

            lock (asyncRequests)
            {
                foreach(var path in paths)
                    asyncRequests.Enqueue(new AsyncRequest(path, fileHashCallback, cancellationToken));
            }
            asyncRequestAvailable.Set();
        }

        private readonly HashSet<AsyncRequest> requestsToProcess = new HashSet<AsyncRequest>();

        private void ComputeFileHashAsyncRunner()
        {
            while (!isDisposing)
            {
                if (asyncRequestAvailable.WaitOne())
                {
                    lock (asyncRequests)
                    {
                        // Dequeue as much as possible in a single row
                        while (true)
                        {
                            AsyncRequest asyncRequest;
                            if (asyncRequests.TryDequeue(out asyncRequest))
                            {
                                requestsToProcess.Add(asyncRequest);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                }

                // Early exit
                if (isDisposing)
                {
                    return;
                }

                foreach (var request in requestsToProcess)
                {
                    if (isDisposing)
                    {
                        return;
                    }

                    if (request.CancellationToken.HasValue && request.CancellationToken.Value.IsCancellationRequested)
                    {
                        continue;
                    }

                    var hash = ComputeFileHash(request.File);

                    if (request.CancellationToken.HasValue && request.CancellationToken.Value.IsCancellationRequested)
                    {
                        continue;
                    }

                    if (isDisposing)
                    {
                        return;
                    }

                    if (request.FileHashCallback != null)
                    {
                        request.FileHashCallback(request.File, hash);
                    }
                }
                // Once we have processed the list, we can clear it
                requestsToProcess.Clear();
            }
        }

        private static void CurrentDomain_ProcessExit(object sender, EventArgs e)
        {
            Shutdown();
        }

        private void Dispose()
        {
            if (isDisposed)
                return;

            // Set to true and let the async runner thread terminates
            isDisposing = true;
            asyncRequestAvailable.Set();

            asyncRunner.Join();

            isDisposed = true;
        }

        private struct AsyncRequest : IEquatable<AsyncRequest>
        {
            public AsyncRequest(UFile file, Action<UFile, ObjectId> fileHashCallback, CancellationToken? cancellationToken)
            {
                File = file;
                FileHashCallback = fileHashCallback;
                CancellationToken = cancellationToken;
            }

            public readonly UFile File;

            public readonly Action<UFile, ObjectId> FileHashCallback;

            public readonly CancellationToken? CancellationToken;

            public bool Equals(AsyncRequest other)
            {
                return Equals(File, other.File) && Equals(FileHashCallback, other.FileHashCallback) && CancellationToken.Equals(other.CancellationToken);
            }

            public override bool Equals(object obj)
            {
                if (ReferenceEquals(null, obj)) return false;
                return obj is AsyncRequest && Equals((AsyncRequest)obj);
            }

            public override int GetHashCode()
            {
                unchecked
                {
                    int hashCode = (File != null ? File.GetHashCode() : 0);
                    hashCode = (hashCode*397) ^ (FileHashCallback != null ? FileHashCallback.GetHashCode() : 0);
                    hashCode = (hashCode*397) ^ CancellationToken.GetHashCode();
                    return hashCode;
                }
            }

            public static bool operator ==(AsyncRequest left, AsyncRequest right)
            {
                return left.Equals(right);
            }

            public static bool operator !=(AsyncRequest left, AsyncRequest right)
            {
                return !left.Equals(right);
            }
        }
    }
}