protected override object ExecuteMethod()

in src/TestFramework/Core/Adapters/ShellAdapterProxy.cs [74:166]
79 lines of code
12 McCabe index (conditional complexity)

        protected override object ExecuteMethod(MethodInfo targetMethod, object[] args)
        {
            //get help message from attribute
            string methodhelp = AdapterProxyHelpers.GetHelpMessage(targetMethod);

            bool compactMode = ((targetMethod.Name == "Initialize" || targetMethod.Name == "Reset")
                && AdapterType.IsAdapterTypeFullName(targetMethod.DeclaringType.FullName)
                );

            if (compactMode)
                return ExecuteMethodCompact(targetMethod, methodhelp);

            // Build parameter on each invoke
            builder = new ParameterDataBuilder(targetMethod);
            builder.Build(args);

            lastOutput = null;
            errorMsg = new StringBuilder();

            object retVal = null;
            string arguments = BuildScriptArguments();

            // Check if this is a method from IAdapter. Any IAdapter methods should be ignored.
            if (!AdapterType.IsAdapterTypeFullName(targetMethod.DeclaringType.FullName)
                && (targetMethod.DeclaringType.FullName != typeof(IDisposable).FullName)
                )
            {
                TestSite.Log.Add(LogEntryKind.EnterAdapter,
                    "Shell adapter: {0}, method: {1}",
                    ProxyType.Name,
                    targetMethod.Name);

                try
                {
                    string path = LookupScript(targetMethod.Name);
                    if (path == null)
                    {
                        TestSite.Assume.Fail(
                            "Shell script file ({0}.sh) can not be found.",
                            targetMethod.Name);
                    }
                    else
                    {
                        int timeout = AdapterProxyHelpers.GetTimeout(targetMethod, int.Parse(TestSite.Properties["AdapterInvokeTimeout"]));

                        Task<int> invokeTask = Task.Run<int>(() =>
                        {
                            TestSite.Log.Add(LogEntryKind.Debug, $"Start to invoke shell {targetMethod.Name}.sh, timeout: {timeout}");
                            int invokeResult = InvokeScript(path, arguments);
                            TestSite.Log.Add(LogEntryKind.Debug, $"Complete execute shell {targetMethod.Name}.sh");

                            return invokeResult;
                        });

                        TimeSpan waiter = TimeSpan.FromMinutes(timeout);
                        if (invokeTask.Wait(waiter))
                        {
                            if (invokeTask.Result != 0)
                            {
                                string exceptionMessage = string.Format("Exception thrown when executing {0}.sh.\nExit code: {1}\nError message: {2}\n", targetMethod.Name, invokeTask.Result, errorMsg);
                                throw new InvalidOperationException(exceptionMessage);
                            }

                            if (builder.HasReturnVal)
                            {
                                retVal = AdapterProxyHelpers.ParseResult(builder.RetValType, lastOutput);
                            }
                        }
                        else
                        {
                            throw new TimeoutException($"Invoke adapater method timeout after wait {timeout} minutes.");
                        }
                    }
                }
                catch (Exception ex)
                {
                    if (ex.InnerException != null)
                    {
                        ex = ex.InnerException;
                    }
                    TestSite.Log.Add(LogEntryKind.Debug, ex.ToString());
                    throw ex;
                }
                finally
                {
                    TestSite.Log.Add(LogEntryKind.ExitAdapter,
                        "Shell adapter: {0}, method: {1}",
                        ProxyType.Name,
                        targetMethod.Name);
                }
            }
            return retVal;
        }