AcCommand.cs

Go to the documentation of this file.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Text;
using System.Threading.Tasks;
using System.Threading.Tasks.Schedulers;

namespace AcUtils
{
    [Serializable]
    public sealed class AcResult
    {
        #region class variables
        private int _retVal = -1;
        private string _cmdResult;
        #endregion

        #region Constructors

        public AcResult() { }

        public AcResult(int retval, string cmdresult)
        {
            _retVal = retval;
            _cmdResult = cmdresult;
        }
        #endregion

        public int RetVal
        {
            get { return _retVal; }
            set { _retVal = value; }
        }

        public string CmdResult
        {
            get { return _cmdResult ?? String.Empty; }
            set { _cmdResult = value; }
        }
    }

    public interface ICmdValidate
    {
        bool isValid(string command, int retval);
    }

    [Serializable]
    public class CmdValidate : ICmdValidate
    {

        public virtual bool isValid(string command, int retval)
        {
            if (retval == 0 || (retval == 1 && (
                command.StartsWith("diff", StringComparison.OrdinalIgnoreCase) ||
                command.StartsWith("merge", StringComparison.OrdinalIgnoreCase)))
            )
                return true;
            else
                return false;
        }
    }

    [Serializable]
    public static class AcCommand
    {
        #region class variables
        private static readonly int MaxConcurrencyDefault = 8; // default when ACUTILS_MAXCONCURRENT environment variable doesn't exist
        private static TaskFactory _taskFactory;
        #endregion


        static AcCommand()
        {
            try
            {
                string maxconcurrent = Environment.GetEnvironmentVariable("ACUTILS_MAXCONCURRENT");
                int max = (maxconcurrent != null) ? Int32.Parse(maxconcurrent) : MaxConcurrencyDefault;
                LimitedConcurrencyLevelTaskScheduler ts = new LimitedConcurrencyLevelTaskScheduler(max);
                _taskFactory = new TaskFactory(ts);
            }

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


        public static async Task<AcResult> runAsync(string command, ICmdValidate validator = null)
        {
            TaskCompletionSource<AcResult> tcs = new TaskCompletionSource<AcResult>();
            StringBuilder error = new StringBuilder(512);
            try
            {
                await _taskFactory.StartNew(() =>
                {
                    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 += (sender, e) =>
                        {
                            error.AppendLine(e.Data);
                        };
                        process.Start();
                        process.BeginErrorReadLine();
                        Task<string> output = process.StandardOutput.ReadToEndAsync();
                        process.WaitForExit();
                        if (process.HasExited)
                        {
                            string err = error.ToString().Trim();
                            if (!String.IsNullOrEmpty(err) &&
                                !(String.Equals("You are not in a directory associated with a workspace", err)))
                            {
                                AcDebug.Log(err, false);
                            }

                            ICmdValidate validate = validator ?? new CmdValidate();
                            if (validate.isValid(command, process.ExitCode))
                            {
                                tcs.SetResult(new AcResult(process.ExitCode, output.Result));
                            }
                            else
                            {
                                tcs.SetException(new AcUtilsException($"AccuRev program return: {process.ExitCode}{Environment.NewLine}accurev {command}")); // let calling method handle
                            }
                        }
                    }
                }).ConfigureAwait(false);
            }

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

            catch (InvalidOperationException ecx)
            {
                string msg = String.Format(@"InvalidOperationException caught and logged in AcCommand.runAsync{0}{1}{0}""accurev {2}""{0}{3}",
                    Environment.NewLine, ecx.Message, command, error.ToString());
                AcDebug.Log(msg);
                tcs.SetException(ecx);
            }

            return await tcs.Task.ConfigureAwait(false);
        }


        public static AcResult run(string command, ICmdValidate validator = null)
        {
            AcResult result = new AcResult();
            StringBuilder error = new StringBuilder(512);
            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 += (sender, e) =>
                    {
                        error.AppendLine(e.Data);
                    };
                    StringBuilder output = new StringBuilder();
                    output.Capacity = 4096;
                    process.OutputDataReceived += (sender, e) =>
                    {
                        output.AppendLine(e.Data);
                    };
                    process.Start();
                    process.BeginErrorReadLine();
                    process.BeginOutputReadLine();
                    process.WaitForExit(); // blocks here. recommended to ensure output buffer has been flushed
                    if (process.HasExited)
                    {
                        string err = error.ToString().Trim();
                        if (!String.IsNullOrEmpty(err) &&
                            !(String.Equals("You are not in a directory associated with a workspace", err)))
                        {
                            AcDebug.Log(err, false);
                        }

                        ICmdValidate validate = validator ?? new CmdValidate();
                        if (validate.isValid(command, process.ExitCode))
                        {
                            result.RetVal = process.ExitCode;
                            result.CmdResult = output.ToString();
                        }
                        else
                        {
                            throw new AcUtilsException($"AccuRev program return: {process.ExitCode}{Environment.NewLine}accurev {command}"); // let calling method handle
                        }
                    }
                }
            }

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

            catch (InvalidOperationException ecx)
            {
                string msg = String.Format(@"InvalidOperationException caught and logged in AcCommand.run{0}{1}{0}""accurev {2}""{0}{3}",
                    Environment.NewLine, ecx.Message, command, error.ToString());
                AcDebug.Log(msg);
            }

            return result;
        }
    }
}