@yvhitxcel/opencode-remote 0.15.0

package/dist/weixin/node_modules/qiniu/qiniu/httpc/regionsRetryPolicy.js

@@ -0,0 +1,242 @@
+const {
+    RetryPolicy
+} = require('../retry');
+const { Region } = require('./region');
+const {
+    StaticRegionsProvider
+} = require('./regionsProvider');
+const {
+    StaticEndpointsProvider
+} = require('./endpointsProvider');
+
+/**
+ * @typedef {EndpointsRetryPolicyContext} RegionsRetryPolicyContext
+ * @property {Region} region
+ * @property {Region[]} alternativeRegions
+ * @property {SERVICE_NAME} serviceName
+ * @property {SERVICE_NAME[]} alternativeServiceNames
+ */
+
+/**
+ * @class
+ * @extends RetryPolicy
+ * @param {SERVICE_NAME} options.serviceName DEPRECATE: use options.serviceNames instead
+ * @param {SERVICE_NAME[]} options.serviceNames
+ * @param {Region[]} [options.regions]
+ * @param {RegionsProvider} [options.regionsProvider]
+ * @param {Endpoint[]} [options.preferredEndpoints]
+ * @param {EndpointsProvider} [options.preferredEndpointsProvider]
+ * @param {function(RegionsRetryPolicyContext): Promise<void>} [options.onChangedRegion]
+ * @constructor
+ */
+function RegionsRetryPolicy (options) {
+    /**
+     * @type {SERVICE_NAME[]}
+     */
+    this.serviceNames = options.serviceNames || [];
+    if (!this.serviceNames.length) {
+        this.serviceNames = [options.serviceName];
+    }
+    if (!this.serviceNames.length) {
+        throw new TypeError('Must provide one service name at least');
+    }
+    // compatible, remove when make break changes
+    this.serviceName = this.serviceNames[0];
+
+    this.regions = options.regions || [];
+    this.regionsProvider = options.regionsProvider || new StaticRegionsProvider([]);
+    this.preferredEndpoints = options.preferredEndpoints || [];
+    this.preferredEndpointsProvider = options.preferredEndpointsProvider || new StaticEndpointsProvider([]);
+    this.onChangedRegion = options.onChangedRegion;
+}
+
+RegionsRetryPolicy.prototype = Object.create(RetryPolicy.prototype);
+RegionsRetryPolicy.prototype.constructor = RegionsRetryPolicy;
+
+/**
+ * @param {RegionsRetryPolicyContext} context
+ * @returns {Promise<void>}
+ */
+RegionsRetryPolicy.prototype.initContext = function (context) {
+    const regionsPromise = this.regions.length > 0
+        ? this.regions
+        : this.regionsProvider.getRegions();
+    const preferredEndpointsPromise = this.preferredEndpoints.length > 0
+        ? this.preferredEndpoints
+        : this.preferredEndpointsProvider.getEndpoints();
+    return Promise.all([
+        regionsPromise,
+        preferredEndpointsPromise
+    ])
+        .then(([regions, preferredEndpoints]) => this._initRegions({
+            context,
+            regions: regions.slice(),
+            preferredEndpoints: preferredEndpoints.slice()
+        }))
+        .then(() => this._prepareEndpoints(context));
+};
+
+/**
+ * @param {RegionsRetryPolicyContext} context
+ * @returns {boolean}
+ */
+RegionsRetryPolicy.prototype.shouldRetry = function (context) {
+    return context.alternativeRegions.length > 0 || context.alternativeServiceNames.length > 0;
+};
+
+/**
+ * @param {RegionsRetryPolicyContext} context
+ * @returns {Promise<void>}
+ */
+RegionsRetryPolicy.prototype.prepareRetry = function (context) {
+    let handleChangedRegionPromise = Promise.resolve();
+    if (context.alternativeServiceNames.length) {
+        context.serviceName = context.alternativeServiceNames.shift();
+    } else if (context.alternativeRegions.length) {
+        context.region = context.alternativeRegions.shift();
+        [context.serviceName, ...context.alternativeServiceNames] = this.serviceNames;
+        if (typeof this.onChangedRegion === 'function') {
+            handleChangedRegionPromise = this.onChangedRegion(context);
+        }
+    } else {
+        return Promise.reject(
+            new Error('There isn\'t available region or service for next try')
+        );
+    }
+    return handleChangedRegionPromise
+        .then(() => this._prepareEndpoints(context));
+};
+
+/**
+ * @typedef GetPreferredRegionInfoResult
+ * @property {number} preferredServiceIndex
+ * @property {number} preferredRegionIndex
+ */
+
+/**
+ * @param {Region[]} options.regions
+ * @param {Endpoint[]} options.preferredEndpoints
+ * @returns {GetPreferredRegionInfoResult}
+ * @protected
+ */
+RegionsRetryPolicy.prototype._getPreferredRegionInfo = function (options) {
+    const {
+        regions,
+        preferredEndpoints
+    } = options;
+
+    const serviceNames = this.serviceNames.slice();
+
+    let preferredServiceIndex = -1;
+    const preferredRegionIndex = regions.findIndex(r =>
+        serviceNames.some((s, si) =>
+            r.services[s].some(e => {
+                const res = preferredEndpoints.some(pe => pe.host === e.host);
+                if (res) {
+                    preferredServiceIndex = si;
+                }
+                return res;
+            })
+        )
+    );
+    return {
+        preferredServiceIndex,
+        preferredRegionIndex
+    };
+};
+
+/**
+ * @param {RegionsRetryPolicyContext} options.context
+ * @param {Region[]} options.regions
+ * @param {Endpoint[]} options.preferredEndpoints
+ * @returns {Promise<void>}
+ * @private
+ */
+RegionsRetryPolicy.prototype._initRegions = function (options) {
+    const {
+        context,
+        regions,
+        preferredEndpoints
+    } = options;
+    // initial region and alternative regions
+    if (!regions.length && !preferredEndpoints.length) {
+        return Promise.reject(
+            new Error('There isn\'t available region or preferred endpoint')
+        );
+    }
+
+    if (!preferredEndpoints.length) {
+        [context.region, ...context.alternativeRegions] = regions;
+        [context.serviceName, ...context.alternativeServiceNames] = this.serviceNames;
+        return Promise.resolve();
+    }
+
+    // find preferred serviceName and region by preferred endpoints
+    const {
+        preferredRegionIndex,
+        preferredServiceIndex
+    } = this._getPreferredRegionInfo({
+        regions,
+        preferredEndpoints
+    });
+
+    // initialize the order of serviceNames and regions
+    if (preferredRegionIndex < 0) {
+        // preferred endpoints is not a region, then make all regions alternative
+        [context.serviceName, ...context.alternativeServiceNames] = this.serviceNames;
+        // compatible, remove when make break changes
+        this.serviceName = context.serviceName;
+
+        context.region = new Region({
+            services: {
+                [context.serviceName]: preferredEndpoints
+            }
+        });
+        context.alternativeRegions = regions;
+    } else {
+        // preferred endpoints in a known region, then reorder the regions and services
+        context.alternativeRegions = regions;
+        [context.region] = context.alternativeRegions.splice(preferredRegionIndex, 1);
+        context.alternativeServiceNames = this.serviceNames.slice();
+        [context.serviceName] = context.alternativeServiceNames.splice(preferredServiceIndex, 1);
+        // compatible, remove when make break changes
+        this.serviceName = context.serviceName;
+    }
+    return Promise.resolve();
+};
+
+/**
+ * @param {RegionsRetryPolicyContext} context
+ * @returns {Promise<void>}
+ * @protected
+ */
+RegionsRetryPolicy.prototype._prepareEndpoints = function (context) {
+    let handleChangedRegionsPromise = Promise.resolve();
+    [context.endpoint, ...context.alternativeEndpoints] = context.region.services[context.serviceName] || [];
+    while (!context.endpoint) {
+        if (context.alternativeServiceNames.length) {
+            context.serviceName = context.alternativeServiceNames.shift();
+            // compatible, remove when make break changes
+            this.serviceName = context.serviceName;
+            [context.endpoint, ...context.alternativeEndpoints] = context.region.services[context.serviceName] || [];
+        } else if (context.alternativeRegions.length) {
+            context.region = context.alternativeRegions.shift();
+            [context.serviceName, ...context.alternativeServiceNames] = this.serviceNames;
+            // compatible, remove when make break changes
+            this.serviceName = context.serviceName;
+            [context.endpoint, ...context.alternativeEndpoints] = context.region.services[context.serviceName] || [];
+            if (typeof this.onChangedRegion === 'function') {
+                handleChangedRegionsPromise = this.onChangedRegion(context);
+            }
+        } else {
+            return Promise.reject(new Error(
+                'There isn\'t available endpoint for ' +
+                this.serviceNames.join(', ') +
+                ' service(s) in any available regions'
+            ));
+        }
+    }
+    return handleChangedRegionsPromise;
+};
+
+exports.RegionsRetryPolicy = RegionsRetryPolicy;

package/dist/weixin/node_modules/qiniu/qiniu/httpc/responseWrapper.js

@@ -0,0 +1,40 @@
+/**
+ * @class
+ * @param {any} data
+ * @param {http.IncomingMessage} resp
+ * @constructor
+ */
+function ResponseWrapper ({
+    data,
+    resp
+}) {
+    this.data = data;
+    this.resp = resp;
+}
+
+/**
+ * @returns {boolean}
+ */
+ResponseWrapper.prototype.ok = function () {
+    return this.resp && Math.floor(this.resp.statusCode / 100) === 2;
+};
+
+/**
+ * @returns {boolean}
+ */
+ResponseWrapper.prototype.needRetry = function () {
+    if (this.resp.statusCode > 0 && this.resp.statusCode < 500) {
+        return false;
+    }
+
+    // https://developer.qiniu.com/fusion/kb/1352/the-http-request-return-a-status-code
+    if ([
+        501, 509, 573, 579, 608, 612, 614, 616, 618, 630, 631, 632, 640, 701
+    ].includes(this.resp.statusCode)) {
+        return false;
+    }
+
+    return true;
+};
+
+exports.ResponseWrapper = ResponseWrapper;

package/dist/weixin/node_modules/qiniu/qiniu/retry/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    Retrier: require('./retrier').Retrier,
+    RetryPolicy: require('./retryPolicy').RetryPolicy
+};

package/dist/weixin/node_modules/qiniu/qiniu/retry/retrier.js

@@ -0,0 +1,99 @@
+/**
+ * @class
+ * @param {RetryPolicy[]} options.retryPolicies
+ * @param {function(RetryPolicyContext, RetryPolicy | undefined): Promise<boolean>} [options.onBeforeRetry]
+ * @constructor
+ */
+function Retrier (options) {
+    this.retryPolicies = options.retryPolicies || [];
+    this.onBeforeRetry = options.onBeforeRetry;
+}
+
+Retrier.prototype.initContext = function () {
+    const context = {
+        error: null,
+        retried: false
+    };
+    return this.retryPolicies.reduce(
+        (promiseChain, retryPolicy) =>
+            promiseChain.then(() =>
+                retryPolicy.initContext(context))
+        ,
+        Promise.resolve()
+    )
+        .then(() => context);
+};
+
+Retrier.prototype._afterRetry = function (context) {
+    return this.retryPolicies.reduce(
+        (promiseChain, retryPolicy) =>
+            promiseChain.then(() =>
+                retryPolicy.afterRetry(context))
+        ,
+        Promise.resolve()
+    );
+};
+
+Retrier.prototype.retry = function (options) {
+    const {
+        func,
+        context
+    } = options;
+    return func(context)
+        .then(result => {
+            context.result = result;
+            if (context.retried) {
+                return this._afterRetry(context);
+            }
+        })
+        .catch(error => {
+            context.error = error;
+            if (context.retried) {
+                return this._afterRetry(context);
+            }
+        })
+        .then(() => {
+            let retryPolicy = this.retryPolicies.find(p => p.isImportant(context));
+            if (retryPolicy && !retryPolicy.shouldRetry(context)) {
+                return [
+                    false,
+                    retryPolicy
+                ];
+            }
+            if (!retryPolicy) {
+                retryPolicy = this.retryPolicies.find(p => p.shouldRetry(context));
+            }
+            const couldRetryPromise = this.onBeforeRetry
+                ? this.onBeforeRetry(context, retryPolicy)
+                : retryPolicy !== undefined;
+            return Promise.all([
+                couldRetryPromise,
+                retryPolicy
+            ]);
+        })
+        .then(([couldRetry, retryPolicy]) => {
+            if (!couldRetry || !retryPolicy) {
+                return;
+            }
+            context.error = null;
+            context.retried = true;
+            delete context.result;
+            return retryPolicy.prepareRetry(context)
+                .catch(err => {
+                    err.message = 'Retrier: prepare retry failed\n' + err.message;
+                    if (context.error) {
+                        err.cause = context.error;
+                    }
+                    return Promise.reject(err);
+                })
+                .then(() => this.retry(options));
+        })
+        .then(() => {
+            if (context.error) {
+                return Promise.reject(context.error);
+            }
+            return context.result;
+        });
+};
+
+exports.Retrier = Retrier;

package/dist/weixin/node_modules/qiniu/qiniu/retry/retryPolicy.js

@@ -0,0 +1,55 @@
+/**
+ * @typedef RetryPolicyContext
+ * @property {any} result
+ * @property {Error | null} error
+ * @property {boolean} retried
+ * @property {...any}
+ */
+
+/**
+ * @class
+ * @constructor
+ */
+function RetryPolicy () {
+}
+
+/**
+ * @param {RetryPolicyContext} _context
+ * @returns {boolean}
+ */
+RetryPolicy.prototype.isImportant = function (_context) {
+    return false;
+};
+
+/**
+ * @abstract
+ * @param {RetryPolicyContext} _context
+ * @returns {Promise<void>}
+ */
+RetryPolicy.prototype.initContext = function (_context) {
+    throw new Error('Method not implemented.');
+};
+
+/**
+ * @abstract
+ * @param {RetryPolicyContext} _context
+ * @returns {boolean}
+ */
+RetryPolicy.prototype.shouldRetry = function (_context) {
+    throw new Error('Method not implemented.');
+};
+
+/**
+ * @abstract
+ * @param {RetryPolicyContext} _context
+ * @returns {Promise<void>}
+ */
+RetryPolicy.prototype.prepareRetry = function (_context) {
+    throw new Error('Method not implemented.');
+};
+
+RetryPolicy.prototype.afterRetry = function () {
+    return Promise.resolve();
+};
+
+exports.RetryPolicy = RetryPolicy;

package/dist/weixin/node_modules/qiniu/qiniu/rpc.js

@@ -0,0 +1,237 @@
+const urllib = require('urllib');
+
+const pkg = require('../package.json');
+const conf = require('./conf');
+const digest = require('./auth/digest');
+const util = require('./util');
+const client = require('./httpc/client');
+const middleware = require('./httpc/middleware');
+
+let uaMiddleware = new middleware.UserAgentMiddleware(pkg.version);
+uaMiddleware = Object.defineProperty(uaMiddleware, 'userAgent', {
+    get: function () {
+        return conf.USER_AGENT;
+    }
+});
+exports.qnHttpClient = new client.HttpClient({
+    middlewares: [
+        uaMiddleware
+    ]
+});
+exports.get = get;
+exports.post = post;
+exports.put = put;
+exports.getWithOptions = getWithOptions;
+exports.getWithToken = getWithToken;
+exports.postWithOptions = postWithOptions;
+exports.postMultipart = postMultipart;
+exports.postWithForm = postWithForm;
+exports.postWithoutForm = postWithoutForm;
+
+function addAuthHeaders (headers, mac) {
+    const xQiniuDate = util.formatDateUTC(new Date(), 'YYYYMMDDTHHmmssZ');
+    if (mac.options.disableQiniuTimestampSignature !== null) {
+        if (!mac.options.disableQiniuTimestampSignature) {
+            headers['X-Qiniu-Date'] = xQiniuDate;
+        }
+    } else if (process.env.DISABLE_QINIU_TIMESTAMP_SIGNATURE) {
+        if (process.env.DISABLE_QINIU_TIMESTAMP_SIGNATURE.toLowerCase() !== 'true') {
+            headers['X-Qiniu-Date'] = xQiniuDate;
+        }
+    } else {
+        headers['X-Qiniu-Date'] = xQiniuDate;
+    }
+    return headers;
+}
+
+function getWithOptions (requestURI, options, callbackFunc) {
+    let headers = options.headers || {};
+    const mac = options.mac || new digest.Mac();
+
+    if (!headers['Content-Type']) {
+        headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    }
+
+    headers = addAuthHeaders(headers, mac);
+
+    // if there are V3, V4 token generator in the future, extends options with signVersion
+    const token = util.generateAccessTokenV2(
+        mac,
+        requestURI,
+        'GET',
+        headers['Content-Type'],
+        null,
+        headers
+    );
+
+    if (mac.accessKey) {
+        headers.Authorization = token;
+    }
+
+    return get(requestURI, headers, callbackFunc);
+}
+
+function getWithToken (requestUrl, token, callbackFunc) {
+    const headers = {
+        'Content-Type': 'application/x-www-form-urlencoded'
+    };
+    if (token) {
+        headers.Authorization = token;
+    }
+    return get(requestUrl, headers, callbackFunc);
+}
+
+function postWithOptions (requestURI, requestForm, options, callbackFunc) {
+    let headers = options.headers || {};
+    const mac = options.mac || new digest.Mac();
+
+    if (!headers['Content-Type']) {
+        headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    }
+
+    headers = addAuthHeaders(headers, mac);
+
+    // if there are V3, V4 token generator in the future, extends options with signVersion
+    const token = util.generateAccessTokenV2(
+        mac,
+        requestURI,
+        'POST',
+        headers['Content-Type'],
+        requestForm,
+        headers
+    );
+
+    if (mac.accessKey) {
+        headers.Authorization = token;
+    }
+
+    return post(requestURI, requestForm, headers, callbackFunc);
+}
+
+function postMultipart (requestURI, requestForm, callbackFunc) {
+    return post(requestURI, requestForm, requestForm.headers(), callbackFunc);
+}
+
+function postWithForm (requestURI, requestForm, token, callbackFunc) {
+    const headers = {
+        'Content-Type': 'application/x-www-form-urlencoded'
+    };
+    if (token) {
+        headers.Authorization = token;
+    }
+    return post(requestURI, requestForm, headers, callbackFunc);
+}
+
+function postWithoutForm (requestURI, token, callbackFunc) {
+    const headers = {
+        'Content-Type': 'application/x-www-form-urlencoded'
+    };
+    if (token) {
+        headers.Authorization = token;
+    }
+    return post(requestURI, null, headers, callbackFunc);
+}
+
+function get (requestUrl, headers, callbackFunc) {
+    headers = headers || {};
+    headers['User-Agent'] = headers['User-Agent'] || conf.USER_AGENT;
+    headers.Connection = 'keep-alive';
+
+    const data = {
+        method: 'GET',
+        headers: headers,
+        dataType: 'json',
+        timeout: conf.RPC_TIMEOUT,
+        gzip: true
+    };
+
+    if (conf.RPC_HTTP_AGENT) {
+        data.agent = conf.RPC_HTTP_AGENT;
+    }
+
+    if (conf.RPC_HTTPS_AGENT) {
+        data.httpsAgent = conf.RPC_HTTPS_AGENT;
+    }
+
+    return urllib.request(
+        requestUrl,
+        data,
+        callbackFunc
+    );
+}
+
+function post (requestUrl, requestForm, headers, callbackFunc) {
+    // var start = parseInt(Date.now() / 1000);
+    headers = headers || {};
+    headers['User-Agent'] = headers['User-Agent'] || conf.USER_AGENT;
+    headers.Connection = 'keep-alive';
+
+    const data = {
+        headers: headers,
+        method: 'POST',
+        dataType: 'json',
+        timeout: conf.RPC_TIMEOUT,
+        gzip: true
+        //  timing: true,
+    };
+
+    if (conf.RPC_HTTP_AGENT) {
+        data.agent = conf.RPC_HTTP_AGENT;
+    }
+
+    if (conf.RPC_HTTPS_AGENT) {
+        data.httpsAgent = conf.RPC_HTTPS_AGENT;
+    }
+
+    if (Buffer.isBuffer(requestForm) || typeof requestForm === 'string') {
+        data.content = requestForm;
+    } else if (requestForm) {
+        data.stream = requestForm;
+    } else {
+        data.headers['Content-Length'] = 0;
+    }
+
+    return urllib.request(
+        requestUrl,
+        data,
+        callbackFunc
+    );
+}
+
+function put (requestUrl, requestForm, headers, callbackFunc) {
+    // var start = parseInt(Date.now() / 1000);
+    headers = headers || {};
+    headers['User-Agent'] = headers['User-Agent'] || conf.USER_AGENT;
+    headers.Connection = 'keep-alive';
+
+    const data = {
+        headers: headers,
+        method: 'PUT',
+        dataType: 'json',
+        timeout: conf.RPC_TIMEOUT,
+        gzip: true
+        //  timing: true,
+    };
+
+    if (conf.RPC_HTTP_AGENT) {
+        data.agent = conf.RPC_HTTP_AGENT;
+    }
+
+    if (conf.RPC_HTTPS_AGENT) {
+        data.httpsAgent = conf.RPC_HTTPS_AGENT;
+    }
+
+    if (Buffer.isBuffer(requestForm) || typeof requestForm === 'string') {
+        data.content = requestForm;
+    } else if (requestForm) {
+        data.stream = requestForm;
+    } else {
+        data.headers['Content-Length'] = 0;
+    }
+
+    return urllib.request(
+        requestUrl,
+        data,
+        callbackFunc
+    );
+}