Synnefo » Pithos MS Client

#region

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

 * <copyright file="FileState.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.Diagnostics.Contracts;

using System.IO;

using System.Reflection;

using System.Threading.Tasks;

using Castle.ActiveRecord;

using Castle.ActiveRecord.Framework;

using Castle.ActiveRecord.Queries;

using NHibernate.Criterion;

using Pithos.Core.Agents;

using Pithos.Interfaces;

using Pithos.Network;

using log4net;

namespace Pithos.Core

{

    using System;

    using System.Collections.Generic;    

    /// <summary>

    /// TODO: Update summary.

    /// </summary>

    [ActiveRecord]

    public class FileState : ActiveRecordLinqBase<FileState>

    {

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

        private IList<FileTag> _tags = new List<FileTag>();

        [PrimaryKey(PrimaryKeyType.Guid)]

        public Guid Id { get; set; }

        //[Property(Unique = true, UniqueKey = "IX_FileState_ObjectID")]

        [Property]

        public string ObjectID { get; set; }

        [Property(Unique = true, UniqueKey = "IX_FileState_FilePath")]

        public string FilePath { get; set; }

        [Property]

        public FileOverlayStatus OverlayStatus { get; set; }

        [Property]

        public FileStatus FileStatus { get; set; }

        [Property]

        public string ConflictReason { get; set; }

        private string _checksum;

        /// <summary>

        /// The tophash value of the file, calculated by using a Merkle hash with the SHA256 algorithm

        /// </summary>

        /// <remarks>

        /// The SHA256 algorithm is substantially more expenive than other algorithms.

        /// Recalculating the Checksum should be avoided whenever possible.

        /// </remarks>

        [Property]

        public string Checksum

        {

            get

            {

                return _checksum;

            }

            set

            {

                _checksum = value;

            }

        }

        /// <summary>

        /// An easy to calcualte hash over the entire file, used to detect file changes

        /// </summary>

        /// <remarks>The algorithm used to calculate this hash should be cheap</remarks>

        [Property(NotNull = true, Default = "")]

        public string ETag { get; set; }

        [Property(NotNull = true, Default = "")]

        public string LastMD5 { get; set; }

        [Property]

        public string Hashes { get; set; }

        [Property]

        public DateTime? LastWriteDate { get; set; }

        [Property]

        public long? LastLength { get; set; }

        [Property]

        public long? Version { get; set; }

        [Property]

        public DateTime? VersionTimeStamp { get; set; }

        [Property]

        public bool IsShared { get; set; }

        [Property]

        public string SharedBy { get; set; }

        [Property]

        public bool ShareWrite { get; set; }

        [Property]

        public bool IsFolder{ get; set; }

        [HasMany(Cascade = ManyRelationCascadeEnum.AllDeleteOrphan, Lazy = true, Inverse = true)]

        public IList<FileTag> Tags

        {

            get { return _tags; }

            set { _tags = value; }

        }

        [Property]

        public DateTime Modified { get; set; }

        public FileSystemInfo GetFileSystemInfo()

        {

            if (String.IsNullOrWhiteSpace(FilePath))

                throw new InvalidOperationException();

            Contract.EndContractBlock();

            return Directory.Exists(FilePath) ?

                (FileSystemInfo)new DirectoryInfo(FilePath)

                : new FileInfo(FilePath);

        }

        public string GetRelativeUrl(AccountInfo accountInfo)

        {

            if (accountInfo==null)

                throw new ArgumentNullException("accountInfo");

            Contract.EndContractBlock();

            var fsi=GetFileSystemInfo();

            return fsi.AsRelativeUrlTo(accountInfo.AccountPath);

        }

        /*public static FileState FindByFilePath(string absolutePath)

        {

            if (string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            try

            {

                return Queryable.FirstOrDefault(s => s.FilePath == absolutePath);

            }

            catch (Exception ex)

            {

                Log.Error(ex.ToString());

                throw;

            }

        }*/

       /* public static void DeleteByFilePath(string absolutePath)

        {

            if (string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            ExecuteWithRetry((session, instance) =>

                        {

                            const string hqlDelete = "delete FileState where FilePath = :path";

                            var deletedEntities = session.CreateQuery(hqlDelete)

                                .SetString("path", absolutePath)

                                .ExecuteUpdate();

                            return deletedEntities;

                        }, null);

        }*/

/*

        public static void StoreFileStatus(string absolutePath, FileStatus newStatus)

        {

            if (string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            ExecuteWithRetry((session, instance) =>

                                 {

                                     const string hqlUpdate =

                                         "update FileState set FileStatus= :status where FilePath = :path ";

                                     using (session.BeginTransaction())

                                     {

                                         var updatedEntities = session.CreateQuery(hqlUpdate)

                                             .SetString("path", absolutePath)

                                             .SetEnum("status", newStatus)

                                             .ExecuteUpdate();

                                         if (updatedEntities == 0)

                                         {

                                             var newState = new FileState

                                                                {

                                                                    FilePath = absolutePath,

                                                                    Id = Guid.NewGuid(),

                                                                    FileStatus = newStatus,

                                                                    IsFolder = Directory.Exists(absolutePath)

                                                                };

                                             newState.CreateAndFlush();

                                         }

                                         return null;

                                     }

                                 }, null);

        }

*/

        public static void StoreOverlayStatus(string absolutePath, FileOverlayStatus newStatus,string etag)

        {

            if (string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            ExecuteWithRetry((session, instance) =>

                        {

                            const string hqlUpdate =

                                "update FileState set OverlayStatus= :status where FilePath = :path ";

                            using (var tx=session.BeginTransaction())

                            {

                                var updatedEntities = session.CreateQuery(hqlUpdate)

                                    .SetString("path", absolutePath)

                                    .SetEnum("status", newStatus)

                                    .ExecuteUpdate();

                                if (updatedEntities == 0)

                                {

                                    var newState = new FileState

                                                       {

                                                           FilePath = absolutePath,

                                                           Id = Guid.NewGuid(),

                                                           OverlayStatus = newStatus,

                                                           ETag = etag ?? String.Empty,

                                                           LastMD5=String.Empty,

                                                           IsFolder = Directory.Exists(absolutePath)

                                                       };

                                    newState.CreateAndFlush();

                                }

                                tx.Commit();

                                return null;

                            }

                        }, null);

        }

/*

        public static void UpdateStatus(string absolutePath, FileStatus fileStatus, FileOverlayStatus overlayStatus)

        {

            if (string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            ExecuteWithRetry((session, instance) =>

                        {

                            const string hqlUpdate =

                                "update FileState set OverlayStatus= :overlayStatus, FileStatus= :fileStatus where FilePath = :path  ";

                            var updatedEntities = session.CreateQuery(hqlUpdate)

                                .SetString("path", absolutePath)

                                .SetEnum("fileStatus", fileStatus)

                                .SetEnum("overlayStatus", overlayStatus)

                                .ExecuteUpdate();

                            return updatedEntities;

                        }, null);

        }

*/

/*

        public static void UpdateStatus(string absolutePath, FileStatus fileStatus)

        {

            if (string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            ExecuteWithRetry((session, instance) =>

                        {

                            const string hqlUpdate =

                                "update FileState set FileStatus= :fileStatus where FilePath = :path  ";

                            var updatedEntities = session.CreateQuery(hqlUpdate)

                                .SetString("path", absolutePath)

                                .SetEnum("fileStatus", fileStatus)

                                .ExecuteUpdate();

                            return updatedEntities;

                        }, null);

        }

*/

        public static void RenameState(string oldPath, string newPath)

        {

            if (string.IsNullOrWhiteSpace(oldPath))

                throw new ArgumentNullException("oldPath");

            Contract.EndContractBlock();

            ExecuteWithRetry((session, instance) =>

                        {

                            const string hqlUpdate =

                                "update FileState set FilePath= :newPath where FilePath = :oldPath ";

                            var updatedEntities = session.CreateQuery(hqlUpdate)

                                .SetString("oldPath", oldPath)

                                .SetString("newPath", newPath)

                                .ExecuteUpdate();

                            return updatedEntities;

                        }, null);

        }

     /*   public static void UpdateStatus(Guid id, FileStatus fileStatus)

        {

            ExecuteWithRetry((session, instance) =>

            {

                const string hqlUpdate =

                    "update FileState set FileStatus= :fileStatus where Id = :id  ";

                var updatedEntities = session.CreateQuery(hqlUpdate)

                    .SetGuid("id", id)

                    .SetEnum("fileStatus", fileStatus)

                    .ExecuteUpdate();

                return updatedEntities;

            }, null);

        }*/

        public static void UpdateFileTreeHash(string absolutePath, TreeHash treeHash)

        {

            if (string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            ExecuteWithRetry((session, instance) =>

            {

                var hashes=treeHash.ToJson();

                const string hqlUpdate = "update FileState set Checksum= :checksum,ETag=:etag, Hashes=:hashes where FilePath = :path ";

                var updatedEntities = session.CreateQuery(hqlUpdate)

                    .SetString("path", absolutePath)

                    .SetString("checksum", treeHash.TopHash.ToHashString())

                    .SetString("etag", treeHash.MD5)

                    .SetString("hashes",hashes)

                    .ExecuteUpdate();

                return updatedEntities;

            }, null);

        }

        public static void UpdateChecksum(string absolutePath, string etag, string checksum)

        {

            if (string.IsNullOrWhiteSpace(absolutePath))

                throw new ArgumentNullException("absolutePath");

            Contract.EndContractBlock();

            ExecuteWithRetry((session, instance) =>

                        {

                            const string hqlUpdate = "update FileState set Checksum= :checksum,ETag=:etag where FilePath = :path ";

                            var updatedEntities = session.CreateQuery(hqlUpdate)

                                .SetString("path", absolutePath)

                                .SetString("checksum", checksum)

                                .SetString("etag", etag)

                                .ExecuteUpdate();

                            return updatedEntities;

                        }, null);

        }

        public static void UpdateLastMD5(FileInfo file, string md5)

        {

            if (file==null)

                throw new ArgumentNullException("file");

            Contract.EndContractBlock();

            ExecuteWithRetry((session, instance) =>

                        {

                            const string hqlUpdate = "update FileState set LastMD5=:md5, LastWriteDate=:date,LastLength=:length where FilePath = :path ";

                            file.Refresh();

                            if (!file.Exists)

                                return 0;

                            var fullName = file.WithProperCapitalization().FullName;

                            using (var tx=session.BeginTransaction())

                            {

                                var updatedEntities = session.CreateQuery(hqlUpdate)

                                    .SetDateTime("date", file.LastWriteTime)

                                    .SetInt64("length", file.Length)

                                    .SetString("md5", md5)

                                    .SetString("path", fullName)

                                    .ExecuteUpdate();

                                if (updatedEntities == 0)

                                {

                                    var newState = new FileState

                                                       {

                                                           FilePath = fullName,

                                                           Id = Guid.NewGuid(),

                                                           OverlayStatus = FileOverlayStatus.Normal,

                                                           FileStatus = FileStatus.Unchanged,

                                                           IsFolder = false,

                                                           LastLength = file.Length,

                                                           LastWriteDate = file.LastWriteTime,

                                                           LastMD5 = md5 ?? String.Empty,

                                                           ETag = String.Empty

                                                       };

                                    newState.CreateAndFlush();

                                }

                                tx.Commit();

                                return updatedEntities;

                            }

                        }, null);

        }

        public static 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) where FilePath like :oldPath || '%' ";

                                var renames = session.CreateQuery(hqlUpdate)

                                    .SetString("oldPath", oldPath)

                                    .SetString("newPath", newPath)

                                    .ExecuteUpdate();

                                return renames;

                            }, null);

        }

        public static FileState CreateFor(FileSystemInfo info,IStatusNotification notification)

        {

            if(info==null)

                throw new ArgumentNullException("info");

            Contract.EndContractBlock();

            if (info is DirectoryInfo)

                return new FileState

                {

                    FilePath = info.FullName,

                    OverlayStatus = FileOverlayStatus.Unversioned,

                    FileStatus = FileStatus.Created,

                    ETag=String.Empty,

                    LastMD5=String.Empty,

                    Id = Guid.NewGuid()

                };

            var etag = ((FileInfo)info).ComputeShortHash(notification);

            var fileState = new FileState

                                {

                                    FilePath = info.FullName,

                                    OverlayStatus = FileOverlayStatus.Unversioned,

                                    FileStatus = FileStatus.Created,               

                                    ETag=etag,

                                    LastMD5=String.Empty,

                                    Id = Guid.NewGuid()

                                };

            return fileState;

        }

        private static void ExecuteWithRetry(NHibernateDelegate call, object state)

        {

            int retries = 3;

            while (retries > 0)

                try

                {

                    using (new SessionScope())

                    {

                        Execute(call, state);

                        return;

                    }

                }

                catch (ActiveRecordException )

                {

                    retries--;

                    if (retries <= 0)

                        throw;

                }

        }

        /// <summary>

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

        /// starts with one of the removed paths

        /// </summary>

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

        public static 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);

            ExecuteWithRetry((session,instance)=>

                                 {

                                     using (var tx=session.BeginTransaction())

                                     {

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

                                         foreach (var state in states)

                                         {

                                             state.FileStatus = FileStatus.Unversioned;

                                             state.OverlayStatus = FileOverlayStatus.Unversioned;

                                             state.Update();

                                         }

                                         tx.Commit();

                                     }

                                     return null;

                                 },null);

        }

        public string ToDebugString()

        {

            return String.Format("[STATE] FilePath:[{0}] ObjectID:[{1}], ETAG: [{2}], LastMD5:[{3}]", FilePath, ObjectID,

                                 ETag, LastMD5);

        }

    }

    [ActiveRecord("Tags")]

    public class FileTag : ActiveRecordLinqBase<FileTag>

    {

        [PrimaryKey]

        public int Id { get; set; }

        [Property]

        public string Name { get; set; }

        [Property]

        public string Value { get; set; }

        [BelongsTo("FileStateId")]

        public FileState FileState { get; set; }

    }

}