ITD stands for Improvised Timeout Device; Timed locks with a fun, bomb-style interface.
Timeout HTTP/HTTPS requests
It is a trap! (for a focus)
support Web Locks API work in major browsers
Emit `ETIMEDOUT` or `ESOCKETTIMEDOUT` when ClientRequest is hanged
A generated SDK for ManagementLockClient.
Timeout a promise after a specified amount of time
Web Locks API
Synchronization for concurrency. Allows for mutex, semaphores, read-write locks, timed locks, and more.
A lightweight JavaScript MP4 (MPEG-4, ISOBMFF) file/box parser.
A minimalist time-based caching system.
Mutex locks, Read/Write locks, Condition variables and Semaphores
A polyfill for web-locks
Enables body scroll locking (for iOS Mobile and Tablet, Android, desktop Safari/Chrome/Firefox) without breaking scrolling of a target element (eg. modal/lightbox/flyouts/nav-menus)
Asynchronous locking utilities
A node.js redlock implementation for distributed redis locks
Atomic locks (mutex) for AdonisJS applications
Timed memoize
TypeScript definitions for locks
Mutex locks for async functions with functionality to use keys for separate locks
Upgrade your npm scripts to make them smarter and more efficient
Lightweight Key-value storage with built-in TTL expiration management
TypeScript definitions for timed-cache
JavaScript HLS client using MediaSourceExtension
It supports rspec and minitest using capybara.Override Date and Date.now in JavaScript by args.
This library implements application mutexes using Redis. The mutexes are shared between separate threads, processes, or machines. Locks are acquired with an expiration time so if process that holds a lock dies unexpectedly, the lock is released automatically after a certain duration.
Lock a server during deploy, to prevent people from deploying at the same time.
Select a leader through a Redis lock and keep it for a time.
|> Distributed locks with "prioritized lock acquisition queue" capabilities based on the Redis Database. |> Each lock request is put into the request queue (each lock is hosted by its own queue separately from other queues) and processed in order of their priority (FIFO). |> Each lock request lives some period of time (RTTL) (with requeue capabilities) which guarantees the request queue will never be stacked. |> In addition to the classic `queued` (FIFO) strategy RQL supports `random` (RANDOM) lock obtaining strategy when any acquirer from the lock queue can obtain the lock regardless the position in the queue. |> Provides flexible invocation flow, parametrized limits (lock request ttl, lock ttl, queue ttl, lock attempts limit, fast failing, etc), logging and instrumentation.
activejob-locking lets you control how ActiveJobs are enqueued and performed: Allow only one job to be enqueued at a time (based on a lock_id) Allow only one job to be performed at a time (also based on a lock_id)
This gem allows to monitor and notify about PostgreSQL database locks which meet certain criteria. You can report locks which are held for a certain amount of time, or locks which are held by a certain query.
A Resque plugin. If you want only one instance of your job queued at a time, extend it with this module. For example: class UpdateNetworkGraph extend Resque::Jobs::Locked def self.perform(repo_id) heavy_lifting end end
A Resque plugin. If you want only one instance of your job queued at a time, extend it with this module. This version stores the timestamp in the lock. For example: class UpdateNetworkGraph extend Resque::Jobs::Locked def self.perform(repo_id) heavy_lifting end end
A Resque plugin. If you want only one instance of your job queued at a time, extend it with this module. For example: class ExampleJob extend Resque::Jobs::Queue::Lock def self.perform(repo_id) heavy_lifting end end
Simple gem to prevent cron-ing your ruby script multiple times by using simple file based locking.
This is a weak deduper to make things like bulk email run safer. It is not a lock safe for financial/security needs because it uses a weak redis locking pattern that can have race conditions. However, imagine a bulk email job that loops over 100 users, and enqueues a background email for each user. If the job fails at iteration 50, a retry would enqueue all the users again and many will receive dupes. This would continue multiple times as the parent job continued to rerun. By marking that a subjob has been enqueued, we can let that isolated job handle its own failures, and the batch enqueue job can run multiple times without re-enqueueing the same subjobs.