@zwa73/utils 1.0.42 → 1.0.44

package/dist/UtilCom.d.ts

@@ -1,7 +1,7 @@
 import { JObject } from "./UtilInterfaces";
 /**网络工具 */
 export declare namespace UtilCom {
-    /**发送一个POST请求并接受数据
+    /**发送一个 https POST请求并接受数据
      * Object ()
      * @async
      * @param {JObject} json 	   - 数据对象
@@ -10,7 +10,7 @@ export declare namespace UtilCom {
      * @returns {Promise<Object|null>} 结果 null 为未能成功接收
      */
     function shttpsPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
-    /**发送一个POST请求并接受数据
+    /**发送一个 http POST请求并接受数据
      * Object ()
      * @async
      * @param {JObject} json 	   - 数据对象
@@ -19,4 +19,35 @@ export declare namespace UtilCom {
      * @returns {Promise<Object|null>} 结果 null 为未能成功接收
      */
     function shttpPost(json: JObject, options: Object, timeLimit?: number): Promise<JObject | null>;
+    /**请求完成状态 成功/失败/终止
+     * 成功/终止 将直接返回
+     * 失败 将重试
+     */
+    type PostStat = "Completed" | "Failed" | "Terminated";
+    /**post处理函数 */
+    type PostProc = (respObj: JObject | null) => Promise<PostStat> | PostStat;
+    /**重复一个 https POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PostProc} [procFunc]     - 判断有效性函数
+     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     */
+    function shttpsRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, procFunc?: PostProc): Promise<JObject | null>;
+    /**重复一个 http POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PostProc} [procFunc]     - 判断有效性函数
+     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     */
+    function shttpRepeatPost(json: JObject, options: Object, timeLimit?: number, repeatCount?: number, repeatTime?: number, procFunc?: PostProc): Promise<JObject | null>;
 }

package/dist/UtilCom.js

@@ -5,16 +5,24 @@ const UtilInterfaces_1 = require("./UtilInterfaces");
 const https = require("https");
 const http = require("http");
 const UtilLogger_1 = require("./UtilLogger");
+const UtilFunctions_1 = require("./UtilFunctions");
 /**网络工具 */
 var UtilCom;
 (function (UtilCom) {
-    function sPost(type, json, options, timeLimit = -1) {
+    /**通用post处理
+     * @param {"http"|"https"} posttype - post类型
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+     */
+    function sPost(posttype, json, options, timeLimit = -1) {
         //转换为毫秒
         const hasTimeLimit = (timeLimit >= 10);
         if (hasTimeLimit)
             timeLimit *= 1000;
         const jsonStr = (0, UtilInterfaces_1.stringifyJToken)(json);
-        const funcName = "s" + type + "Psot";
+        const funcName = "s" + posttype + "Psot";
         return new Promise((resolve, rejecte) => {
             const resFunc = (res) => {
                 try {
@@ -62,9 +70,9 @@ var UtilCom;
             };
             //路由 http/https
             let req = null;
-            if (type === "https")
+            if (posttype === "https")
                 req = https.request(options, resFunc);
-            else if (type === "http")
+            else if (posttype === "http")
                 req = http.request(options, resFunc);
             //请求超时
             if (hasTimeLimit) {
@@ -81,7 +89,7 @@ var UtilCom;
             req.end();
         });
     }
-    /**发送一个POST请求并接受数据
+    /**发送一个 https POST请求并接受数据
      * Object ()
      * @async
      * @param {JObject} json 	   - 数据对象
@@ -93,7 +101,7 @@ var UtilCom;
         return sPost("https", json, options, timeLimit);
     }
     UtilCom.shttpsPost = shttpsPost;
-    /**发送一个POST请求并接受数据
+    /**发送一个 http POST请求并接受数据
      * Object ()
      * @async
      * @param {JObject} json 	   - 数据对象
@@ -105,4 +113,121 @@ var UtilCom;
         return sPost("http", json, options, timeLimit);
     }
     UtilCom.shttpPost = shttpPost;
+    /**通用重复post处理
+     * @async
+     * @param {"http"|"https"} posttype - post类型
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PostProc} [procFunc]     - 判断有效性函数
+     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     */
+    async function sRepeatPost(posttype, json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, procFunc) {
+        //转换为毫秒
+        const hasRepeatTime = (repeatTime >= 10);
+        if (hasRepeatTime)
+            repeatTime *= 1000;
+        //验证处理函数
+        if (procFunc === undefined)
+            procFunc = () => "Completed";
+        //计时器
+        let timer = null;
+        let timerP = null;
+        let resolveFn = null;
+        /**清理计时器 */
+        const clearTimer = () => {
+            if (timer != null)
+                clearInterval(timer);
+            if (resolveFn != null)
+                resolveFn("Timeout");
+            timerP = null;
+            timer = null;
+            resolveFn = null;
+        };
+        //进行中的请求
+        const plist = new Array(repeatCount).fill(UtilFunctions_1.UtilFunc.getNeverResolvedPromise());
+        for (let i = 0; i < repeatCount;) {
+            UtilLogger_1.SLogger.info("开始第 " + (i + 1) + " 次 sRepeatPost");
+            //创建当前任务
+            plist[i] = sPost(posttype, json, options, timeLimit)
+                .then(result => ({ result, stat: procFunc(result), index: i }));
+            //创建定时器
+            if (timerP == null) {
+                timerP = new Promise(function (resolve, rejecte) {
+                    resolveFn = resolve;
+                    timer = setTimeout(() => resolve("Timeout"), hasRepeatTime ? repeatTime : Infinity); //无限制则无限时间
+                });
+            }
+            //等待完成
+            const currObj = await Promise.race([...plist, timerP]);
+            //超时处理
+            if (currObj == "Timeout") {
+                UtilLogger_1.SLogger.warn(`第 ${(i + 1)} 次 sRepeatPost 超时 ${repeatTime} ms 开始重试`);
+                clearTimer();
+                i++;
+                continue;
+            }
+            else {
+                const poststat = await currObj.stat;
+                switch (poststat) {
+                    case "Completed": //完成
+                        UtilLogger_1.SLogger.info("第 " + (currObj.index + 1) + " 次 sRepeatPost 成功");
+                        clearTimer();
+                        return currObj.result;
+                    case "Terminated": //终止
+                        UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 sRepeatPost 终止 停止重试");
+                        clearTimer();
+                        return currObj.result;
+                    case "Failed": //验证失败
+                        //是当前
+                        if (currObj.index == i) {
+                            UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 sRepeatPost 失败 开始重试");
+                            clearTimer();
+                            i++;
+                            continue;
+                        }
+                        //非当前
+                        UtilLogger_1.SLogger.warn("第 " + (currObj.index + 1) + " 次 sRepeatPost 失败");
+                        //抛弃失败
+                        plist[currObj.index] = UtilFunctions_1.UtilFunc.getNeverResolvedPromise();
+                        continue;
+                }
+            }
+        }
+        clearTimer();
+        //全部失败或超时则返回null
+        return null;
+    }
+    /**重复一个 https POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PostProc} [procFunc]     - 判断有效性函数
+     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     */
+    function shttpsRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, procFunc) {
+        return sRepeatPost("https", json, options, timeLimit, repeatCount, repeatTime, procFunc);
+    }
+    UtilCom.shttpsRepeatPost = shttpsRepeatPost;
+    /**重复一个 http POST请求并接受数据
+     * Object ()
+     * @async
+     * @param {JObject} json 	        - 数据对象
+     * @param {Object} options          - 参数对象
+     * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+     * @param {number} [repeatCount]    - 重试次数
+     * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+     * @param {PostProc} [procFunc]     - 判断有效性函数
+     * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+     */
+    function shttpRepeatPost(json, options, timeLimit = -1, repeatCount = 3, repeatTime = 180, procFunc) {
+        return sRepeatPost("http", json, options, timeLimit, repeatCount, repeatTime, procFunc);
+    }
+    UtilCom.shttpRepeatPost = shttpRepeatPost;
 })(UtilCom = exports.UtilCom || (exports.UtilCom = {}));

package/dist/UtilFunctions.d.ts

@@ -49,4 +49,6 @@ export declare namespace UtilFunc {
         stdout: string;
         stderr: string;
     }>;
+    /**获得一个永不完成的Promise单例 */
+    function getNeverResolvedPromise<T>(): Promise<T>;
 }

package/dist/UtilFunctions.js

@@ -92,4 +92,10 @@ var UtilFunc;
         });
     }
     UtilFunc.exec = exec;
+    const NeverResolvedPromise = new Promise(() => { });
+    /**获得一个永不完成的Promise单例 */
+    function getNeverResolvedPromise() {
+        return NeverResolvedPromise;
+    }
+    UtilFunc.getNeverResolvedPromise = getNeverResolvedPromise;
 })(UtilFunc = exports.UtilFunc || (exports.UtilFunc = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zwa73/utils",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "description": "my utils",
   "main": "index.js",
   "scripts": {

package/src/UtilCom.ts

@@ -2,19 +2,27 @@ import { JObject, stringifyJToken } from "./UtilInterfaces";
 import * as https from 'https';
 import * as http from 'http';
 import { SLogger } from "./UtilLogger";
+import { UtilFunc } from "./UtilFunctions";
 
 
 /**网络工具 */
 export namespace UtilCom{
 
-function sPost(type:"http"|"https",json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
+/**通用post处理  
+ * @param {"http"|"https"} posttype - post类型
+ * @param {JObject} json 	        - 数据对象
+ * @param {Object} options          - 参数对象
+ * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+ * @returns {Promise<Object|null>} 结果 null 为未能成功接收
+ */
+function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
     //转换为毫秒
     const hasTimeLimit = (timeLimit>=10);
     if(hasTimeLimit)
         timeLimit*=1000
 
     const jsonStr = stringifyJToken(json);
-    const funcName = "s"+type+"Psot";
+    const funcName = "s"+posttype+"Psot";
 
     return new Promise((resolve, rejecte)=>{
         const resFunc = (res:http.IncomingMessage)=>{
@@ -65,9 +73,9 @@ function sPost(type:"http"|"https",json:JObject,options:Object,timeLimit:number=
         };
         //路由 http/https
         let req:http.ClientRequest=null as any as http.ClientRequest;
-        if(type === "https")
+        if(posttype === "https")
             req = https.request(options, resFunc);
-        else if(type === "http")
+        else if(posttype === "http")
             req = http.request(options, resFunc);
 
         //请求超时
@@ -88,8 +96,8 @@ function sPost(type:"http"|"https",json:JObject,options:Object,timeLimit:number=
     });
 }
 
-/**发送一个POST请求并接受数据
- * Object ()
+/**发送一个 https POST请求并接受数据  
+ * Object ()  
  * @async
  * @param {JObject} json 	   - 数据对象
  * @param {Object} options     - 参数对象
@@ -100,8 +108,8 @@ export function shttpsPost(json:JObject,options:Object,timeLimit:number=-1):Prom
     return sPost("https",json,options,timeLimit);
 }
 
-/**发送一个POST请求并接受数据
- * Object ()
+/**发送一个 http POST请求并接受数据  
+ * Object ()  
  * @async
  * @param {JObject} json 	   - 数据对象
  * @param {Object} options     - 参数对象
@@ -111,4 +119,147 @@ export function shttpsPost(json:JObject,options:Object,timeLimit:number=-1):Prom
 export function shttpPost(json:JObject,options:Object,timeLimit:number=-1):Promise<JObject|null>{
     return sPost("http",json,options,timeLimit);
 }
+
+/**进行中的请求 */
+type ProcessingPost = {
+    /**主体请求 */
+    result:JObject|null;
+    /**请求状态 */
+    stat:PostStat|Promise<PostStat>;
+    /**请求下标/序号 */
+    index:number;
+}
+/**请求完成状态 成功/失败/终止  
+ * 成功/终止 将直接返回  
+ * 失败 将重试  
+ */
+export type PostStat = "Completed"|"Failed"|"Terminated";
+/**post处理函数 */
+export type PostProc = (respObj:JObject|null)=>Promise<PostStat>|PostStat;
+
+/**通用重复post处理  
+ * @async
+ * @param {"http"|"https"} posttype - post类型
+ * @param {JObject} json 	        - 数据对象
+ * @param {Object} options          - 参数对象
+ * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+ * @param {number} [repeatCount]    - 重试次数
+ * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+ * @param {PostProc} [procFunc]     - 判断有效性函数
+ * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+ */
+async function sRepeatPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:number=-1,
+    repeatCount:number=3,repeatTime:number=180,procFunc?:PostProc):Promise<JObject|null>{
+    //转换为毫秒
+    const hasRepeatTime = (repeatTime>=10);
+    if(hasRepeatTime) repeatTime*=1000;
+
+    //验证处理函数
+    if(procFunc===undefined)
+        procFunc = ()=>"Completed";
+
+    //计时器
+    let timer:NodeJS.Timer|null = null;
+    let timerP:Promise<"Timeout">|null=null;
+    let resolveFn:((value: "Timeout" | PromiseLike<"Timeout">)=>void)|null = null;
+    /**清理计时器 */
+    const clearTimer = ()=>{
+        if(timer!=null)
+            clearInterval(timer);
+        if(resolveFn!=null)
+            resolveFn("Timeout");
+        timerP=null;
+        timer=null;
+        resolveFn=null;
+    }
+
+    //进行中的请求
+	const plist:Promise<ProcessingPost>[] = new Array(repeatCount).fill(UtilFunc.getNeverResolvedPromise());
+    for(let i=0;i<repeatCount;){
+        SLogger.info("开始第 "+(i+1)+" 次 sRepeatPost");
+        //创建当前任务
+        plist[i] = sPost(posttype,json,options,timeLimit)
+            .then(result => ({result, stat:procFunc!(result), index:i}));
+
+        //创建定时器
+        if(timerP==null){
+            timerP = new Promise<"Timeout">(function(resolve, rejecte){
+                resolveFn = resolve;
+                timer = setTimeout(()=>resolve("Timeout"),
+                    hasRepeatTime? repeatTime:Infinity);//无限制则无限时间
+            })
+        }
+
+        //等待完成
+        const currObj = await Promise.race([...plist, timerP]);
+
+        //超时处理
+        if(currObj=="Timeout"){
+            SLogger.warn(`第 ${(i+1)} 次 sRepeatPost 超时 ${repeatTime} ms 开始重试`);
+            clearTimer(); i++;
+            continue;
+        }else{
+            const poststat = await currObj.stat;
+            switch(poststat){
+                case "Completed"://完成
+                    SLogger.info("第 "+(currObj.index+1)+" 次 sRepeatPost 成功");
+                    clearTimer();
+                    return currObj.result;
+                case "Terminated"://终止
+                    SLogger.warn("第 "+(currObj.index+1)+" 次 sRepeatPost 终止 停止重试");
+                    clearTimer();
+                    return currObj.result;
+                case "Failed"://验证失败
+                    //是当前
+                    if(currObj.index==i){
+                        SLogger.warn("第 "+(currObj.index+1)+" 次 sRepeatPost 失败 开始重试");
+                        clearTimer(); i++;
+                        continue;
+                    }
+                    //非当前
+                    SLogger.warn("第 "+(currObj.index+1)+" 次 sRepeatPost 失败");
+                    //抛弃失败
+                    plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
+                    continue;
+            }
+        }
+    }
+    clearTimer();
+    //全部失败或超时则返回null
+    return null;
+}
+
+
+/**重复一个 https POST请求并接受数据  
+ * Object ()  
+ * @async
+ * @param {JObject} json 	        - 数据对象
+ * @param {Object} options          - 参数对象
+ * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+ * @param {number} [repeatCount]    - 重试次数
+ * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+ * @param {PostProc} [procFunc]     - 判断有效性函数
+ * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+ */
+export function shttpsRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
+    repeatCount:number=3,repeatTime:number=180,procFunc?:PostProc):Promise<JObject|null>{
+    return sRepeatPost("https",json,options,timeLimit,repeatCount,repeatTime,procFunc);
+}
+
+/**重复一个 http POST请求并接受数据  
+ * Object ()  
+ * @async
+ * @param {JObject} json 	        - 数据对象
+ * @param {Object} options          - 参数对象
+ * @param {number} [timeLimit]      - 超时时间/秒  最小为10秒
+ * @param {number} [repeatCount]    - 重试次数
+ * @param {number} [repeatTime]     - 超时时间/秒  最小为10秒
+ * @param {PostProc} [procFunc]     - 判断有效性函数
+ * @returns {Promise<Object|null>}  - 结果 null 为未能成功接收
+ */
+export function shttpRepeatPost(json:JObject,options:Object,timeLimit:number=-1,
+    repeatCount:number=3,repeatTime:number=180,procFunc?:PostProc):Promise<JObject|null>{
+    return sRepeatPost("http",json,options,timeLimit,repeatCount,repeatTime,procFunc);
+}
+
 }

package/src/UtilFunctions.ts

@@ -91,5 +91,11 @@ export function exec(command: string) {
 	});
 }
 
+const NeverResolvedPromise = new Promise(()=>{});
+/**获得一个永不完成的Promise单例 */
+export function getNeverResolvedPromise<T>():Promise<T>{
+    return NeverResolvedPromise as Promise<T>;
+}
+
 }
 

package/src/UtilInterfaces.ts

@@ -69,4 +69,4 @@ export type ExclusiveRecord<B, T, K extends string[], TMP = ExclusiveRecursive<B
 
 /**符合JObject约束的互斥表 */
 export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string[],
-    TMP extends JArray = ExclusiveRecursive<B,T,K>> = TMP[number];
+    TMP extends JArray = ExclusiveRecursive<B,T,K>> = TMP[number];