@salto-io/persistent-pool 0.3.40-main.5ef2e84db → 0.3.40-publishOnlyDist.57b77fb79

package/src/lib/renewed_lease.ts

@@ -1,83 +0,0 @@
-/*
-*                      Copyright 2023 Salto Labs Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-import { types } from '@salto-io/lowerdash'
-import { logger } from '@salto-io/logging'
-import { Pool, LeaseUpdateOpts, Lease, InstanceId, InstanceNotLeasedError } from '../types'
-
-const log = logger(module)
-
-const poolFuncs: (keyof Pool)[] = ['lease', 'return']
-const isPool = (
-  o: Pool | (() => Promise<Pool>)
-): o is Pool => poolFuncs.every((f: keyof Pool) => typeof (o as Pool)[f] === 'function')
-
-export type RenewedLeaseOpts<T> = {
-  poolOrFactory: Pool | (() => Promise<Pool>)
-  lease: Lease<T>
-  timeout: number
-  renewMargin: number
-}
-
-export default class RenewedLease<T> extends types.Bean<RenewedLeaseOpts<T>>
-  implements Lease<T> {
-  timeoutId: NodeJS.Timeout | undefined
-
-  constructor(opts: RenewedLeaseOpts<T>) {
-    super(opts)
-    this.timeoutId = this.renewTimeout()
-  }
-
-  private pool(): Promise<Pool> {
-    return isPool(this.poolOrFactory)
-      ? Promise.resolve(this.poolOrFactory)
-      : this.poolOrFactory()
-  }
-
-  get value(): T {
-    return this.lease.value
-  }
-
-  get id(): InstanceId {
-    return this.lease.id
-  }
-
-  private renewTimeout(): NodeJS.Timeout {
-    return setTimeout(this.renew.bind(this), this.timeout - this.renewMargin)
-  }
-
-  private async renew(): Promise<void> {
-    const pool = await this.pool()
-    try {
-      await pool.updateTimeout(this.lease.id, this.timeout)
-      this.timeoutId = this.renewTimeout()
-    } catch (e) {
-      if (!(e instanceof InstanceNotLeasedError)) {
-        throw e
-      }
-      log.warn('lease returned by unknown entity, stops renew interval')
-    }
-  }
-
-  async return(opts?: LeaseUpdateOpts): Promise<void> {
-    if (this.timeoutId !== undefined) {
-      clearTimeout(this.timeoutId)
-      this.timeoutId = undefined
-    }
-
-    const pool = await this.pool()
-    return pool.return(this.lease.id, opts)
-  }
-}

package/src/types.ts

@@ -1,106 +0,0 @@
-/*
-*                      Copyright 2023 Salto Labs Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with
-* the License.  You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-import { retry } from '@salto-io/lowerdash'
-
-export type InstanceId = string
-
-export type RetryStrategy = retry.RetryStrategy
-
-export type Lease<T = unknown> = {
-  id: InstanceId
-  value: T
-}
-
-export type UnavailableLease = {
-  leaseExpiresBy: Date
-  clientId: string
-}
-
-export type LeaseWithStatus<T> = Lease<T> & (
-  ({ status: 'suspended'; suspensionReason: string } & UnavailableLease)
-  | ({ status: 'leased' } & UnavailableLease)
-  | { status: 'available' }
-)
-
-export type LeaseUpdateOpts = { validateClientId: boolean }
-
-export const DEFAULT_LEASE_UPDATE_OPTS: LeaseUpdateOpts = Object.freeze({ validateClientId: true })
-
-export type Pool<T = unknown> = AsyncIterable<LeaseWithStatus<T>> & {
-  register(value: T, id?: InstanceId): Promise<InstanceId>
-  unregister(id: InstanceId): Promise<void>
-  suspend(
-    id: InstanceId,
-    reason: string,
-    timeout: number,
-    opts?: Partial<LeaseUpdateOpts>,
-  ): Promise<void>
-  lease(returnTimeout: number): Promise<Lease<T> | null>
-  waitForLease(returnTimeout: number, retryStrategy: () => RetryStrategy): Promise<Lease<T>>
-  updateTimeout(id: InstanceId, newTimeout: number, opts?: Partial<LeaseUpdateOpts>): Promise<void>
-  return(id: InstanceId, opts?: Partial<LeaseUpdateOpts>): Promise<void>
-  clear(): Promise<void>
-}
-
-export type RepoOpts = {
-  clientId: string
-}
-
-export type Repo = {
-  pool<T extends {}>(typeName: string): Promise<Pool<T>>
-}
-
-export type RepoMaker<TOpts extends RepoOpts> = (opts: TOpts) => Repo
-
-export abstract class InstanceError extends Error {
-  readonly id: string
-  readonly typeName: string
-
-  constructor(
-    { id, typeName, message }: { id: InstanceId; typeName: string; message: string }
-  ) {
-    super(`Instance "${id}" of type "${typeName}": ${message}`)
-    this.id = id
-    this.typeName = typeName
-  }
-}
-
-export class InstanceIdAlreadyRegistered extends InstanceError {
-  constructor(
-    { id, typeName }: { id: InstanceId; typeName: string }
-  ) {
-    super({ id, typeName, message: 'already exists' })
-  }
-}
-
-export class InstanceNotFoundError extends InstanceError {
-  constructor(
-    { id, typeName }: { id: InstanceId; typeName: string }
-  ) {
-    super({ id, typeName, message: 'not found' })
-  }
-}
-
-export class InstanceNotLeasedError extends InstanceError {
-  readonly clientId: string
-
-  constructor(
-    { id, typeName, clientId }: { id: InstanceId; typeName: string; clientId: string }
-  ) {
-    super({ id, typeName, message: `not leased by client "${clientId}"` })
-    this.clientId = clientId
-  }
-}