@lskjs/proxy/ProxyModule.js

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _typeof = require("@babel/runtime/helpers/typeof");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = exports.ProxyModule = void 0;

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _module = _interopRequireDefault(require("@lskjs/module"));

var _asyncMapValues = _interopRequireDefault(require("@lskjs/utils/asyncMapValues"));

var _find = _interopRequireDefault(require("lodash/find"));

var _flatten = _interopRequireDefault(require("lodash/flatten"));

var _max = _interopRequireDefault(require("lodash/max"));

var _pick = _interopRequireDefault(require("lodash/pick"));

var _uniq = _interopRequireDefault(require("lodash/uniq"));

var _uniqBy = _interopRequireDefault(require("lodash/uniqBy"));

var _collectMetrics = require("./collectMetrics");

var _Proxy2 = require("./Proxy");

var _setProxyWorker = require("./setProxyWorker");

var _filterProxy = require("./utils/filterProxy");

function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

// const isDebug = isDev;
var isDebug = false;

var ProxyModule = /*#__PURE__*/function (_Module) {
  (0, _inherits2["default"])(ProxyModule, _Module);

  var _super = _createSuper(ProxyModule);

  function ProxyModule() {
    (0, _classCallCheck2["default"])(this, ProxyModule);
    return _super.apply(this, arguments);
  }

  (0, _createClass2["default"])(ProxyModule, [{
    key: "getActiveProvidersNames",
    value: function getActiveProvidersNames() {
      var _this = this;

      return Object.keys(this.config.providers || {}, function (provider) {
        return !!_this.config.providers[provider] && !_this.config.providers[provider].disabled;
      });
    }
  }, {
    key: "getModules",
    value: function getModules() {
      return _objectSpread(_objectSpread({}, (0, _get2["default"])((0, _getPrototypeOf2["default"])(ProxyModule.prototype), "getModules", this).call(this)), {}, {
        providers: [Promise.resolve().then(function () {
          return _interopRequireWildcard(require('@lskjs/module/asyncModules'));
        }), {
          items: (0, _pick["default"])(this.providers, this.getActiveProvidersNames()),
          config: this.config.providers
        }],
        tests: [Promise.resolve().then(function () {
          return _interopRequireWildcard(require('./ProxyTests'));
        }), {
          tests: this.tests,
          config: this.config.tests
        }]
      });
    }
  }, {
    key: "runProvidersMethod",
    value: function () {
      var _runProvidersMethod = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(method) {
        var _this2 = this;

        var _len,
            args,
            _key,
            providers,
            _args2 = arguments;

        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                for (_len = _args2.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                  args[_key - 1] = _args2[_key];
                }

                _context2.next = 3;
                return this.module('providers.*');

              case 3:
                providers = _context2.sent;
                return _context2.abrupt("return", (0, _asyncMapValues["default"])(providers, /*#__PURE__*/function () {
                  var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(provider) {
                    var res;
                    return _regenerator["default"].wrap(function _callee$(_context) {
                      while (1) {
                        switch (_context.prev = _context.next) {
                          case 0:
                            _context.prev = 0;
                            _context.next = 3;
                            return provider[method].apply(provider, args);

                          case 3:
                            res = _context.sent;
                            return _context.abrupt("return", res);

                          case 7:
                            _context.prev = 7;
                            _context.t0 = _context["catch"](0);

                            _this2.log.error('[provider] err', provider, _context.t0);

                            return _context.abrupt("return", null);

                          case 11:
                          case "end":
                            return _context.stop();
                        }
                      }
                    }, _callee, null, [[0, 7]]);
                  }));

                  return function (_x2) {
                    return _ref.apply(this, arguments);
                  };
                }()));

              case 5:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function runProvidersMethod(_x) {
        return _runProvidersMethod.apply(this, arguments);
      }

      return runProvidersMethod;
    }()
  }, {
    key: "getProxyStats",
    value: function () {
      var _getProxyStats = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(proxyList) {
        var tests;
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _context3.next = 2;
                return this.module('tests');

              case 2:
                tests = _context3.sent;
                return _context3.abrupt("return", tests.getProxyStats(proxyList));

              case 4:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function getProxyStats(_x3) {
        return _getProxyStats.apply(this, arguments);
      }

      return getProxyStats;
    }()
  }, {
    key: "getAllProxyList",
    value: function () {
      var _getAllProxyList = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4() {
        var _ref2,
            _ref2$localhost,
            localhost,
            res,
            listOfLists,
            rawProxyList,
            _args4 = arguments;

        return _regenerator["default"].wrap(function _callee4$(_context4) {
          while (1) {
            switch (_context4.prev = _context4.next) {
              case 0:
                _ref2 = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : {}, _ref2$localhost = _ref2.localhost, localhost = _ref2$localhost === void 0 ? false : _ref2$localhost;
                _context4.next = 3;
                return this.runProvidersMethod('getList');

              case 3:
                res = _context4.sent;
                listOfLists = Object.values(res).map(function (a) {
                  return (a === null || a === void 0 ? void 0 : a.list) || [];
                });
                if (isDebug) listOfLists = listOfLists.map(function (l) {
                  return l.slice(0, 2);
                });
                rawProxyList = (0, _uniqBy["default"])((0, _flatten["default"])(listOfLists), 'key');

                if (!localhost) {
                  _context4.next = 9;
                  break;
                }

                return _context4.abrupt("return", [new _Proxy2.Proxy({
                  provider: 'localhost'
                })].concat((0, _toConsumableArray2["default"])(rawProxyList)));

              case 9:
                return _context4.abrupt("return", rawProxyList);

              case 10:
              case "end":
                return _context4.stop();
            }
          }
        }, _callee4, this);
      }));

      function getAllProxyList() {
        return _getAllProxyList.apply(this, arguments);
      }

      return getAllProxyList;
    }()
  }, {
    key: "fetchProxyList",
    value: function () {
      var _fetchProxyList = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5() {
        var res, proxies;
        return _regenerator["default"].wrap(function _callee5$(_context5) {
          while (1) {
            switch (_context5.prev = _context5.next) {
              case 0:
                _context5.next = 2;
                return this.runProvidersMethod('fetchList');

              case 2:
                res = _context5.sent;
                proxies = (0, _flatten["default"])(Object.values(res).map(function (a) {
                  return a || [];
                }));
                return _context5.abrupt("return", proxies);

              case 5:
              case "end":
                return _context5.stop();
            }
          }
        }, _callee5, this);
      }));

      function fetchProxyList() {
        return _fetchProxyList.apply(this, arguments);
      }

      return fetchProxyList;
    }()
  }, {
    key: "getProxyTestsResults",
    value: function () {
      var _getProxyTestsResults = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6() {
        var tests;
        return _regenerator["default"].wrap(function _callee6$(_context6) {
          while (1) {
            switch (_context6.prev = _context6.next) {
              case 0:
                _context6.next = 2;
                return this.module('tests');

              case 2:
                tests = _context6.sent;
                return _context6.abrupt("return", tests.getResults());

              case 4:
              case "end":
                return _context6.stop();
            }
          }
        }, _callee6, this);
      }));

      function getProxyTestsResults() {
        return _getProxyTestsResults.apply(this, arguments);
      }

      return getProxyTestsResults;
    }()
  }, {
    key: "runProxyTests",
    value: function () {
      var _runProxyTests = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(proxyList) {
        var tests;
        return _regenerator["default"].wrap(function _callee7$(_context7) {
          while (1) {
            switch (_context7.prev = _context7.next) {
              case 0:
                _context7.next = 2;
                return this.module('tests');

              case 2:
                tests = _context7.sent;

                if (proxyList) {
                  _context7.next = 7;
                  break;
                }

                _context7.next = 6;
                return this.getAllProxyList({
                  localhost: true
                });

              case 6:
                proxyList = _context7.sent;

              case 7:
                return _context7.abrupt("return", tests.runTests(proxyList));

              case 8:
              case "end":
                return _context7.stop();
            }
          }
        }, _callee7, this);
      }));

      function runProxyTests(_x4) {
        return _runProxyTests.apply(this, arguments);
      }

      return runProxyTests;
    }()
  }, {
    key: "runProxyTest",
    value: function () {
      var _runProxyTest = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8(_ref3) {
        var proxyKey, testId, force, tests, proxyList, proxy;
        return _regenerator["default"].wrap(function _callee8$(_context8) {
          while (1) {
            switch (_context8.prev = _context8.next) {
              case 0:
                proxyKey = _ref3.proxyKey, testId = _ref3.testId, force = _ref3.force;
                _context8.next = 3;
                return this.module('tests');

              case 3:
                tests = _context8.sent;
                _context8.next = 6;
                return this.getAllProxyList();

              case 6:
                proxyList = _context8.sent;
                proxy = (0, _find["default"])(proxyList, {
                  key: proxyKey
                });
                return _context8.abrupt("return", tests.runTest({
                  proxy: proxy,
                  testId: testId,
                  force: force
                }));

              case 9:
              case "end":
                return _context8.stop();
            }
          }
        }, _callee8, this);
      }));

      function runProxyTest(_x5) {
        return _runProxyTest.apply(this, arguments);
      }

      return runProxyTest;
    }()
  }, {
    key: "getList",
    value: function () {
      var _getList = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9() {
        var filter,
            res,
            fetchedAt,
            proxyList,
            proxyStats,
            filteredProxyList,
            _args9 = arguments;
        return _regenerator["default"].wrap(function _callee9$(_context9) {
          while (1) {
            switch (_context9.prev = _context9.next) {
              case 0:
                filter = _args9.length > 0 && _args9[0] !== undefined ? _args9[0] : {};
                _context9.next = 3;
                return this.runProvidersMethod('getList');

              case 3:
                res = _context9.sent;
                fetchedAt = (0, _max["default"])(Object.values(res).map(function (a) {
                  return a === null || a === void 0 ? void 0 : a.fetchedAt;
                }));
                _context9.next = 7;
                return this.getAllProxyList();

              case 7:
                proxyList = _context9.sent;
                _context9.next = 10;
                return this.getProxyStats(proxyList);

              case 10:
                proxyStats = _context9.sent;
                proxyList = proxyList.map(function (p) {
                  var _ref4;

                  // TODO: как-то облагородить
                  var proxyTests = proxyStats[p.key] || [];
                  proxyTests = proxyTests.filter(function (test) {
                    return test.status === 'success';
                  });
                  var testIds = proxyTests.map(function (t) {
                    var _t$test;

                    return t === null || t === void 0 ? void 0 : (_t$test = t.test) === null || _t$test === void 0 ? void 0 : _t$test.id;
                  });
                  var tagsList = proxyTests.map(function (t) {
                    var _t$test2;

                    return t === null || t === void 0 ? void 0 : (_t$test2 = t.test) === null || _t$test2 === void 0 ? void 0 : _t$test2.tags;
                  });
                  var testTags = (0, _uniq["default"])((_ref4 = []).concat.apply(_ref4, (0, _toConsumableArray2["default"])(tagsList))); // eslint-disable-next-line no-param-reassign

                  p.targets = testTags; // eslint-disable-next-line no-param-reassign

                  p.tests = testIds;
                  return p;
                });
                (0, _setProxyWorker.setProxyWorker)(proxyList, this.config.workers); // const testedAt = max(Object.values(proxyStats).map((p) => p.updatedAt));
                // console.log({testedAt}, Object.values(proxyStats).map((p) => p.updatedAt))

                filteredProxyList = (0, _filterProxy.filterProxy)(proxyList, filter);
                return _context9.abrupt("return", {
                  fetchedAt: fetchedAt,
                  // testedAt,
                  total: proxyList.length,
                  count: filteredProxyList.length,
                  list: filteredProxyList
                });

              case 15:
              case "end":
                return _context9.stop();
            }
          }
        }, _callee9, this);
      }));

      function getList() {
        return _getList.apply(this, arguments);
      }

      return getList;
    }()
  }, {
    key: "updateProxyList",
    value: function () {
      var _updateProxyList = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee10() {
        var res;
        return _regenerator["default"].wrap(function _callee10$(_context10) {
          while (1) {
            switch (_context10.prev = _context10.next) {
              case 0:
                // TODO: mutex
                this.log.trace('[updateProxyList] start');
                _context10.next = 3;
                return this.runProvidersMethod('update');

              case 3:
                res = _context10.sent;
                this.log.debug('[updateProxyList]', res);

              case 5:
              case "end":
                return _context10.stop();
            }
          }
        }, _callee10, this);
      }));

      function updateProxyList() {
        return _updateProxyList.apply(this, arguments);
      }

      return updateProxyList;
    }()
  }, {
    key: "updateProxyTests",
    value: function () {
      var _updateProxyTests = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee11() {
        var res;
        return _regenerator["default"].wrap(function _callee11$(_context11) {
          while (1) {
            switch (_context11.prev = _context11.next) {
              case 0:
                // TODO: mutex
                this.log.trace('[updateProxyTests] start');
                _context11.next = 3;
                return this.runProxyTests();

              case 3:
                res = _context11.sent;
                // All proxies
                this.log.debug('[updateProxyTests]', res.map(function (_ref5) {
                  var id = _ref5.id,
                      status = _ref5.status;
                  return "".concat(id, ": ").concat(status);
                }));

              case 5:
              case "end":
                return _context11.stop();
            }
          }
        }, _callee11, this);
      }));

      function updateProxyTests() {
        return _updateProxyTests.apply(this, arguments);
      }

      return updateProxyTests;
    }()
  }, {
    key: "buyProxies",
    value: function () {
      var _buyProxies = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee12() {
        return _regenerator["default"].wrap(function _callee12$(_context12) {
          while (1) {
            switch (_context12.prev = _context12.next) {
              case 0:
                // TODO: mutex
                this.log.trace('[buyProxies] nothing');

              case 1:
              case "end":
                return _context12.stop();
            }
          }
        }, _callee12, this);
      }));

      function buyProxies() {
        return _buyProxies.apply(this, arguments);
      }

      return buyProxies;
    }()
  }, {
    key: "metrics",
    value: function () {
      var _metrics = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee13() {
        return _regenerator["default"].wrap(function _callee13$(_context13) {
          while (1) {
            switch (_context13.prev = _context13.next) {
              case 0:
                return _context13.abrupt("return", _collectMetrics.collectMetrics.call(this));

              case 1:
              case "end":
                return _context13.stop();
            }
          }
        }, _callee13, this);
      }));

      function metrics() {
        return _metrics.apply(this, arguments);
      }

      return metrics;
    }()
  }]);
  return ProxyModule;
}(_module["default"]);

exports.ProxyModule = ProxyModule;
var _default = ProxyModule;
exports["default"] = _default;
//# sourceMappingURL=ProxyModule.js.map