resilient-http/resilient.js

File resilient.js has 2004 lines of code (exceeds 250 allowed). Consider refactoring.

Open

/*! resilient - v0.4.0 - MIT License - https://github.com/resilient-http/resilient.js */
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.resilient = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
var _ = require('./utils')

module.exports = Cache

Function 23 has 280 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{}],23:[function(require,module,exports){
/*! lil-http - v0.1.17 - MIT License - https://github.com/lil-js/http */
;(function (root, factory) {
  if (typeof define === 'function' && define.amd) {
    define(['exports'], factory)

Function 11 has 210 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./defaults":3,"./servers":18,"./utils":20}],11:[function(require,module,exports){
var _ = require('./utils')
var http = require('./http')
var ResilientError = require('./error')
var resilientOptions = require('./defaults').resilientOptions

Function 12 has 161 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./defaults":3,"./error":5,"./http":7,"./utils":20}],12:[function(require,module,exports){
var EventBus = require('lil-event')
var _ = require('./utils')
var Sync = require('./sync')
var Cache = require('./cache')

Function 13 has 152 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./cache":1,"./client":2,"./evaluator":6,"./middleware":9,"./options":10,"./resolvers/discovery":14,"./sync":19,"./utils":20,"lil-event":22}],13:[function(require,module,exports){
var _ = require('./utils')
var Servers = require('./servers')
var Requester = require('./requester')
var ResilientError = require('./error')

Function Resolver has 118 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function Resolver (resilient, options, cb) {
  cb = wrapHandler(cb)

  var sync = resilient._sync
  var middleware = resilient._middleware

Function 4 has 110 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{}],4:[function(require,module,exports){
var _ = require('./utils')
var Servers = require('./servers')
var Requester = require('./requester')
var ResilientError = require('./error')

Function 18 has 108 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./defaults":3}],18:[function(require,module,exports){
var _ = require('./utils')
var Server = require('./server')
var RoundRobin = require('./roundrobin')

Function 20 has 98 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./utils":20}],20:[function(require,module,exports){
var _ = exports
var toStr = Object.prototype.toString
var slice = Array.prototype.slice
var hasOwn = Object.prototype.hasOwnProperty

Function 2 has 96 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./utils":20}],2:[function(require,module,exports){
var _ = require('./utils')
var resolver = require('./resolver')
var http = require('./http')

Function 15 has 87 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"../discovery":4,"../error":5,"../requester":11,"./service":15}],15:[function(require,module,exports){
var _ = require('../utils')
var ResilientError = require('../error')

module.exports = ServiceResolve

Function 3 has 81 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./http":7,"./resolver":13,"./utils":20}],3:[function(require,module,exports){
var defaults = module.exports = Object.create(null)

defaults.service = {
  method: 'GET',

Function 22 has 75 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{}],22:[function(require,module,exports){
/*! lil-event - v0.1 - MIT License - https://github.com/lil-js/event */
(function (root, factory) {
  if (typeof define === 'function' && define.amd) {
    define(['exports'], factory)

Function 24 has 75 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{}],24:[function(require,module,exports){
(function (root, factory) {
  if (typeof define === 'function' && define.amd) {
    define(['exports'], factory)
  } else if (typeof exports === 'object') {

Function 7 has 69 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{}],7:[function(require,module,exports){
var _ = require('./utils')

var IS_BROWSER = typeof window === 'object' && window
var JSON_MIME = /application\/json/i

Function 10 has 62 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./utils":20,"midware":24}],10:[function(require,module,exports){
var _ = require('./utils')
var defaults = require('./defaults')
var Servers = require('./servers')

Function ServiceResolve has 59 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function ServiceResolve (resilient) {
  var middleware = resilient._middleware
  var options = resilient.options('discovery')

  function isCacheEnabled () {

Function 9 has 55 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./client":2,"./defaults":3,"./http":7,"./options":10,"./resilient":12}],9:[function(require,module,exports){
var _ = require('./utils')
var midware = require('midware')

var hooks = ['in', 'out']

Function 17 has 55 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{}],17:[function(require,module,exports){
var balancerOptions = require('./defaults').balancer

module.exports = Server

Function ServersDiscovery has 51 lines of code (exceeds 25 allowed). Consider refactoring.

Open

function ServersDiscovery (resilient, options, servers) {
  var requester = Requester(resilient)
  var middleware = resilient._middleware

  function getOptions () {

Function midware has 50 lines of code (exceeds 25 allowed). Consider refactoring.

Open

  function midware(ctx) {
    var calls = use.stack = []
    ctx = ctx || null
       
    function use() {

Function 14 has 44 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./discovery":4,"./error":5,"./requester":11,"./resolvers/discovery":14,"./servers":18,"./utils":20}],14:[function(require,module,exports){
var ResilientError = require('../error')
var Requester = require('../requester')
var ServersDiscovery = require('../discovery')
var ServiceResolve = require('./service')

Function 19 has 39 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./roundrobin":16,"./server":17,"./utils":20}],19:[function(require,module,exports){
var isArr = require('./utils').isArr

module.exports = Sync

Function 16 has 32 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"../error":5,"../utils":20}],16:[function(require,module,exports){
module.exports = roundRobinSerie

function roundRobinSerie (arr, size) {
  var max = +size < 2 ? 2 : size

Function 1 has 31 lines of code (exceeds 25 allowed). Consider refactoring.

Open

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.resilient = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
var _ = require('./utils')

module.exports = Cache

Function 5 has 28 lines of code (exceeds 25 allowed). Consider refactoring.

Open

},{"./error":5,"./requester":11,"./servers":18,"./utils":20}],5:[function(require,module,exports){
module.exports = ResilientError

var MESSAGES = {
  1000: 'All requests failed. No servers available',

Function requestHandler has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

function requestHandler (server, operation, options, resolve, nextServer, resilient) {

Function handleMissingServers has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

function handleMissingServers (resilient, servers, options, getPreviousResponse, cb) {

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function Resolver (resilient, options, cb) {
  cb = wrapHandler(cb)

  var sync = resilient._sync
  var middleware = resilient._middleware

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function ServiceResolve (resilient) {
  var middleware = resilient._middleware
  var options = resilient.options('discovery')

  function isCacheEnabled () {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function ServersDiscovery (resilient, options, servers) {
  var requester = Requester(resilient)
  var middleware = resilient._middleware

  function getOptions () {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function roundRobin (n, ps) {
  var k
  var j
  var i
  var rs = [] // rs = round array

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Client.prototype.send = function (path, options, cb, method) {
  var args = normalizeArgs.call(this, path, options, cb, method)
  var opts = args[0]
  var callback = args[1]

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Servers.prototype.sort = function (operation, options) {
  var servers = this.servers.slice(0)
  if (servers.length) {
    if (!options.get('disableWeight')) {
      servers.sort(function (x, y) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function requestHandler (server, operation, options, resolve, nextServer, resilient) {
  var start = _.now()
  return function requestReporter (err, res) {
    var latency = _.now() - start
    resilient.emit('request:incoming', err, res, options, resilient)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function DiscoveryResolver (resilient, options, servers) {
  var sync = resilient._sync

  function resolver (resolve) {
    return function (err, res) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function register (pool) {
  return function (mw) {
    var hook = 'in'
    var handler = mw.handler

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function ResilientError (status, error) {
  if (error instanceof Error) {
    Error.call(this)
    this.error = error
    if (error.code) this.code = error.code

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function Requester (resilient) {
  return function request (servers, options, cb, buf) {
    var operation = getOperation(options.method)
    var serversList = getServersList(resilient, servers, operation)
    options = _.clone(options)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function normalizeArgs (path, options, cb, method) {
  if (typeof options === 'function') {
    cb = options
    options = arguments[0]
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

defaults.discovery = {
  servers: null,
  method: 'GET',
  retry: 3,
  parallel: true,

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Options.prototype.set = function (key, value) {
  if (_.isObj(key)) {
    _.each(key, _.bind(this, this.set))
  } else if (value !== undefined) {
    if (key === 'servers') {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

exports.each = function (obj, fn) {
  var i = null
  var l = 0
  if (_.isArr(obj)) {
    for (i = 0, l = obj.length; i < l; i += 1) fn(obj[i], i)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.latestServers =
Resilient.prototype.getUpdatedServers = function (options, cb) {
  cb = typeof options === 'function' ? options : cb

  if (this.discoveryServers()) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.options = function (type, options) {
  if (type && _.isObj(options)) {
    var store = this._options.get(type)
    if (store instanceof Options) {
      store.set(options)

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function shuffle (arr) {
  var array = arr.slice(0)
  for (var i = array.length - 1; i > 0; i -= 1) {
    var j = Math.random() * (i + 1) | 0
    var temp = array[i]

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function mapResponse (cb) {
  return function (err, res, body) {
    if (res && res.statusCode) {
      res.status = res.statusCode
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function Resilient (options) {
  if (!(this instanceof Resilient)) return new Resilient(options)
  this.cache = new Cache()
  this._sync = new Sync()
  this._client = new Client(this)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Options.define = function (options, defaultOptions) {
  var store = new Options()
  var opts = options || {}

  Object.keys(defaultOptions || defaults)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function getTimeout (options) {
  var timeout = options.$timeout || options.timeout
  var timeouts = options.timeouts
  var method = options.method

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Servers.prototype.find = function (url) {
  var server = null
  for (var i = 0, l = this.servers.length; i < l; i += 1) {
    if (this.servers[i].url === url) {
      server = this.servers[i]

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function matchHttpMethod (methods, method) {
  method = (method || 'GET').toUpperCase()
  return methods
    .filter(function (m) { return typeof m === 'string' })
    .map(function (m) { return m.toUpperCase().trim() })

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

exports.omit = function (obj, keys) {
  var key = null
  var buf = {}
  if (_.isObj(obj)) {
    for (key in obj) if (hasOwn.call(obj, key)) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function mapOptions (options) {
  if (typeof options === 'string') {
    options = { url: options }
  } else {
    options = options || {}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function getRefreshOptions (options) {
  var defaultOptions = _.omit(options.get(), ['servers', 'refreshOptions'])
  var refreshOptions = _.merge(defaultOptions, options.get('refreshOptions'), { discoverBeforeRetry: false })
  var basePath = getRefreshBasePath(options.get())
  if (basePath) refreshOptions.basePath = basePath

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function roundRobinSort (servers, options) {
  var size = 0
  if (options && options.get('roundRobin')) {
    var configSize = +options.get('roundRobinSize')
    size = configSize > servers.length ? servers.length : configSize

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

Cache.prototype.exists = function (key) {
  var value = this.store[key]
  return _.isObj(value) && (
    (_.isArr(value.data) && value.data.length > 0) ||
    _.isObj(value.data)) ||

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function handleMissingServers (resilient, servers, options, getPreviousResponse, cb) {
  var cachedPreviousResponse = getPreviousResponse()
  var responseObj = getFirstValue(cachedPreviousResponse)

  if (shouldOmitRetryCycle(options, responseObj)) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function isValidResponse (res) {
  var valid = false
  if (res) {
    if (_.isArr(res.data) && res.data.length) {
      valid = true

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function mapRequestBody (options) {
  var body = options.data || options.body

  if (body && _.isObj(body) || _.isArr(body)) {
    options.json = true

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function retrier (resilient, servers, options, cb) {
  return function () {
    if (servers.exists()) {
      options.retry -= 1
      resilient.emit('request:retry', options, servers)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function mapServer (data) {
  var server
  if (data instanceof Server) {
    server = data
  } else {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Middleware.prototype.use = function (resilient, args) {
  var pool = this.pool
  var middlewares = _.toArr(args)

  middlewares

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function sendRequest (resilient, options, handler, buf) {
  resilient.emit('request:outgoing', options, resilient)

  try {
    var request = getHttpClient(resilient)(_.omit(options, resilientOptions), handler)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

defaults.service = {
  method: 'GET',
  timeout: 10 * 1000,
  timeouts: null,
  servers: null,

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Sync.prototype.push = function (state, task) {
  var queue = this.queues[state]
  if (isArr(queue) === false) {
    queue = this.queues[state] = []
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Server.prototype.balance = function (operation, options) {
  var stats = this.stats(operation)
  var weight = balancerOptions.weight
  var total = stats.request + stats.error
  return total ? calculateStatsBalance(stats, weight, total) : 0

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function calculateStatsBalance (stats, weight, total) {
  return round(
    ((((stats.request * 100 / total) * weight.success) +
    ((stats.error * 100 / total) * weight.error)) +
    (stats.latency * weight.latency)) / 100)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Server.prototype.report = function (operation, latency, type) {
  var stats = this.stats(operation)
  if (stats) {
    stats[type || 'request'] += 1
    stats.latency = calculateAvgLatency(latency || 0, stats)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function resolveRequest (cb) {
  var mapAndResolve = http.mapResponse(cb)
  return function (err, res) {
    var resolution = err || res
    var body = resolution ? resolution.body || resolution.data : null

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.resetScore =
Resilient.prototype.resetStats = function (type) {
  var servers = this.options(type || 'service').servers()
  if (servers) {
    servers.resetStats()

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Options.prototype.setServers = function (servers) {
  if (this.store.servers) {
    this.store.servers.set(servers)
  } else {
    this.store.servers = new Servers(servers)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function fetchHandler (cb) {
  return function (err, res) {
    if (err) {
      cb(err)
    } else if (res && res.data) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.serversUpdated = function () {
  var updated = this.servers().lastUpdate()
  var refresh = this.options('discovery').get('refreshInterval') || 0
  return updated < refresh
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Servers.prototype.set = function (servers) {
  if (_.isArr(servers)) {
    this.updated = _.now()
    this.servers = mapServers.call(this, servers)
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function merger (target, key, value) {
  if (_.isObj(value) && _.isObj(target[key])) {
    _.merge(target[key], value)
  } else {
    extender(target, key, value)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function mergeHttpOptions (resilient, options) {
  var defaults = resilient.options('service').get()

  if (options.timeout) {
    options.$timeout = options.timeout

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.discoveryServers = function (list) {
  if (_.isArr(list)) {
    this.options('discovery').servers(list)
  } else {
    return this.servers('discovery')

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function getRaw (options) {
  var buf = {}
  _.each(options, function (key, value) {
    if (value instanceof Options) {
      buf[key] = value.get()

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function closePendingRequest (client) {
  if (client) {
    if (client.xhr) {
      if (client.xhr.readyState !== 4) {
        closeClient(client.xhr)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function onUpdateInParallel (servers, counter, next) {
  return function handler (err, res) {
    var pending = counter()
    if (err == null || pending === 0) {
      counter(true)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

;['get', 'post', 'put', 'del', 'delete', 'head', 'patch']
  .forEach(function defineMethodProxy (verb) {
    Resilient.prototype[verb] = function (path, options, cb) {
      return this._client[verb](path, options, cb)
    }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function retryRequest (resilient, servers, options, cb) {
  var onRetry = retrier(resilient, servers, options, cb)
  var retry = waitBeforeRetry(onRetry, options)

  if (options.discoverBeforeRetry) {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function shouldOmitRetryCycle (options, err) {
  return shouldOmitOnErrorCode(options.omitRetryOnErrorCodes, err ? err.status : null) ||
    shouldOmitOnMethod(options.omitRetryOnMethods, options.method) ||
    shouldOmitWhenRules(options.omitRetryWhen, options.method, err)
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function passArgs (resilient) {
  return function (mw) {
    var type = mw.type || 'service'
    var opts = resilient.options(type)
    return { type: type, handler: mw(opts, resilient) }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.mock = function (mockFn) {
  this.useHttpClient(function (options, cb) {
    _.delay(function () { mockFn(options, cb) })
  })
  return this

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function getServersList (resilient, servers, operation) {
  if (resilient.balancer().get('enable')) {
    return servers.sort(operation, resilient.balancer())
  } else {
    return servers.get()

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function roundRobinSerie (arr, size) {
  var max = +size < 2 ? 2 : size
  var rounds = roundRobin(max, arr).shift()
  return [].concat.apply([], rounds)
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function updateDiscoveryServersAndRetry (resilient, onRetry) {
  if (resilient.hasDiscoveryServers()) {
    resilient._sync.unlock('updating')
    Requester.DiscoveryResolver.update(resilient, null, onRetry)
  } else {

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Cache.prototype.flush = function (key) {
  if (key) {
    this.store[key] = null
  } else {
    this.store = _.emptyObject()

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function plainHttpRequest (resilient, options, cb) {
  if (options.path) {
    options.url = options.path
    options.path = null
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function defineUserAgent (options) {
  options.headers = options.headers || {}

  if (!options.headers['User-Agent']) {
    options.headers['User-Agent'] = getUserAgent()

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function updateServers (resilient, method, options, cb) {
  if (typeof options === 'function') { cb = options; options = null }
  DiscoveryResolver[method](resilient, options, cb || _.noop)
  return resilient
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Server.prototype.stats = function (operation, field) {
  var stats = this.statsStore[operation || 'read']
  if (stats && field) stats = stats[field]
  return stats
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

defaults.balancer = {
  enable: true,
  random: false,
  roundRobin: false,
  roundRobinSize: 3,

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

Resilient.prototype.serviceOptions = function (options) {
  if (options) {
    this.options('service', options)
  } else {
    return this.options('service').get()

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

Resilient.prototype.discoveryOptions = function (options) {
  if (options) {
    this.options('discovery', options)
  } else {
    return this.options('discovery').get()

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function matchRuleStatusCode (rule, status) {
  return status && ((rule.code && rule.code === status) ||
    (_.isArr(rule.codes) && shouldOmitOnErrorCode(rule.codes, status)))
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Cache.prototype.set = function (key, data) {
  if (key) {
    this.store[key] = { data: data, time: _.now() }
  }
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function canUpdateDiscoveryServers (options) {
  var refreshServers = options.get('refreshServers')
  return options.get('enableRefreshServers') &&
    (options.get('enableSelfRefresh') ||
    (refreshServers && refreshServers.exists()))

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function eachArgument (target, iterator) {
  return function (obj) {
    if (_.isObj(obj)) {
      _.each(obj, function (key, value) {
        iterator(target, key, value)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function defineRequestOptions (server, options) {
  options.url = _.join(server.url, options.basePath, options.path)
  options.timeout = getTimeout(options)
  return options
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function isUnavailableStatus (err, res) {
  return (err && (err.code !== undefined ||
    (err.status === undefined && res === undefined))) ||
    isInvalidStatus(err || res) ||
    false

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.hasDiscoveryServers = function () {
  var servers = this.discoveryServers()
  return _.isObj(servers) && servers.exists() || false
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function Options (options, type) {
  this.store = type ? _.clone(defaults[type]) : Object.create(null)
  this.set(options)
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function matchRuleMethod (rule, method) {
  return ((rule.method && rule.method === method) ||
    _.isArr(rule.methods) && matchHttpMethod(rule.methods, method))
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function isErrorResponse (resilient, options, err, res) {
  return isUnavailableStatus(err, res) ||
    resilient._failStrategies.eval(err, res) ||
    (options.promiscuousErrors && (isErrorStatus(err || res)))
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.servers = function (type) {
  var options = this.options(type || 'service')
  return options ? options.servers() : null
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function counter (total) {
  total = total > 2 ? CONCURRENCY : total
  return function decrement (reset) {
    return (total = reset ? -1 : (total - 1))
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function shouldOmitOnErrorCode (codes, status) {
  return status && _.isArr(codes) && codes.length &&
    ~codes.indexOf(status) &&
    status >= 300
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.balancer = function (options) {
  if (options) {
    this.options('balancer', options)
  } else {
    return this.options('balancer')

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

  function once (fn) {
    var called = false
    return function () {
      if (called === false) {
        called = true

• Read up
  Read up

Identical blocks of code found in 3 locations. Consider refactoring.

Open

function once (fn) {
  var called = false
  return function () {
    if (called === false) {
      called = true

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.httpOptions = function (type) {
  var options = this.options(type || 'service')
  if (options) return options.http()
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function objIterator (iterator) {
  return function (target) {
    var args = _.toArr(arguments, 1)
    _.each(args, eachArgument(target, iterator))
    return target

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

exports.join = function (base) {
  return (base || '') +
  (_.toArr(arguments, 1)
    .filter(notEmpty)
    .join(''))

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function ruleFilter (method, err) {
  return function (rule) {
    return _.isObj(rule) &&
      matchRuleMethod(rule, method) &&
      matchRuleStatusCode(rule, err.status)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.serversURL = function (type) {
  var servers = this.servers(type)
  return servers ? servers.urls() : null
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function parseAsJSON (res) {
  try {
    res.data = JSON.parse(res.data)
    return true
  } catch (e) {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function getRefreshBasePath (options) {
  return options && (options.refreshPath ||
    (_.isObj(options.refreshOptions) &&
    options.refreshOptions.basePath)) ||
    false

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.send =
Resilient.prototype.request = function (path, options, cb) {
  return this._client.send(path, options, cb)
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

exports.bind = function (ctx, fn) {
  return bind ? fn.bind(ctx) : function () {
    return fn.apply(ctx, arguments)
  }
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  } else if (typeof exports === 'object') {
    factory(exports)
    if (typeof module === 'object' && module !== null) {
      module.exports = exports = exports.http
    }

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

  } else if (typeof exports === 'object') {
    factory(exports)
    if (typeof module === 'object' && module !== null) {
      module.exports = exports = exports.midware
    }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function requester (options, cb) {
  if (isFullUrlSchema(options)) {
    return plainHttpRequest(this._resilient, options, cb)
  } else {
    return resolver(this._resilient, options, cb)

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function addTimeStamp (options) {
  return _.extend(options.params || options.qs || {}, { _time: _.now() })
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function closeAndEmptyPendingRequests (buf) {
  if (buf) {
    if (!isEmptyBuffer(buf)) {
      buf.forEach(closePendingRequest)
    }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function shouldOmitWhenRules (rules, method, res) {
  return _.isArr(rules) &&
    res && res.status &&
    rules.some(ruleFilter(method, res))
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Servers.prototype.resetStats = function () {
  this.servers.forEach(function (server) {
    server.resetStats()
  })
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function isValidURI (uri) {
  if (_.isObj(uri)) uri = uri.url || uri.uri
  return _.isURI(uri)
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Evaluator.prototype.eval = function (err, res) {
  return this.strategies.some(function (strategy) {
    return strategy(err, res)
  })
}

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

function checkResponseStatus (code, res) {
  return (res && !res.code && (res.status >= code || res.status === 0)) || false
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Resilient.prototype.failStrategy =
Resilient.prototype.addFailStrategy = function (strategy) {
  this._failStrategies.add(strategy)
  return this
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function closeClient (client) {
  if (typeof client.abort === 'function') {
    try { client.abort() } catch (e) {}
  }
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Sync.prototype.enqueue = function (state, task) {
  if (getSync(this.locks, state)) {
    this.push(state, task)
  }
}

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

Cache.prototype.get = function (key) {
  return key ? this.store[key] : _.clone(this.store)
}

• Read up
  Read up

Similar blocks of code found in 4 locations. Consider refactoring.

Open

Options.prototype.get = function (key) {
  return key ? this.store[key] : _.clone(this.store)
}

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

function getSync (locks, state) {
  var lock = locks[state]
  if (lock === undefined) {
    lock = locks[state] = false
  }

• Read up
  Read up

Identical blocks of code found in 2 locations. Consider refactoring.

Open

Evaluator.prototype.add = function (strategy) {
  if (typeof strategy === 'function') {
    this.strategies.push(strategy)
  }
}

• Read up
  Read up