Synnefo » Pithos MS Client

#region

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

 * <copyright file="SnapshotDifferencer.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.Collections.Concurrent;

using System.Diagnostics.Contracts;

using Pithos.Interfaces;

using Pithos.Network;

using System;

using System.Collections.Generic;

using System.Linq;

namespace Pithos.Core.Agents

{

    /// <summary>

    /// Calculates the differences between two ObjectInfo snapshots.

    /// </summary>

    public class SnapshotDifferencer

    {

        /// <summary>

        /// Contains the previous and current listings.

        /// Using a separate class for the state simplifies the Post method

        /// which has to modify the listings

        /// </summary>

        private class State

        {

            /// <summary>

            /// The previous snapshot listing

            /// </summary>

            public readonly ObjectInfo[] Previous;

            /// <summary>

            /// The current snapshot listing

            /// </summary>

            public readonly ObjectInfo[] Current;

            public readonly Dictionary<string, ObjectInfo> CurrentDict;

            public readonly Dictionary<string, ObjectInfo> PreviousDict;

            /// <summary>

            /// Common objects, lazily evalueated. 

            /// The common objects are used to calculate both the Changed and Unchanged objects

            /// </summary>

            public readonly Lazy<IEnumerable<ObjectInfo>> Common;

            private readonly static ObjectInfo[] Empty = new ObjectInfo[0];

            [ContractInvariantMethod]

            private void StatInvariant()

            {

// ReSharper disable InvocationIsSkipped

                Contract.Invariant(Current!=null);

                Contract.Invariant(Previous!=null);

                Contract.Invariant(CurrentDict!=null);

                Contract.Invariant(PreviousDict!=null);

                Contract.Invariant(Common!=null);

// ReSharper restore InvocationIsSkipped

            }

            public State(ObjectInfo[] previous, ObjectInfo[] current)

            {

                Previous = previous ?? Empty;

                Current = current ?? Empty;

                CurrentDict = Current.ToDictionary(info => info.UUID);

                PreviousDict = Previous.ToDictionary(info => info.UUID);

                Common=new Lazy<IEnumerable<ObjectInfo>>(() =>

                    Current.Join(Previous,

                                outKey => new { outKey.Account, outKey.Container, outKey.Name },

                                inKey => new { inKey.Account, inKey.Container, inKey.Name },

                                (outer, inner) =>outer.SetPrevious(inner)));            

            }

        }

        private State _state;

        /// <summary>

        /// The comparer used to identify common objects.

        /// Objects are considered common when they have the same Account, Container and Name

        /// </summary>

        private readonly ObjectInfoComparer _comparer = new ObjectInfoComparer();

        /// <summary>

        /// Default constructor. Initializes the Current and Previous listings to empty lists

        /// </summary>

        public SnapshotDifferencer()

        {                        

            _state = new State(null, null);

        }

        /// <summary>

        /// Posts a new listing

        /// </summary>

        /// <param name="list"></param>

        /// <returns></returns>

        public SnapshotDifferencer Post(IEnumerable<ObjectInfo> list)

        {

            ObjectInfo[] newCurrent=null;

            if (list != null)

            {

                //The state field holds the old state

                var oldState = _state;

                //Replace any NoModification entries with previous values that have

                //the same account, container and possibly, folder

                newCurrent = list.Replace(

                    info => info is NoModificationInfo,

                    noMod => oldState.Current.Where(noMod.CorrespondsTo))

                    .ToArray();

            }

            //Set the new state

            _state = new State(_state.Current, newCurrent);

            return this;

        }

        /// <summary>

        /// Deleted objects are those that existed in the Previous listing

        /// but are not found in the Current listing, and their UUIDs do not

        /// appear in the Current listing (ie they were not renamed/moved)

        /// </summary>

        public IEnumerable<ObjectInfo> Deleted

        {

            get { return _state.Previous.Except(_state.Current,_comparer)

                .Where(info=>!_state.CurrentDict.ContainsKey(info.UUID)); }

        }

        /// <summary>

        /// Created objects are those that exist in the Current listing

        /// but are not found in the Previous listing, and their UUIDs do not

        /// appear in the Previous listing (ie they were not renamed/moved)

        /// </summary>

        public IEnumerable<ObjectInfo> Created

        {

            get { return _state.Current.Except(_state.Previous,_comparer)

                .Where(info=>!_state.PreviousDict.ContainsKey(info.UUID)); }

        }

        public IEnumerable<ObjectInfo> Common

        {

            get { return _state.Common.Value; }

        }

        public IEnumerable<ObjectInfo> Changed

        {

            get{return Common.Where(i=>i.PreviousHash!=i.Hash);}

        }

        public IEnumerable<ObjectInfo> Unchanged

        {

            get{ return Common.Where(i => i.PreviousHash == i.Hash);}

        }

        public IEnumerable<ObjectInfo>  Moved

        {

            get

            {

                return _state.Current.Join(_state.Previous,

                                    outer => outer.UUID,

                                    inner => inner.UUID,

                                    (outer, inner) => (outer.Name == inner.Name ? null : outer.SetPrevious(inner)))

                    .Where(t => t != null);                

            }

        }

    }

    public class AccountsDifferencer

    {

        readonly ConcurrentDictionary<string, SnapshotDifferencer> _differencers = new ConcurrentDictionary<string, SnapshotDifferencer>();

        public ConcurrentDictionary<string, SnapshotDifferencer> Differencers { get { return _differencers; } }

        public SnapshotDifferencer PostSnapshot(AccountInfo accountInfo, List<ObjectInfo> cleanRemotes)

        {

            SnapshotDifferencer differencer;

            if (!_differencers.TryGetValue(accountInfo.UserName, out differencer))

            {

                differencer = new SnapshotDifferencer();

                _differencers[accountInfo.UserName] = differencer;

            }

            differencer.Post(cleanRemotes);

            return differencer;

        }

    }

}