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;

using System.Collections.Concurrent;

using System.Diagnostics.Contracts;

using Pithos.Interfaces;

using Pithos.Network;

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

                //Attach the previous version to the current listings

                foreach (var info in Current)

                {

                    ObjectInfo prev;

                    if (PreviousDict.TryGetValue(info.UUID, out prev))

                        info.SetPrevious(prev);

                }

                Common=Current.Where(c=>c.Previous !=null);

            }

        }

        private State _state;

        /// <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;

        }

        public ObjectInfo[] Previous

        {

            get

            {

                if (_state==null)

                    return new ObjectInfo[0];

                return _state.Previous;

            }

        }

        public ObjectInfo[] Current

        {

            get

            {

                if (_state == null)

                    return new ObjectInfo[0];

                return _state.Current;                

            }

        }

        /// <summary>

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

        /// but are not found in the Current listing

        /// </summary>

        public IEnumerable<ObjectInfo> Deleted

        {

            get { return _state.Previous

                .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 

        /// </summary>

        public IEnumerable<ObjectInfo> Created

        {

            get { return _state.Current

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

        }

        public IEnumerable<ObjectInfo> Common

        {

            get { return _state.Common; }

        }

        public IEnumerable<ObjectInfo> Changed

        {

            get

            {

                return Common.Where(info => 

                    //The hash is different

                    info.PreviousHash != info.X_Object_Hash 

                    //And the Uri is unchanged or there is no previous version

                    && (info.Previous == null ||  info.Uri == info.Previous.Uri));

            }

        }

        /// <summary>

        /// Unchanged objects have the same current and previous hash

        /// </summary>

        public IEnumerable<ObjectInfo> Unchanged

        {

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

        }

        /// <summary>

        /// Moved objects have a previous version with a different name

        /// </summary>

        public IEnumerable<ObjectInfo>  Moved

        {

            get

            {                                

                return Common.Where(info=>

                    //A previous version exists

                    info.Previous!= null 

                    //and the Uri is different

                    && info.Uri!=info.Previous.Uri);                    

            }

        }

    }

    public class AccountsDifferencer

    {

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

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

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

        {

            SnapshotDifferencer differencer;

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

            {

                differencer = new SnapshotDifferencer();

                _differencers[accountInfo.AccountKey] = differencer;

            }

            differencer.Post(cleanRemotes);

            return differencer;

        }

    }

}