Shared File Fix for Upload

[pithos-ms-client] / trunk / Pithos.Core / InMemStatusChecker.cs

diff --git a/trunk/Pithos.Core/InMemStatusChecker.cs b/trunk/Pithos.Core/InMemStatusChecker.cs
index e45b61f..bedd4c9 100644 (file)
--- a/trunk/Pithos.Core/InMemStatusChecker.cs
+++ b/trunk/Pithos.Core/InMemStatusChecker.cs
@@ -1,8 +1,12 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using System.Diagnostics.Contracts;
+using System.Linq;
+using System.Threading;
 using Pithos.Interfaces;
+using Pithos.Network;
 
 namespace Pithos.Core
 {
@@ -14,14 +18,14 @@ namespace Pithos.Core
 
         private readonly string[] _states = {"Normal", "Modified", "Conflict","Synch"};
 
-        Dictionary<string,FileOverlayStatus> _overlayCache=new Dictionary<string,FileOverlayStatus>();
-        Dictionary<string, FileStatus> _statusCache= new Dictionary<string, FileStatus>();
-        Dictionary<string, string> _checksums = new Dictionary<string, string>();
+        ConcurrentDictionary<string, FileOverlayStatus> _overlayCache = new ConcurrentDictionary<string, FileOverlayStatus>();
+        ConcurrentDictionary<string, FileStatus> _statusCache = new ConcurrentDictionary<string, FileStatus>();
+        ConcurrentDictionary<string, string> _checksums = new ConcurrentDictionary<string, string>();
 
         public FileOverlayStatus GetFileOverlayStatus(string path)
         {
             if (!_overlayCache.ContainsKey(path))
-                return FileOverlayStatus.NA;
+                return FileOverlayStatus.Unversioned;
 
             var pithosPath = Settings.PithosPath;
             if (path.StartsWith(pithosPath,true,null))
@@ -29,7 +33,34 @@ namespace Pithos.Core
                 var status = _overlayCache[path];
                 return status;
             }
-            return FileOverlayStatus.NA;
+            return FileOverlayStatus.Unversioned;
+        }
+
+        public void StoreUnversionedFiles(IEnumerable<FileInfo> paths)
+        {
+
+            var newFiles = (from file in paths
+                            where !_overlayCache.ContainsKey(file)
+                            select new {
+                                           FilePath = file,
+                                           OverlayStatus = FileOverlayStatus.Unversioned,
+                                           FileStatus = FileStatus.Created,
+                                           Checksum = Signature.CalculateMD5(file)
+                                       });
+            ConcurrentBag<string> files = new ConcurrentBag<string>();           
+            newFiles.ForAll(state =>
+                                {
+                                    _overlayCache[state.FilePath] = state.OverlayStatus;
+                                    _statusCache[state.FilePath] = state.FileStatus;
+                                    _checksums[state.FilePath] = state.Checksum;
+                                    files.Add(state.FilePath);
+                                });
+            return files.GetConsumingEnumerable();
+        }
+
+        public void Stop()
+        {
+            
         }
 
 
@@ -44,6 +75,43 @@ namespace Pithos.Core
             return _pithosStatus;
         }
 
+    public void SetStatus(string path, Action<FileState> setter)
+        {
+            throw new NotImplementedException();
+        }
+
+        ConcurrentDictionary<string, NetworkOperation> _networkState = new ConcurrentDictionary<string, NetworkOperation>();
+
+    
+        public void SetNetworkState(string path, NetworkOperation operation)
+        {
+            _networkState[path.ToLower()] = operation;
+            //Removing may fail so we store the "None" value anyway
+            if (operation == NetworkOperation.None)
+            {
+                NetworkOperation oldOperation;
+                _networkState.TryRemove(path, out oldOperation);
+            }
+        }
+
+        public NetworkOperation GetNetworkState(string path)
+        {
+            NetworkOperation operation;
+            if (_networkState.TryGetValue(path, out operation))
+                return operation;
+            return NetworkOperation.None;
+        }
+
+        public void StartProcessing(CancellationToken token)
+        {
+            
+        }
+
+        public string BlockHash { get; set; }
+
+        public int BlockSize { get; set; }
+        
+
         public void SetFileOverlayStatus(string path, FileOverlayStatus overlayStatus)
         {
             _overlayCache[path] = overlayStatus;
@@ -51,14 +119,16 @@ namespace Pithos.Core
 
         public void RemoveFileOverlayStatus(string path)
         {
-            _overlayCache.Remove(path);
+            FileOverlayStatus value;
+            _overlayCache.TryRemove(path, out value);
         }
 
         public void RenameFileOverlayStatus(string oldPath, string newPath)
         {
             var status=_overlayCache[oldPath];
-            _overlayCache[newPath] = status;            
-            _overlayCache.Remove(oldPath);
+            _overlayCache[newPath] = status;
+            FileOverlayStatus value;
+            _overlayCache.TryRemove(oldPath,out value);
         }
 
         public void SetFileStatus(string path, FileStatus status)
@@ -66,6 +136,33 @@ namespace Pithos.Core
             _statusCache[path] = status;
         }
 
+        public void SetFileState(string path, FileStatus fileStatus, FileOverlayStatus overlayStatus)
+        {
+            if (String.IsNullOrWhiteSpace(path))
+                throw new ArgumentNullException("path","path can't be empty");
+            _statusCache[path] = fileStatus;
+            _overlayCache[path] = overlayStatus;
+        }
+
+        public void StoreInfo(string path, ObjectInfo objectInfo)
+        {
+            if (String.IsNullOrWhiteSpace(path))
+                throw new ArgumentNullException("path", "path can't be empty");
+            if (objectInfo == null)
+                throw new ArgumentNullException("objectInfo", "objectInfo can't be empty");
+
+            _statusCache[path] = FileStatus.Unchanged;
+            _overlayCache[path] = FileOverlayStatus.Normal;
+            _checksums[path] = objectInfo.Hash;
+
+
+        }
+
+        public T GetStatus<T>(string path, Func<FileState, T> getter, T defaultValue)
+        {
+            throw new NotImplementedException();
+        }
+
         public FileStatus GetFileStatus(string path)
         {
             if (!_statusCache.ContainsKey(path))
@@ -75,7 +172,8 @@ namespace Pithos.Core
 
         public void ClearFileStatus(string path)
         {
-            _statusCache.Remove(path);
+            FileStatus value;
+            _statusCache.TryRemove(path,out value);
         }
 
         public void UpdateFileChecksum(string path, string checksum)