AcDepots.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace AcUtils
{
    #region enums

    public enum CaseSensitivity {
        insensitive,
        sensitive
    };
    #endregion

    [Serializable]
    [DebuggerDisplay("{ToString(\"lv\")}")]
    public sealed class AcDepot : IFormattable, IEquatable<AcDepot>, IComparable<AcDepot>, IComparable
    {
        #region class variables
        private string _name; // depot name
        private int _id; // depot ID number
        private int _slice; // depot slice number
        private bool _exclusiveLocking; // whether or not all workspaces created for this depot use exclusive file locking
        private CaseSensitivity _case; // whether the depot is case sensitive or insensitive
        private bool _dynamicOnly; // true if request is for dynamic streams only
        private bool _includeHidden; // true if removed streams should be included in the list
        internal AcStreams _streams; // list of streams in this depot as per constructor parameters
        [NonSerialized] private Task<MultiValueDictionary<int, int>> _hierarchy; // [parent,children]
        [NonSerialized] private object _hierSync = null;
        [NonSerialized] private bool _hierInit;
        #endregion

        #region object construction:

        internal AcDepot(bool dynamicOnly, bool includeHidden)
        {
            _dynamicOnly = dynamicOnly;
            _includeHidden = includeHidden;
        }


        public AcDepot(string name, bool dynamicOnly = false, bool includeHidden = false)
            : this(dynamicOnly, includeHidden)
        {
            _name = name;
        }


        public AcDepot(int id, bool dynamicOnly = false, bool includeHidden = false)
            : this(dynamicOnly, includeHidden)
        {
            _id = id;
        }


        public async Task<bool> initAsync()
        {
            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fx depots").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    IEnumerable<XElement> filter = null;
                    if (_id > 0)
                        filter = from element in xml.Elements("Element")
                                 where (int)element.Attribute("Number") == _id
                                 select element;
                    else
                        filter = from element in xml.Elements("Element")
                                 where (string)element.Attribute("Name") == _name
                                 select element;

                    XElement e = filter.SingleOrDefault();
                    if (e != null)
                    {
                        ID = (int)e.Attribute("Number");
                        Name = (string)e.Attribute("Name");
                        Slice = (int)e.Attribute("Slice");
                        ExclusiveLocking = (bool)e.Attribute("exclusiveLocking");
                        string temp = (string)e.Attribute("case");
                        Case = (CaseSensitivity)Enum.Parse(typeof(CaseSensitivity), temp);
                        _streams = new AcStreams(_dynamicOnly, _includeHidden);
                        ret = await _streams.initAsync(this, listFile()).ConfigureAwait(false);
                    }
                }
            }

            catch (AcUtilsException ecx)
            {
                AcDebug.Log($"AcUtilsException caught and logged in AcDepot.initAsync{Environment.NewLine}{ecx.Message}");
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcDepot.initAsync{Environment.NewLine}{ecx.Message}");
            }

            return ret;
        }
        #endregion

        #region Equality comparison

        public bool Equals(AcDepot other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            return ID == other.ID;
        }

        public override bool Equals(object other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            if (GetType() != other.GetType()) return false;
            return this.Equals(other as AcDepot);
        }

        public override int GetHashCode()
        {
            return ID;
        }
        #endregion

        #region Order comparison


        public int CompareTo(AcDepot other)
        {
            int result;
            if (AcDepot.ReferenceEquals(this, other))
                result = 0;
            else
                result = String.Compare(Name, other.Name);

            return result;
        }

        int IComparable.CompareTo(object other)
        {
            if (!(other is AcDepot))
                throw new ArgumentException("Argument is not an AcDepot", "other");
            AcDepot o = (AcDepot)other;
            return this.CompareTo(o);
        }
        #endregion

        public int ID
        {
            get { return _id; }
            internal set { _id = value; }
        }

        public string Name
        {
            get { return _name ?? String.Empty; }
            internal set { _name = value; }
        }

        public int Slice
        {
            get { return _slice; }
            internal set { _slice = value; }
        }

        public bool ExclusiveLocking
        {
            get { return _exclusiveLocking; }
            internal set { _exclusiveLocking = value; }
        }

        public CaseSensitivity Case
        {
            get { return _case; }
            internal set { _case = value; }
        }

        public IEnumerable<AcStream> Streams
        {
            get { return _streams; }
        }

        public AcStream getStream(string name)
        {
            AcStream stream = _streams.SingleOrDefault(s => s.Name == name);
            return stream;
        }

        public AcStream getStream(int ID)
        {
            AcStream stream = _streams.SingleOrDefault(s => s.ID == ID);
            return stream;
        }

        public AcStream getBasis(string name)
        {
            AcStream basis = null;
            // ignore root stream (1) since it has no parent
            AcStream stream = _streams.Where(s => s.ID > 1).SingleOrDefault(s => s.Name == name);
            if (stream != null)
                basis = getStream(stream.BasisID);

            return basis;
        }

        public AcStream getBasis(int ID)
        {
            AcStream basis = null;
            // ignore root stream (1) since it has no parent
            AcStream stream = _streams.Where(s => s.ID > 1).SingleOrDefault(s => s.ID == ID);
            if (stream != null)
                basis = getStream(stream.BasisID);

            return basis;
        }


        public async Task<bool> forStreamAndAllChildrenAsync(AcStream stream, Action<AcStream> cb, bool includeWSpaces = false)
        {
            cb(stream);
            var children = await getChildrenAsync(stream, includeWSpaces).ConfigureAwait(false);
            if (children == null) return false; //  operation failed, check log file
            if (children.Item1 == null) return false; // ..
            if (children.Item1 == true) // if children exist
                foreach (AcStream child in children.Item2)
                    await forStreamAndAllChildrenAsync(child, cb, includeWSpaces).ConfigureAwait(false);

            return true;
        }


        public async Task<Tuple<bool?, IList<AcStream>>> getChildrenAsync(AcStream stream, bool includeWSpaces = false)
        {
            IList<AcStream> children = null;
            if (stream.Type == StreamType.workspace)
                return Tuple.Create((bool?)false, children); // workspaces don't have children

            bool? ret = null;
            // thread safe one-time stream hierarchy initialization
            // see "C# Lazy Initialization && Race-to-initialize" http://stackoverflow.com/questions/11555755/c-sharp-lazy-initialization-race-to-initialize
            await LazyInitializer.EnsureInitialized(ref _hierarchy, ref _hierInit, ref _hierSync, 
                async () => await getHierarchyAsync(includeWSpaces).ConfigureAwait(false)).ConfigureAwait(false);
            if (_hierarchy == null)
                return Tuple.Create(ret, children); // initialization failed, check log file

            IReadOnlyCollection<int> list = null;
            ret = _hierarchy.Result.TryGetValue(stream.ID, out list);
            if (ret == true)
            {
                children = new List<AcStream>(list.Count);
                foreach (int id in list)
                {
                    AcStream child = getStream(id);
                    children.Add(child);
                }
            }

            return Tuple.Create(ret, children);
        }


        private async Task<MultiValueDictionary<int, int>> getHierarchyAsync(bool includeWSpaces = false)
        {
            MultiValueDictionary<int, int> hierarchy = null;
            try
            {
                AcResult r = await AcCommand.runAsync($@"show -p ""{this}"" {(_includeHidden ? " -fix" : " -fx")} -s 1 -r streams")
                    .ConfigureAwait(false);
                if (r != null && r.RetVal == 0) // if command succeeded
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    IEnumerable<XElement> filter;
                    if (includeWSpaces)
                        filter = from s in xml.Elements("stream")
                                 select s;
                    else
                        filter = from s in xml.Elements("stream")
                                 where (string)s.Attribute("type") != "workspace" // all except workspaces
                                 select s;

                    int capacity = filter.Count();
                    hierarchy = new MultiValueDictionary<int, int>(capacity);
                    foreach (XElement e in filter)
                    {
                        // XML attribute basisStreamNumber does not exist in the case of root streams
                        int parent = (int?)e.Attribute("basisStreamNumber") ?? -1;
                        int child = (int)e.Attribute("streamNumber");
                        hierarchy.Add(parent, child);
                    }
                }
            }

            catch (AcUtilsException ecx)
            {
                AcDebug.Log($"AcUtilsException caught and logged in AcDepot.getHierarchyAsync{Environment.NewLine}{ecx.Message}");
                hierarchy = null;
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcDepot.getHierarchyAsync{Environment.NewLine}{ecx.Message}");
                hierarchy = null;
            }

            return hierarchy;
        }



        internal string listFile()
        {
            string listfile = null;
            try
            {
                string appdata = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
                string actools = Path.Combine(appdata, "AcTools");
                string exeroot = String.Empty;
                using (Process currentProcess = Process.GetCurrentProcess())
                {
                    ProcessModule pm = currentProcess.MainModule;
                    exeroot = Path.GetFileNameWithoutExtension(pm.ModuleName);
                }

                string progfolder = Path.Combine(actools, exeroot);
                string temp = Path.Combine(progfolder, Name);
                string file = Path.ChangeExtension(temp, "streams");
                if (File.Exists(file))
                    listfile = file;
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcDepot.listFile{Environment.NewLine}{ecx.Message}");
            }

            return listfile;
        }

        #region ToString
        public string ToString(string format, IFormatProvider provider)
        {
            if (provider != null)
            {
                ICustomFormatter fmt = provider.GetFormat(this.GetType()) as ICustomFormatter;
                if (fmt != null)
                    return fmt.Format(format, this, provider);
            }

            if (String.IsNullOrEmpty(format))
                format = "G";

            switch (format.ToUpperInvariant())
            {
                case "G": // Depot name (default when not using a format specifier).
                    return Name; // general format should be short since it can be called by anything
                case "LV": // long version (verbose)
                    return $"{Name} ({ID}), slice {Slice}, {Case}{(ExclusiveLocking ? ", exclusive locking" : String.Empty)}";
                case "I": // depot ID number
                    return ID.ToString();
                case "S": // depot's slice number
                    return Slice.ToString();
                case "E": // exclusive locking status
                    return ExclusiveLocking.ToString();
                case "C": // whether the depot is case sensitive or insensitive
                    return Case.ToString();
                default:
                    throw new FormatException($"The {format} format string is not supported.");
            }
        }

        // Calls ToString(string, IFormatProvider) version with a null IFormatProvider argument.
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        // Calls ToString(string, IFormatProvider) version with the general format and a null IFormatProvider argument.
        public override string ToString()
        {
            return ToString("G", null);
        }
        #endregion ToString
    }

    [Serializable]
    public sealed class AcDepots : List<AcDepot>
    {
        #region class variables
        private AcPermissions _permissions;
        [NonSerialized] private Task<bool> _depotPermObj;
        [NonSerialized] private object _permSync = null;
        [NonSerialized] private bool _permInit;
        private bool _dynamicOnly; // true if request is for dynamic streams only
        private bool _includeHidden; // true if removed streams should be included in the list
        [NonSerialized] private readonly object _locker = new object(); // token for lock keyword scope
        [NonSerialized] private int _counter; // used to report initialization progress back to the caller
        #endregion

        #region object construction:


        public AcDepots(bool dynamicOnly = false, bool includeHidden = false)
        {
            _dynamicOnly = dynamicOnly;
            _includeHidden = includeHidden;
        }


        public async Task<bool> initAsync(DepotsCollection depotsCol = null, IProgress<int> progress = null)
        {
            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fx depots").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    IEnumerable<XElement> query = null;
                    if (depotsCol == null)
                        query = from e in xml.Elements("Element") select e;
                    else
                        query = from e in xml.Elements("Element")
                                where depotsCol.OfType<DepotElement>().Any(de => de.Depot == (string)e.Attribute("Name"))
                                select e;

                    int num = query.Count();
                    List<Task<bool>> tasks = new List<Task<bool>>(num);
                    Func<Task<bool>, bool> cf = t =>
                    {
                        bool res = t.Result;
                        if (res && progress != null) progress.Report(Interlocked.Increment(ref _counter));
                        return res;
                    };

                    foreach (XElement e in query)
                    {
                        AcDepot depot = new AcDepot(_dynamicOnly, _includeHidden);
                        depot.ID = (int)e.Attribute("Number");
                        depot.Name = (string)e.Attribute("Name");
                        depot.Slice = (int)e.Attribute("Slice");
                        depot.ExclusiveLocking = (bool)e.Attribute("exclusiveLocking");
                        string temp = (string)e.Attribute("case");
                        depot.Case = (CaseSensitivity)Enum.Parse(typeof(CaseSensitivity), temp);
                        depot._streams = new AcStreams(_dynamicOnly, _includeHidden);
                        lock (_locker) { Add(depot); }
                        Task<bool> t = depot._streams.initAsync(depot, depot.listFile()).ContinueWith(cf);
                        tasks.Add(t);
                    }

                    bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
                    ret = (arr != null && arr.All(n => n == true)); // true if all succeeded
                }
            }

            catch (AcUtilsException ecx)
            {
                AcDebug.Log($"AcUtilsException caught and logged in AcDepots.initAsync{Environment.NewLine}{ecx.Message}");
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcDepots.initAsync{Environment.NewLine}{ecx.Message}");
            }

            return ret;
        }
        #endregion

        #pragma warning disable 0642

        public async Task<string> canViewAsync(AcUser user)
        {
            // create permissions object as a singleton (thread safe)
            // see "C# Lazy Initialization && Race-to-initialize" http://stackoverflow.com/questions/11555755/c-sharp-lazy-initialization-race-to-initialize
            await LazyInitializer.EnsureInitialized(ref _depotPermObj, ref _permInit, ref _permSync,
                async () =>
                {
                    _permissions = new AcPermissions(PermKind.depot);
                    return await _permissions.initAsync().ConfigureAwait(false);
                }).ConfigureAwait(false);

            if (_depotPermObj.Result == false)
                return null; // initialization failure, check log file

            // get the membership list for the user (includes explicit and implicit membership)
            SortedSet<string> members = user.Principal.Members;
            // list that will contain the depots this user has permission to view
            List<string> canView = new List<string>();

            foreach (AcDepot depot in this)
            {
                bool isInheritable = false;
                // Any() returns true if the collection contains one or more items that satisfy the condition defined by the predicate
                // first, is an 'all' or 'none' permission explicitly set for this user on this depot?
                if (_permissions.Any(p =>
                {
                    bool all = (p.Type == PermType.user && p.Rights == PermRights.all &&
                        p.AppliesTo == user.Principal.Name && p.Name == depot.Name);
                    if (all)
                        isInheritable = (p.Inheritable == true && p.Type == PermType.user && p.Rights == PermRights.all &&
                            p.AppliesTo == user.Principal.Name && p.Name == depot.Name);
                    return all;
                }))
                {
                    canView.Add($"{depot.Name}{(isInheritable ? "+" : String.Empty)}");
                }
                else if (_permissions.Any(p =>
                {
                    return (p.Type == PermType.user && p.Rights == PermRights.none &&
                        p.AppliesTo == user.Principal.Name && p.Name == depot.Name);
                }))
                {
                    ; // user does not have permission to this depot
                }
                else // check permissions based on user's group memberships
                {
                    bool all = false;
                    bool none = _permissions.Any(p =>
                    {
                        return (p.Name == depot.Name && p.Rights == PermRights.none &&
                            p.Type == PermType.group && members.Any(m => p.AppliesTo == m));
                    });

                    // by default everyone has access unless there's a "none" with no "all" override
                    if (none)
                    {
                        all = _permissions.Any(p =>
                        {
                            return (p.Name == depot.Name && p.Rights == PermRights.all &&
                                p.Type == PermType.group && members.Any(m => p.AppliesTo == m));
                        });
                    }

                    if (none && !all)
                        ; // user does not have permission to this depot
                    else // no permission(s) set or an 'all' that overrides one or more 'none' permissions
                    {
                        isInheritable = _permissions.Any(p =>
                        {
                            return (p.Inheritable == true && p.Name == depot.Name && 
                                p.Type == PermType.group && members.Any(m => p.AppliesTo == m));
                        });

                        canView.Add($"{depot.Name}{(isInheritable ? "+" : String.Empty)}");
                    }
                }
            }

            IEnumerable<string> e = canView.OrderBy(n => n);
            string depots = String.Join(", ", e);
            return depots;
        }

        public AcDepot getDepot(string name)
        {
            return this.SingleOrDefault(n => n.Name == name);
        }

        public AcDepot getDepot(int ID)
        {
            return this.SingleOrDefault(n => n.ID == ID);
        }

        public AcDepot getDepotForStream(string name)
        {
            AcDepot depot = (from d in this
                             from s in d.Streams.Where(n => n.Name == name)
                             select d).SingleOrDefault();
            return depot;
        }

        public AcStream getStream(string name)
        {
            AcStream stream = (from d in this
                               from s in d.Streams.Where(n => n.Name == name)
                               select s).SingleOrDefault();
            return stream;
        }
    }
}