Synnefo » Pithos MS Client

#region

/* -----------------------------------------------------------------------

 * <copyright file="StatusAgent.cs" company="GRNet">

 * 

 * Copyright 2011-2012 GRNET S.A. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or

 * without modification, are permitted provided that the following

 * conditions are met:

 *

 *   1. Redistributions of source code must retain the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer.

 *

 *   2. Redistributions in binary form must reproduce the above

 *      copyright notice, this list of conditions and the following

 *      disclaimer in the documentation and/or other materials

 *      provided with the distribution.

 *

 *

 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * The views and conclusions contained in the software and

 * documentation are those of the authors and should not be

 * interpreted as representing official policies, either expressed

 * or implied, of GRNET S.A.

 * </copyright>

 * -----------------------------------------------------------------------

 */

#endregion

using System;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.Data;

using System.Data.SqlServerCe;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Threading;

using System.Threading.Tasks;

using NHibernate;

using NHibernate.Cfg;

using NHibernate.Cfg.MappingSchema;

using NHibernate.Criterion;

using NHibernate.Dialect;

using NHibernate.Linq;

using NHibernate.Mapping.ByCode;

using NHibernate.Tool.hbm2ddl;

using Pithos.Interfaces;

using Pithos.Network;

using log4net;

using Environment = System.Environment;

namespace Pithos.Core.Agents

{

    [Export(typeof(IStatusChecker)),Export(typeof(IStatusKeeper))]

    public class StatusAgent:IStatusChecker,IStatusKeeper

    {

        private static readonly ILog Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        [System.ComponentModel.Composition.Import]

        public IPithosSettings Settings { get; set; }

        [System.ComponentModel.Composition.Import]

        public IStatusNotification StatusNotification { get; set; }

        //private Agent<Action> _persistenceAgent;

        public StatusAgent()

        {

            var appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);

            _pithosDataPath = Path.Combine(appDataPath, "GRNET\\PITHOS");

            if (!Directory.Exists(_pithosDataPath))

                Directory.CreateDirectory(_pithosDataPath);

            var dbPath = Path.Combine(_pithosDataPath, "pithos.sdf");

            //MigrateOldDb(dbPath, appDataPath);

            var cfg = Configure(dbPath);

            var connectionString = "Data Source=" + dbPath;

            using (var sqlCeEngine = new SqlCeEngine(connectionString))

            {

                if (!File.Exists(dbPath))

                {

                    sqlCeEngine.CreateDatabase();

                    new SchemaExport(cfg).Execute(true, true, false);

                    _factory = cfg.BuildSessionFactory();

                    using (var session = _factory.OpenStatelessSession())

                    {

                        session.Insert(new PithosVersion {Id = 1, Version = "0.0.0.0"});

                    }

                }

                else

                {

                    try

                    {

                        if (!sqlCeEngine.Verify(VerifyOption.Enhanced))

                            sqlCeEngine.Repair(connectionString, RepairOption.RecoverAllOrFail);

                    }

                    catch(SqlCeException ex)

                    {

                        //Rethrow except for sharing errors while repairing

                        if (ex.NativeError != 25035)

                            throw;

                    }

                    var update = new SchemaUpdate(cfg);

                    update.Execute(script=>Log.WarnFormat("[DBUPDATE] : {0}",script),true);

                    _factory = cfg.BuildSessionFactory();                    

                }

                UpgradeDatabase();

            }

        }

        private void UpgradeDatabase()

        {

            using (var session = _factory.OpenSession())

            {

                var storedVersion = session.Get<PithosVersion>(1);

                var actualVersion = Assembly.GetEntryAssembly().GetName().Version;

                if (actualVersion == new Version(storedVersion.Version)) 

                    return;

                storedVersion.Version = actualVersion.ToString();

                session.Update(storedVersion);

                session.Flush();

            }

        }

        private static Configuration Configure(string pithosDbPath)

        {

            if (String.IsNullOrWhiteSpace(pithosDbPath))

                throw new ArgumentNullException("pithosDbPath");

            if (!Path.IsPathRooted(pithosDbPath))

                throw new ArgumentException("path must be a rooted path", "pithosDbPath");

            Contract.EndContractBlock();

            var cfg = new Configuration();                

                cfg.DataBaseIntegration(db=>

                                         {

                                             db.Dialect<MsSqlCe40Dialect>();

                                             db.ConnectionString = "Data Source=" + pithosDbPath;

                                             db.AutoCommentSql = true;

                                             db.KeywordsAutoImport = Hbm2DDLKeyWords.AutoQuote;

                                             db.SchemaAction = SchemaAutoAction.Update;

                                             db.LogSqlInConsole = false;                                             

                                         })                                                     

                .SessionFactory()                      

                    .GenerateStatistics()                    

                    .Integrate.Schema

                        .Updating();            

            var mapping = GetMapping();            

            cfg.AddMapping(mapping);

            return cfg;

        }

        private static HbmMapping GetMapping()

        {

            var mapper = new ModelMapper();

            mapper.Class<FileState>(fm =>

                                        {

                                            fm.Id(x => x.Id, m => m.Generator(Generators.GuidComb));

                                            fm.Property(x => x.ObjectID, m =>

                                            {

                                                m.Index("IX_FileState_ObjectID");

                                            });

                                            fm.Property(x => x.FilePath, m =>

                                            {

                                                m.Unique(true);

                                                m.UniqueKey("U_FileState_FilePath");

                                                m.Index("IX_FileState_FilePath");                                                

                                                m.Length(1024);

                                            });

                                            fm.Property(x => x.OverlayStatus);

                                            fm.Property(x => x.FileStatus);

                                            fm.Property(x => x.ConflictReason);

                                            fm.Property(x => x.Checksum, m => m.Length(64));

                                            fm.Property(x => x.ETag, m => m.Length(64));

                                            fm.Property(x => x.Hashes, m => m.Type(NHibernateUtil.StringClob));

                                            fm.Property(x => x.LastWriteDate);

                                            fm.Property(x => x.LastLength);

                                            fm.Property(x => x.Version);

                                            fm.Property(x => x.VersionTimeStamp);

                                            fm.Property(x => x.IsShared);

                                            fm.Property(x => x.SharedBy);

                                            fm.Property(x => x.ShareWrite);

                                            fm.Property(x => x.IsFolder);

                                            fm.Property(x => x.Modified);                                            

                                        });

            mapper.Class<PithosVersion>(fm =>

                                        {

                                            fm.Id(x => x.Id, m => m.Generator(Generators.Assigned));

                                            fm.Property(x => x.Version, m => m.Length(20));

                                        });

            var mapping = mapper.CompileMappingFor(new[] {typeof (FileState),typeof(PithosVersion)});

            return mapping;

        }

        public void StartProcessing(CancellationToken token)

        {

        }

        public void Stop()

        {

        }

        public void ProcessExistingFiles(IEnumerable<FileInfo> existingFiles)

        {

            if (existingFiles == null)

                throw new ArgumentNullException("existingFiles");

            Contract.EndContractBlock();

            //Find new or matching files with a left join to the stored states

            using (var session = _factory.OpenSession())

            {

                var fileStates = session.Query<FileState>().ToList();

                var currentFiles = from file in existingFiles

                                   join state in fileStates on file.FullName.ToLower() equals state.FilePath.ToLower()

                                       into

                                       gs

                                   from substate in gs.DefaultIfEmpty()

                                   select Tuple.Create(file, substate);

                //To get the deleted files we must get the states that have no corresponding

                //files. 

                //We can't use the File.Exists method inside a query, so we get all file paths from the states

                var statePaths = (from state in fileStates

                                  select new {state.Id, state.FilePath}).ToList();

                //and check each one

                var missingStates = (from path in statePaths

                                     where !File.Exists(path.FilePath) && !Directory.Exists(path.FilePath)

                                     select path.Id).ToList();

                //Finally, retrieve the states that correspond to the deleted files            

                var deletedFiles = from state in fileStates

                                   where missingStates.Contains(state.Id)

                                   select Tuple.Create(default(FileInfo), state);

                var pairs = currentFiles.Union(deletedFiles).ToList();

                i = 1;

                var total = pairs.Count;

                foreach (var pair in pairs)

                {

                    ProcessFile(session,total, pair);

                }

                session.Flush();

            }

        }

        int i = 1;

        private void ProcessFile(ISession session,int total, System.Tuple<FileInfo, FileState> pair)

        {

            var idx = Interlocked.Increment(ref i);

            using (StatusNotification.GetNotifier("Indexing file {0} of {1}", "Indexed file {0} of {1} ", true,idx, total))

            {

                var fileState = pair.Item2;

                var file = pair.Item1;

                if (fileState == null)

                {

                    //This is a new file                        

                    var createState = FileState.CreateFor(file,StatusNotification);                    

                    session.Save(createState);

                    //_persistenceAgent.Post(createState.Create);

                }

                else if (file == null)

                {

                    //This file was deleted while we were down. We should mark it as deleted

                    //We have to go through UpdateStatus here because the state object we are using

                    //was created by a different ORM session.

                    UpdateStatusDirect(session,fileState.Id, FileStatus.Deleted);

                    //_persistenceAgent.Post(() => UpdateStatusDirect((Guid) fileState.Id, FileStatus.Deleted));

                }

                //else

                //{

                //    //This file has a matching state. Need to check for possible changes

                //    //To check for changes, we use the cheap (in CPU terms) MD5 algorithm

                //    //on the entire file.

                //    var hashString = file.ComputeShortHash(StatusNotification);

                //    Debug.Assert(hashString.Length==32);

                //    //TODO: Need a way to attach the hashes to the filestate so we don't

                //    //recalculate them each time a call to calculate has is made

                //    //We can either store them to the filestate or add them to a 

                //    //dictionary

                //    //If the hashes don't match the file was changed

                //    if (fileState.ETag != hashString)

                //    {

                //        _persistenceAgent.Post(() => UpdateStatusDirect((Guid) fileState.Id, FileStatus.Modified));

                //    }

                //}

            }

        }

        private int UpdateStatusDirect(ISession session,Guid id, FileStatus status)

        {

            using (ThreadContext.Stacks["StatusAgent"].Push("UpdateStatusDirect"))

            {

                try

                {

                        //var updatecmd = session.CreateSQLQuery(

                    var updatecmd = session.CreateQuery(

                        "update FileState set FileStatus= :fileStatus, Modified=:modified where Id = :id  ")

                        .SetGuid("id", id)

                        .SetEnum("fileStatus", status)

                        .SetDateTime("modified",DateTime.Now);

                    var affected = updatecmd.ExecuteUpdate();

                        session.Flush();

                    return affected;

                }

                catch (Exception exc)

                {

                    Log.Error(exc.ToString());

                    throw;

                }

            }

        }

        public string BlockHash { get; set; }

        public int BlockSize { get; set; }

        public void ChangeRoots(string oldPath, string newPath)

        {

            if (String.IsNullOrWhiteSpace(oldPath))

                throw new ArgumentNullException("oldPath");

            if (!Path.IsPathRooted(oldPath))

                throw new ArgumentException("oldPath must be an absolute path", "oldPath");

            if (String.IsNullOrWhiteSpace(newPath))

                throw new ArgumentNullException("newPath");

            if (!Path.IsPathRooted(newPath))

                throw new ArgumentException("newPath must be an absolute path", "newPath");

            Contract.EndContractBlock();

            ChangeRootPath(oldPath,newPath);

        }

        private readonly string _pithosDataPath;

        private readonly ISessionFactory _factory;

        public FileState GetStateByFilePath(string path)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted", "path");

            Contract.EndContractBlock();

            try

            {

                using(var session=_factory.OpenStatelessSession())

                {

                    var state=session.Query<FileState>().SingleOrDefault(s => s.FilePath == path);

                    if (state==null)

                        return null;

                    state.FilePath=state.FilePath??String.Empty;

                    state.OverlayStatus = state.OverlayStatus ??FileOverlayStatus.Unversioned;

                    state.FileStatus = state.FileStatus ?? FileStatus.Missing;

                    state.Checksum = state.Checksum ?? String.Empty;

                    state.ETag = state.ETag ?? String.Empty;

                    state.SharedBy = state.SharedBy ?? String.Empty;

                    return state;

                }

            }

            catch (Exception exc)

            {

                Log.ErrorFormat(exc.ToString());

                throw;

            }            

        }

        public FileOverlayStatus GetFileOverlayStatus(string path)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted", "path");

            Contract.EndContractBlock();

            try

            {

                using(var session=_factory.OpenStatelessSession())

                {

                    return (from state in session.Query<FileState>()

                            where state.FilePath == path

                            select state.OverlayStatus)

                            .Single()

                            .GetValueOrDefault(FileOverlayStatus.Unversioned);

                }

            }

            catch (Exception exc)

            {

                Log.ErrorFormat(exc.ToString());

                return FileOverlayStatus.Unversioned;

            }

        }

        public void SetFileOverlayStatus(string path, FileOverlayStatus overlayStatus)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted","path");

            Contract.EndContractBlock();

            StoreOverlayStatus(path,overlayStatus);

        }

        public void SetFileState(string path, FileStatus fileStatus, FileOverlayStatus overlayStatus, string conflictReason)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted", "path");

            Contract.EndContractBlock();

            Debug.Assert(!path.Contains(FolderConstants.CacheFolder));

            Debug.Assert(!path.EndsWith(".ignore"));

            using (ThreadContext.Stacks["StatusAgent"].Push("SetFileState"))

            {

                try

                {

                    using (var session = _factory.OpenSession())

                    using (var tx=session.BeginTransaction(IsolationLevel.ReadCommitted))

                    {

                        var state = session.Query<FileState>().FirstOrDefault(s => s.FilePath == path)

                                          ?? 

                                          ((path.Length<=260) 

                                               ?FileState.CreateFor(FileInfoExtensions.FromPath(path), StatusNotification)

                                               :new FileState{

                                                   FilePath = path,

                                                   OverlayStatus = FileOverlayStatus.Conflict,

                                                   FileStatus = Pithos.Core.FileStatus.Conflict,               

                                                   ETag=String.Empty,

                                                   //LastMD5=md5,

                                                   LastWriteDate = DateTime.Today,

                                                   LastLength = 0,

                                                   IsFolder=Directory.Exists(path),

                                                   Modified=DateTime.Now

                                               });

                        state.FileStatus = fileStatus;

                        state.OverlayStatus = overlayStatus;

                        state.ConflictReason = conflictReason;

                        state.Modified = DateTime.Now;

                        session.SaveOrUpdate(state);

/*

                        //var updatecmd = session.CreateSQLQuery("update FileState set OverlayStatus= :overlayStatus, FileStatus= :fileStatus,ConflictReason= :conflictReason where FilePath = :path ")

                        var updatecmd = session.CreateQuery("update FileState set OverlayStatus= :overlayStatus, FileStatus= :fileStatus,ConflictReason= :conflictReason, Modified=:modified where FilePath = :path")

                            .SetString("path", path)

                            .SetEnum("fileStatus", fileStatus)

                            .SetEnum("overlayStatus", overlayStatus)

                            .SetString("conflictReason", conflictReason)

                            .SetDateTime("modified",DateTime.Now);

                        var affected = updatecmd.ExecuteUpdate();

                        if (affected == 0)

                        {

                            //Can happen when downloading a new file

                            var createdState = FileState.CreateFor(FileInfoExtensions.FromPath(path), StatusNotification);

                            createdState.FileStatus = fileStatus;

                            createdState.OverlayStatus = overlayStatus;                            

                            createdState.ConflictReason = conflictReason;

                            session.Save(createdState);

                            //createdState.Create();

                        }*/

                        session.Flush();

                        tx.Commit();                        

                    }

                }

                catch (Exception exc)

                {

                    Log.Error(exc.ToString());

                    throw;

                }

            }            

        }

        public void StoreInfo(string path, ObjectInfo objectInfo, TreeHash treeHash)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (treeHash==null)

                throw new ArgumentNullException("treeHash");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted", "path");

            if (objectInfo == null)

                throw new ArgumentNullException("objectInfo", "objectInfo can't be empty");

            Contract.EndContractBlock();

            StoreInfoDirect(path, objectInfo, treeHash);

        }

        public void StoreInfo(string path, ObjectInfo objectInfo)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted", "path");

            if (objectInfo == null)

                throw new ArgumentNullException("objectInfo", "objectInfo can't be empty");

            Contract.EndContractBlock();

            StoreInfoDirect(path, objectInfo, null);

        }

        private void StoreInfoDirect(string path, ObjectInfo objectInfo,TreeHash treeHash)

        {

            try

            {

                    using (var session = _factory.OpenSession())

                    using (var tx=session.BeginTransaction(IsolationLevel.ReadCommitted))

                    {                        

                        //An entry for the new path may exist, 

                        IQuery deletecmd = session.CreateQuery(

                            "delete from FileState where FilePath=:path and ObjectID is null")

                            .SetString("path", path);

                        deletecmd.ExecuteUpdate();

                        //string md5=treeHash.NullSafe(t=>t.MD5);                        

                        string hashes = treeHash.NullSafe(t => t.ToJson());

                        var info = FileInfoExtensions.FromPath(path);

                        var lastWriteTime = info.LastWriteTime;

                        var isFolder = (info is DirectoryInfo);

                        var lastLength = isFolder ? 0 : ((FileInfo) info).Length;

                        var state = session.Query<FileState>().SingleOrDefault(s => s.ObjectID == (objectInfo.UUID??"?"))   //Handle null UUIDs

                                     ?? session.Query<FileState>().SingleOrDefault(s => s.FilePath == path)

                                     ?? new FileState();

                        state.FilePath = path;

                        state.IsFolder = isFolder;

                        state.LastWriteDate = lastWriteTime;

                        state.LastLength = lastLength;

                        state.Checksum = objectInfo.X_Object_Hash;

                        state.Hashes = hashes;

                        state.Version = objectInfo.Version.GetValueOrDefault();

                        state.VersionTimeStamp = objectInfo.VersionTimestamp;

                        state.ETag = objectInfo.ETag;

                        state.FileStatus = FileStatus.Unchanged;

                        state.OverlayStatus = FileOverlayStatus.Normal;

                        state.ObjectID = objectInfo.UUID;

                        state.Modified = DateTime.Now;

                        session.SaveOrUpdate(state);

                        session.Flush();

                        tx.Commit();

                        if (Log.IsDebugEnabled)

                            Log.DebugFormat("DebugDB [{0}]:[{1}]\r\n{2}", path, objectInfo.UUID, objectInfo.X_Object_Hash);

                    }

            }

            catch (Exception exc)

            {

                Log.ErrorFormat("Failed to update [{0}]:[{1}]\r\n{2}",path,objectInfo.UUID, exc);

                throw;

            }

        }

        public void SetFileStatus(string path, FileStatus status)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted", "path");

            Contract.EndContractBlock();

            using (ThreadContext.Stacks["StatusAgent"].Push("SetFileStatus"))

            {

                try

                {                    

                    using (var session = _factory.OpenSession())

                    using (var tx=session.BeginTransaction(IsolationLevel.ReadCommitted))

                    {

                        //var updatecmd = session.CreateSQLQuery(

                        var updatecmd = session.CreateQuery(

                            "update FileState set FileStatus= :fileStatus, Modified=:modified where FilePath = :path ")

                            .SetString("path", path)

                            .SetEnum("fileStatus", status)

                            .SetDateTime("modified",DateTime.Now);

                        var affected = updatecmd.ExecuteUpdate();

                        if (affected == 0)

                        {                            

                            var createdState = FileState.CreateFor(FileInfoExtensions.FromPath(path), StatusNotification);

                            createdState.FileStatus = status;

                            session.Save(createdState);

                        }

                        session.Flush();

                        tx.Commit();

                    }

                }

                catch (Exception exc)

                {

                    Log.Error(exc.ToString());

                    throw;

                }

            }            

        }

        public FileStatus GetFileStatus(string path)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted", "path");

            Contract.EndContractBlock();

            using(var session=_factory.OpenStatelessSession())

                return (from state in session.Query<FileState>()

                        select state.FileStatus).SingleOrDefault()??FileStatus.Missing;

        }

        /// <summary>

        /// Deletes the status of the specified file

        /// </summary>

        /// <param name="path"></param>

        public void ClearFileStatus(string path)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted", "path");

            Contract.EndContractBlock();

            using(var session=_factory.OpenSession())

            {

                DeleteDirect(session,path);

                session.Flush();                

            }

        }

        /// <summary>

        /// Deletes the status of the specified folder and all its contents

        /// </summary>

        /// <param name="path"></param>

        public void ClearFolderStatus(string path)

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

            if (!Path.IsPathRooted(path))

                throw new ArgumentException("The path must be rooted", "path");

            Contract.EndContractBlock();

            using (ThreadContext.Stacks["StatusAgent"].Push("DeleteDirect"))

            {

                try

                {

                    using (var session = _factory.OpenSession())

                    {

                        DeleteDirect(session,path);

                        session.Flush();

                    }

                }

                catch (Exception exc)

                {

                    Log.Error(exc.ToString());

                    throw;

                }

            }            

        }

        public IEnumerable<FileState> GetChildren(FileState fileState)

        {

            if (fileState == null)

                throw new ArgumentNullException("fileState");

            Contract.EndContractBlock();

            var session = _factory.GetCurrentSession();

            var children = from state in session.Query<FileState>()

                           where state.FilePath.StartsWith(fileState.FilePath + "\\")

                           select state;

            return children;

        }

        public void EnsureFileState(string path)

        {

            var existingState = GetStateByFilePath(path);

            if (existingState != null)

                return;

            var fileInfo = FileInfoExtensions.FromPath(path);

            using (var session=_factory.OpenSession())

            {

                var newState = FileState.CreateFor(fileInfo,StatusNotification);

                newState.FileStatus=FileStatus.Missing;

                session.SaveOrUpdate(newState);

                session.Flush();

                //_persistenceAgent.PostAndAwait(newState.CreateAndFlush).Wait();

            }

        }

        private void DeleteDirect(ISession session,string filePath)

        {

            using (ThreadContext.Stacks["StatusAgent"].Push("DeleteDirect"))

            {

                try

                {

                    var deletes= session.CreateQuery("delete from FileState where FilePath = :path")

                        .SetParameter("path", filePath)

                        .ExecuteUpdate();                    

                }

                catch (Exception exc)

                {

                    Log.Error(exc.ToString());

                    throw;

                }

            }

        }

        public void CleanupOrphanStates()

        {

            //Orphan states are those that do not correspond to an account, ie. their paths

            //do not start with the root path of any registered account

            var roots=(from account in Settings.Accounts

                      select account.RootPath).ToList();

            using (var session = _factory.OpenSession())

            {

                var allStates = from state in session.Query<FileState>()

                                select state.FilePath;

                foreach (var statePath in allStates)

                {

                    if (!roots.Any(root => statePath.StartsWith(root, StringComparison.InvariantCultureIgnoreCase)))

                        this.DeleteDirect(session,statePath);

                }

                session.Flush();

            }

        }

        public void SaveCopy<T>(T state) where T:class

        {

            using (var session = _factory.OpenSession())

            {

                session.Merge(state);

                session.Flush();

            }

        }

        public void CleanupStaleStates(AccountInfo accountInfo, List<ObjectInfo> objectInfos)

        {

            if (accountInfo == null)

                throw new ArgumentNullException("accountInfo");

            if (objectInfos == null)

                throw new ArgumentNullException("objectInfos");

            Contract.EndContractBlock();

            //Stale states are those that have no corresponding local or server file

            var agent=FileAgent.GetFileAgent(accountInfo);

            var localFiles=agent.EnumerateFiles();

            var localSet = new HashSet<string>(localFiles);

            //RelativeUrlToFilePath will fail for

            //infos of accounts, containers which have no Name

            var serverFiles = from info in objectInfos

                              where info.Name != null

                              select Path.Combine(accountInfo.AccountPath,info.RelativeUrlToFilePath(accountInfo.UserName));

            var serverSet = new HashSet<string>(serverFiles);

            using (var session = _factory.OpenSession())

            {

                var allStates = from state in session.Query<FileState>()

                                where state.FilePath.StartsWith(agent.RootPath)

                                select state.FilePath;

                var stateSet = new HashSet<string>(allStates);

                stateSet.ExceptWith(serverSet);

                stateSet.ExceptWith(localSet);

                foreach (var remainder in stateSet)

                {

                    DeleteDirect(session,remainder);

                }

                session.Flush();

            }

        }

        public static TreeHash CalculateTreeHash(FileSystemInfo fileInfo, AccountInfo accountInfo, FileState fileState, byte hashingParallelism, CancellationToken cancellationToken, IProgress<HashProgress> progress)

        {

            fileInfo.Refresh();

            //If the file doesn't exist, return the empty treehash

            if (!fileInfo.Exists)

                return TreeHash.Empty;

            //FileState may be null if there is no stored state for this file

            //if (fileState==null)

                return TaskEx.Run(async () =>await Signature.CalculateTreeHashAsync(fileInfo,

                                                 accountInfo.BlockSize,

                                                 accountInfo.BlockHash,

                                                 hashingParallelism,

                                                 cancellationToken, progress).ConfigureAwait(false)).Result;

            //Can we use the stored hashes?

            //var localTreeHash = fileState.LastMD5 == Signature.CalculateMD5(fileInfo)

            //                        ? TreeHash.Parse(fileState.Hashes)

            //                        : Signature.CalculateTreeHashAsync(fileInfo,

            //                                                           accountInfo.BlockSize,

            //                                                           accountInfo.BlockHash,

            //                                                           hashingParallelism,

            //                                                           cancellationToken, progress);

            //return localTreeHash;

        }

        private object ExecuteWithRetry(Func<ISession, object, object> call, object state)

        {

            int retries = 3;

            while (retries > 0)

                try

                {

                    using (var session=_factory.OpenSession())

                    {

                        var result=call(session, state);

                        session.Flush();

                        return result;

                    }

                }

                catch (Exception/* ActiveRecordException */)

                {

                    retries--;

                    if (retries <= 0)

                        throw;

                }

            return null;

        }

        //TODO: Must separate between UpdateChecksum and UpdateFileHashes

        public  void ChangeRootPath(string oldPath, string newPath)

        {

            if (String.IsNullOrWhiteSpace(oldPath))

                throw new ArgumentNullException("oldPath");

            if (!Path.IsPathRooted(oldPath))

                throw new ArgumentException("oldPath must be an absolute path", "oldPath");

            if (string.IsNullOrWhiteSpace(newPath))

                throw new ArgumentNullException("newPath");

            if (!Path.IsPathRooted(newPath))

                throw new ArgumentException("newPath must be an absolute path", "newPath");

            Contract.EndContractBlock();

            //Ensure the paths end with the same character

            if (!oldPath.EndsWith("\\"))

                oldPath = oldPath + "\\";

            if (!newPath.EndsWith("\\"))

                newPath = newPath + "\\";

            ExecuteWithRetry((session, instance) =>

            {

                const string hqlUpdate =

                    "update FileState set FilePath = replace(FilePath,:oldPath,:newPath), Modified=:modified where FilePath like :oldPath || '%' ";

                var renames = session.CreateQuery(hqlUpdate)

                    .SetString("oldPath", oldPath)

                    .SetString("newPath", newPath)

                    .SetDateTime("modified",DateTime.Now)

                    .ExecuteUpdate();

                return renames;

            }, null);

        }

        /// <summary>

        /// Mark Unversioned all FileState rows from the database whose path

        /// starts with one of the removed paths

        /// </summary>

        /// <param name="removed"></param>

        public void UnversionPaths(List<string> removed)

        {

            if (removed == null)

                return;

            if (removed.Count == 0)

                return;

            //Create a disjunction (list of OR statements

            var disjunction = new Disjunction();

            foreach (var path in removed)

            {

                //with the restriction FileState.FilePath like '@path%'

                disjunction.Add(Restrictions.On<FileState>(s => s.FilePath)

                                    .IsLike(path, MatchMode.Start));

            }

            //Generate a query from the disjunction

            var query = QueryOver.Of<FileState>().Where(disjunction);

            using (var session = _factory.OpenSession())

            using (var tx = session.BeginTransaction())

            {

                var states = query.GetExecutableQueryOver(session).List();

                foreach (var state in states)

                {

                    state.FileStatus = FileStatus.Unversioned;

                    state.OverlayStatus = FileOverlayStatus.Unversioned;

                    session.Update(state);

                }

                tx.Commit();

                session.Flush();

            }

        }

        public List<FileState> GetAllStates()

        {

            using(var session=_factory.OpenSession())

            {

                return session.Query<FileState>().ToList();

            }

        }

        public List<string> GetAllStatePaths()

        {

            using (var session = _factory.OpenSession())

            {

                return session.Query<FileState>().Select(state => state.FilePath).ToList();

            }

        }

        public List<FileState> GetConflictStates()

        {

            using (var session = _factory.OpenSession())

            {