Fix temporary file path

ZeroLevel/Services/FileSystem/FSUtils.cs

@@ -321,7 +321,7 @@ namespace ZeroLevel.Services.FileSystem
 
         public static void PackFolder(string sourceFolder, string zipPath, Func<FileInfo, bool> selector = null)
         {
-            var tmp = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+            var tmp = FSUtils.GetAppLocalTemporaryDirectory();
             var tmpDir = Directory.CreateDirectory(tmp);
             var files = new DirectoryInfo(sourceFolder)
                 .GetFiles("*.*", SearchOption.AllDirectories)

ZeroLevel/Services/PartitionStorage/Partition/CompactKeyStorePartitionBuilder.cs

@@ -0,0 +1,156 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using ZeroLevel.Services.FileSystem;
+using ZeroLevel.Services.PartitionStorage.Interfaces;
+using ZeroLevel.Services.Serialization;
+
+namespace ZeroLevel.Services.PartitionStorage.Partition
+{
+    internal sealed class CompactKeyStorePartitionBuilder<TKey, TInput, TValue, TMeta>
+         : BasePartition<TKey, TInput, TValue, TMeta>, IStorePartitionBuilder<TKey, TInput, TValue>
+    {
+        private readonly Action<TKey, TInput> _storeMethod;
+
+        private long _totalRecords = 0;
+
+        public long TotalRecords { get { return _totalRecords; } }
+
+        public CompactKeyStorePartitionBuilder(StoreOptions<TKey, TInput, TValue, TMeta> options,
+            TMeta info,
+            IStoreSerializer<TKey, TInput, TValue> serializer)
+            : base(options, info, serializer)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+            if (options.ThreadSafeWriting)
+            {
+                _storeMethod = StoreDirectSafe;
+            }
+            else
+            {
+                _storeMethod = StoreDirect;
+            }
+        }
+
+        #region IStorePartitionBuilder
+
+
+        public void Store(TKey key, TInput value)
+        {
+            _storeMethod.Invoke(key, value);
+            Interlocked.Increment(ref _totalRecords);
+        }
+
+        public void CompleteAdding()
+        {
+            CloseWriteStreams();
+        }
+
+        public void Compress()
+        {
+            var files = Directory.GetFiles(_catalog);
+            if (files != null && files.Length > 0)
+            {
+                Parallel.ForEach(files, file => CompressFile(file));
+            }
+        }
+        public IEnumerable<StorePartitionKeyValueSearchResult<TKey, TInput>> Iterate()
+        {
+            var files = Directory.GetFiles(_catalog);
+            if (files != null && files.Length > 0)
+            {
+                foreach (var file in files)
+                {
+                    if (TryGetReadStream(file, out var reader))
+                    {
+                        using (reader)
+                        {
+                            while (reader.EOS == false)
+                            {
+                                var key = Serializer.KeyDeserializer.Invoke(reader);
+                                var val = Serializer.InputDeserializer.Invoke(reader);
+                                yield return new StorePartitionKeyValueSearchResult<TKey, TInput> { Key = key, Value = val, Status = SearchResult.Success };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        public void RebuildIndex() => RebuildIndexes();
+        #endregion
+
+        #region Private methods
+        private void StoreDirect(TKey key, TInput value)
+        {
+            var groupKey = _options.GetFileName(key, _info);
+            if (TryGetWriteStream(groupKey, out var stream))
+            {
+                Serializer.KeySerializer.Invoke(stream, key);
+                Thread.MemoryBarrier();
+                Serializer.InputSerializer.Invoke(stream, value);
+            }
+        }
+        private void StoreDirectSafe(TKey key, TInput value)
+        {
+            var groupKey = _options.GetFileName(key, _info);
+            bool lockTaken = false;
+            if (TryGetWriteStream(groupKey, out var stream))
+            {
+                Monitor.Enter(stream, ref lockTaken);
+                try
+                {
+                    Serializer.KeySerializer.Invoke(stream, key);
+                    Thread.MemoryBarrier();
+                    Serializer.InputSerializer.Invoke(stream, value);
+                }
+                finally
+                {
+                    if (lockTaken)
+                    {
+                        Monitor.Exit(stream);
+                    }
+                }
+            }
+        }
+
+        internal void CompressFile(string file)
+        {
+            var dict = new Dictionary<TKey, HashSet<TInput>>();
+            using (var reader = new MemoryStreamReader(new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.None, 4096 * 1024)))
+            {
+                while (reader.EOS == false)
+                {
+                    var key = Serializer.KeyDeserializer.Invoke(reader);
+                    if (false == dict.ContainsKey(key))
+                    {
+                        dict[key] = new HashSet<TInput>();
+                    }
+                    if (reader.EOS)
+                    {
+                        break;
+                    }
+                    var input = Serializer.InputDeserializer.Invoke(reader);
+                    dict[key].Add(input);
+                }
+            }
+            var tempFile = FSUtils.GetAppLocalTemporaryFile();
+            using (var writer = new MemoryStreamWriter(new FileStream(tempFile, FileMode.Create, FileAccess.Write, FileShare.None, 4096 * 1024)))
+            {
+                // sort for search acceleration
+                foreach (var pair in dict.OrderBy(p => p.Key))
+                {
+                    var v = _options.MergeFunction(pair.Value);
+                    writer.SerializeCompatible(pair.Key);
+                    writer.SerializeCompatible(v);
+                }
+            }
+            File.Delete(file);
+            File.Move(tempFile, file, true);
+        }
+        #endregion
+    }
+}

ZeroLevel/Services/PartitionStorage/Partition/InternalDirectHybridPartition.cs

@@ -0,0 +1,7 @@
+namespace ZeroLevel.Services.PartitionStorage.Partition
+{
+    internal class InternalDirectHybridPartition<TKey, TCompactKey>
+    {
+
+    }
+}

ZeroLevel/Services/PartitionStorage/Partition/StorePartitionAccessor.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using ZeroLevel.Services.FileSystem;
 using ZeroLevel.Services.PartitionStorage.Interfaces;
 using ZeroLevel.Services.PartitionStorage.Partition;
 
@@ -324,8 +325,7 @@ namespace ZeroLevel.Services.PartitionStorage
                 }
 
                 // 2. Temporary file from ranges
-                var tempPath = Path.GetTempPath();
+                var tempFile = FSUtils.GetAppLocalTemporaryFile();
-                var tempFile = Path.Combine(tempPath, Path.GetTempFileName());
 
                 using (var readStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096 * 1024))
                 {

ZeroLevel/Services/PartitionStorage/Partition/StorePartitionBuilder.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using ZeroLevel.Services.FileSystem;
 using ZeroLevel.Services.PartitionStorage.Interfaces;
 using ZeroLevel.Services.PartitionStorage.Partition;
 using ZeroLevel.Services.Serialization;
@@ -136,8 +137,7 @@ namespace ZeroLevel.Services.PartitionStorage
                     dict[key].Add(input);
                 }
             }
-            var tempPath = Path.GetTempPath();
+            var tempFile = FSUtils.GetAppLocalTemporaryFile();
-            var tempFile = Path.Combine(tempPath, Path.GetTempFileName());
             using (var writer = new MemoryStreamWriter(new FileStream(tempFile, FileMode.Create, FileAccess.Write, FileShare.None, 4096 * 1024)))
             {
                 // sort for search acceleration

ZeroLevel/ZeroLevel.csproj

@@ -6,16 +6,16 @@
 </Description>
     <Authors>ogoun</Authors>
     <Company>ogoun</Company>
-    <AssemblyVersion>3.3.8.4</AssemblyVersion>
+    <AssemblyVersion>3.3.8.5</AssemblyVersion>
-    <PackageReleaseNotes>PartitionStorage. TotalRecords, count of recorded and merged values</PackageReleaseNotes>
+    <PackageReleaseNotes>Fix temporary file path generation</PackageReleaseNotes>
     <PackageProjectUrl>https://github.com/ogoun/Zero/wiki</PackageProjectUrl>
     <Copyright>Copyright Ogoun 2022</Copyright>
     <PackageLicenseUrl></PackageLicenseUrl>
     <PackageIconUrl></PackageIconUrl>
     <RepositoryUrl>https://github.com/ogoun/Zero</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <Version>3.3.8.4</Version>
+    <Version>3.3.8.5</Version>
-    <FileVersion>3.3.8.4</FileVersion>
+    <FileVersion>3.3.8.5</FileVersion>
     <Platforms>AnyCPU;x64;x86</Platforms>
     <PackageIcon>zero.png</PackageIcon>
     <DebugType>full</DebugType>