AcQuery.cs

Go to the documentation of this file.

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

namespace AcUtils
{
    [Serializable]
    public static class AcQuery
    {


        public static async Task<string> getPrincipalAsync()
        {
            string prncpl = null;
            try
            {
                AcResult r = await AcCommand.runAsync("info").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    using (StringReader reader = new StringReader(r.CmdResult))
                    {
                        bool? login = null; // don't know yet
                        string line;
                        char[] sep = new char[] { ':' };
                        while ((line = reader.ReadLine()) != null && login == null)
                        {
                            string[] arr = line.Split(sep); // "Principal:      barnyrd"
                            if (arr.Length == 2)
                            {
                                if (String.Equals(arr[0], "Principal"))
                                {
                                    string temp = arr[1].Replace("\t", "");
                                    if (String.Equals(temp, "(not logged in)"))
                                        login = false;
                                    else
                                    {
                                        prncpl = temp; // AccuRev principal name
                                        login = true;
                                    }
                                }
                            }
                        }
                    }
                }
            }

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

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

            return prncpl; // principal name or null if not logged in
        }



        public static async Task<string> getCatFileAsync(int eid, AcDepot depot, string ver_spec)
        {
            string tmpFile = null;
            try
            {
                AcResult r = await AcCommand.runAsync($@"cat -v ""{ver_spec}"" -p ""{depot}"" -e {eid}")
                    .ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    tmpFile = Path.GetTempFileName();
                    using (StreamWriter streamWriter = new StreamWriter(tmpFile))
                    {
                        streamWriter.Write(r.CmdResult);
                    }
                }
            }

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

            catch (Exception ecx) // IOException, DirectoryNotFoundException, PathTooLongException, SecurityException... others
            {
                AcDebug.Log($"Exception caught and logged in AcQuery.getCatFileAsync{Environment.NewLine}{ecx.Message}");
            }

            return tmpFile;
        }


        public static async Task<int[]> getBackedVersionAsync(string realverspec, AcDepot depot, string depotrelpath)
        {
            int[] arr = null; // {realStreamNumber, realVersionNumber}
            try
            {
                AcResult r = await AcCommand.runAsync($@"diff -fx -v ""{realverspec}"" -b -i -p ""{depot}"" ""{depotrelpath}""")
                    .ConfigureAwait(false);
                if (r != null && r.RetVal < 2)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    XElement stream2 = xml.Descendants().Where(n => n.Name == "Stream2").SingleOrDefault();
                    if (stream2 != null)
                    {
                        XAttribute version = stream2.Attributes("Version").SingleOrDefault();
                        if (version != null)
                        {
                            string temp = (string)version;
                            string[] a = temp.Split('/');
                            int realStreamNumber = Int32.Parse(a[0], NumberStyles.Integer);
                            int realVersionNumber = Int32.Parse(a[1], NumberStyles.Integer);
                            arr = new int[] { realStreamNumber, realVersionNumber };
                        }
                    }
                }
            }

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

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

            return arr;
        }



        public static async Task<Tuple<string, int>> getElementNameAsync(string stream, int EID)
        {
            Tuple<string, int> ret = null; // depot-relative path, parent folder EID
            try
            {
                AcResult r = await AcCommand.runAsync($@"name -v ""{stream}"" -fx -e {EID}").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    string location = (string)xml.Element("element").Attribute("location");
                    int parent_id = (int)xml.Element("element").Attribute("parent_id");
                    ret = Tuple.Create(location, parent_id);
                }
            }

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

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

            return ret;
        }


        public static T getAppConfigSetting<T>(string key)
        {
            var value = ConfigurationManager.AppSettings[key];
            return (T)System.Convert.ChangeType(value, typeof(T),
                CultureInfo.InvariantCulture);
        }



        public static async Task<int[]> getAccuRevVersionAsync()
        {
            int[] arr = null; // major, minor, patch
            string tempFile = null;
            try
            {
                tempFile = Path.GetTempFileName(); // the AccuRev xml command requires a file as its argument
                using (StreamWriter streamWriter = new StreamWriter(tempFile))
                {
                    streamWriter.Write(@"<serverInfo/>"); // set up the query
                }

                AcResult r = await AcCommand.runAsync($@"xml -l ""{tempFile}""").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    using (StringReader reader = new StringReader(r.CmdResult))
                    {
                        XElement doc = XElement.Load(reader);
                        XElement sv = doc.Element("serverVersion");
                        int major = (int)sv.Attribute("major");
                        int minor = (int)sv.Attribute("minor");
                        int patch = (int)sv.Attribute("patch");
                        arr = new int[] { major, minor, patch };
                    }
                }
            }

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

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

            finally
            {
                if (tempFile != null)
                    File.Delete(tempFile);
            }

            return arr;
        }


        public static async Task<int> getUsersCountAsync(bool includeDeactivated = false)
        {
            int count = -1; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync(includeDeactivated ? "show -fix users" : "show -fx users").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement t = XElement.Parse(r.CmdResult);
                    count = t.Elements("Element").Count();
                }
            }

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

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

            return count;
        }


        public static async Task<int> getDepotsCountAsync()
        {
            int count = -1; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fx depots").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement t = XElement.Parse(r.CmdResult);
                    count = t.Elements("Element").Count();
                }
            }

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

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

            return count;
        }


        public static async Task<int> getDynStreamsCountAsync()
        {
            int count = -1; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fx -d streams").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement s = XElement.Parse(r.CmdResult);
                    count = (from d in s.Elements("stream") where d.Attribute("isDynamic").Value == "true" select d).Count();
                }
            }

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

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

            return count;
        }


        public static async Task<int> getTotalStreamsCountAsync()
        {
            int count = -1; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fix streams").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement t = XElement.Parse(r.CmdResult);
                    count = t.Elements("stream").Count();
                }
            }

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

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

            return count;
        }


        public static async Task<int> getStreamsWithDefaultGroupCountAsync()
        {
            int count = -1; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fx -d streams").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement t = XElement.Parse(r.CmdResult);
                    count = t.Elements("stream").Count();
                }
            }

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

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

            return count;
        }


        public static async Task<int> getTotalWorkspaceCountAsync()
        {
            int count = -1; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync("show -fix -a wspaces").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement t = XElement.Parse(r.CmdResult);
                    count = t.Elements("Element").Count();
                }
            }

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

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

            return count;
        }

        public static bool getAcGUIpath(out string path)
        {
            bool error = false; // assume success
            path = null;
            string temp = String.Empty;
            try
            {
                using (Process process = new Process())
                {
                    process.StartInfo.RedirectStandardOutput = true;
                    process.StartInfo.CreateNoWindow = true;
                    process.StartInfo.UseShellExecute = false;
                    process.StartInfo.Arguments = "acgui.exe";
                    process.StartInfo.FileName = "where";
                    process.Start();
                    temp = process.StandardOutput.ReadToEnd();
                    process.WaitForExit();
                }
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcQuery.getAcGUIpath{Environment.NewLine}{ecx.Message}");
                error = true;
            }

            bool result = (!error && !String.IsNullOrEmpty(temp));
            if (result)
                path = temp.Substring(0, temp.IndexOf('\r'));
            return result;
        }

        private static bool getAcClientCnfPath(out string path)
        {
            path = String.Empty;
            string temp;
            bool ret = getAcGUIpath(out temp);
            if (ret)
            {
                string dir = Path.GetDirectoryName(temp);
                path = Path.Combine(dir, "acclient.cnf");
                return true;
            }

            return false;
        }

        public static bool getServerFromAcClientCnf(out string server)
        {
            server = null;
            FileStream fs = null;
            try
            {
                string cnfFile;
                if (getAcClientCnfPath(out cnfFile))
                {
                    fs = new FileStream(cnfFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
                    using (StreamReader sr = new StreamReader(fs))
                    {
                        string line = sr.ReadLine();
                        string[] arr = line.Split('=');
                        server = arr[1].Trim();
                    }

                    return true;
                }
            }

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

            finally // avoids CA2202: Do not dispose objects multiple times
            {
                if (fs != null) fs.Dispose();
            }

            return false;
        }


        public static async Task<List<string>> getDepotNameListAsync()
        {
            List<string> depots = null;
            AcResult result = null;
            try { result = await AcCommand.runAsync("show -fx depots").ConfigureAwait(false); }

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

            if (result != null && result.RetVal == 0) // if command succeeded
            {
                XElement xml = XElement.Parse(result.CmdResult);
                IEnumerable<XElement> query = from e in xml.Elements("Element")
                                              select e;
                int num = query.Count();
                depots = new List<string>(num);
                foreach (XElement n in query)
                    depots.Add((string)n.Attribute("Name"));

                depots.Sort();
            }

            return depots;
        }
    }
}