effect-distributed-lock 0.0.6 → 0.0.7

package/redis-semaphore/src/multiSemaphore/release/index.ts

@@ -1,22 +0,0 @@
-import createDebug from 'debug'
-import { RedisClient } from '../../types'
-import { releaseLua } from './lua'
-
-const debug = createDebug('redis-semaphore:multi-semaphore:release')
-
-export interface Options {
-  identifier: string
-  lockTimeout: number
-  now: number
-}
-
-export async function releaseSemaphore(
-  client: RedisClient,
-  key: string,
-  permits: number,
-  identifier: string
-): Promise<void> {
-  debug(key, identifier, permits)
-  const result = await releaseLua(client, [key, permits, identifier])
-  debug('result', typeof result, result)
-}

package/redis-semaphore/src/multiSemaphore/release/lua.ts

@@ -1,17 +0,0 @@
-import { createEval } from '../../utils/index'
-
-export const releaseLua = createEval<[string, number, string], number>(
-  `
-  local key = KEYS[1]
-  local permits = tonumber(ARGV[1])
-  local identifier = ARGV[2]
-  local args = {}
-
-  for i=0, permits - 1 do
-    table.insert(args, identifier .. '_' .. i)
-  end
-
-  return redis.call('zrem', key, unpack(args))
-`,
-  1
-)

package/redis-semaphore/src/mutex/acquire.ts

@@ -1,42 +0,0 @@
-import createDebug from 'debug'
-import { RedisClient } from '../types'
-import { delay } from '../utils'
-
-const debug = createDebug('redis-semaphore:mutex:acquire')
-
-export interface Options {
-  identifier: string
-  lockTimeout: number
-  acquireTimeout: number
-  acquireAttemptsLimit: number
-  retryInterval: number
-}
-
-export async function acquireMutex(
-  client: RedisClient,
-  key: string,
-  options: Options
-): Promise<boolean> {
-  const {
-    identifier,
-    lockTimeout,
-    acquireTimeout,
-    acquireAttemptsLimit,
-    retryInterval
-  } = options
-  let attempt = 0
-  const end = Date.now() + acquireTimeout
-  while (Date.now() < end && ++attempt <= acquireAttemptsLimit) {
-    debug(key, identifier, 'attempt', attempt)
-    const result = await client.set(key, identifier, 'PX', lockTimeout, 'NX')
-    debug('result', typeof result, result)
-    if (result === 'OK') {
-      debug(key, identifier, 'acquired')
-      return true
-    } else {
-      await delay(retryInterval)
-    }
-  }
-  debug(key, identifier, 'timeout or reach limit')
-  return false
-}

package/redis-semaphore/src/mutex/refresh.ts

@@ -1,37 +0,0 @@
-import createDebug from 'debug'
-import { RedisClient } from '../types'
-import { createEval } from '../utils/index'
-
-const debug = createDebug('redis-semaphore:mutex:refresh')
-
-export const expireIfEqualLua = createEval<[string, string, number], 0 | 1>(
-  `
-  local key = KEYS[1]
-  local identifier = ARGV[1]
-  local lockTimeout = ARGV[2]
-
-  local value = redis.call('get', key)
-
-  if value == identifier then
-    redis.call('pexpire', key, lockTimeout)
-    return 1
-  end
-
-  return 0
-  `,
-  1
-)
-
-export async function refreshMutex(
-  client: RedisClient,
-  key: string,
-  identifier: string,
-  lockTimeout: number
-): Promise<boolean> {
-  debug(key, identifier)
-  const result = await expireIfEqualLua(client, [key, identifier, lockTimeout])
-  debug('result', typeof result, result)
-
-  // support options.stringNumbers
-  return +result === 1
-}

package/redis-semaphore/src/mutex/release.ts

@@ -1,30 +0,0 @@
-import createDebug from 'debug'
-import { createEval } from '../utils/index'
-
-import type { RedisClient } from '../types'
-
-const debug = createDebug('redis-semaphore:mutex:release')
-
-export const delIfEqualLua = createEval<[string, string], 0 | 1>(
-  `
-  local key = KEYS[1]
-  local identifier = ARGV[1]
-
-  if redis.call('get', key) == identifier then
-    return redis.call('del', key)
-  end
-
-  return 0
-  `,
-  1
-)
-
-export async function releaseMutex(
-  client: RedisClient,
-  key: string,
-  identifier: string
-): Promise<void> {
-  debug(key, identifier)
-  const result = await delIfEqualLua(client, [key, identifier])
-  debug('result', typeof result, result)
-}

package/redis-semaphore/src/redlockMultiSemaphore/acquire.ts

@@ -1,56 +0,0 @@
-import createDebug from 'debug'
-import { acquireLua } from '../multiSemaphore/acquire/lua'
-import { RedisClient } from '../types'
-import { delay } from '../utils'
-import { getQuorum, smartSum } from '../utils/redlock'
-
-const debug = createDebug('redis-semaphore:redlock-multi-semaphore:acquire')
-
-export interface Options {
-  identifier: string
-  lockTimeout: number
-  acquireTimeout: number
-  acquireAttemptsLimit: number
-  retryInterval: number
-}
-
-export async function acquireRedlockMultiSemaphore(
-  clients: RedisClient[],
-  key: string,
-  limit: number,
-  permits: number,
-  options: Options
-): Promise<boolean> {
-  const {
-    identifier,
-    lockTimeout,
-    acquireTimeout,
-    acquireAttemptsLimit,
-    retryInterval
-  } = options
-  let attempt = 0
-  const end = Date.now() + acquireTimeout
-  const quorum = getQuorum(clients.length)
-  let now: number
-  while ((now = Date.now()) < end && ++attempt <= acquireAttemptsLimit) {
-    debug(key, identifier, 'attempt', attempt)
-    const promises = clients.map(client =>
-      acquireLua(client, [key, limit, permits, identifier, lockTimeout, now])
-        .then(result => +result)
-        .catch(() => 0)
-    )
-    const results = await Promise.all(promises)
-    if (results.reduce(smartSum, 0) >= quorum) {
-      debug(key, identifier, 'acquired')
-      return true
-    } else {
-      const promises = clients.map(client =>
-        client.zrem(key, identifier).catch(() => 0)
-      )
-      await Promise.all(promises)
-      await delay(retryInterval)
-    }
-  }
-  debug(key, identifier, 'timeout or reach limit')
-  return false
-}

package/redis-semaphore/src/redlockMultiSemaphore/refresh.ts

@@ -1,68 +0,0 @@
-import createDebug from 'debug'
-import { acquireLua } from '../multiSemaphore/acquire/lua'
-import { refreshLua } from '../multiSemaphore/refresh/lua'
-import { releaseLua } from '../multiSemaphore/release/lua'
-import { RedisClient } from '../types'
-import { getQuorum, smartSum } from '../utils/redlock'
-
-const debug = createDebug('redis-semaphore:redlock-semaphore:refresh')
-
-interface Options {
-  identifier: string
-  lockTimeout: number
-}
-
-export async function refreshRedlockMultiSemaphore(
-  clients: RedisClient[],
-  key: string,
-  limit: number,
-  permits: number,
-  options: Options
-): Promise<boolean> {
-  const { identifier, lockTimeout } = options
-  const now = Date.now()
-  debug(key, identifier, now)
-  const quorum = getQuorum(clients.length)
-  const promises = clients.map(client =>
-    refreshLua(client, [key, limit, permits, identifier, lockTimeout, now])
-      .then(result => +result)
-      .catch(() => 0)
-  )
-  const results = await Promise.all(promises)
-  debug('results', results)
-  const refreshedCount = results.reduce(smartSum, 0)
-  if (refreshedCount >= quorum) {
-    debug(key, identifier, 'refreshed')
-    if (refreshedCount < clients.length) {
-      debug(key, identifier, 'try to acquire on failed nodes')
-      const promises = results
-        .reduce<RedisClient[]>((failedClients, result, index) => {
-          if (!result) {
-            failedClients.push(clients[index])
-          }
-          return failedClients
-        }, [])
-        .map(client =>
-          acquireLua(client, [
-            key,
-            limit,
-            permits,
-            identifier,
-            lockTimeout,
-            now
-          ])
-            .then(result => +result)
-            .catch(() => 0)
-        )
-      const acquireResults = await Promise.all(promises)
-      debug(key, identifier, 'acquire on failed nodes results', acquireResults)
-    }
-    return true
-  } else {
-    const promises = clients.map(client =>
-      releaseLua(client, [key, permits, identifier]).catch(() => 0)
-    )
-    await Promise.all(promises)
-    return false
-  }
-}

package/redis-semaphore/src/redlockMultiSemaphore/release.ts

@@ -1,19 +0,0 @@
-import createDebug from 'debug'
-import { releaseLua } from '../multiSemaphore/release/lua'
-import { RedisClient } from '../types'
-
-const debug = createDebug('redis-semaphore:redlock-mutex:release')
-
-export async function releaseRedlockMultiSemaphore(
-  clients: RedisClient[],
-  key: string,
-  permits: number,
-  identifier: string
-): Promise<void> {
-  debug(key, identifier)
-  const promises = clients.map(client =>
-    releaseLua(client, [key, permits, identifier]).catch(() => 0)
-  )
-  const results = await Promise.all(promises)
-  debug('results', results)
-}

package/redis-semaphore/src/redlockMutex/acquire.ts

@@ -1,54 +0,0 @@
-import createDebug from 'debug'
-import { delIfEqualLua } from '../mutex/release'
-import { RedisClient } from '../types'
-import { delay } from '../utils'
-import { getQuorum, smartSum } from '../utils/redlock'
-
-const debug = createDebug('redis-semaphore:redlock-mutex:acquire')
-
-export interface Options {
-  identifier: string
-  lockTimeout: number
-  acquireTimeout: number
-  acquireAttemptsLimit: number
-  retryInterval: number
-}
-
-export async function acquireRedlockMutex(
-  clients: RedisClient[],
-  key: string,
-  options: Options
-): Promise<boolean> {
-  const {
-    identifier,
-    lockTimeout,
-    acquireTimeout,
-    acquireAttemptsLimit,
-    retryInterval
-  } = options
-  let attempt = 0
-  const end = Date.now() + acquireTimeout
-  const quorum = getQuorum(clients.length)
-  while (Date.now() < end && ++attempt <= acquireAttemptsLimit) {
-    debug(key, identifier, 'attempt', attempt)
-    const promises = clients.map(client =>
-      client
-        .set(key, identifier, 'PX', lockTimeout, 'NX')
-        .then(result => (result === 'OK' ? 1 : 0))
-        .catch(() => 0)
-    )
-    const results = await Promise.all(promises)
-    if (results.reduce(smartSum, 0) >= quorum) {
-      debug(key, identifier, 'acquired')
-      return true
-    } else {
-      const promises = clients.map(client =>
-        delIfEqualLua(client, [key, identifier]).catch(() => 0)
-      )
-      await Promise.all(promises)
-      await delay(retryInterval)
-    }
-  }
-  debug(key, identifier, 'timeout or reach limit')
-  return false
-}

package/redis-semaphore/src/redlockMutex/refresh.ts

@@ -1,53 +0,0 @@
-import createDebug from 'debug'
-import { expireIfEqualLua } from '../mutex/refresh'
-import { delIfEqualLua } from '../mutex/release'
-import { RedisClient } from '../types'
-import { getQuorum, smartSum } from '../utils/redlock'
-
-const debug = createDebug('redis-semaphore:redlock-mutex:refresh')
-
-export async function refreshRedlockMutex(
-  clients: RedisClient[],
-  key: string,
-  identifier: string,
-  lockTimeout: number
-): Promise<boolean> {
-  debug(key, identifier)
-  const quorum = getQuorum(clients.length)
-  const promises = clients.map(client =>
-    expireIfEqualLua(client, [key, identifier, lockTimeout])
-      .then(result => +result)
-      .catch(() => 0)
-  )
-  const results = await Promise.all(promises)
-  debug('results', results)
-  const refreshedCount = results.reduce(smartSum, 0)
-  if (refreshedCount >= quorum) {
-    debug(key, identifier, 'refreshed')
-    if (refreshedCount < clients.length) {
-      debug(key, identifier, 'try to acquire on failed nodes')
-      const promises = results
-        .reduce<RedisClient[]>((failedClients, result, index) => {
-          if (!result) {
-            failedClients.push(clients[index])
-          }
-          return failedClients
-        }, [])
-        .map(client =>
-          client
-            .set(key, identifier, 'PX', lockTimeout, 'NX')
-            .then(result => (result === 'OK' ? 1 : 0))
-            .catch(() => 0)
-        )
-      const acquireResults = await Promise.all(promises)
-      debug(key, identifier, 'acquire on failed nodes results', acquireResults)
-    }
-    return true
-  } else {
-    const promises = clients.map(client =>
-      delIfEqualLua(client, [key, identifier]).catch(() => 0)
-    )
-    await Promise.all(promises)
-    return false
-  }
-}

package/redis-semaphore/src/redlockMutex/release.ts

@@ -1,19 +0,0 @@
-import createDebug from 'debug'
-import { delIfEqualLua } from '../mutex/release'
-
-import type { RedisClient } from '../types'
-
-const debug = createDebug('redis-semaphore:redlock-mutex:release')
-
-export async function releaseRedlockMutex(
-  clients: RedisClient[],
-  key: string,
-  identifier: string
-): Promise<void> {
-  debug(key, identifier)
-  const promises = clients.map(client =>
-    delIfEqualLua(client, [key, identifier]).catch(() => 0)
-  )
-  const results = await Promise.all(promises)
-  debug('results', results)
-}

package/redis-semaphore/src/redlockSemaphore/acquire.ts

@@ -1,55 +0,0 @@
-import createDebug from 'debug'
-import { acquireLua } from '../semaphore/acquire/lua'
-import { RedisClient } from '../types'
-import { delay } from '../utils'
-import { getQuorum, smartSum } from '../utils/redlock'
-
-const debug = createDebug('redis-semaphore:redlock-semaphore:acquire')
-
-export interface Options {
-  identifier: string
-  lockTimeout: number
-  acquireTimeout: number
-  acquireAttemptsLimit: number
-  retryInterval: number
-}
-
-export async function acquireRedlockSemaphore(
-  clients: RedisClient[],
-  key: string,
-  limit: number,
-  options: Options
-): Promise<boolean> {
-  const {
-    identifier,
-    lockTimeout,
-    acquireTimeout,
-    acquireAttemptsLimit,
-    retryInterval
-  } = options
-  let attempt = 0
-  const end = Date.now() + acquireTimeout
-  const quorum = getQuorum(clients.length)
-  let now: number
-  while ((now = Date.now()) < end && ++attempt <= acquireAttemptsLimit) {
-    debug(key, identifier, 'attempt', attempt)
-    const promises = clients.map(client =>
-      acquireLua(client, [key, limit, identifier, lockTimeout, now])
-        .then(result => +result)
-        .catch(() => 0)
-    )
-    const results = await Promise.all(promises)
-    if (results.reduce(smartSum, 0) >= quorum) {
-      debug(key, identifier, 'acquired')
-      return true
-    } else {
-      const promises = clients.map(client =>
-        client.zrem(key, identifier).catch(() => 0)
-      )
-      await Promise.all(promises)
-      await delay(retryInterval)
-    }
-  }
-  debug(key, identifier, 'timeout or reach limit')
-  return false
-}

package/redis-semaphore/src/redlockSemaphore/refresh.ts

@@ -1,60 +0,0 @@
-import createDebug from 'debug'
-import { acquireLua } from '../semaphore/acquire/lua'
-import { refreshLua } from '../semaphore/refresh/lua'
-import { getQuorum, smartSum } from '../utils/redlock'
-
-import type { RedisClient } from '../types'
-
-const debug = createDebug('redis-semaphore:redlock-semaphore:refresh')
-
-interface Options {
-  identifier: string
-  lockTimeout: number
-}
-
-export async function refreshRedlockSemaphore(
-  clients: RedisClient[],
-  key: string,
-  limit: number,
-  options: Options
-): Promise<boolean> {
-  const { identifier, lockTimeout } = options
-  const now = Date.now()
-  debug(key, identifier, now)
-  const quorum = getQuorum(clients.length)
-  const promises = clients.map(client =>
-    refreshLua(client, [key, limit, identifier, lockTimeout, now])
-      .then(result => +result)
-      .catch(() => 0)
-  )
-  const results = await Promise.all(promises)
-  debug('results', results)
-  const refreshedCount = results.reduce(smartSum, 0)
-  if (refreshedCount >= quorum) {
-    debug(key, identifier, 'refreshed')
-    if (refreshedCount < clients.length) {
-      debug(key, identifier, 'try to acquire on failed nodes')
-      const promises = results
-        .reduce<RedisClient[]>((failedClients, result, index) => {
-          if (!result) {
-            failedClients.push(clients[index])
-          }
-          return failedClients
-        }, [])
-        .map(client =>
-          acquireLua(client, [key, limit, identifier, lockTimeout, now])
-            .then(result => +result)
-            .catch(() => 0)
-        )
-      const acquireResults = await Promise.all(promises)
-      debug(key, identifier, 'acquire on failed nodes results', acquireResults)
-    }
-    return true
-  } else {
-    const promises = clients.map(client =>
-      client.zrem(key, identifier).catch(() => 0)
-    )
-    await Promise.all(promises)
-    return false
-  }
-}

package/redis-semaphore/src/redlockSemaphore/release.ts

@@ -1,18 +0,0 @@
-import createDebug from 'debug'
-
-import type { RedisClient } from '../types'
-
-const debug = createDebug('redis-semaphore:redlock-mutex:release')
-
-export async function releaseRedlockSemaphore(
-  clients: RedisClient[],
-  key: string,
-  identifier: string
-): Promise<void> {
-  debug(key, identifier)
-  const promises = clients.map(client =>
-    client.zrem(key, identifier).catch(() => 0)
-  )
-  const results = await Promise.all(promises)
-  debug('results', results)
-}

package/redis-semaphore/src/semaphore/acquire/index.ts

@@ -1,52 +0,0 @@
-import createDebug from 'debug'
-import { RedisClient } from '../../types'
-import { delay } from '../../utils'
-import { acquireLua } from './lua'
-
-const debug = createDebug('redis-semaphore:semaphore:acquire')
-
-export interface Options {
-  identifier: string
-  lockTimeout: number
-  acquireTimeout: number
-  acquireAttemptsLimit: number
-  retryInterval: number
-}
-
-export async function acquireSemaphore(
-  client: RedisClient,
-  key: string,
-  limit: number,
-  options: Options
-): Promise<boolean> {
-  const {
-    identifier,
-    lockTimeout,
-    acquireTimeout,
-    acquireAttemptsLimit,
-    retryInterval
-  } = options
-  let attempt = 0
-  const end = Date.now() + acquireTimeout
-  let now
-  while ((now = Date.now()) < end && ++attempt <= acquireAttemptsLimit) {
-    debug(key, identifier, limit, lockTimeout, 'attempt', attempt)
-    const result = await acquireLua(client, [
-      key,
-      limit,
-      identifier,
-      lockTimeout,
-      now
-    ])
-    debug(key, 'result', typeof result, result)
-    // support options.stringNumbers
-    if (+result === 1) {
-      debug(key, identifier, 'acquired')
-      return true
-    } else {
-      await delay(retryInterval)
-    }
-  }
-  debug(key, identifier, limit, lockTimeout, 'timeout or reach limit')
-  return false
-}

package/redis-semaphore/src/semaphore/acquire/lua.ts

@@ -1,25 +0,0 @@
-import { createEval } from '../../utils/index'
-
-export const acquireLua = createEval<
-  [string, number, string, number, number],
-  0 | 1
->(
-  `
-  local key = KEYS[1]
-  local limit = tonumber(ARGV[1])
-  local identifier = ARGV[2]
-  local lockTimeout = tonumber(ARGV[3])
-  local now = tonumber(ARGV[4])
-  local expiredTimestamp = now - lockTimeout
-
-  redis.call('zremrangebyscore', key, '-inf', expiredTimestamp)
-
-  if redis.call('zcard', key) < limit then
-    redis.call('zadd', key, now, identifier)
-    redis.call('pexpire', key, lockTimeout)
-    return 1
-  else
-    return 0
-  end`,
-  1
-)

package/redis-semaphore/src/semaphore/refresh/index.ts

@@ -1,31 +0,0 @@
-import createDebug from 'debug'
-import { RedisClient } from '../../types'
-import { refreshLua } from './lua'
-
-const debug = createDebug('redis-semaphore:semaphore:refresh')
-
-export interface Options {
-  identifier: string
-  lockTimeout: number
-}
-
-export async function refreshSemaphore(
-  client: RedisClient,
-  key: string,
-  limit: number,
-  options: Options
-): Promise<boolean> {
-  const { identifier, lockTimeout } = options
-  const now = Date.now()
-  debug(key, identifier, now)
-  const result = await refreshLua(client, [
-    key,
-    limit,
-    identifier,
-    lockTimeout,
-    now
-  ])
-  debug('result', typeof result, result)
-  // support options.stringNumbers
-  return +result === 1
-}