Prepare for release

.github/workflows/ci.yaml

@@ -13,8 +13,8 @@ jobs:
             ~/.cargo/registry
             ~/.cargo/git
             ./target
-          key: ${{ runner.os }}-redlock-rs-${{ hashFiles('Cargo.toml') }}
-          restore-keys: ${{ runner.os }}-redlock-rs-
+          key: ${{ runner.os }}-redsync-${{ hashFiles('Cargo.toml') }}
+          restore-keys: ${{ runner.os }}-redsync-
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
@@ -34,8 +34,8 @@ jobs:
             ~/.cargo/registry
             ~/.cargo/git
             ./target
-          key: ${{ runner.os }}-redlock-rs-${{ hashFiles('Cargo.toml') }}
-          restore-keys: ${{ runner.os }}-redlock-rs-
+          key: ${{ runner.os }}-redsync-${{ hashFiles('Cargo.toml') }}
+          restore-keys: ${{ runner.os }}-redsync-
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
@@ -57,8 +57,8 @@ jobs:
             ~/.cargo/registry
             ~/.cargo/git
             ./target
-          key: ${{ runner.os }}-redlock-rs-${{ hashFiles('Cargo.toml') }}
-          restore-keys: ${{ runner.os }}-redlock-rs-
+          key: ${{ runner.os }}-redsync-${{ hashFiles('Cargo.toml') }}
+          restore-keys: ${{ runner.os }}-redsync-
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal
@@ -80,8 +80,8 @@ jobs:
             ~/.cargo/registry
             ~/.cargo/git
             ./target
-          key: ${{ runner.os }}-redlock-rs-${{ hashFiles('Cargo.toml') }}
-          restore-keys: ${{ runner.os }}-redlock-rs-
+          key: ${{ runner.os }}-redsync-${{ hashFiles('Cargo.toml') }}
+          restore-keys: ${{ runner.os }}-redsync-
       - uses: actions-rs/toolchain@v1
         with:
           profile: minimal

Cargo.toml

@@ -1,12 +1,15 @@
 [package]
-name = "redlock-rs"
+name = "redsync"
 version = "0.1.0"
 authors = ["jace-ys <[email protected]>"]
 edition = "2018"
-
-[lib]
-name = "redlock"
-path = "src/lib.rs"
+description = "A Rust implementation of Redlock for distributed locks with Redis"
+readme = "README.md"
+homepage = "https://github.com/jace-ys/redsync"
+repository = "https://github.com/jace-ys/redsync"
+license-file = "LICENSE"
+keywords = ["redsync", "redlock", "redis", "distributed-locks", "distributed-systems"]
+categories = ["concurrency", "algorithms"]
 
 [[bin]]
 name = "example"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Jace Tan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,8 +1,8 @@
 [![ci-badge]][ci-workflow]
 
-[ci-badge]: https://github.com/jace-ys/redlock-rs/workflows/ci/badge.svg
-[ci-workflow]: https://github.com/jace-ys/redlock-rs/actions?query=workflow%3Aci
+[ci-badge]: https://github.com/jace-ys/redsync/workflows/ci/badge.svg
+[ci-workflow]: https://github.com/jace-ys/redsync/actions?query=workflow%3Aci
 
-# `redlock-rs`
+# Redsync
 
 A Rust implementation of [Redlock](https://redis.io/topics/distlock) for distributed locks with Redis.

examples/example.rs

@@ -2,7 +2,7 @@ use std::error::Error;
 use std::thread;
 use std::time::Duration;
 
-use redlock::{RedisInstance, Redlock, RedlockError};
+use redsync::{RedisInstance, Redsync, RedsyncError};
 
 fn main() {
     if let Err(err) = run() {
@@ -11,7 +11,7 @@ fn main() {
 }
 
 fn run() -> Result<(), Box<dyn Error>> {
-    let dlm = Redlock::new(vec![
+    let dlm = Redsync::new(vec![
         RedisInstance::new("redis://127.0.0.1:6389")?,
         RedisInstance::new("redis://127.0.0.1:6399")?,
         RedisInstance::new("redis://127.0.0.1:6379")?,
@@ -35,8 +35,8 @@ fn run() -> Result<(), Box<dyn Error>> {
 
     match dlm.unlock(&lock1) {
         Ok(()) => println!("[t = 2] Released 1st lock after 2 seconds!"),
-        Err(RedlockError::UnlockFailed(err)) => {
-            if err.includes(RedlockError::InvalidLease) {
+        Err(RedsyncError::UnlockFailed(err)) => {
+            if err.includes(RedsyncError::InvalidLease) {
                 println!("[t = 2] Failed to release 1st lock. Lock has expired!")
             }
         }

src/builder.rs

@@ -1,15 +1,15 @@
 use crate::instance::Instance;
-use crate::redlock::Redlock;
+use crate::redsync::Redsync;
 
 use std::time::Duration;
 
-pub struct RedlockBuilder<I: Instance> {
+pub struct RedsyncBuilder<I: Instance> {
     cluster: Vec<I>,
     retry_count: u32,
     retry_delay: Duration,
 }
 
-impl<I: Instance> RedlockBuilder<I> {
+impl<I: Instance> RedsyncBuilder<I> {
     pub fn new(cluster: Vec<I>) -> Self {
         Self {
             cluster,
@@ -28,11 +28,11 @@ impl<I: Instance> RedlockBuilder<I> {
         self
     }
 
-    pub fn build(self) -> Redlock<I> {
+    pub fn build(self) -> Redsync<I> {
         let quorum = (self.cluster.len() as u32) / 2 + 1;
         let retry_jitter = self.retry_delay.as_millis() as f64 * 0.5;
 
-        Redlock {
+        Redsync {
             cluster: self.cluster,
             quorum,
             retry_count: self.retry_count,
@@ -46,52 +46,52 @@ impl<I: Instance> RedlockBuilder<I> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::errors::RedlockError;
+    use crate::errors::RedsyncError;
     use crate::instance::RedisInstance;
 
     #[test]
-    fn default() -> Result<(), RedlockError> {
+    fn default() -> Result<(), RedsyncError> {
         let cluster = vec![RedisInstance::new("redis://127.0.0.1:6379")?];
-        let redlock = RedlockBuilder::new(cluster).build();
+        let redsync = RedsyncBuilder::new(cluster).build();
 
-        assert_eq!(redlock.cluster.len(), 1);
-        assert_eq!(redlock.quorum, 1);
-        assert_eq!(redlock.retry_count, 3);
-        assert_eq!(redlock.retry_delay, Duration::from_millis(200));
-        assert_eq!(redlock.retry_jitter, 100.0);
-        assert_eq!(redlock.drift_factor, 0.01);
+        assert_eq!(redsync.cluster.len(), 1);
+        assert_eq!(redsync.quorum, 1);
+        assert_eq!(redsync.retry_count, 3);
+        assert_eq!(redsync.retry_delay, Duration::from_millis(200));
+        assert_eq!(redsync.retry_jitter, 100.0);
+        assert_eq!(redsync.drift_factor, 0.01);
 
         Ok(())
     }
 
     #[test]
-    fn retry_count() -> Result<(), RedlockError> {
+    fn retry_count() -> Result<(), RedsyncError> {
         let cluster = vec![RedisInstance::new("redis://127.0.0.1:6379")?];
-        let redlock = RedlockBuilder::new(cluster).retry_count(5).build();
+        let redsync = RedsyncBuilder::new(cluster).retry_count(5).build();
 
-        assert_eq!(redlock.cluster.len(), 1);
-        assert_eq!(redlock.quorum, 1);
-        assert_eq!(redlock.retry_count, 5);
-        assert_eq!(redlock.retry_delay, Duration::from_millis(200));
-        assert_eq!(redlock.retry_jitter, 100.0);
-        assert_eq!(redlock.drift_factor, 0.01);
+        assert_eq!(redsync.cluster.len(), 1);
+        assert_eq!(redsync.quorum, 1);
+        assert_eq!(redsync.retry_count, 5);
+        assert_eq!(redsync.retry_delay, Duration::from_millis(200));
+        assert_eq!(redsync.retry_jitter, 100.0);
+        assert_eq!(redsync.drift_factor, 0.01);
 
         Ok(())
     }
 
     #[test]
-    fn retry_delay() -> Result<(), RedlockError> {
+    fn retry_delay() -> Result<(), RedsyncError> {
         let cluster = vec![RedisInstance::new("redis://127.0.0.1:6379")?];
-        let redlock = RedlockBuilder::new(cluster)
+        let redsync = RedsyncBuilder::new(cluster)
             .retry_delay(Duration::from_millis(100))
             .build();
 
-        assert_eq!(redlock.cluster.len(), 1);
-        assert_eq!(redlock.quorum, 1);
-        assert_eq!(redlock.retry_count, 3);
-        assert_eq!(redlock.retry_delay, Duration::from_millis(100));
-        assert_eq!(redlock.retry_jitter, 50.0);
-        assert_eq!(redlock.drift_factor, 0.01);
+        assert_eq!(redsync.cluster.len(), 1);
+        assert_eq!(redsync.quorum, 1);
+        assert_eq!(redsync.retry_count, 3);
+        assert_eq!(redsync.retry_delay, Duration::from_millis(100));
+        assert_eq!(redsync.retry_jitter, 50.0);
+        assert_eq!(redsync.drift_factor, 0.01);
 
         Ok(())
     }

src/errors.rs

@@ -4,7 +4,7 @@ use std::ops::{Deref, DerefMut};
 use thiserror::Error;
 
 #[derive(Error, Debug, PartialEq)]
-pub enum RedlockError {
+pub enum RedsyncError {
     #[error("{0}")]
     RedisError(#[from] redis::RedisError),
     #[error("unexpected response from Redis: {0:?}")]
@@ -24,7 +24,7 @@ pub enum RedlockError {
 }
 
 #[derive(Debug, Default, PartialEq)]
-pub struct MultiError(Vec<RedlockError>);
+pub struct MultiError(Vec<RedsyncError>);
 
 impl MultiError {
     pub fn new() -> Self {
@@ -35,13 +35,13 @@ impl MultiError {
         self.clear()
     }
 
-    pub fn includes(&self, e: RedlockError) -> bool {
+    pub fn includes(&self, e: RedsyncError) -> bool {
         self.contains(&e)
     }
 }
 
 impl Deref for MultiError {
-    type Target = Vec<RedlockError>;
+    type Target = Vec<RedsyncError>;
 
     fn deref(&self) -> &Self::Target {
         &self.0