A Redis-based distributed lock class, based on the solution proposed by Chris Lamb (https://chris-lamb.co.uk/posts/distributing-locking-python-and-redis).

100%

A Redis-based distributed lock class, based on the solution proposed by Chris Lamb (https://chris-lamb.co.uk/posts/distributing-locking-python-and-redis).

✓ Published0🌍 Public

Last edited Apr 29, 2014

Created on Jul 29, 2013

This example demonstrates a distributed lock implementation for coordinating access to shared resources in a Python application. It shows a `Lock` class that uses Redis’s watch-multi-exec transaction pipeline to atomically acquire and release locks, with expiration and retry logic to handle contention. The code uses `redis.Redis`, `pipeline()`, `watch()`, `execute()`, and `delete()`, along with `time.sleep` and `time.time` for timeout handling. A command-line test acquires a lock on key `user:abc` for 10 seconds, then releases it after a simulated 20-second wait.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 5ff2cc9f47a62f78fe295c76dd14eab2

This example demonstrates a multitenancy collision test in a Python datastore environment. It verifies that separate namespace assignments remain isolated across concurrent processes, ensuring that parallel operations do not interfere with each other’s namespace context. The code uses `multiprocessing.Process`, `multiprocessing.Manager`, and a shared dictionary for inter-process communication. It also employs `unittest` with setup/teardown fixtures and the `time` module to coordinate process timing. The test asserts that each process retrieves its assigned namespace correctly while the original namespace remains unchanged.

CCheckroth

47% match

Loading thumbnail…

Distributed Read-Write Mutex in Go

This example compares the performance of Go’s standard `sync.RWMutex` against a custom distributed read-write mutex (DRWMutex) across increasing core counts. The plot shows mean execution time for 10 runs at each core count, with error bars for the 25th and 75th percentiles, revealing that DRWMutex outperforms `sync.RWMutex` at low write ratios. The DRWMutex assigns each CPU core its own `sync.RWMutex` and uses the CPUID instruction via assembly to determine the current core, periodically refreshing the mapping. The benchmark runs concurrent goroutines that randomly choose read or write lock operations with configurable work and write probability, using `runtime.GOMAXPROCS` and `syscall` for core affinity.

Aadkatrit

46% match

Loading thumbnail…

Express authentication using Redis for session store and Couchdb for database (in coffeescript!)

This example shows a complete Express authentication system that uses Redis as a session store and CouchDB as the user database, with CoffeeScript as the implementation language. The code demonstrates session management with `req.session.regenerate()` and `req.session.destroy()`, password hashing via `hash.sha1`, and CSRF protection through the `csrf.check()` middleware. Routes for login, signup, dashboard, and logout interact with the CouchDB client through `db.getDoc` and `db.saveDoc`, while the fugue library handles multi-process server startup.

Aanatolyg

44% match

Loading thumbnail…

Express authentication using Redis for session store and Couchdb for database (in coffeescript!)

This example demonstrates user authentication and session management in a CoffeeScript-built Express application, showing how login, signup, and logout routes handle password hashing and session regeneration. The code uses Redis as the session store via `connect-redis` and CouchDB for user persistence through the `couchdb` client, with CSRF protection from `express-csrf` and password salting via `hash.sha1`. The visualization highlights the request flow across these middleware and database calls, including error handling for duplicate users and failed logins, while relying on the Fugue cluster for deployment.

AAnsonT

44% match

Loading thumbnail…

multiprocessing

This example demonstrates a multiprocessing pipeline where eight producer processes concurrently process one hundred documents from a shared task queue, while the main process consumes and prints the results. The code uses Python's `multiprocessing` module, specifically the `Process`, `Queue`, and `join()` APIs to coordinate work and synchronization. Each producer pulls documents, simulates variable processing time with `time.sleep` and `random.uniform`, and pushes results to a separate result queue. The consumer function tracks completion until all documents are processed, illustrating a classic producer-consumer pattern with sentinel values to terminate workers.

JJastor11

42% match

Loading thumbnail…

lf-auth-notes

This interactive visualization demonstrates how cryptographic keys and team membership are managed in a decentralized graph, where each node is an encrypted lockbox containing keys accessible only to designated devices or roles. It shows the flow of authority from the group’s founder through admin roles to individual members, with mutual removals resolved by seniority. Built on the CRDX library, the graph uses asymmetric encryption for each node, and the visualization renders the key graph and lockbox relationships using custom SVG rendering. The code highlights the concrete APIs for graph traversal and cryptographic operations, such as key derivation and signature verification, as seen in the invitation and lockbox logic. Data is sourced from the embedded gist’s markdown and assets.

HHerbCaudill

42% match

Loading thumbnail…

python teams_keeper.py

This example shows a Microsoft Teams activity keeper that prevents the user’s status from switching to “away” by simulating small mouse movements at regular intervals. The tool runs a background thread using Python’s `threading` module, and it relies on `pyautogui` to nudge the cursor one pixel and back every four minutes by default. It also optionally registers a Ctrl+Shift+Q hotkey via the `keyboard` library to stop the process, while printing timestamped confirmation messages to the console.

JJastor11

42% match

Loading thumbnail…

Gist a803adce92b47f80c229d8375adfa195

This example demonstrates an automated pipeline that fetches Twitch clips, edits them into a compilation video, and uploads the result to Streamable, with Reddit integration for sharing. The workflow is orchestrated through a series of Python scripts (`get_videos.py`, `edit_videos.py`, `upload_video.py`, `main.py`) running inside a Docker container, using environment variables for configuration like `twitch_id` and `streamable_username`. The code relies on the `requests` library for API calls to Twitch and Streamable, while video editing is performed programmatically, though the specific editing library is not visible in the provided files. The container sets up a Python 3 environment and installs dependencies from `requirements.txt`, with all credentials and settings passed via `env.list`.

CConorAspell

41% match