unique_thread 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2861f1fe74d69bad9f3cd3b472d8f8442b676eeb
+  data.tar.gz: a9c158c7b3e95b56739b386f4ded1ad6028b8889
+SHA512:
+  metadata.gz: f5db23b797560f957aa04de3f8590353f13a922f56f367901860c0f9e68ab946084c1cd45b5e08b97c197a68770fab70e2382666b0a68d776688b5a103218cff
+  data.tar.gz: 9912187f3f39a9f29e1742d591b1f99b90ce5e68b945fd1fb388743461633a1ee582461f83ca03fb1902e5e38ea276cbbd03b149638e9cba7b0425ef08b196d4

data/lib/unique_thread/locksmith.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+class UniqueThread
+  class Locksmith
+    attr_reader :name, :stopwatch, :redis, :logger
+
+    def initialize(name:, stopwatch:, redis:, logger:)
+      @name      = name
+      @stopwatch = stopwatch
+      @redis     = redis
+      @logger    = logger
+
+      @lua_scripts = Hash[Dir[File.join(__dir__, 'redis_lua', '*.lua')].map do |lua_file|
+        [File.basename(lua_file, '.lua').to_sym, redis.script(:load, File.read(lua_file))]
+      end]
+    end
+
+    def new_lock
+      lock_from_redis_command(:get_lock, name, stopwatch.now, stopwatch.next_renewal)
+    end
+
+    def renew_lock(lock)
+      lock_from_redis_command(:extend_lock, name, lock.locked_until, stopwatch.next_renewal)
+    end
+
+    private
+
+    RedisResult = Struct.new(:lock_acquired, :locked_until) do
+      def lock_acquired?
+        lock_acquired == '1'
+      end
+    end
+
+    attr_reader :lua_scripts
+
+    def lock_from_redis_command(script, *args)
+      redis_result = RedisResult.new(*redis.evalsha(lua_scripts[script], args))
+
+      klass = if redis_result.lock_acquired?
+                HeldLock
+              else
+                Lock
+              end
+
+      klass.new(redis_result.locked_until, stopwatch, self, logger)
+    end
+  end
+
+  private
+
+  class Lock
+    attr_reader :locked_until, :stopwatch, :locksmith, :logger
+
+    def initialize(locked_until, stopwatch, locksmith, logger)
+      @locked_until = locked_until
+      @stopwatch    = stopwatch
+      @locksmith    = locksmith
+      @logger       = logger
+    end
+
+    def acquired?
+      false
+    end
+
+    def while_held
+      nil
+    end
+  end
+
+  class HeldLock < Lock
+    def acquired?
+      true
+    end
+
+    def while_held
+      worker = Thread.new do
+        yield
+        logger.error('The blocked passed is not an infinite loop.')
+      end
+
+      renew_indefinitely
+
+      logger.info('Lock lost! Killing the unique thread.')
+      worker.terminate
+    end
+
+    private
+
+    def renew_indefinitely
+      active_lock = self
+
+      while active_lock.acquired?
+        logger.debug('Lock renewed! Sleeping until next renewal attempt.')
+        stopwatch.sleep_until_renewal_attempt
+        active_lock = locksmith.renew_lock(active_lock)
+      end
+    end
+  end
+end

data/lib/unique_thread/stopwatch.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class UniqueThread
+  class Stopwatch
+    attr_reader :downtime
+
+    def initialize(downtime:)
+      @downtime = downtime.to_f
+    end
+
+    def now
+      Time.now.to_f
+    end
+
+    # FIXME: Bad name. Lap maybe? Milestone?
+    def next_renewal
+      now + (downtime * 2 / 3)
+    end
+
+    def sleep_until_next_attempt(locked_until)
+      seconds_until_next_attempt = [locked_until - now + Random.new.rand(downtime / 3), 0].max
+
+      Kernel.sleep(seconds_until_next_attempt)
+    end
+
+    def sleep_until_renewal_attempt
+      Kernel.sleep(downtime / 3)
+    end
+  end
+end

data/lib/unique_thread.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'redis'
+require_relative 'unique_thread/stopwatch'
+require_relative 'unique_thread/locksmith'
+
+class UniqueThread
+  attr_reader :logger, :stopwatch, :locksmith
+
+  def initialize(name, downtime: 30, logger: Logger.new(STDOUT), redis: Redis.new)
+    @logger    = logger
+    @stopwatch = Stopwatch.new(downtime: downtime)
+    @locksmith = Locksmith.new(name: name, stopwatch: stopwatch, redis: redis, logger: logger)
+  end
+
+  def run(&block)
+    safe_infinite_loop do
+      lock = locksmith.new_lock
+
+      if lock.acquired?
+        logger.info('Lock acquired! Running the unique thread.')
+        lock.while_held(&block)
+      else
+        logger.debug('Could not acquire the lock. Sleeping until next attempt.')
+        stopwatch.sleep_until_next_attempt(lock.locked_until.to_f)
+      end
+    end
+  end
+
+  private
+
+  def safe_infinite_loop
+    Thread.new do
+      begin
+        loop { yield }
+      rescue StandardError => error
+        logger.error(error)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: unique_thread
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Fernando Seror
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: 
+email: ferdy89@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/unique_thread.rb
+- lib/unique_thread/locksmith.rb
+- lib/unique_thread/stopwatch.rb
+homepage: https://github.com/Ferdy89/unique_thread
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Allows a block of code to be run once across many processes
+test_files: []