lock_manager 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a235cfae8f73825fbc5b738d4f2adeac031f1b2
-  data.tar.gz: 1440406b654d29de1949e76b4f04f80b3117df91
+  metadata.gz: 6182864c1d1e43eda6276e9459037dd7c0aaf176
+  data.tar.gz: 6b6eb4cc2823147881e540080ddc930c2d942dcc
 SHA512:
-  metadata.gz: 884bc3e33046cf124843fc424b22d51f5affff5063886d690243a510b3b4d3927988c95906cbd1dfac82de04486e78ec64188631585655de741b8115a66a28b2
-  data.tar.gz: 6b77f05acfb5f783121bf345c0d93c7c1b96f64af4555cd372999a0071d141ff1a8f226dde7aa9d176a5e5a122cae1eb213a5937f36e021d72ae748ec4483967
+  metadata.gz: 9bdb3020bb25b41f471c102864f86a93eefb4948ccf204d19d16b155be91c4a84fbaa9deb53ac65be109fd4b3e1f918e446c091ce5ab3f9542f03b93e6767f6b
+  data.tar.gz: 0fe35dfea4dd4c5768e32f665b9859ab89f7973bfb14d288fb5c04dd50db4a2a02b49aab49c15e12bb0b819f215d8b1c951de25f2ad5b1286fd5b1dd787d6577

data/lib/lock_manager/connection.rb

@@ -0,0 +1,31 @@
+class LockManager
+  class Connection
+    attr_reader :options
+
+    def self.connection_class(type)
+      case type.to_s
+      when 'redis'
+        require 'lock_manager/redis_connection'
+        LockManager::RedisConnection
+      else
+        fail ArgumentError, "Unknown connection type: #{type}"
+      end
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def write(key, value)
+      fail "Not implemented: write(#{key}, #{value})"
+    end
+
+    def read(key)
+      fail "Not implemented: read(#{key})"
+    end
+
+    def remove(key)
+      fail "Not implemented: remove(#{key})"
+    end
+  end
+end

data/lib/lock_manager/redis_connection.rb

@@ -0,0 +1,45 @@
+require 'redis'
+
+class LockManager
+  class RedisConnection < LockManager::Connection
+    attr_reader :server, :port
+
+    def initialize(options = {})
+      super
+      fail ArgumentError, ':server option is mandatory for redis connections' unless options[:server]
+      @server = options[:server]
+      @port = options[:port]
+    end
+
+    def read(host)
+      handle.get key_from_host(host)
+    end
+
+    def write_if_not_exists(host, value)
+      handle.setnx(key_from_host(host), value)
+    end
+
+    def write(host, value)
+      handle.set(key_from_host(host), value)
+    end
+
+    def remove(host)
+      handle.del key_from_host(host)
+    end
+
+    def key_from_host(host)
+      "node_lock_#{host}"
+    end
+
+    def handle
+      @handle ||= connect_redis(server, port)
+    end
+
+    # Create a connection to redis.
+    def connect_redis(redis_server, redis_port = 6379)
+      redis = Redis.new(host: redis_server, port: redis_port)
+      redis.ping
+      redis
+    end
+  end
+end

data/lib/lock_manager/worker.rb

@@ -0,0 +1,97 @@
+require 'lock_manager/connection'
+require 'resolv'
+class LockManager
+  class Worker
+    attr_reader :connection, :host, :user
+
+    def initialize(connection, host)
+      @connection = connection
+      if host =~ Regexp.union(Resolv::IPv4::Regex, Resolv::IPv6::Regex)
+        fail ArgumentError, 'Please use a DNS name rather than an IP address.'
+      else
+        # Using the shortname of the host has the downside of being unable to
+        # lock two hosts with the same shortname and different domains.
+        # However, since the majority of users interact with shortname only,
+        # we're using shortname to normalize and prevent the system from
+        # allowing a lock on aixbuilder1 if aixbuilder1.delivery.puppetlabs.net
+        # is locked.
+        @host = host.split('.')[0]
+      end
+    end
+
+    def lock(user, reason = nil)
+      lock_contents = {
+        user:  user,
+        time: Time.now.to_s,
+        reason: reason
+      }
+      r = connection.write_if_not_exists host, lock_contents.to_json
+      log "#{host} already locked." if r == false
+      r
+    end
+
+    def lock!(user, reason = nil)
+      lock_contents = {
+        user:  user,
+        time: Time.now.to_s,
+        reason: reason
+      }
+      r = connection.write host, lock_contents.to_json
+      r == 'OK'
+    end
+
+    # Boolean to figure out if a host is locked.
+    #
+    # @return [Bool] whether or not the host is locked.
+    def locked?
+      !!connection.read(host)
+    end
+
+    def unlock(user)
+      if !locked?
+        log "Refusing to unlock. No lock exists on #{host}."
+        false
+      elsif user == lock_user
+        unlock!
+      else
+        log "Refusing to unlock. Lock on #{host} is owned by #{lock_user}."
+        false
+      end
+    end
+
+    def unlock!
+      connection.remove(host) > 0
+    end
+
+    def lock_user
+      lock_data = connection.read host
+      return false unless lock_data
+      result = JSON.parse lock_data
+      result['user']
+    end
+
+    def polling_lock(user, reason = nil)
+      sleep_duration = 1
+      loop do
+        if locked?
+          log "#{host} is locked..."
+          log "waiting #{sleep_duration} seconds."
+          sleep sleep_duration
+          sleep_duration *= 2
+        else
+          break
+        end
+      end
+      lock(user, reason)
+    end
+
+    def show
+      data = connection.read(host)
+      data ? JSON.parse(data) : nil
+    end
+
+    def log(message)
+      warn message
+    end
+  end
+end

data/lib/lock_manager.rb

@@ -0,0 +1,36 @@
+require 'json'
+require 'lock_manager/worker'
+require 'lock_manager/connection'
+
+class LockManager
+  attr_reader :options
+
+  def initialize(options = {})
+    @options = options
+  end
+
+  def lock(host, user, reason = nil)
+    LockManager::Worker.new(connection, host).lock(user, reason)
+  end
+
+  def polling_lock(host, user, reason = nil)
+    LockManager::Worker.new(connection, host).polling_lock(user, reason)
+  end
+
+  def unlock(host, user)
+    LockManager::Worker.new(connection, host).unlock(user)
+  end
+
+  def locked?(host)
+    LockManager::Worker.new(connection, host).locked?
+  end
+
+  def show(host)
+    LockManager::Worker.new(connection, host).show
+  end
+
+  def connection
+    fail ArgumentError, ':type option is required' unless options[:type]
+    @connection ||= LockManager::Connection.connection_class(options[:type]).new(options)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lock_manager
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Puppet Labs
@@ -61,6 +61,10 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/lock_manager.rb
+- lib/lock_manager/connection.rb
+- lib/lock_manager/redis_connection.rb
+- lib/lock_manager/worker.rb
 - test/test_helper.rb
 - test/test_lock.rb
 - test/test_poll.rb