AcGroups.cs

Go to the documentation of this file.

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

namespace AcUtils
{
    [Serializable]
    public sealed class AcGroups : List<AcPrincipal>
    {
        #region Class variables
        private bool _includeMembersList;
        private bool _includeDeactivated;
        [NonSerialized] private readonly object _locker = new object(); // token for lock keyword scope
        [NonSerialized] private int _counter; // used to report membership initialization progress back to the caller
        #endregion

        #region object construction:


        public AcGroups(bool includeMembersList = false, bool includeDeactivated = false)
        {
            _includeMembersList = includeMembersList;
            _includeDeactivated = includeDeactivated;
        }


        public async Task<bool> initAsync(IProgress<int> progress = null)
        {
            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync($"show {(_includeDeactivated ? "-fix" : "-fx")} groups")
                    .ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    IEnumerable<XElement> query = from element in xml.Elements("Element") select element;
                    List<Task<bool>> tasks = null;
                    if (_includeMembersList)
                    {
                        int num = query.Count();
                        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)
                    {
                        AcPrincipal group = new AcPrincipal();
                        group.Name = (string)e.Attribute("Name");
                        group.ID = (int)e.Attribute("Number");
                        // XML attribute isActive exists only if the group is inactive, otherwise it isn't there
                        group.Status = (e.Attribute("isActive") == null) ? PrinStatus.Active : PrinStatus.Inactive;
                        lock (_locker) { Add(group); }
                        if (_includeMembersList)
                        {
                            Task<bool> t = initMembersListAsync(group.Name).ContinueWith(cf);
                            tasks.Add(t);
                        }
                    }

                    if (!_includeMembersList)
                        ret = true; // list initialization succeeded
                    else // run membership initialization in parallel
                    {
                        bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
                        ret = (arr != null && arr.All(n => n == true));
                    }
                }
            }

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

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

            return ret;
        }
        #endregion


        private async Task<bool> initMembersListAsync(string group)
        {
            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync($@"show -fx -g ""{group}"" members").ConfigureAwait(false);
                if (r != null && r.RetVal == 0) // if command succeeded
                {
                    SortedSet<string> members = new SortedSet<string>();
                    XElement xml = XElement.Parse(r.CmdResult);
                    foreach (XElement e in xml.Elements("Element"))
                    {
                        string name = (string)e.Attribute("User");
                        members.Add(name);
                    }

                    lock (_locker)
                    {
                        AcPrincipal prncpl = getPrincipal(group);
                        prncpl.Members = members;
                    }

                    ret = true; // operation succeeded
                }
            }

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

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

            return ret;
        }


        public static bool isMember(string user, string group)
        {
            bool ret = false; // assume not a member
            string command = String.Format(@"ismember ""{0}"" ""{1}""", user, group);
            try
            {
                using (Process process = new Process())
                {
                    process.StartInfo.FileName = "accurev";
                    process.StartInfo.Arguments = command;
                    process.StartInfo.UseShellExecute = false;
                    process.StartInfo.CreateNoWindow = true;
                    process.StartInfo.RedirectStandardInput = true; // fix for AccuRev defect 29059
                    process.StartInfo.RedirectStandardOutput = true;
                    process.StartInfo.RedirectStandardError = true;
                    process.StartInfo.StandardOutputEncoding = Encoding.UTF8;
                    process.StartInfo.StandardErrorEncoding = Encoding.UTF8;
                    process.ErrorDataReceived += new DataReceivedEventHandler(AcDebug.errorDataHandler);
                    process.Start();
                    process.BeginErrorReadLine();
                    string result = process.StandardOutput.ReadToEnd();
                    process.WaitForExit();
                    if (process.ExitCode == 0)
                    {
                        if (result.Length > 0 && result[0] == '1')
                            ret = true;
                    }
                    else
                    {
                        string err = String.Format("AccuRev program return: {0}{1}{2}", process.ExitCode, Environment.NewLine, "accurev " + command);
                        throw new AcUtilsException(err); // let calling method handle
                    }
                }
            }

            catch (Win32Exception ecx)
            {
                string msg = String.Format("Win32Exception caught and logged in AcGroups.isMember{0}{1}{0}accurev {2}{0}errorcode: {3}{0}native errorcode: {4}{0}{5}{0}{6}{0}{7}",
                    Environment.NewLine, ecx.Message, command, ecx.ErrorCode.ToString(), ecx.NativeErrorCode.ToString(), ecx.StackTrace, ecx.Source, ecx.GetBaseException().Message);
                AcDebug.Log(msg);
            }

            catch (InvalidOperationException ecx)
            {
                string msg = String.Format("InvalidOperationException caught and logged in AcGroups.isMember{0}{1}{0}accurev {2}",
                    Environment.NewLine, ecx.Message, command);
                AcDebug.Log(msg);
            }

            return ret;
        }

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


        public string getMembers(string group)
        {
            string list = null;
            AcPrincipal prncpl = getPrincipal(group);
            if (prncpl != null)
            {
                SortedSet<string> members = prncpl.Members;
                if (members != null)
                    list = String.Join(", ", members);
            }

            return list;
        }
    }
}