cvitool 1.0.71 → 1.0.73

package/build/src/cutil.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { Encoding } from 'crypto';
+import { ReadStream } from 'fs';
 interface randomStringOptions {
     special?: boolean;
     lowercase?: boolean;
@@ -8,9 +10,15 @@ interface randomStringOptions {
     number?: boolean;
     specials?: string;
 }
+interface getMediaFileTypeRes {
+    type: string;
+    extname: string;
+}
 declare function randomString(length: number, options?: randomStringOptions): string;
 declare function encryptCBC(data: string, length: 128 | 192 | 256, key: Buffer, iv: Buffer, inputEncoding?: Encoding): string;
 declare function decryptCBC(encryptData: string, length: 128 | 192 | 256, key: Buffer, iv: Buffer, outputEncoding?: Encoding): string;
 declare function md5(data: string, inputEncoding?: Encoding): string;
 declare function execCmdCommand(command: string): Promise<unknown>;
-export { randomStringOptions, randomString, encryptCBC, decryptCBC, md5, execCmdCommand };
+declare function getValueType(value: any): "string" | "number" | "undefined" | "object" | "array" | "null" | "unkonw";
+declare function getMediaFileType(target: string | Buffer | ReadStream): Promise<getMediaFileTypeRes>;
+export { randomStringOptions, getMediaFileTypeRes, randomString, encryptCBC, decryptCBC, md5, execCmdCommand, getValueType, getMediaFileType };

package/build/src/cutil.js

@@ -9,9 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execCmdCommand = exports.md5 = exports.decryptCBC = exports.encryptCBC = exports.randomString = void 0;
+exports.getMediaFileType = exports.getValueType = exports.execCmdCommand = exports.md5 = exports.decryptCBC = exports.encryptCBC = exports.randomString = void 0;
 const crypto_1 = require("crypto");
 const child_process_1 = require("child_process");
+const hgo = require("./hgo");
 function randomString(length, options) {
     let { special = false, lowercase = true, upperCase = true, number = true, specials } = options || {};
     if (specials) {
@@ -92,3 +93,146 @@ function execCmdCommand(command) {
     });
 }
 exports.execCmdCommand = execCmdCommand;
+function getValueType(value) {
+    const typeStr = Object.prototype.toString.call(value);
+    let type;
+    switch (typeStr) {
+        case '[object Number]':
+            type = 'number';
+            break;
+        case '[object String]':
+            type = 'string';
+            break;
+        case '[object Object]':
+            type = 'object';
+            break;
+        case '[object Array]':
+            type = 'array';
+            break;
+        case '[object Undefined]':
+            type = 'undefined';
+            break;
+        case '[object Null]':
+            type = 'null';
+            break;
+        default:
+            type = 'unkonw';
+            break;
+    }
+    ;
+    return type;
+}
+exports.getValueType = getValueType;
+function getMediaFileType(target) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const readStreamOnceBuffer = (stream) => __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                stream.once('data', chunk => {
+                    stream.close();
+                    resolve(chunk);
+                });
+                stream.on('error', e => {
+                    reject(e);
+                });
+            });
+        });
+        const checkString = (waitMatchStr, byteStart, byteEnd, buffer) => {
+            return waitMatchStr === Buffer.from(buffer.slice(byteStart, byteEnd + 1)).toString();
+        };
+        const checkBuffer = (waitMatchBuffer, byteStart, byteEnd, buffer) => {
+            let equal = true;
+            const sliceBufferList = buffer.slice(byteStart, byteEnd + 1);
+            for (const [index, item] of waitMatchBuffer.entries()) {
+                if (item !== sliceBufferList[index]) {
+                    equal = false;
+                    break;
+                }
+            }
+            return equal;
+        };
+        const getResult = (typeStr) => {
+            const arr = typeStr.split('|');
+            return {
+                type: arr[0],
+                extname: arr[1]
+            };
+        };
+        let buffer;
+        const targetType = this.getValueType(target);
+        if (targetType === 'string') {
+            const res = yield hgo.get(target, {
+                resType: 'buffer',
+                headers: {
+                    Range: 'bytes=0-20'
+                }
+            });
+            buffer = res.resBody;
+        }
+        else if (targetType === 'array') {
+            buffer = target;
+        }
+        else {
+            buffer = yield readStreamOnceBuffer(target);
+        }
+        buffer = buffer.slice(0, 20);
+        if (checkBuffer([0xff, 0xd8], 0, 1, buffer)) {
+            return getResult('image|jpg');
+        }
+        if (checkString('PNG', 1, 3, buffer)) {
+            return getResult('image|png');
+        }
+        if (checkBuffer([0x49, 0x44, 0x33], 0, 2, buffer) || checkBuffer([0xff, 0xf3], 0, 1, buffer)) {
+            return getResult('audio|mp3');
+        }
+        if (checkString('WAV', 8, 10, buffer)) {
+            return getResult('audio|wav');
+        }
+        if (checkString('M4A', 8, 10, buffer)) {
+            return getResult('audio|m4a');
+        }
+        if (checkString('heic', 8, 11, buffer) || checkString('mif1', 8, 11, buffer)) {
+            return getResult('image|heic');
+        }
+        if (checkString('ftyp', 4, 7, buffer)) {
+            if (checkString('ftypqt', 4, 9, buffer)) {
+                return getResult('video|mov');
+            }
+            return getResult('video|mp4');
+        }
+        if (checkString('WEBP', 8, 11, buffer)) {
+            return getResult('image|webp');
+        }
+        if (checkBuffer([0x47, 0x49, 0x46], 0, 2, buffer)) {
+            return getResult('image|gif');
+        }
+        if (checkBuffer([0x42, 0x4d], 0, 1, buffer)) {
+            return getResult('image|bmp');
+        }
+        if (checkBuffer([0x46, 0x4c, 0x56], 0, 2, buffer)) {
+            return getResult('video|flv');
+        }
+        if (checkBuffer([0x4f, 0x67, 0x67, 0x53], 0, 3, buffer)) {
+            return getResult('video|ogg');
+        }
+        if (checkBuffer([0x1a, 0x45, 0xdf, 0xa3], 0, 3, buffer)) {
+            return getResult('video|mkv');
+        }
+        if (checkBuffer([0x30, 0x26, 0xb2], 0, 2, buffer)) {
+            return getResult('video|wmv');
+        }
+        if (checkString('AVI', 8, 10, buffer)) {
+            return getResult('video|avi');
+        }
+        if (checkBuffer([0xff, 0xf1], 0, 1, buffer)) {
+            return getResult('audio|aac');
+        }
+        if (checkString('PCM', 10, 12, buffer)) {
+            return getResult('audio|pcm');
+        }
+        if (checkBuffer([0x66, 0x4c, 0x61, 0x43], 0, 3, buffer)) {
+            return getResult('audio|flac');
+        }
+        return getResult('unknow|unknow');
+    });
+}
+exports.getMediaFileType = getMediaFileType;

package/build/src/hgo.d.ts

@@ -28,10 +28,16 @@ interface reqOptions extends baseReqOptions {
     body?: {
         [key: string]: any;
     };
+    retries?: number;
+    retryInterval?: number;
+    [key: string]: any;
 }
 interface reqSendBufferOptions extends baseReqOptions {
-    method?: Method;
     buffer: Buffer;
+    method?: Method;
+    retries?: number;
+    retryInterval?: number;
+    [key: string]: any;
 }
 interface reqSendStreamOptions extends baseReqOptions {
     method?: Method;

package/build/src/hgo.js

@@ -26,7 +26,7 @@ function getProtocol(url) {
 }
 function request(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        let { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json', connectTimeOut, readTimeOut } = options || {};
+        let { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json', connectTimeOut, readTimeOut, retries, retryInterval, retrieds } = options || {};
         if (timeout && !(connectTimeOut && readTimeOut)) {
             connectTimeOut = timeout;
             readTimeOut = timeout;
@@ -49,72 +49,108 @@ function request(url, options) {
                 'Content-length': Buffer.byteLength(data)
             };
         }
-        return new Promise((resolve, reject) => {
-            const req = protocol.request(url, {
-                timeout: connectTimeOut,
-                headers: Object.assign(headers, baseHeaders),
-                method,
-                agent
-            }, res => {
-                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
-            });
-            req.on('timeout', () => {
-                req.destroy();
-                reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
-            });
-            req.on('error', e => {
-                req.destroy();
-                reject(e);
-            });
-            if (isbodyEmpty) {
-                req.end();
-            }
-            else {
-                req.write(data, (e) => {
-                    req.end();
-                    if (e) {
-                        req.destroy();
-                        reject(e);
-                    }
+        let res;
+        try {
+            res = yield new Promise((resolve, reject) => {
+                const req = protocol.request(url, {
+                    timeout: connectTimeOut,
+                    headers: Object.assign(headers, baseHeaders),
+                    method,
+                    agent
+                }, res => {
+                    resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+                });
+                req.on('timeout', () => {
+                    req.destroy();
+                    reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
+                });
+                req.on('error', e => {
+                    req.destroy();
+                    reject(e);
                 });
+                if (isbodyEmpty) {
+                    req.end();
+                }
+                else {
+                    req.write(data, (e) => {
+                        req.end();
+                        if (e) {
+                            req.destroy();
+                            reject(e);
+                        }
+                    });
+                }
+            });
+        }
+        catch (e) {
+            if ((retrieds || 0) < (retries || 0)) {
+                if (retryInterval) {
+                    yield new Promise((resolve) => {
+                        setTimeout(() => {
+                            resolve(1);
+                        }, retryInterval);
+                    });
+                }
+                res = yield request(url, Object.assign(Object.assign({}, options), { retrieds: (retrieds || 0) + 1 }));
+                return res;
             }
-        });
+            throw e;
+        }
+        return res;
     });
 }
 exports.request = request;
 function reqSendBuffer(url, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        let { timeout = 5000, headers = {}, buffer, method = 'post', agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+        let { timeout = 5000, headers = {}, buffer, method = 'post', agent, resType = 'json', connectTimeOut, readTimeOut, retries, retryInterval, retrieds } = options;
         if (timeout && !(connectTimeOut && readTimeOut)) {
             connectTimeOut = timeout;
             readTimeOut = timeout;
         }
         const protocol = getProtocol(url);
-        return new Promise((resolve, reject) => {
-            const req = protocol.request(url, {
-                timeout: connectTimeOut,
-                headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
-                method,
-                agent
-            }, res => {
-                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
-            });
-            req.on('timeout', () => {
-                req.destroy();
-                reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
-            });
-            req.on('error', e => {
-                req.destroy();
-                reject(e);
-            });
-            req.write(buffer, (e) => {
-                req.end();
-                if (e) {
+        let res;
+        try {
+            res = yield new Promise((resolve, reject) => {
+                const req = protocol.request(url, {
+                    timeout: connectTimeOut,
+                    headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
+                    method,
+                    agent
+                }, res => {
+                    resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+                });
+                req.on('timeout', () => {
+                    req.destroy();
+                    reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
+                });
+                req.on('error', e => {
                     req.destroy();
                     reject(e);
-                }
+                });
+                req.write(buffer, (e) => {
+                    req.end();
+                    if (e) {
+                        req.destroy();
+                        reject(e);
+                    }
+                });
             });
-        });
+        }
+        catch (e) {
+            if ((retrieds || 0) < (retries || 0)) {
+                if (retryInterval) {
+                    yield new Promise((resolve) => {
+                        setTimeout(() => {
+                            resolve(1);
+                        }, retryInterval);
+                    });
+                }
+                res = yield reqSendBuffer(url, Object.assign(Object.assign({}, options), { retrieds: (retrieds || 0) + 1 }));
+                return res;
+            }
+            throw e;
+        }
+        return res;
     });
 }
 exports.reqSendBuffer = reqSendBuffer;
@@ -126,7 +162,7 @@ function reqSendStream(url, options) {
             readTimeOut = timeout;
         }
         const protocol = getProtocol(url);
-        return new Promise((resolve, reject) => {
+        const res = yield new Promise((resolve, reject) => {
             const baseHeaders = {
                 'Content-Type': 'application/octet-stream',
                 'Transfer-Encoding': 'chunked',
@@ -151,6 +187,7 @@ function reqSendStream(url, options) {
             stream.on('data', chunk => {
                 req.write(chunk, e => {
                     if (e) {
+                        stream.close();
                         req.destroy();
                         reject(e);
                     }
@@ -158,7 +195,6 @@ function reqSendStream(url, options) {
             });
             stream.on('end', () => {
                 req.end();
-                stream.close();
             });
             stream.on('error', e => {
                 req.destroy();
@@ -166,6 +202,7 @@ function reqSendStream(url, options) {
                 reject(e);
             });
         });
+        return res;
     });
 }
 exports.reqSendStream = reqSendStream;
@@ -177,7 +214,7 @@ function reqSendMultiPart(url, options) {
             readTimeOut = timeout;
         }
         const protocol = getProtocol(url);
-        return new Promise((resolve, reject) => {
+        const res = yield new Promise((resolve, reject) => {
             const req = protocol.request(url, {
                 timeout: connectTimeOut,
                 headers: Object.assign(headers, Object.assign({}, form.getHeaders())),
@@ -192,6 +229,7 @@ function reqSendMultiPart(url, options) {
             });
             req.on('error', e => {
                 req.destroy();
+                form.destroy();
                 reject(e);
             });
             form.pipe(req);
@@ -204,6 +242,7 @@ function reqSendMultiPart(url, options) {
                 reject(e);
             });
         });
+        return res;
     });
 }
 exports.reqSendMultiPart = reqSendMultiPart;

package/index.d.ts

@@ -14,7 +14,8 @@ import {
 } from './src/streamhelper';
 
 import {
-    randomStringOptions
+    randomStringOptions,
+    getMediaFileTypeRes
 } from './src/cutil';
 
 interface Hgo {
@@ -119,7 +120,17 @@ interface Cutil {
      * 调用终端执行命令
      * @param command 
      */
-    execCmdCommand(command: string): string
+    execCmdCommand(command: string): Promise<string>
+    /**
+     * 获取给定值node类型
+     * @param value 
+     */
+    getValueType(value: any): string
+    /**
+     * 获取媒体文件类型
+     * @param target 文件url/buffer数据/可读流
+     */
+    getMediaFileType(target: string | Buffer | ReadStream): Promise<getMediaFileTypeRes>
 }
 
 declare const hgo: Hgo;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cvitool",
-  "version": "1.0.71",
+  "version": "1.0.73",
   "description": "cvitool",
   "main": "index.js",
   "scripts": {
@@ -9,11 +9,14 @@
   },
   "dependencies": {},
   "devDependencies": {
+    "@types/node": "20.10.4",
     "@typescript-eslint/eslint-plugin": "5.54.0",
     "@typescript-eslint/parser": "5.54.0",
     "eslint": "7.32.0",
-    "eslint-config-standard": "16.0.3",
-    "@types/node": "20.10.4"
+    "eslint-config-standard": "16.0.3"
+  },
+  "engines": {
+    "node": ">=16.0.0"
   },
   "files": [
     "build/src",

package/src/cutil.ts

@@ -8,6 +8,8 @@ import {
 import {
     spawn
 } from 'child_process';
+import { ReadStream } from 'fs';
+import * as hgo from './hgo';
 
 interface randomStringOptions {
     special?: boolean,
@@ -17,6 +19,11 @@ interface randomStringOptions {
     specials?: string
 }
 
+interface getMediaFileTypeRes {
+    type: string,
+    extname: string
+}
+
 function randomString(length: number, options?: randomStringOptions) {
     let { special = false, lowercase = true, upperCase = true, number = true, specials } = options || {};
     if (specials) {
@@ -93,11 +100,155 @@ async function execCmdCommand(command: string) {
     });
 }
 
+function getValueType(value: any) {
+    const typeStr = Object.prototype.toString.call(value);
+    let type: 'number' | 'string' | 'array' | 'object' | 'undefined' | 'null' | 'unkonw';
+    switch (typeStr) {
+        case '[object Number]':
+            type = 'number';
+            break;
+        case '[object String]':
+            type = 'string';
+            break;
+        case '[object Object]':
+            type = 'object';
+            break;
+        case '[object Array]':
+            type = 'array';
+            break;
+        case '[object Undefined]':
+            type = 'undefined';
+            break;
+        case '[object Null]':
+            type = 'null';
+            break;
+        default:
+            type = 'unkonw';
+            break;
+    };
+    return type;
+}
+
+async function getMediaFileType(target: string | Buffer | ReadStream): Promise<getMediaFileTypeRes> {
+    const readStreamOnceBuffer = async (stream: ReadStream): Promise<Buffer> => {
+        return new Promise((resolve, reject) => {
+            stream.once('data', chunk => {
+                stream.close();
+                resolve(chunk as Buffer);
+            });
+            stream.on('error', e => {
+                reject(e);
+            });
+        });
+    };
+    const checkString = (waitMatchStr: string, byteStart: number, byteEnd: number, buffer: Buffer) => {
+        return waitMatchStr === Buffer.from(buffer.slice(byteStart, byteEnd + 1)).toString();
+    };
+    const checkBuffer = (waitMatchBuffer: number[], byteStart: number, byteEnd: number, buffer: Buffer) => {
+        let equal = true;
+        const sliceBufferList = buffer.slice(byteStart, byteEnd + 1);
+        for (const [index, item] of waitMatchBuffer.entries()) {
+            if (item !== sliceBufferList[index]) {
+                equal = false;
+                break;
+            }
+        }
+        return equal;
+    };
+    const getResult = (typeStr: string) => {
+        const arr = typeStr.split('|');
+        return {
+            type: arr[0],
+            extname: arr[1]
+        };
+    };
+    let buffer: Buffer;
+    const targetType = this.getValueType(target);
+    if (targetType === 'string') {
+        const res = await hgo.get(
+            target as string,
+            {
+                resType: 'buffer',
+                headers: {
+                    Range: 'bytes=0-20'
+                }
+            }
+        );
+        buffer = res.resBody as Buffer;
+    } else if (targetType === 'array') {
+        buffer = target as Buffer;
+    } else {
+        buffer = await readStreamOnceBuffer(target as ReadStream);
+    }
+    buffer = buffer.slice(0, 20);
+    if (checkBuffer([0xff, 0xd8], 0, 1, buffer)) {
+        return getResult('image|jpg');
+    }
+    if (checkString('PNG', 1, 3, buffer)) {
+        return getResult('image|png');
+    }
+    if (checkBuffer([0x49, 0x44, 0x33], 0, 2, buffer) || checkBuffer([0xff, 0xf3], 0, 1, buffer)) {
+        return getResult('audio|mp3');
+    }
+    if (checkString('WAV', 8, 10, buffer)) {
+        return getResult('audio|wav');
+    }
+    if (checkString('M4A', 8, 10, buffer)) {
+        return getResult('audio|m4a');
+    }
+    if (checkString('heic', 8, 11, buffer) || checkString('mif1', 8, 11, buffer)) {
+        return getResult('image|heic');
+    }
+    if (checkString('ftyp', 4, 7, buffer)) {
+        if (checkString('ftypqt', 4, 9, buffer)) {
+            return getResult('video|mov');
+        }
+        return getResult('video|mp4');
+    }
+    if (checkString('WEBP', 8, 11, buffer)) {
+        return getResult('image|webp');
+    }
+    if (checkBuffer([0x47, 0x49, 0x46], 0, 2, buffer)) {
+        return getResult('image|gif');
+    }
+    if (checkBuffer([0x42, 0x4d], 0, 1, buffer)) {
+        return getResult('image|bmp');
+    }
+    if (checkBuffer([0x46, 0x4c, 0x56], 0, 2, buffer)) {
+        return getResult('video|flv');
+    }
+    if (checkBuffer([0x4f, 0x67, 0x67, 0x53], 0, 3, buffer)) {
+        return getResult('video|ogg');
+    }
+    if (checkBuffer([0x1a, 0x45, 0xdf, 0xa3], 0, 3, buffer)) {
+        return getResult('video|mkv');
+    }
+    if (checkBuffer([0x30, 0x26, 0xb2], 0, 2, buffer)) {
+        return getResult('video|wmv');
+    }
+    if (checkString('AVI', 8, 10, buffer)) {
+        return getResult('video|avi');
+    }
+    if (checkBuffer([0xff, 0xf1], 0, 1, buffer)) {
+        return getResult('audio|aac');
+    }
+    if (checkString('PCM', 10, 12, buffer)) {
+        return getResult('audio|pcm');
+    }
+    if (checkBuffer([0x66, 0x4c, 0x61, 0x43], 0, 3, buffer)) {
+        return getResult('audio|flac');
+    }
+    return getResult('unknow|unknow');
+}
+
 export {
     randomStringOptions,
+    getMediaFileTypeRes,
     randomString,
     encryptCBC,
     decryptCBC,
     md5,
-    execCmdCommand
+    execCmdCommand,
+    getValueType,
+    getMediaFileType
 };

package/src/hgo.ts

@@ -18,7 +18,7 @@ interface baseReqOptions {
     },
     resType?: ResType,
     connectTimeOut?: number,
-    readTimeOut?: number,
+    readTimeOut?: number
 }
 
 interface reqOptions extends baseReqOptions {
@@ -28,12 +28,18 @@ interface reqOptions extends baseReqOptions {
     },
     body?: {
         [key: string]: any
-    }
+    },
+    retries?: number,
+    retryInterval?: number,
+    [key: string]: any
 }
 
 interface reqSendBufferOptions extends baseReqOptions {
+    buffer: Buffer,
     method?: Method,
-    buffer: Buffer
+    retries?: number,
+    retryInterval?: number,
+    [key: string]: any
 }
 
 interface reqSendStreamOptions extends baseReqOptions {
@@ -65,7 +71,10 @@ function getProtocol(url: string) {
 }
 
 async function request(url: string, options?: reqOptions): Promise<ResData> {
-    let { query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json', connectTimeOut, readTimeOut } = options || {};
+    let {
+        query = {}, body = {}, headers = {}, timeout = 5000, method = 'get', agent, resType = 'json', connectTimeOut,
+        readTimeOut, retries, retryInterval, retrieds
+    } = options || {};
     if (timeout && !(connectTimeOut && readTimeOut)) {
         connectTimeOut = timeout;
         readTimeOut = timeout;
@@ -87,79 +96,118 @@ async function request(url: string, options?: reqOptions): Promise<ResData> {
             'Content-length': Buffer.byteLength(data)
         };
     }
-    return new Promise((resolve, reject) => {
-        const req = protocol.request(url, {
-            timeout: connectTimeOut,
-            headers: Object.assign(headers, baseHeaders),
-            method,
-            agent
-        }, res => {
-            resHandld(res, resolve, reject, resType, method, readTimeOut, req);
-        });
-        req.on('timeout', () => {
-            req.destroy();
-            reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
-        });
-        req.on('error', e => {
-            req.destroy();
-            reject(e);
-        });
-        if (isbodyEmpty) {
-            req.end();
-        } else {
-            req.write(data, (e) => {
-                req.end();
-                if (e) {
-                    req.destroy();
-                    reject(e);
-                }
+    let res: ResData;
+    try {
+        res = await new Promise((resolve, reject) => {
+            const req = protocol.request(url, {
+                timeout: connectTimeOut,
+                headers: Object.assign(headers, baseHeaders),
+                method,
+                agent
+            }, res => {
+                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
             });
+            req.on('error', e => {
+                req.destroy();
+                reject(e);
+            });
+            if (isbodyEmpty) {
+                req.end();
+            } else {
+                req.write(data, (e) => {
+                    req.end();
+                    if (e) {
+                        req.destroy();
+                        reject(e);
+                    }
+                });
+            }
+        });
+    } catch (e) {
+        if ((retrieds || 0) < (retries || 0)) {
+            if (retryInterval) {
+                await new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve(1);
+                    }, retryInterval);
+                });
+            }
+            res = await request(url, { ...options, retrieds: (retrieds || 0) + 1 });
+            return res;
         }
-    });
+        throw e;
+    }
+    return res;
 }
 
 async function reqSendBuffer(url: string, options: reqSendBufferOptions): Promise<ResData> {
-    let { timeout = 5000, headers = {}, buffer, method = 'post', agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+    let {
+        timeout = 5000, headers = {}, buffer, method = 'post', agent, resType = 'json', connectTimeOut, readTimeOut,
+        retries, retryInterval, retrieds
+    } = options;
     if (timeout && !(connectTimeOut && readTimeOut)) {
         connectTimeOut = timeout;
         readTimeOut = timeout;
     }
     const protocol = getProtocol(url);
-    return new Promise((resolve, reject) => {
-        const req = protocol.request(url, {
-            timeout: connectTimeOut,
-            headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
-            method,
-            agent
-        }, res => {
-            resHandld(res, resolve, reject, resType, method, readTimeOut, req);
-        });
-        req.on('timeout', () => {
-            req.destroy();
-            reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
-        });
-        req.on('error', e => {
-            req.destroy();
-            reject(e);
-        });
-        req.write(buffer, (e) => {
-            req.end();
-            if (e) {
+    let res: ResData;
+    try {
+        res = await new Promise((resolve, reject) => {
+            const req = protocol.request(url, {
+                timeout: connectTimeOut,
+                headers: Object.assign(headers, { 'Content-Length': buffer.byteLength }),
+                method,
+                agent
+            }, res => {
+                resHandld(res, resolve, reject, resType, method, readTimeOut, req);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                reject(buildTimeOutErr('connectTimeOut', connectTimeOut, url));
+            });
+            req.on('error', e => {
                 req.destroy();
                 reject(e);
-            }
+            });
+            req.write(buffer, (e) => {
+                req.end();
+                if (e) {
+                    req.destroy();
+                    reject(e);
+                }
+            });
         });
-    });
+    } catch (e) {
+        if ((retrieds || 0) < (retries || 0)) {
+            if (retryInterval) {
+                await new Promise((resolve) => {
+                    setTimeout(() => {
+                        resolve(1);
+                    }, retryInterval);
+                });
+            }
+            res = await reqSendBuffer(url, { ...options, retrieds: (retrieds || 0) + 1 });
+            return res;
+        }
+        throw e;
+    }
+    return res;
 }
 
 async function reqSendStream(url: string, options: reqSendStreamOptions): Promise<ResData> {
-    let { timeout = 5000, method = 'post', stream, headers = {}, agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+    let {
+        timeout = 5000, method = 'post', stream, headers = {}, agent, resType = 'json', connectTimeOut, readTimeOut
+    } = options;
     if (timeout && !(connectTimeOut && readTimeOut)) {
         connectTimeOut = timeout;
         readTimeOut = timeout;
     }
     const protocol = getProtocol(url);
-    return new Promise((resolve, reject) => {
+    const res: ResData = await new Promise((resolve, reject) => {
         const baseHeaders = {
             'Content-Type': 'application/octet-stream',
             'Transfer-Encoding': 'chunked',
@@ -184,6 +232,7 @@ async function reqSendStream(url: string, options: reqSendStreamOptions): Promis
         stream.on('data', chunk => {
             req.write(chunk, e => {
                 if (e) {
+                    stream.close();
                     req.destroy();
                     reject(e);
                 }
@@ -191,7 +240,6 @@ async function reqSendStream(url: string, options: reqSendStreamOptions): Promis
         });
         stream.on('end', () => {
             req.end();
-            stream.close();
         });
         stream.on('error', e => {
             req.destroy();
@@ -199,16 +247,19 @@ async function reqSendStream(url: string, options: reqSendStreamOptions): Promis
             reject(e);
         });
     });
+    return res;
 }
 
 async function reqSendMultiPart(url: string, options: reqSendMultiPartOptions): Promise<ResData> {
-    let { timeout = 60000, headers = {}, form, agent, resType = 'json', connectTimeOut, readTimeOut } = options;
+    let {
+        timeout = 60000, headers = {}, form, agent, resType = 'json', connectTimeOut, readTimeOut
+    } = options;
     if (timeout && !(connectTimeOut && readTimeOut)) {
         connectTimeOut = timeout;
         readTimeOut = timeout;
     }
     const protocol = getProtocol(url);
-    return new Promise((resolve, reject) => {
+    const res: ResData = await new Promise((resolve, reject) => {
         const req = protocol.request(url, {
             timeout: connectTimeOut,
             headers: Object.assign(headers, { ...form.getHeaders() }),
@@ -223,6 +274,7 @@ async function reqSendMultiPart(url: string, options: reqSendMultiPartOptions):
         });
         req.on('error', e => {
             req.destroy();
+            form.destroy();
             reject(e);
         });
         form.pipe(req);
@@ -235,6 +287,7 @@ async function reqSendMultiPart(url: string, options: reqSendMultiPartOptions):
             reject(e);
         });
     });
+    return res;
 }
 
 function resHandld(res: http.IncomingMessage, resolve: any, reject: any, resType: ResType, method: Method, readTimeOut: number, req: http.ClientRequest) {