AcLocks.cs

Go to the documentation of this file.

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

namespace AcUtils
{
    #region enums

    public enum LockKind {
        from,
        to,
        all
    };

    public enum PrinType
    {
        group,
        user,
        none
    };

    public enum OnlyExcept {
        Only,
        Except
    };
    #endregion

    [Serializable]
    public sealed class AcLock : IFormattable, IEquatable<AcLock>, IComparable<AcLock>, IComparable
    {
        #region class variables
        // Kind and Name are the only ones that always exist in the XML.
        // Others exist only if there are values for them.
        private LockKind _kind;
        private string _name;
        private PrinType _type;
        private string _exceptFor;
        private string _onlyFor;
        private string _comment;
        #endregion

        internal AcLock() {}

        #region Equality comparison

        public bool Equals(AcLock other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            // [stream], [from|to|all]
            var left = Tuple.Create(Name, Kind);
            var right = Tuple.Create(other.Name, other.Kind);
            return left.Equals(right);
        }

        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 Equals(other as AcLock);
        }

        public override int GetHashCode()
        {
            var hash = Tuple.Create(Name, Kind);
            return hash.GetHashCode();
        }
        #endregion

        #region Order comparison


        public int CompareTo(AcLock other)
        {
            int result;
            if (AcLock.ReferenceEquals(this, other))
                result = 0;
            else
            {
                result = (-1 * Kind.CompareTo(other.Kind)); // descending
                if (result == 0)
                    result = String.Compare(Name, other.Name);
            }

            return result;
        }

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

        public LockKind Kind
        {
            get { return _kind; }
            internal set { _kind = value; }
        }

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

        public PrinType Type
        {
            get { return _type; }
            internal set { _type = value; }
        }

        public string ExceptFor
        {
            get { return _exceptFor ?? String.Empty; }
            internal set { _exceptFor = value; }
        }

        public string OnlyFor
        {
            get { return _onlyFor ?? String.Empty; }
            internal set { _onlyFor = value; }
        }

        public string Comment
        {
            get { return _comment ?? String.Empty; }
            internal set { _comment = value; }
        }

        #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": // long version and default when not using a format specifier
                {
                    string kind = $"{((Kind == LockKind.all) ? "promotions to and from" : "promotions " + Kind)}";
                    string howfor = String.Format("{0}", 
                    (Kind == LockKind.all) || (String.IsNullOrEmpty(ExceptFor) && String.IsNullOrEmpty(OnlyFor)) ?
                        "for all" : !String.IsNullOrEmpty(ExceptFor) ?
                            ("except for " + Type + " " + ExceptFor) : ("for " + Type + " " + OnlyFor + " only"));
                    return $"Lock {kind} {Name} {howfor}. {Comment}";
                }
                case "K": // kind of AccuRev lock: from, to, or all
                    return Kind.ToString();
                case "N": // name of stream the lock applies to
                    return Name;
                case "T": // whether lock is for a user or group
                    return Type.ToString();
                case "E": // lock applies to all except this principal
                    return ExceptFor;
                case "O": // lock applies only to this principal
                    return OnlyFor;
                case "C": // comment given to the lock
                    return Comment;
                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 AcLocks : List<AcLock>
    {
        #region class variables
        [NonSerialized] private readonly object _locker = new object();
        #endregion

        #region object construction:


        public AcLocks() { }


        public async Task<bool> initAsync(AcDepot depot = null)
        {
            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fx locks").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    IEnumerable<XElement> query = null;
                    if (depot == null)
                        query = from e in xml.Elements("Element")
                                select e;
                    else
                        query = from e in xml.Elements("Element")
                                join AcStream s in depot.Streams on (string)e.Attribute("Name") equals s.Name
                                select e;
                    ret = initList(query);
                }
            }

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

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

            return ret;
        }


        public async Task<bool> initAsync(DepotsCollection depots)
        {
            AcDepots dlist = new AcDepots();
            if (!(await dlist.initAsync(depots).ConfigureAwait(false))) return false;

            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fx locks").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    bool result = true;
                    XElement xml = XElement.Parse(r.CmdResult);
                    for (int ii = 0; ii < dlist.Count && result; ii++)
                    {
                        AcDepot depot = dlist[ii];
                        IEnumerable<XElement> query = from e in xml.Elements("Element")
                                                      join AcStream s in depot.Streams on (string)e.Attribute("Name") equals s.Name
                                                      select e;
                        result = initList(query);
                    }

                    ret = result;
                }
            }

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

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

            return ret;
        }


        public async Task<bool> initAsync(StreamsCollection streams)
        {
            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fx locks").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    IEnumerable<XElement> query = from e in xml.Elements("Element")
                                                  where streams.OfType<StreamElement>().Any(se => se.Stream == (string)e.Attribute("Name"))
                                                  select e;
                    ret = initList(query);
                }
            }

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

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

            return ret;
        }
        #endregion


        private bool initList(IEnumerable<XElement> query)
        {
            bool ret = false; // assume failure
            try
            {
                foreach (XElement e in query)
                {
                    AcLock lk = new AcLock();
                    // Kind and Name are the only ones that always exist in the XML
                    // others exist only if there are values for them
                    string kind = (string)e.Attribute("kind");
                    lk.Kind = (LockKind)Enum.Parse(typeof(LockKind), kind);
                    lk.Name = (string)e.Attribute("Name");
                    string type = (string)e.Attribute("userType") ?? String.Empty;
                    lk.Type = String.IsNullOrEmpty(type) ? PrinType.none :
                        (PrinType)Enum.Parse(typeof(PrinType), type);
                    lk.ExceptFor = (string)e.Attribute("exceptFor") ?? String.Empty;
                    lk.OnlyFor = (string)e.Attribute("onlyFor") ?? String.Empty;
                    lk.Comment = (string)e.Attribute("comment") ?? String.Empty;
                    lock (_locker) { Add(lk); }
                }

                ret = true; // operation succeeded
            }

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

            return ret;
        }

        public bool hasLock(string stream)
        {
            AcLock lk = this.FirstOrDefault(n => n.Name == stream);
            return (lk != null);
        }


        public async Task<bool> lockAsync(string stream, string comment, LockKind kind = LockKind.all, AcPrincipal prncpl = null, OnlyExcept onlyexcept = OnlyExcept.Except)
        {
            bool ret = false; // assume failure
            try
            {
                string cmd = null;
                if (kind == LockKind.from)
                    if (prncpl != null)
                        cmd = $@"lock -c ""{comment}"" -kf {((onlyexcept == OnlyExcept.Except) ? "-e" : "-o")} ""{prncpl}"" ""{stream}""";
                    else
                        cmd = $@"lock -c ""{comment}"" -kf ""{stream}""";  // lock 'from' for all
                else if (kind == LockKind.to)
                    if (prncpl != null)
                        cmd = $@"lock -c ""{comment}"" -kt {((onlyexcept == OnlyExcept.Except) ? "-e" : "-o")} ""{prncpl}"" ""{stream}""";
                    else
                        cmd = $@"lock -c ""{comment}"" -kt ""{stream}"""; // lock 'to' for all
                else if (kind == LockKind.all)
                    cmd = $@"lock -c ""{comment}"" ""{stream}"""; // lock 'to and from' for all

                AcResult r = await AcCommand.runAsync(cmd).ConfigureAwait(false);
                ret = (r != null && r.RetVal == 0);
            }

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

            return ret;
        }


        public async Task<bool> unlockAsync(string stream, LockKind kind = LockKind.all)
        {
            bool ret = false; // assume failure
            try
            {
                string cmd = null;
                if (kind == LockKind.from)
                    cmd = $@"unlock -kf ""{stream}""";
                else if (kind == LockKind.to)
                    cmd = $@"unlock -kt ""{stream}""";
                else if (kind == LockKind.all)
                    cmd = $@"unlock ""{stream}""";

                AcResult r = await AcCommand.runAsync(cmd).ConfigureAwait(false);
                ret = (r != null && r.RetVal == 0);
            }

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

            return ret;
        }
    }
}