Exports

Author: josePereiro

src/SimpleLockFiles.jl

@@ -2,6 +2,9 @@ module SimpleLockFiles
 
 include("core.jl")
 
+export SimpleLockFile
 export lock_path, rand_lkid
+export acquire_lock, release_lock
+export lock
 
 end

src/core.jl

@@ -66,7 +66,7 @@ read_lock_file(slf::SimpleLockFile) = _read_lock_file(lock_path(slf))
 
 _is_valid_ttag(ttag) = ttag > time()
 
-function has_lock(lf::String, lkid::String)
+function is_locked(lf::String, lkid::String)
 
     # read
     curr_lid, ttag = _read_lock_file(lf)
@@ -81,22 +81,22 @@ function has_lock(lf::String, lkid::String)
     return lkid == curr_lid
 end
 
-has_lock(slf::SimpleLockFile, lkid::String) = has_lock(lock_path(slf), lkid)
+is_locked(slf::SimpleLockFile, lkid::String) = is_locked(lock_path(slf), lkid)
 
 # ----------------------------------------------------------------------
 # release
 
 function release_lock(lf::String, lkid::String)
     !isfile(lf) && return false
-    !has_lock(lf, lkid) && return false
+    !is_locked(lf, lkid) && return false
     isfile(lf) && rm(lf; force = true)
     return true
 end
 
 release_lock(slf::SimpleLockFile, lkid::String) = release_lock(lock_path(slf), lkid)
 
 # ----------------------------------------------------------------------
-# acquire
+# acquire_lock
 
 function _acquire(lf::String, lkid::String = rand_lkid();
         vtime = _LOCK_DFT_VALID_TIME
@@ -120,7 +120,7 @@ function _acquire(lf::String, lkid::String = rand_lkid();
     return _write_lock_file(lf; lkid, vtime)
 end
 
-function acquire(lf::String, lkid::String = rand_lkid();
+function acquire_lock(lf::String, lkid::String = rand_lkid();
         vtime = _LOCK_DFT_VALID_TIME, 
         wt = _LOCK_DFT_WAIT_TIME, 
         tout = _LOCK_DFT_TIME_OUT,
@@ -147,7 +147,7 @@ function acquire(lf::String, lkid::String = rand_lkid();
     end
 end
 
-acquire(slf::SimpleLockFile, lkid::String = rand_lkid(); kwargs...) = acquire(lock_path(slf), lkid)
+acquire_lock(slf::SimpleLockFile, lkid::String = rand_lkid(); kwargs...) = acquire_lock(lock_path(slf), lkid)
 
 # ----------------------------------------------------------------------
 # Base.lock
@@ -161,10 +161,10 @@ import Base.lock
         force = false
     )
 
-Acquire the lock, execute `f()` with the lock held, and release the lock when f returns.
+acquire_lock the lock, execute `f()` with the lock held, and release the lock when f returns.
 If the lock is already locked by a different `lkid`, wait (till `tout`) for it to become available.
-During waiting, it will sleep `wt` seconds before re-attemping to acquire.
-If `force = true` it will acquire the lock after `tout`.
+During waiting, it will sleep `wt` seconds before re-attemping to acquire_lock.
+If `force = true` it will acquire_lock the lock after `tout`.
 This method is not fully secure to race, but it must be ok for sllow applications.
 Returns `true` if the lock
     
@@ -179,10 +179,10 @@ function lock(
 
     lf = lock_path(slf)
     try
-        acquire(lf, lkid; force, vtime, wt, tout)
+        acquire_lock(lf, lkid; force, vtime, wt, tout)
         f()
     finally
-        ok_flag = has_lock(lf, lkid)
+        ok_flag = is_locked(lf, lkid)
         release_lock(lf, lkid)
         return ok_flag
     end

test/runtests.jl

@@ -23,39 +23,39 @@ using Test
     @test ttag3 > time()
     @test isfile(slf)
 
-    @test SLF.has_lock(slf, lid3)
+    @test SLF.is_locked(slf, lid3)
 
-    lid4, ttag4 = SLF.acquire(slf) # This must be taken
+    lid4, ttag4 = SLF.acquire_lock(slf) # This must be taken
     @test isempty(lid4)
     @test ttag3 == ttag4
 
     sleep(2 * vtime) # expire lock
 
-    @test !SLF.has_lock(slf, lid3)
-    @test !isfile(slf) # has_lock must delete an invalid lock file
+    @test !SLF.is_locked(slf, lid3)
+    @test !isfile(slf) # is_locked must delete an invalid lock file
 
     vtime = 50.0
-    lid4, ttag4 = SLF.acquire(slf; vtime) # This must be free
+    lid4, ttag4 = SLF.acquire_lock(slf; vtime) # This must be free
     @test lid4 != lid3 
     @test ttag4 > ttag3
     @test isfile(slf)
 
     # test wait
-    lid5, ttag5 = SLF.acquire(slf; tout = 2.0) # This must fail
+    lid5, ttag5 = SLF.acquire_lock(slf; tout = 2.0) # This must fail
     @test isempty(lid5)
     @test ttag4 == ttag5
 
     # Test release
-    @test SLF.has_lock(slf, lid4)
+    @test SLF.is_locked(slf, lid4)
     @test SLF.release_lock(slf, lid4)
-    @test !SLF.has_lock(slf, lid4)
+    @test !SLF.is_locked(slf, lid4)
     @test !isfile(slf)
 
     # base.lock
     lock(slf; vtime = 3.0) do
         # all this time the lock is taken
         for it in 1:10
-            @test !SLF.has_lock(slf, "Not a lock id")
+            @test !SLF.is_locked(slf, "Not a lock id")
             sleep(0.2)
         end
     end