AcWorkspaces.cs

Go to the documentation of this file.

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

namespace AcUtils
{
    #region enums

    public enum WsType {
        Standard = 1,
        RefTree = 3,
        Exclusive = 9,
        Anchor = 17
    };

    public enum WsEOL {
        Platform = 0,
        Unix = 1,
        Windows = 2
    };
    #endregion

    [Serializable]
    [DebuggerDisplay("{Name} ({ID}), {Host}, {Location} ULevel-Target [{UpdateLevel}:{TargetLevel}]")]
    public sealed class AcWorkspace : IFormattable, IEquatable<AcWorkspace>, IComparable<AcWorkspace>, IComparable
    {
        #region class variables
        private string _name; // workspace name
        private int _id; // workspace ID number
        private string _location; // workspace location; the path on the machine where the workspace is located
        private string _storage; // location on the host (storage) where the elements physically reside
        private string _host; // machine name (host) where the elements physically reside
        private bool _hidden; // true if the workspace has been removed (hidden), false if it is active
        private AcDepot _depot; // depot the workspace is located in
        private int _targetLevel; // how up-to-date the workspace should be
        private int _updateLevel; // how up-to-date the workspace actually is
        private DateTime? _fileModTime; // time of the oldest non-member file in the workspace with modified status, otherwise time the update command was issued
        private WsType _type; // 1 (standard workspace), 3 (reference tree), 9 (exclusive-file locking), 17 (anchor-required)
        private WsEOL _eol; // 0 (platform-appropriate), 1 (Unix/Linux style:NL), 2 (Windows style: CR-LF)
        private AcPrincipal _principal = new AcPrincipal(); // principal who owns the workspace
        #endregion

        internal AcWorkspace() { }

        #region Equality comparison

        public bool Equals(AcWorkspace other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            var left = Tuple.Create(ID, Depot);
            var right = Tuple.Create(other.ID, other.Depot);
            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 AcWorkspace);
        }

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

        #region Order comparison


        public int CompareTo(AcWorkspace other)
        {
            int result;
            if (AcWorkspace.ReferenceEquals(this, other))
                result = 0;
            else
            {
                result = Depot.CompareTo(other.Depot);
                if (result == 0)
                    result = Name.CompareTo(other.Name);
            }

            return result;
        }

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

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

        public bool Hidden
        {
            get { return _hidden; }
            internal set { _hidden = value; }
        }


        public string Location
        {
            get { return _location ?? String.Empty; }
            internal set { _location = value; }
        }


        public string Storage
        {
            get { return _storage ?? String.Empty; }
            internal set { _storage = value; }
        }


        public string Host
        {
            get { return _host ?? String.Empty; }
            internal set { _host = value; }
        }

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

        public AcDepot Depot
        {
            get { return _depot; }
            internal set { _depot = value; }
        }

        public int TargetLevel
        {
            get { return _targetLevel; }
            internal set { _targetLevel = value; }
        }

        public int UpdateLevel
        {
            get { return _updateLevel; }
            internal set { _updateLevel = value; }
        }

        public DateTime? FileModTime
        {
            get { return _fileModTime; }
            internal set { _fileModTime = value; }
        }

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

        public WsEOL EOL
        {
            get { return _eol; }
            internal set { _eol = value; }
        }

        public AcPrincipal Principal
        {
            get { return _principal; }
            internal set { _principal = value; }
        }

        public AcStream getBasis()
        {
            AcStream basis = _depot.getBasis(_id);
            return basis;
        }

        #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": // name of the workspace, e.g. MARS_DEV3_barnyrd
                    return Name; // general format should be short since it can be called by anything
                case "LV": // long version (verbose)
                    return $"{Name} ({ID}) {{{Type}}}{Environment.NewLine}" +
                        $@"Location: ""{Location}"", Storage: ""{Storage}""{Environment.NewLine}" +
                        $"Host: {Host}, ULevel-Target [{UpdateLevel}:{TargetLevel}]{((TargetLevel != UpdateLevel) ? " (incomplete)" : String.Empty)}{Environment.NewLine}" +
                        $"Depot: {Depot}, EOL: {EOL}, Hidden: {Hidden}{Environment.NewLine}";
                case "I": // workspace ID number
                    return ID.ToString();
                case "L": // workspace location
                    return Location;
                case "S": // location on the host (storage) where the elements physically reside
                    return Storage;
                case "M": // machine name (host) where the elements physically reside
                    return Host;
                case "H": // True if workspace is hidden, False otherwise
                    return Hidden.ToString();
                case "D": // depot name
                    return Depot.ToString();
                case "TL": // how up-to-date the workspace should be
                    return TargetLevel.ToString();
                case "UL": // how up-to-date the workspace actually is
                    return UpdateLevel.ToString();
                case "U": // time of the oldest non-member file in the workspace with modified status, otherwise time the update command was issued
                    return FileModTime.ToString();
                case "T": // type of workspace: standard, exclusive-file locking, anchor-required, or reference tree
                    return Type.ToString();
                case "E": // end-of-line character in use by the workspace: platform-appropriate, Unix/Linux style, or Windows style
                    return EOL.ToString();
                case "PI": // ID number of the AccuRev principal who owns the workspace
                    return Principal.ID.ToString();
                case "PN": // principal name of the workspace owner
                    return Principal.Name;
                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 AcWorkspaces : List<AcWorkspace>
    {
        #region class variables
        private AcDepots _depots;
        private bool _allWSpaces;
        private bool _includeHidden;
        private bool _includeRefTrees;
        [NonSerialized] private readonly object _locker = new object();
        #endregion

        #region object construction:


        public AcWorkspaces(AcDepots depots, bool allWSpaces, bool includeHidden, bool includeRefTrees = false)
        {
            _depots = depots;
            _allWSpaces = allWSpaces;
            _includeHidden = includeHidden;
            _includeRefTrees = includeRefTrees;
        }


        public async Task<bool> initAsync(AcDepot depot = null)
        {
            Task<AcResult> ws = getWorkspacesXMLAsync();
            if (_includeRefTrees)
            {
                // run both in parallel
                Task<AcResult> rt = getReferenceTreesXMLAsync();
                AcResult[] arr = await Task.WhenAll(ws, rt).ConfigureAwait(false);
                bool ret = (arr != null && arr.All(n => n != null && n.RetVal == 0)); // true if both were successful
                if (!ret) return false;
                foreach (AcResult r in arr)
                {
                    if (!storeWSpaces(r, depot))
                        return false;
                }
            }
            else
            {
                AcResult r = await ws.ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    if (!storeWSpaces(r, depot))
                        return false;
                }
                else
                    return false;
            }

            return true;
        }
        #endregion



        private async Task<AcResult> getWorkspacesXMLAsync()
        {
            AcResult result = null;
            try
            {
                string cmd = null;
                // for all below, -v option adds the Loc (location) to output
                if (_allWSpaces && _includeHidden)
                    // All workspaces, not just those that belong to the principal. Include deactivated workspaces.
                    cmd = "show -fvix -a wspaces"; // -a is the only option available for show wspaces
                else if (_allWSpaces && !_includeHidden)
                    // All workspaces, not just those that belong to the principal. Do not include deactivated workspaces.
                    cmd = "show -fvx -a wspaces";
                else if (!_allWSpaces && _includeHidden)
                    // Only those workspaces that belong to the principal. Include deactivated workspaces.
                    cmd = "show -fvix wspaces";
                else if (!_allWSpaces && !_includeHidden)
                    // Only those workspaces that belong to the principal. Do not include deactivated workspaces.
                    cmd = "show -fvx wspaces";
                result = await AcCommand.runAsync(cmd).ConfigureAwait(false);
            }

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

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

            return result;
        }



        private async Task<AcResult> getReferenceTreesXMLAsync()
        {
            AcResult result = null;
            try
            {
                // -fvix: display all reference trees including deactivated ones
                // -fvx: display only active reference trees
                result = await AcCommand.runAsync($"show {(_includeHidden ? "-fvix" : "-fvx")} refs").ConfigureAwait(false);
            }

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

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

            return result;
        }

        private bool storeWSpaces(AcResult result, AcDepot depot = null)
        {
            bool ret = false; // assume failure
            try
            {
                // filter out workspace/ref trees not in the user's default list
                XElement xml = XElement.Parse(result.CmdResult);
                IEnumerable<XElement> filter;
                if (depot != null)
                    filter = from w in xml.Elements("Element")
                             join AcDepot d in _depots on
                             (string)w.Attribute("depot") equals d.Name
                             where (string)w.Attribute("depot") == depot.Name
                             select w;
                else
                    filter = from w in xml.Elements("Element")
                             join AcDepot d in _depots on
                             (string)w.Attribute("depot") equals d.Name
                             select w;

                foreach (XElement e in filter)
                {
                    AcWorkspace ws = new AcWorkspace();
                    ws.Name = (string)e.Attribute("Name");
                    ws.Hidden = (e.Attribute("hidden") != null); // attribute hidden exists only when true
                    ws.Location = (string)e.Attribute("Loc");
                    ws.Storage = (string)e.Attribute("Storage");
                    ws.Host = (string)e.Attribute("Host");
                    ws.ID = (int)e.Attribute("Stream");
                    string temp = (string)e.Attribute("depot");
                    ws.Depot = _depots.getDepot(temp);
                    ws.TargetLevel = (int)e.Attribute("Target_trans");
                    ws.UpdateLevel = (int)e.Attribute("Trans");
                    ws.FileModTime = e.acxTime("fileModTime");
                    int type = (int)e.Attribute("Type");
                    ws.Type = (WsType)type;
                    int eol = (int)e.Attribute("EOL");
                    ws.EOL = (WsEOL)eol;
                    ws.Principal.ID = (int)e.Attribute("user_id");
                    ws.Principal.Name = (string)e.Attribute("user_name");
                    lock (_locker) { Add(ws); }
                }

                ret = true; // operation succeeded
            }

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

            return ret;
        }

        public AcDepot getDepot(string name)
        {
            AcWorkspace wspace = this.SingleOrDefault(n => n.Name == name);
            return (wspace != null) ? wspace.Depot : null;
        }

        public AcWorkspace getWorkspace(AcDepot depot, int ID)
        {
            return this.SingleOrDefault(n => n.ID == ID && n.Depot.Equals(depot));
        }

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