优化 Robot

dotnet/Library/Sers/Sers.Core/Sers.Core/Module/Api/ApiClient.cs

@@ -21,7 +21,7 @@ namespace Sers.Core.Module.Api
         /// callbacks长度必须大于1
         /// </summary>
         /// <param name="callbacks"></param>
-        public static void SetOnSendRequest(Action<Vit.Core.Util.Pipelines.ByteData, Action<ArraySegment<byte>>>[] callbacks,int requestTimeoutMs)
+        public static void SetOnSendRequest(Action<Vit.Core.Util.Pipelines.ByteData, Action<ArraySegment<byte>>>[] callbacks, int requestTimeoutMs)
         {
             Instances = new ApiClient[callbacks.Length];
 
@@ -31,7 +31,7 @@ namespace Sers.Core.Module.Api
 
             for (int i = 1; i < callbacks.Length; i++)
             {
-                Instances[i] = new ApiClient { OnSendRequest = callbacks[i], requestTimeoutMs= requestTimeoutMs };
+                Instances[i] = new ApiClient { OnSendRequest = callbacks[i], requestTimeoutMs = requestTimeoutMs };
             }
         }
 
@@ -50,7 +50,7 @@ namespace Sers.Core.Module.Api
 
 
 
-        #region CallApi 原始
+        #region CallApiAsync 原始
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void CallApiAsync(Vit.Core.Util.Pipelines.ByteData apiRequestData, Action<ArraySegment<byte>> callback)
@@ -85,7 +85,8 @@ namespace Sers.Core.Module.Api
                 {
                     ApiMessage apiReplyMessage = null;
 
-                    CallApiAsync(apiRequestMessage.Package(), (apiReplyData) => {
+                    CallApiAsync(apiRequestMessage.Package(), (apiReplyData) =>
+                    {
                         apiReplyMessage = new ApiMessage(apiReplyData);
                         mEvent?.Set();
                     });
@@ -214,7 +215,32 @@ namespace Sers.Core.Module.Api
             return ret;
         }
 
-     
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="ReturnType"></typeparam>
+        /// <param name="callback"></param>
+        /// <param name="route"></param>
+        /// <param name="arg"></param>
+        /// <param name="httpMethod">可为 GET、POST、DELETE、PUT等,可不指定</param>
+        /// <param name="InitRpc">对Rpc的额外处理,如添加header</param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CallApiAsync<ReturnType>(Action<ReturnType> callback, string route, Object arg = null, string httpMethod = null, Action<RpcContextData> InitRpc = null)
+        {
+            var apiRequestMessage = new ApiMessage().InitAsApiRequestMessage(route, arg, httpMethod, InitRpc);
+
+            CallApiAsync(apiRequestMessage.Package(), replyData =>
+            {
+                var apiReplyMessage = new ApiMessage(replyData);
+                var replyValue = apiReplyMessage.value_OriData.DeserializeFromArraySegmentByte<ReturnType>();
+                callback?.Invoke(replyValue);
+            });
+        }
+
+
 
         #endregion
 
@@ -223,7 +249,7 @@ namespace Sers.Core.Module.Api
 
 
 
-    
+
 
 
 
@@ -294,7 +320,7 @@ namespace Sers.Core.Module.Api
         /// <returns></returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static async Task<ApiMessage> CallRemoteApiAsync(ApiMessage request)
-        {   
+        {
             return await Instance.CallApiAsync(request);
         }
 
@@ -313,6 +339,24 @@ namespace Sers.Core.Module.Api
         {
             return await Instance.CallApiAsync<ReturnType>(route, arg, httpMethod, InitRpc);
         }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <typeparam name="ReturnType"></typeparam>
+        /// <param name="callback"></param>
+        /// <param name="route"></param>
+        /// <param name="arg"></param>
+        /// <param name="httpMethod">可为 GET、POST、DELETE、PUT等,可不指定</param>
+        /// <param name="InitRpc">对Rpc的额外处理,如添加header</param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void CallRemoteApiAsync<ReturnType>(Action<ReturnType> callback, string route, Object arg = null, string httpMethod = null, Action<RpcContextData> InitRpc = null)
+        {
+            Instance.CallApiAsync<ReturnType>(callback, route, arg, httpMethod, InitRpc);
+        }
+
         #endregion
 
 

dotnet/Library/Vit/Vit.Core/Vit.Core/Util/Threading/LongTaskHelp.cs

@@ -3,6 +3,7 @@ using System.Threading;
 using Vit.Extensions;
 using Vit.Core.Module.Log;
 using Vit.Core.Util.ComponentModel.SsError;
+using System.Runtime.CompilerServices;
 
 namespace Vit.Core.Util.Threading
 {
@@ -70,6 +71,7 @@ namespace Vit.Core.Util.Threading
 
         public bool IsRunning => runningThreadCount!=0;//threads != null && threads.Any(item=> item.IsAlive);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         void Run()
         {
             try

dotnet/Library/Vit/Vit.Core/Vit.Core/Util/Threading/RepeatTaskHelp.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using Vit.Core.Module.Log;
 using Vit.Extensions;
@@ -67,6 +68,7 @@ namespace Vit.Core.Util.Threading
 
         public bool IsRunning => runningThreadCount != 0;//threads != null && threads.Any(item=> item.IsAlive);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         void Run()
         {
             Interlocked.Increment(ref runningThreadCount);

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Controllers/TaskController.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using App.Robot.Station.Logical;
-using App.Robot.Station.Logical.Model;
 using Sers.SersLoader;
 using Sers.SersLoader.ApiDesc.Attribute.Valid;
 using Sers.Core.Module.Rpc;
@@ -8,6 +7,7 @@ using Sers.Core.Module.App;
 using Vit.Core.Util.ComponentModel.Api;
 using Vit.Core.Util.ComponentModel.Data;
 using Vit.Core.Util.Threading;
+using App.Robot.Station.Logical.Worker;
 
 namespace App.Robot.Station.Controllers
 {
@@ -47,7 +47,7 @@ namespace App.Robot.Station.Controllers
         /// <returns>ArgModelDesc-returns</returns>
         [SsRoute("task/getAll")]
         [SsCallerSource(ECallerSource.Internal)]
-        public ApiReturn<List<Task>> GetAll()
+        public ApiReturn<List<IWorker>> GetAll()
         {
             return TaskMng.Instance.GetAll();
         }

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Logical/Model/Task.cs

@@ -1,199 +0,0 @@
-using System;
-using System.Threading;
-using Newtonsoft.Json;
-using Sers.Core.Module.Api;
-using Vit.Core.Module.Log;
-using Vit.Core.Util.ComponentModel.Data;
-using Vit.Core.Util.Net;
-using Vit.Core.Util.Threading;
-using Vit.Extensions;
-
-namespace App.Robot.Station.Logical.Model
-{
-
-    /// <summary>
-    /// RepeatTaskHelp
-    /// </summary>
-    public class Task
-    {
-        public string name => config.name;
-        public int id;
-
-        [JsonIgnore]
-        RepeatTaskHelp tasks = new RepeatTaskHelp();
-
-        public int RunningThreadCount => tasks.RunningThreadCount;
-
-
-        public bool IsRunning => tasks.IsRunning;
- 
-        public int targetCount => config.threadCount * config.loopCountPerThread;
-
-        public int sumCount = 0;
-        public int sumFailCount = 0;
-
-        public int curCount=0;
-        public int failCount=0;
-        public TaskConfig config;
-
-        void StepUp(bool success)
-        {
-            Interlocked.Increment(ref curCount);
-            Interlocked.Increment(ref sumCount);
-            if (!success)
-            {
-                Interlocked.Increment(ref sumFailCount);
-                Interlocked.Increment(ref failCount);
-            }
-
-        }
-
-      
-        public Task(TaskConfig config)
-        {
-            this.config = config;
-
-            tasks.threadCount = config.threadCount;
-            tasks.repeatCountPerThread = config.loopCountPerThread;
-
-            if (config.apiRoute.StartsWith("http"))
-            {
-                if (config.httpUseHttpUtil)
-                {
-                    httpClient = new HttpClient();
-                    httpClient_ReqParam = new HttpRequest
-                    {
-                        url = config.apiRoute,
-                        body = config.apiArg,
-                        httpMethod = config.httpMethod
-                    };
-
-                    tasks.action = ActionHttpClient;
-                }
-                else
-                {
-
-                    httpUtil = new HttpUtil();
-                    httpUtil_Request = new RequestParam
-                    {
-                        url = config.apiRoute,
-                        body = config.apiArg,
-                        Method = config.httpMethod
-                    };
-                    tasks.action = ActionHttpUtil;
-                }
-               
-            }
-            else
-            {
-                tasks.action = ActionApiClient;
-            }           
-        }
-
-
-
-        #region ActionHttpClient       
-        HttpClient httpClient;
-        HttpRequest httpClient_ReqParam;
-        void ActionHttpClient()
-        {
-            bool success = false;
-            try
-            {    
-
-                var ret = httpClient.Send<ApiReturn>(httpClient_ReqParam)?.data;
-                if (ret.success)
-                {
-                    success = true;
-                }
-                else
-                {
-                    if (config.logError)
-                        Logger.Info("失败：ret:" + ret.Serialize());
-                }
-            }
-            catch (Exception ex)
-            {
-                Interlocked.Increment(ref failCount);
-                Logger.Error(ex);
-            }
-            StepUp(success);
-            Thread.Sleep(config.interval);
-        }
-        #endregion
-
-
-        #region ActionHttpUtil
-
-        HttpUtil httpUtil;
-        RequestParam httpUtil_Request;
-        void ActionHttpUtil()
-        {
-            bool success = false;
-            try
-            {
-                var ret = httpUtil.Ajax<ApiReturn>(httpUtil_Request);
-                if (ret.success)
-                {
-                    success = true;
-                }
-                else
-                {
-                    if (config.logError)
-                        Logger.Info("失败：ret:" + ret.Serialize());
-                }
-            }
-            catch (Exception ex)
-            {
-                Interlocked.Increment(ref failCount);
-                Logger.Error(ex);
-            }
-            StepUp(success);
-            Thread.Sleep(config.interval);
-        }
-        #endregion
-
-
-        void ActionApiClient()
-        {
-            bool success = false;
-            try
-            {
-                
-                var ret = ApiClient.CallRemoteApi<ApiReturn>(config.apiRoute, config.apiArg, config.httpMethod);
-                if (ret!=null && ret.success)
-                {
-                    success = true;
-                }
-                else
-                {
-                    if(config.logError)
-                    Logger.Info("失败：ret:" + ret.Serialize());
-                }
-            }
-            catch (Exception ex)
-            {
-                Interlocked.Increment(ref failCount);
-                Logger.Error(ex);
-            }
-            StepUp(success);
-            if(config.interval>0)
-                Thread.Sleep(config.interval);
-        }
-
-        public void Start()
-        {
-            tasks.threadName = "Robot-"+ config.name;
-
-            curCount = 0;
-            failCount = 0;
-            tasks.Start();
-        }
-
-        public void Stop()
-        {
-            tasks.Stop();
-        }
-
-    }
-}

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Logical/Model/TaskConfig.cs → dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Logical/TaskConfig.cs

@@ -1,7 +1,14 @@
-namespace App.Robot.Station.Logical.Model
+namespace App.Robot.Station.Logical
 {
     public class TaskConfig
     {
+
+        /// <summary>
+        /// ApiClient、ApiClientAsync、 HttpClient、HttpUtil
+        /// </summary>
+        public string type = "ApiClient";
+
+
         public string name="taskName";
 
         public string apiRoute;
@@ -9,16 +16,11 @@
         public string httpMethod;
 
 
-        /// <summary>
-        /// （为http时有效）是否使用HttpUtil。默认使用HttpClient 
-        /// </summary>
-        public bool httpUseHttpUtil;
-
 
         public int threadCount=1;
-        public int loopCountPerThread=2000;     
-
 
+        public int loopCountPerThread=2000;     
+        
 
  
         /// <summary>

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Logical/TaskMng.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
-using App.Robot.Station.Logical.Model;
+using App.Robot.Station.Logical.Worker;
 using Newtonsoft.Json;
 using Vit.Core.Util.ConfigurationManager;
 
@@ -37,7 +37,7 @@ namespace App.Robot.Station.Logical
 
 
         [JsonProperty]
-         ConcurrentDictionary<int, Task> tasks = new ConcurrentDictionary<int, Task>();
+         ConcurrentDictionary<int, IWorker> tasks = new ConcurrentDictionary<int, IWorker>();
         [JsonProperty]
         int curKeyIndex = 0;
 
@@ -56,7 +56,16 @@ namespace App.Robot.Station.Logical
         {
             var key = GetNewKey();
 
-            var task = new Task(config);
+            IWorker task;
+
+            switch (config.type)
+            {
+                case "ApiClientAsync": task = new Worker_ApiClientAsync(config); break;
+                case "HttpClient": task = new Worker_HttpClient(config); break;
+                case "HttpUtil": task = new Worker_HttpUtil(config); break;
+                default: config.type = "ApiClient"; task = new Worker_ApiClient(config); break;
+            }
+
             task.id = key;
             return tasks.TryAdd(key, task);
         }
@@ -92,7 +101,7 @@ namespace App.Robot.Station.Logical
         }
 
 
-        public  List<Task> GetAll()
+        public  List<IWorker> GetAll()
         {
             return tasks.Values.ToList();
         }

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Logical/Worker/IWorker.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace App.Robot.Station.Logical.Worker
+{
+    public interface IWorker
+    {
+        int id { get; set; }
+
+        TaskConfig config { get; set; }
+
+        void Start();
+
+        void Stop();
+    }
+}

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Logical/Worker/Worker_ApiClient.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Newtonsoft.Json;
+using Sers.Core.Module.Api;
+using Vit.Core.Module.Log;
+using Vit.Core.Util.ComponentModel.Data;
+using Vit.Core.Util.Threading;
+using Vit.Extensions;
+
+namespace App.Robot.Station.Logical.Worker
+{
+
+
+    public class Worker_ApiClient: IWorker
+    {
+        public Worker_ApiClient(TaskConfig config)
+        {
+            this.config = config;
+
+            tasks.threadCount = config.threadCount;
+            tasks.repeatCountPerThread = config.loopCountPerThread;
+
+            tasks.action = Processor;
+        }
+
+
+        public string name => config.name;
+        public int id { get; set; }
+
+        [JsonIgnore]
+        RepeatTaskHelp tasks = new RepeatTaskHelp();
+
+        public int RunningThreadCount => tasks.RunningThreadCount;
+
+
+        public bool IsRunning => tasks.IsRunning;
+ 
+        public int targetCount => config.threadCount * config.loopCountPerThread;
+
+        public int sumCount = 0;
+        public int sumFailCount = 0;
+
+        public int curCount=0;
+        public int failCount=0;
+        public TaskConfig config { get; set; }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void StepUp(bool success)
+        {
+            Interlocked.Increment(ref curCount);
+            Interlocked.Increment(ref sumCount);
+            if (!success)
+            {
+                Interlocked.Increment(ref sumFailCount);
+                Interlocked.Increment(ref failCount);
+            }
+
+        }
+
+      
+    
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected virtual void Processor()
+        {
+            bool success = false;
+            try
+            {
+                
+                var ret = ApiClient.CallRemoteApi<ApiReturn>(config.apiRoute, config.apiArg, config.httpMethod);
+                if (ret == null || ret.success)
+                {
+                    success = true;
+                }
+                else
+                {
+                    if(config.logError)
+                    Logger.Info("失败：ret:" + ret.Serialize());
+                }
+            }
+            catch (Exception ex)
+            {
+                Interlocked.Increment(ref failCount);
+                Logger.Error(ex);
+            }
+            StepUp(success);
+            if(config.interval>0)
+                Thread.Sleep(config.interval);
+        }
+
+        public void Start()
+        {
+            tasks.threadName = "Robot-"+ config.name;
+
+            curCount = 0;
+            failCount = 0;
+            tasks.Start();
+        }
+
+        public void Stop()
+        {
+            tasks.Stop();
+        }
+
+    }
+}

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Logical/Worker/Worker_ApiClientAsync.cs

@@ -0,0 +1,108 @@
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Sers.Core.Module.Api;
+using Vit.Core.Module.Log;
+using Vit.Core.Util.ComponentModel.Data;
+using Vit.Extensions;
+
+namespace App.Robot.Station.Logical.Worker
+{
+
+
+    public class Worker_ApiClientAsync: IWorker
+    {
+        public Worker_ApiClientAsync(TaskConfig config)
+        {
+            this.config = config;
+        }
+
+
+        public string name => config.name;
+        public int id { get; set; }
+
+
+
+        public int RunningThreadCount = 0;
+
+
+        bool needRunning = false;
+
+        public bool IsRunning => RunningThreadCount==0;
+ 
+        public int targetCount => config.threadCount * config.loopCountPerThread;
+
+        public int sumCount = 0;
+        public int sumFailCount = 0;
+
+        public int curCount=0;
+        public int failCount=0;
+        public TaskConfig config { get; set; }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void StepUp(bool success)
+        {
+            Interlocked.Increment(ref curCount);
+            Interlocked.Increment(ref sumCount);
+            if (!success)
+            {
+                Interlocked.Increment(ref sumFailCount);
+                Interlocked.Increment(ref failCount);
+            }
+
+        }
+
+      
+    
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected  void CallApi()
+        {
+            ApiClient.CallRemoteApiAsync<ApiReturn>((ret) =>
+            {
+                bool success = false;
+                if (ret == null || ret.success)
+                {
+                    success = true;
+                }
+                else
+                {
+                    if (config.logError)
+                        Logger.Info("失败：ret:" + ret.Serialize());
+                }
+
+                StepUp(success);
+
+                if (config.interval > 0)
+                    Thread.Sleep(config.interval);
+
+                if (needRunning) CallApi();
+                else
+                {
+                    Interlocked.Decrement(ref RunningThreadCount);
+                }
+
+            },config.apiRoute, config.apiArg, config.httpMethod);      
+          
+        }
+
+        public void Start()
+        { 
+            curCount = 0;
+            failCount = 0;
+            needRunning = true;
+
+            for (var t = 0; t < config.threadCount; t++) 
+            {
+                Interlocked.Increment(ref RunningThreadCount);
+                CallApi();
+            }
+        }
+
+        public void Stop()
+        {
+            needRunning = false;
+        }
+
+    }
+}

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Logical/Worker/Worker_HttpClient.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Vit.Core.Module.Log;
+using Vit.Core.Util.ComponentModel.Data;
+using Vit.Extensions;
+using Vit.Core.Util.Net;
+
+namespace App.Robot.Station.Logical.Worker
+{
+
+
+    public class Worker_HttpClient: Worker_ApiClient
+    {
+
+        HttpClient httpClient;
+        HttpRequest httpClient_ReqParam;
+        public Worker_HttpClient(TaskConfig config):base(config)
+        {
+            httpClient = new HttpClient();
+            httpClient_ReqParam = new HttpRequest
+            {
+                url = config.apiRoute,
+                body = config.apiArg,
+                httpMethod = config.httpMethod
+            };
+
+        }
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected override void Processor()
+        {
+            bool success = false;
+            try
+            {
+
+                var ret = httpClient.Send<ApiReturn>(httpClient_ReqParam)?.data;
+                if (ret.success)
+                {
+                    success = true;
+                }
+                else
+                {
+                    if (config.logError)
+                        Logger.Info("失败：ret:" + ret.Serialize());
+                }
+            }
+            catch (Exception ex)
+            {
+                Interlocked.Increment(ref failCount);
+                Logger.Error(ex);
+            }
+            StepUp(success);
+            Thread.Sleep(config.interval);
+        }
+
+        
+
+    }
+}

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/Logical/Worker/Worker_HttpUtil.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Vit.Core.Module.Log;
+using Vit.Core.Util.ComponentModel.Data;
+using Vit.Extensions;
+using Vit.Core.Util.Net;
+
+namespace App.Robot.Station.Logical.Worker
+{
+
+
+    public class Worker_HttpUtil : Worker_ApiClient
+    {
+
+        HttpUtil httpUtil;
+        RequestParam httpUtil_Request;
+        public Worker_HttpUtil(TaskConfig config) : base(config)
+        {
+            httpUtil = new HttpUtil();
+            httpUtil_Request = new RequestParam
+            {
+                url = config.apiRoute,
+                body = config.apiArg,
+                Method = config.httpMethod
+            };
+        }
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected override void Processor()
+        {
+            bool success = false;
+            try
+            {
+                var ret = httpUtil.Ajax<ApiReturn>(httpUtil_Request);
+                if (ret.success)
+                {
+                    success = true;
+                }
+                else
+                {
+                    if (config.logError)
+                        Logger.Info("失败：ret:" + ret.Serialize());
+                }
+            }
+            catch (Exception ex)
+            {
+                Interlocked.Increment(ref failCount);
+                Logger.Error(ex);
+            }
+            StepUp(success);
+            Thread.Sleep(config.interval);
+        }
+
+
+
+    }
+}

dotnet/ServiceStation/Demo/StressTest/App.Robot.Station/wwwroot/_robot_/TaskMng.html

@@ -107,7 +107,7 @@
         var config = new Vue({
             el: '#txtTaskConfig',
             data: {
-                config: '{ "name": "Demo[8-0]","apiRoute": "/demo/v1/api/333/arg", "//apiArg": "{\\"Name\\":\\"lith\\"}","httpMethod":"POST","httpUseHttpUtil":false, "threadCount": 8,"interval": 0, "autoStart": false,"loopCountPerThread": 1000000000 }'
+                config: '{"type":"ApiClientAsync","name": "Demo[8-0]","apiRoute": "/a", "//apiArg": "{\\"Name\\":\\"lith\\"}","httpMethod":"POST", "threadCount": 8,"interval": 0, "autoStart": false,"loopCountPerThread": 1000000000, "//type":"ApiClient、ApiClientAsync、 HttpClient、HttpUtil","//apiRoute": "/demo/v1/api/333/arg" }'
             }
         });