Merge remote-tracking branch 'origin/master' into netstandard

osu.Game/IO/Archives/ArchiveReader.cs

@@ -0,0 +1,47 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using osu.Framework.IO.Stores;
+
+namespace osu.Game.IO.Archives
+{
+    public abstract class ArchiveReader : IDisposable, IResourceStore<byte[]>
+    {
+        /// <summary>
+        /// Opens a stream for reading a specific file from this archive.
+        /// </summary>
+        public abstract Stream GetStream(string name);
+
+        public abstract void Dispose();
+
+        /// <summary>
+        /// The name of this archive (usually the containing filename).
+        /// </summary>
+        public readonly string Name;
+
+        protected ArchiveReader(string name)
+        {
+            Name = name;
+        }
+
+        public abstract IEnumerable<string> Filenames { get; }
+
+        public virtual byte[] Get(string name)
+        {
+            using (Stream input = GetStream(name))
+            {
+                if (input == null)
+                    return null;
+
+                byte[] buffer = new byte[input.Length];
+                input.Read(buffer, 0, buffer.Length);
+                return buffer;
+            }
+        }
+
+        public abstract Stream GetUnderlyingStream();
+    }
+}

osu.Game/IO/Archives/LegacyFilesystemReader.cs

@@ -0,0 +1,34 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using osu.Framework.IO.File;
+
+namespace osu.Game.IO.Archives
+{
+    /// <summary>
+    /// Reads an extracted legacy beatmap from disk.
+    /// </summary>
+    public class LegacyFilesystemReader : ArchiveReader
+    {
+        private readonly string path;
+
+        public LegacyFilesystemReader(string path) : base(Path.GetFileName(path))
+        {
+            this.path = path;
+        }
+
+        public override Stream GetStream(string name) => File.OpenRead(Path.Combine(path, name));
+
+        public override void Dispose()
+        {
+            // no-op
+        }
+
+        public override IEnumerable<string> Filenames => Directory.GetFiles(path, "*", SearchOption.AllDirectories).Select(f => FileSafety.GetRelativePath(f, path)).ToArray();
+
+        public override Stream GetUnderlyingStream() => null;
+    }
+}

osu.Game/IO/Archives/ZipArchiveReader.cs

@@ -0,0 +1,50 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using SharpCompress.Archives.Zip;
+
+namespace osu.Game.IO.Archives
+{
+    public sealed class ZipArchiveReader : ArchiveReader
+    {
+        private readonly Stream archiveStream;
+        private readonly ZipArchive archive;
+
+        public ZipArchiveReader(Stream archiveStream, string name = null)
+            : base(name)
+        {
+            this.archiveStream = archiveStream;
+            archive = ZipArchive.Open(archiveStream);
+        }
+
+        public override Stream GetStream(string name)
+        {
+            ZipArchiveEntry entry = archive.Entries.SingleOrDefault(e => e.Key == name);
+            if (entry == null)
+                throw new FileNotFoundException();
+
+            // allow seeking
+            MemoryStream copy = new MemoryStream();
+
+            using (Stream s = entry.OpenEntryStream())
+                s.CopyTo(copy);
+
+            copy.Position = 0;
+
+            return copy;
+        }
+
+        public override void Dispose()
+        {
+            archive.Dispose();
+            archiveStream.Dispose();
+        }
+
+        public override IEnumerable<string> Filenames => archive.Entries.Select(e => e.Key).ToArray();
+
+        public override Stream GetUnderlyingStream() => archiveStream;
+    }
+}

osu.Game/IO/FileStore.cs

@@ -21,86 +21,94 @@ namespace osu.Game.IO
 
         public new Storage Storage => base.Storage;
 
-        public FileStore(Func<OsuDbContext> createContext, Storage storage) : base(createContext, storage.GetStorageForDirectory(@"files"))
+        public FileStore(IDatabaseContextFactory contextFactory, Storage storage) : base(contextFactory, storage.GetStorageForDirectory(@"files"))
         {
             Store = new StorageBackedResourceStore(Storage);
         }
 
         public FileInfo Add(Stream data, bool reference = true)
         {
-            var context = GetContext();
-
-            string hash = data.ComputeSHA2Hash();
-
-            var existing = context.FileInfo.FirstOrDefault(f => f.Hash == hash);
-
-            var info = existing ?? new FileInfo { Hash = hash };
-
-            string path = info.StoragePath;
-
-            // we may be re-adding a file to fix missing store entries.
-            if (!Storage.Exists(path))
+            using (var usage = ContextFactory.GetForWrite())
             {
-                data.Seek(0, SeekOrigin.Begin);
+                string hash = data.ComputeSHA2Hash();
 
-                using (var output = Storage.GetStream(path, FileAccess.Write))
-                    data.CopyTo(output);
+                var existing = usage.Context.FileInfo.FirstOrDefault(f => f.Hash == hash);
 
-                data.Seek(0, SeekOrigin.Begin);
+                var info = existing ?? new FileInfo { Hash = hash };
+
+                string path = info.StoragePath;
+
+                // we may be re-adding a file to fix missing store entries.
+                if (!Storage.Exists(path))
+                {
+                    data.Seek(0, SeekOrigin.Begin);
+
+                    using (var output = Storage.GetStream(path, FileAccess.Write))
+                        data.CopyTo(output);
+
+                    data.Seek(0, SeekOrigin.Begin);
+                }
+
+                if (reference || existing == null)
+                    Reference(info);
+
+                return info;
             }
-
-            if (reference || existing == null)
-                Reference(info);
-
-            return info;
         }
 
-        public void Reference(params FileInfo[] files) => reference(GetContext(), files);
-
-        private void reference(OsuDbContext context, FileInfo[] files)
+        public void Reference(params FileInfo[] files)
         {
-            foreach (var f in files.GroupBy(f => f.ID))
-            {
-                var refetch = context.Find<FileInfo>(f.First().ID) ?? f.First();
-                refetch.ReferenceCount += f.Count();
-                context.FileInfo.Update(refetch);
-            }
+            if (files.Length == 0) return;
 
-            context.SaveChanges();
+            using (var usage = ContextFactory.GetForWrite())
+            {
+                var context = usage.Context;
+
+                foreach (var f in files.GroupBy(f => f.ID))
+                {
+                    var refetch = context.Find<FileInfo>(f.First().ID) ?? f.First();
+                    refetch.ReferenceCount += f.Count();
+                    context.FileInfo.Update(refetch);
+                }
+            }
         }
 
-        public void Dereference(params FileInfo[] files) => dereference(GetContext(), files);
-
-        private void dereference(OsuDbContext context, FileInfo[] files)
+        public void Dereference(params FileInfo[] files)
         {
-            foreach (var f in files.GroupBy(f => f.ID))
-            {
-                var refetch = context.FileInfo.Find(f.Key);
-                refetch.ReferenceCount -= f.Count();
-                context.FileInfo.Update(refetch);
-            }
+            if (files.Length == 0) return;
 
-            context.SaveChanges();
+            using (var usage = ContextFactory.GetForWrite())
+            {
+                var context = usage.Context;
+
+                foreach (var f in files.GroupBy(f => f.ID))
+                {
+                    var refetch = context.FileInfo.Find(f.Key);
+                    refetch.ReferenceCount -= f.Count();
+                    context.FileInfo.Update(refetch);
+                }
+            }
         }
 
         public override void Cleanup()
         {
-            var context = GetContext();
-
-            foreach (var f in context.FileInfo.Where(f => f.ReferenceCount < 1))
+            using (var usage = ContextFactory.GetForWrite())
             {
-                try
+                var context = usage.Context;
+
+                foreach (var f in context.FileInfo.Where(f => f.ReferenceCount < 1))
                 {
-                    Storage.Delete(f.StoragePath);
-                    context.FileInfo.Remove(f);
-                }
-                catch (Exception e)
-                {
-                    Logger.Error(e, $@"Could not delete beatmap {f}");
+                    try
+                    {
+                        Storage.Delete(f.StoragePath);
+                        context.FileInfo.Remove(f);
+                    }
+                    catch (Exception e)
+                    {
+                        Logger.Error(e, $@"Could not delete beatmap {f}");
+                    }
                 }
             }
-
-            context.SaveChanges();
         }
     }
 }