コード例 #1
0
        public MethodInfoFinder(Basics.Context.Request.HttpMethod httpMethod, string searchName)
        {
            this._HttpMethod = httpMethod;
            this._SearchName = searchName;

            this.Identifier = $"{this._HttpMethod}_{this._SearchName}";
        }
コード例 #2
0
        public bool Find(MethodInfo mI)
        {
            foreach (object aT in mI.GetCustomAttributes(false))
            {
                Type workingType = aT.GetType();

                if (workingType != typeof(Basics.Attribute.HttpMethodAttribute))
                {
                    continue;
                }

                Basics.Context.Request.HttpMethod httpMethod =
                    (Basics.Context.Request.HttpMethod)workingType.InvokeMember("Method", BindingFlags.GetProperty, null, aT, null);
                object bindProcedureName =
                    workingType.InvokeMember("BindProcedureName", BindingFlags.GetProperty, null, aT, null);

                if (httpMethod != this._HttpMethod)
                {
                    return(false);
                }

                if (!string.IsNullOrEmpty(bindProcedureName.ToString()))
                {
                    return(string.CompareOrdinal(bindProcedureName.ToString(), this._SearchName) == 0);
                }

                break;
            }

            return(string.Compare(this._SearchName, mI.Name, StringComparison.OrdinalIgnoreCase) == 0);
        }
コード例 #3
0
ファイル: Executer.cs プロジェクト: xeora/v7-framework
        public static Basics.Execution.InvokeResult <T> InvokeBind <T>(Basics.Context.Request.HttpMethod httpMethod, Basics.Execution.Bind bind, ExecuterTypes executerType)
        {
            if (bind == null)
            {
                throw new NoNullAllowedException("Requires bind!");
            }
            // Check if BindInfo Parameters has been parsed!
            if (!bind.Ready)
            {
                throw new Exception("Bind Parameters should be parsed first!");
            }

            DateTime executionBegins = DateTime.Now;

            Basics.Execution.InvokeResult <T> rInvokeResult =
                new Basics.Execution.InvokeResult <T>(bind);

            object invokedObject =
                ApplicationFactory.Prepare(bind.Executable).Invoke(
                    httpMethod,
                    bind.Classes,
                    bind.Procedure,
                    bind.Parameters.Values,
                    bind.InstanceExecution,
                    executerType
                    );

            if (invokedObject is Exception exception)
            {
                rInvokeResult.Exception = exception;
            }
            else
            {
                rInvokeResult.Result = (T)invokedObject;
            }

            if (!Basics.Configurations.Xeora.Application.Main.PrintAnalysis)
            {
                return(rInvokeResult);
            }

            double totalMs =
                DateTime.Now.Subtract(executionBegins).TotalMilliseconds;

            Basics.Console.Push(
                "analysed - execution duration",
                $"{totalMs}ms - {bind}",
                string.Empty, false, groupId: Basics.Helpers.Context.UniqueId,
                type: totalMs > Basics.Configurations.Xeora.Application.Main.AnalysisThreshold ? Basics.Console.Type.Warn: Basics.Console.Type.Info);

            return(rInvokeResult);
        }
コード例 #4
0
        public object Invoke(Basics.Context.Request.HttpMethod httpMethod, string[] classNames, string functionName, object[] functionParams, bool instanceExecute, ExecuterTypes executerType)
        {
            if (string.IsNullOrEmpty(functionName))
            {
                throw new ArgumentNullException(nameof(functionName));
            }
            functionParams ??= new object[] { };

            string executionId =
                Guid.NewGuid().ToString();
            object result = null;

            DomainExecutable domainInstance =
                this.LoadDomainExecutable(out Exception exception);

            if (exception != null)
            {
                return(exception);
            }

            try
            {
                Type assemblyObject = classNames != null
                    ? this._AssemblyDll.GetType($"Xeora.Domain.{string.Join("+", classNames)}", true, true)
                    : domainInstance.GetType();

                MethodInfo assemblyMethod =
                    this.GetAssemblyMethod(ref assemblyObject, httpMethod, functionName, ref functionParams, executerType);

                if (assemblyMethod == null)
                {
                    return(this.GetMethodException(httpMethod, classNames, functionName, functionParams));
                }

                ApplicationContext.InvokePreExecution(domainInstance, executionId, assemblyMethod);

                result = this.InvokeMethod(instanceExecute, assemblyObject, assemblyMethod, functionParams);
            }
            catch (Exception ex)
            {
                return(this.GetExecutionError(classNames, functionName, functionParams, ex));
            }
            finally
            {
                ApplicationContext.InvokePostExecution(domainInstance, executionId, ref result);
            }

            return(result);
        }
コード例 #5
0
        private MethodInfo GetAssemblyMethod(ref Type assemblyObject, Basics.Context.Request.HttpMethod httpMethod, string functionName, ref object[] functionParams, ExecuterTypes executerType)
        {
            MethodInfoFinder methodFinder =
                new MethodInfoFinder(httpMethod, functionName);
            string searchKey =
                $"{assemblyObject.FullName}.{methodFinder.Identifier}";

            MethodInfo[] possibleMethodInfos;

            lock (this._AssemblyMethodLock)
            {
                if (this._AssemblyMethods.ContainsKey(searchKey))
                {
                    possibleMethodInfos = this._AssemblyMethods[searchKey];
                }
                else
                {
                    possibleMethodInfos =
                        Array.FindAll(assemblyObject.GetMethods(), methodFinder.Find);
                    this._AssemblyMethods[searchKey] = possibleMethodInfos;
                }
            }

            MethodInfo methodInfoResult =
                this.FindBestMatch(possibleMethodInfos, ref functionParams, executerType);

            if (methodInfoResult != null)
            {
                return(methodInfoResult);
            }

            if (assemblyObject.BaseType == null)
            {
                return(null);
            }

            Type       baseType       = assemblyObject.BaseType;
            MethodInfo assemblyMethod =
                this.GetAssemblyMethod(ref baseType, httpMethod, functionName, ref functionParams, executerType);

            if (assemblyMethod != null)
            {
                assemblyObject = baseType;
            }

            return(assemblyMethod);
        }
コード例 #6
0
        private Exception GetMethodException(Basics.Context.Request.HttpMethod httpMethod, string[] classNames, string functionName, IReadOnlyCollection <object> functionParams)
        {
            System.Text.StringBuilder sB = new System.Text.StringBuilder();

            sB.AppendLine("Assembly does not have following procedure!");
            sB.AppendLine("--------------------------------------------------");
            sB.AppendFormat("ExecutableName: {0}", this._ExecutableName);
            sB.AppendLine();
            sB.AppendFormat("ClassName: {0}", string.Join(".", classNames));
            sB.AppendLine();
            sB.AppendFormat("FunctionName: {0}", functionName);
            sB.AppendLine();
            sB.AppendFormat("FunctionParamsLength: {0}", functionParams.Count);
            foreach (object param in functionParams)
            {
                sB.AppendFormat(", {0}", param.GetType());
            }
            sB.AppendLine();
            sB.AppendFormat("HttpMethod: {0}", httpMethod);
            sB.AppendLine();

            return(new TargetException(sB.ToString()));
        }
コード例 #7
0
        public bool Parse()
        {
            string header = this.ExtractHeader();

            StringReader sR = new StringReader(header);

            int lineNumber = 1;

            while (sR.Peek() > -1)
            {
                string line = sR.ReadLine();

                if (string.IsNullOrEmpty(line))
                {
                    return(lineNumber != 1);
                }

                switch (lineNumber)
                {
                case 1:
                    string[] lineParts = line.Split(' ');

                    if (!Enum.TryParse(lineParts[0], out this._Method))
                    {
                        this._Method = Basics.Context.Request.HttpMethod.GET;
                    }

                    this.Url      = new Url(lineParts[1]);
                    this.Protocol = lineParts[2];

                    break;

                default:
                    int colonIndex = line.IndexOf(':');
                    if (colonIndex == -1)
                    {
                        return(false);
                    }

                    string key   = line.Substring(0, colonIndex);
                    string value = line.Substring(colonIndex + 1);
                    value = value.Trim();

                    switch (key.ToLowerInvariant())
                    {
                    case "host":
                        this.Host = value;

                        break;

                    case "user-agent":
                        this.UserAgent = value;

                        break;

                    case "content-length":
                        int.TryParse(value, out this._ContentLength);

                        break;

                    case "content-type":
                        string[] contentTypeValues = value.Split(';');

                        this.ContentType = contentTypeValues[0];

                        for (int cC = 1; cC < contentTypeValues.Length; cC++)
                        {
                            string keyAndValue = contentTypeValues[cC];

                            int equalsIndex = keyAndValue.IndexOf('=');
                            if (equalsIndex == -1)
                            {
                                continue;
                            }

                            string contentKey =
                                keyAndValue.Substring(0, equalsIndex).Trim();
                            switch (contentKey)
                            {
                            case "boundary":
                                string boundaryValue =
                                    keyAndValue.Substring(equalsIndex + 1).Trim();
                                this.Boundary = boundaryValue.Replace("\"", string.Empty);

                                break;

                            case "charset":
                                string charsetValue =
                                    keyAndValue.Substring(equalsIndex + 1).Trim();
                                try
                                {
                                    this.ContentEncoding = Encoding.GetEncoding(charsetValue);
                                }
                                catch (Exception)
                                {
                                    this.ContentEncoding = null;
                                }

                                break;
                            }
                        }

                        break;

                    case "cookie":
                        this.ParseCookies(value);

                        break;

                    default:
                        AddOrUpdate(key, value);

                        break;
                    }

                    break;
                }

                lineNumber++;
            }

            return(false);
        }
コード例 #8
0
ファイル: Executer.cs プロジェクト: xeora/v7-framework
 // This function is for external call out side of the project DO NOT DISABLE IT
 public static Basics.Execution.InvokeResult <T> InvokeBind <T>(Basics.Context.Request.HttpMethod httpMethod, Basics.Execution.Bind bind) =>
 Executer.InvokeBind <T>(httpMethod, bind, ExecuterTypes.Undefined);
コード例 #9
0
 public object Invoke(Basics.Context.Request.HttpMethod httpMethod, string[] classNames, string functionName, object[] functionParams, bool instanceExecute, ExecuterTypes executerType) =>
 this._Context.Invoke(httpMethod, classNames, functionName, functionParams, instanceExecute, executerType);