lita-locker 0.7.0 → 1.0.0

data/lib/lita/handlers/locker_resources.rb

@@ -17,7 +17,7 @@ module Lita
       )
 
       route(
-        /^locker\sresource\screate\s#{RESOURCE_REGEX}$/,
+        /^locker\sresource\screate\s#{RESOURCES_REGEX}$/,
         :create,
         command: true,
         restrict_to: [:locker_admins],
@@ -27,7 +27,7 @@ module Lita
       )
 
       route(
-        /^locker\sresource\sdelete\s#{RESOURCE_REGEX}$/,
+        /^locker\sresource\sdelete\s#{RESOURCES_REGEX}$/,
         :delete,
         command: true,
         restrict_to: [:locker_admins],
@@ -44,36 +44,66 @@ module Lita
       )
 
       def list(response)
-        output = ''
-        resources.each do |r|
-          r_name = r.sub('resource_', '')
-          res = resource(r_name)
-          output += t('resource.desc', name: r_name, state: res['state'])
+        should_rate_limit = false
+
+        Resource.list.each_slice(10) do |slice|
+          if should_rate_limit
+            sleep 1
+          else
+            should_rate_limit = true
+          end
+
+          slice.each do |r|
+            res = Resource.new(r)
+            response.reply(t('resource.desc', name: r, state: res.state.value))
+          end
         end
-        response.reply(output)
       end
 
       def create(response)
-        name = response.matches[0][0]
-        if create_resource(name)
-          response.reply(t('resource.created', name: name))
-        else
-          response.reply(t('resource.exists', name: name))
+        names = response.match_data['resources'].split(/,\s*/)
+        results = []
+
+        names.each do |name|
+          if Resource.exists?(name)
+            results <<= t('resource.exists', name: name)
+          else
+            Resource.create(name)
+            results <<= t('resource.created', name: name)
+          end
         end
+
+        response.reply(results.join(', '))
       end
 
       def delete(response)
-        name = response.matches[0][0]
-        return response.reply(t('resource.does_not_exist', name: name)) unless resource_exists?(name)
-        delete_resource(name)
-        response.reply(t('resource.deleted', name: name))
+        names = response.match_data['resources'].split(/,\s*/)
+        results = []
+
+        names.each do |name|
+          if Resource.exists?(name)
+            Resource.delete(name)
+            results <<= t('resource.deleted', name: name)
+          else
+            results <<= t('resource.does_not_exist', name: name)
+          end
+        end
+
+        response.reply(results.join(', '))
       end
 
       def show(response)
-        name = response.matches[0][0]
-        return response.reply(t('resource.does_not_exist', name: name)) unless resource_exists?(name)
-        r = resource(name)
-        response.reply(t('resource.desc', name: name, state: r['state']))
+        name = response.match_data['resource']
+        return response.reply(t('resource.does_not_exist', name: name)) unless Resource.exists?(name)
+        r = Resource.new(name)
+        resp = t('resource.desc', name: name, state: r.state.value)
+        if r.labels.count > 0
+          resp += ', used by: '
+          r.labels.each do |label|
+            resp += Label.new(label).id
+          end
+        end
+        response.reply(resp)
       end
 
       Lita.register_handler(LockerResources)

data/lib/lita-locker.rb

@@ -4,6 +4,9 @@ Lita.load_locales Dir[File.expand_path(
   File.join('..', '..', 'locales', '*.yml'), __FILE__
 )]
 
+require 'redis-objects'
+require 'time-lord'
+
 require 'locker/label'
 require 'locker/misc'
 require 'locker/regex'
@@ -15,3 +18,23 @@ require 'lita/handlers/locker_labels'
 require 'lita/handlers/locker_misc'
 require 'lita/handlers/locker_resources'
 require 'lita/handlers/locker'
+
+Lita::Handlers::Locker.template_root File.expand_path(
+  File.join('..', '..', 'templates'),
+  __FILE__
+)
+
+Lita::Handlers::LockerResources.template_root File.expand_path(
+  File.join('..', '..', 'templates'),
+  __FILE__
+)
+
+Lita::Handlers::LockerLabels.template_root File.expand_path(
+  File.join('..', '..', 'templates'),
+  __FILE__
+)
+
+Lita::Handlers::LockerMisc.template_root File.expand_path(
+  File.join('..', '..', 'templates'),
+  __FILE__
+)

data/lib/locker/label.rb

@@ -2,66 +2,173 @@
 module Locker
   # Label helpers
   module Label
-    def label(name)
-      redis.hgetall("label_#{name}")
-    end
+    # Proper Resource class
+    class Label
+      include Redis::Objects
 
-    def labels
-      redis.keys('label_*')
-    end
+      value :state
+      value :owner_id
+      value :taken_at
 
-    def label_exists?(name)
-      redis.exists("label_#{name}")
-    end
+      set :membership
+      list :wait_queue
+      list :journal
 
-    def lock_label!(name, owner, time_until)
-      return false unless label_exists?(name)
-      key = "label_#{name}"
-      members = label_membership(name)
-      members.each do |m|
-        return false unless lock_resource!(m, owner, time_until)
-      end
-      redis.hset(key, 'state', 'locked')
-      redis.hset(key, 'owner_id', owner.id)
-      redis.hset(key, 'until', time_until)
-      true
-    end
+      lock :coord, expiration: 5
+
+      attr_reader :id
 
-    def unlock_label!(name)
-      return false unless label_exists?(name)
-      key = "label_#{name}"
-      members = label_membership(name)
-      members.each do |m|
-        unlock_resource!(m)
+      def initialize(key)
+        fail 'Unknown label key' unless Label.exists?(key)
+        @id = Label.normalize(key)
       end
-      redis.hset(key, 'state', 'unlocked')
-      redis.hset(key, 'owner_id', '')
-      true
-    end
 
-    def create_label(name)
-      label_key = "label_#{name}"
-      redis.hset(label_key, 'state', 'unlocked') unless
-        resource_exists?(name) || label_exists?(name)
-    end
+      def self.exists?(key)
+        redis.sismember('label-list', Label.normalize(key))
+      end
 
-    def delete_label(name)
-      label_key = "label_#{name}"
-      redis.del(label_key) if label_exists?(name)
-    end
+      def self.create(key)
+        fail 'Label key already exists' if Label.exists?(key)
+        redis.sadd('label-list', Label.normalize(key))
+        l = Label.new(key)
+        l.state    = 'unlocked'
+        l.owner_id = ''
+        l.log('Created')
+        l
+      end
+
+      def self.delete(key)
+        fail 'Unknown label key' unless Label.exists?(key)
+        %w(state, owner_id, membership, wait_queue, journal).each do |item|
+          redis.del("label:#{key}:#{item}")
+        end
+        redis.srem('label-list', Label.normalize(key))
+      end
+
+      def self.list
+        redis.smembers('label-list').sort
+      end
+
+      def self.normalize(key)
+        key.strip.downcase
+      end
+
+      def lock!(owner_id)
+        if locked?
+          wait_queue << owner_id if wait_queue.last != owner_id
+          return false
+        end
+
+        coord_lock.lock do
+          membership.each do |resource_name|
+            r = Locker::Resource::Resource.new(resource_name)
+            return false if r.locked?
+          end
+          # TODO: read-modify-write cycle, not the best
+          membership.each do |resource_name|
+            r = Locker::Resource::Resource.new(resource_name)
+            r.lock!(owner_id)
+          end
+          self.owner_id = owner_id
+          self.state = 'locked'
+          self.taken_at = Time.now.utc
+        end
+        u = Lita::User.fuzzy_find(owner_id)
+        log("Locked by #{u.name}")
+        true
+      end
+
+      def unlock!
+        return true if state == 'unlocked'
+        coord_lock.lock do
+          self.owner_id = ''
+          self.state = 'unlocked'
+          self.taken_at = ''
+          membership.each do |resource_name|
+            r = Locker::Resource::Resource.new(resource_name)
+            r.unlock!
+          end
+        end
+        log('Unlocked')
 
-    def label_membership(name)
-      redis.smembers("membership_#{name}")
+        # FIXME: Possible race condition where resources become unavailable between unlock and relock
+        if wait_queue.count > 0
+          next_user = wait_queue.shift
+          self.lock!(next_user)
+        end
+        true
+      end
+
+      def steal!(owner_id)
+        log("Stolen from #{owner.id} to #{owner_id}")
+        wait_queue.unshift(owner_id)
+        self.unlock!
+      end
+
+      def locked?
+        (state == 'locked')
+      end
+
+      def add_resource(resource)
+        log("Resource #{resource.id} added")
+        resource.labels << id
+        membership << resource.id
+      end
+
+      def remove_resource(resource)
+        log("Resource #{resource.id} removed")
+        resource.labels.delete(id)
+        membership.delete(resource.id)
+      end
+
+      def owner
+        return nil unless locked?
+        Lita::User.find_by_id(owner_id.value)
+      end
+
+      def held_for
+        return '' unless locked?
+        TimeLord::Time.new(Time.parse(taken_at.value) - 1).period.to_words
+      end
+
+      def to_json
+        val = { id: id,
+                state: state.value,
+                membership: membership }
+
+        if locked?
+          val[:owner_id] = owner_id.value
+          val[:taken_at] = taken_at.value
+          val[:wait_queue] = wait_queue
+        end
+
+        val.to_json
+      end
+
+      def log(statement)
+        journal << "#{Time.now.utc}: #{statement}"
+      end
     end
 
-    def add_resource_to_label(label, resource)
-      return unless label_exists?(label) && resource_exists?(resource)
-      redis.sadd("membership_#{label}", resource)
+    def label_ownership(name)
+      l = Label.new(name)
+      return label_dependencies(name) unless l.locked?
+      mention = l.owner.mention_name ? "(@#{l.owner.mention_name})" : ''
+      failed(t('label.owned_lock', name: name, owner_name: l.owner.name, mention: mention, time: l.held_for))
     end
 
-    def remove_resource_from_label(label, resource)
-      return unless label_exists?(label) && resource_exists?(resource)
-      redis.srem("membership_#{label}", resource)
+    def label_dependencies(name)
+      msg = failed(t('label.dependency')) + "\n"
+      deps = []
+      l = Label.new(name)
+      l.membership.each do |resource_name|
+        resource = Locker::Resource::Resource.new(resource_name)
+        if resource.state.value == 'locked'
+          deps.push "#{resource_name} - #{resource.owner.name}"
+        end
+      end
+      msg += deps.join("\n")
+      msg
     end
   end
 end

data/lib/locker/misc.rb

@@ -4,12 +4,27 @@ module Locker
   module Misc
     def user_locks(user)
       owned = []
-      labels.each do |name|
-        name.slice! 'label_'
-        label = label(name)
-        owned.push(name) if label['owner_id'] == user.id
+      Locker::Label::Label.list.each do |name|
+        label = Locker::Label::Label.new(name)
+        owned.push(name) if label.owner == user
       end
       owned
     end
+
+    def success(message)
+      render_template('success', string: message)
+    end
+
+    def failed(message)
+      render_template('failed', string: message)
+    end
+
+    def locked(message)
+      render_template('lock', string: message)
+    end
+
+    def unlocked(message)
+      render_template('unlock', string: message)
+    end
   end
 end

data/lib/locker/regex.rb

@@ -2,11 +2,13 @@
 module Locker
   # Regex definitions
   module Regex
-    LABEL_REGEX    = /([\.\w\s-]+)/
-    RESOURCE_REGEX = /([\.\w-]+)/
+    LABEL_REGEX    = /(?<label>[\.\w\s-]+)(\s)?/
+    LABELS_REGEX   = /(?<labels>[\.\w\s-]+(?:,\s*[\.\w\s-]+)*)(\s)?/
+    RESOURCE_REGEX = /(?<resource>[\.\w-]+)/
+    RESOURCES_REGEX = /(?<resources>[\.\w-]+(?:,\s*[\.\w-]+)*)/
     COMMENT_REGEX  = /(\s\#.+)?/
     LOCK_REGEX     = /\(lock\)\s/i
-    USER_REGEX     = /(?:@)?(?<username>[\w\s]+)/
+    USER_REGEX     = /(?:@)?(?<username>[\w\s-]+)/
     UNLOCK_REGEX   = /(?:\(unlock\)|\(release\))\s/i
   end
 end

data/lib/locker/resource.rb

@@ -2,47 +2,82 @@
 module Locker
   # Resource helpers
   module Resource
-    def resource(name)
-      redis.hgetall("resource_#{name}")
-    end
+    # Proper Resource class
+    class Resource
+      include Redis::Objects
 
-    def resources
-      redis.keys('resource_*')
-    end
+      value :state
+      value :owner_id
+      set :labels
 
-    def resource_exists?(name)
-      redis.exists("resource_#{name}")
-    end
+      lock :coord, expiration: 5
 
-    def lock_resource!(name, owner, time_until)
-      return false unless resource_exists?(name)
-      resource_key = "resource_#{name}"
-      value = redis.hget(resource_key, 'state')
-      return false unless value == 'unlocked'
-      # FIXME: Race condition!
-      redis.hset(resource_key, 'state', 'locked')
-      redis.hset(resource_key, 'owner_id', owner.id)
-      redis.hset(resource_key, 'until', time_until)
-      true
-    end
+      attr_reader :id
 
-    def unlock_resource!(name)
-      return false unless resource_exists?(name)
-      key = "resource_#{name}"
-      redis.hset(key, 'state', 'unlocked')
-      redis.hset(key, 'owner_id', '')
-      true
-    end
+      def initialize(key)
+        fail 'Unknown resource key' unless Resource.exists?(key)
+        @id = key
+      end
 
-    def create_resource(name)
-      resource_key = "resource_#{name}"
-      redis.hset(resource_key, 'state', 'unlocked') unless
-        resource_exists?(name) || label_exists?(name)
-    end
+      def self.exists?(key)
+        redis.sismember('resource-list', key)
+      end
+
+      def self.create(key)
+        fail 'Resource key already exists' if Resource.exists?(key)
+        redis.sadd('resource-list', key)
+        r = Resource.new(key)
+        r.state    = 'unlocked'
+        r.owner_id = ''
+        r
+      end
+
+      def self.delete(key)
+        fail 'Unknown resource key' unless Resource.exists?(key)
+        %w(state, owner_id).each do |item|
+          redis.del("resource:#{key}:#{item}")
+        end
+        redis.srem('resource-list', key)
+      end
+
+      def self.list
+        redis.smembers('resource-list').sort
+      end
+
+      def lock!(owner_id)
+        return false if state == 'locked'
+        coord_lock.lock do
+          self.owner_id = owner_id
+          self.state = 'locked'
+        end
+        true
+      end
+
+      def unlock!
+        return true if state == 'unlocked'
+        coord_lock.lock do
+          self.owner_id = ''
+          self.state = 'unlocked'
+        end
+        true
+      end
+
+      def locked?
+        (state == 'locked')
+      end
+
+      def owner
+        return nil unless locked?
+        Lita::User.find_by_id(owner_id.value)
+      end
 
-    def delete_resource(name)
-      resource_key = "resource_#{name}"
-      redis.del(resource_key) if resource_exists?(name)
+      def to_json
+        {
+          id: id,
+          state: state.value,
+          owner_id: owner_id.value
+        }.to_json
+      end
     end
   end
 end

data/lita-locker.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = 'lita-locker'
-  spec.version       = '0.7.0'
+  spec.version       = '1.0.0'
   spec.authors       = ['Eric Sigler']
   spec.email         = ['me@esigler.com']
   spec.description   = '"lock" and "unlock" arbitrary subjects'
@@ -10,11 +10,13 @@ Gem::Specification.new do |spec|
   spec.metadata      = { 'lita_plugin_type' => 'handler' }
 
   spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'lita', '>= 4.0.1'
+  spec.add_runtime_dependency 'lita', '>= 4.2'
+  spec.add_runtime_dependency 'redis-objects'
+  spec.add_runtime_dependency 'time-lord'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'coveralls'
@@ -22,4 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec', '>= 3.0.0'
   spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'simplecov'
+
+  spec.post_install_message = 'After upgrading to lita-locker 1.x, you should read: ' \
+                              'https://github.com/esigler/lita-locker/blob/master/UPGRADING.md'
 end

data/locales/en.yml

@@ -7,6 +7,12 @@ en:
           already_unlocked: "%{label} was already unlocked"
           self: Why are you stealing the lock from yourself?
         help:
+          log:
+            syntax: locker log <label>
+            desc: Show up to the last 10 activity log entries for <label>
+          dequeue:
+            syntax: locker dequeue <label>
+            desc: Remove yourself from the queue for a label
           lock:
             syntax: lock <subject>
             desc: Make something unavailable to others. Can have # comments afterwards.
@@ -27,11 +33,11 @@ en:
               syntax: locker resource list
               desc: List all resources
             create:
-              syntax: locker resource create <name>
-              desc: Create a resource with <name>
+              syntax: "locker resource create <name>[, <name> ...]"
+              desc: Create resource(s) with each <name>
             delete:
-              syntax: locker resource delete <name>
-              desc: Delete the resource with <name>
+              syntax: "locker resource delete <name>[, <name> ...]"
+              desc: Delete the resource(s) with each <name>
             show:
               syntax: locker resource show <name>
               desc: Show the state of <name>
@@ -40,20 +46,20 @@ en:
               syntax: locker label list
               desc: List all labels
             create:
-              syntax: locker label create <name>
-              desc: Create a label with <name>
+              syntax: "locker label create <name>[, <name> ...]"
+              desc: Create label(s) with each <name>
             delete:
-              syntax: locker label delete <name>
-              desc: Delete the label with <name>
+              syntax: "locker label delete <name>[, <name> ...]"
+              desc: Delete the label(s) with each <name>
             show:
               syntax: locker label show <name>
               desc: Show all resources for <name>
             add:
-              syntax: locker label add <resource> to <name>
-              desc: Adds <resource> to the list of things to lock/unlock for <name>
+              syntax: "locker label add <resource>[, <resource> ...] to <name>"
+              desc: Adds each <resource> to the list of things to lock/unlock for <name>
             remove:
-              syntax: locker label remove <resource> from <name>
-              desc: Removes <resource> from <name>
+              syntax: "locker label remove <resource>[, <resource> ...] from <name>"
+              desc: Removes each <resource> from <name>
         resource:
           created: "Resource %{name} created"
           desc: "Resource: %{name}, state: %{state}"
@@ -69,14 +75,17 @@ en:
         subject:
           does_not_exist: "Sorry, that does not exist"
         label:
+          log_entry: "%{entry}"
+          self_lock: "You already have the lock on %{name}"
           unlock: "%{name} unlocked"
-          owned: "%{name} is locked by %{owner_name}"
-          owned_mention: "%{name} is locked by %{owner_name} (@%{owner_mention})"
+          owned_lock: "%{name} is locked by %{owner_name} %{mention} (taken %{time}), you have been added to the queue, type 'locker dequeue %{name}' to be removed"
+          owned_unlock: "%{name} is locked by %{owner_name} %{mention} (taken %{time})"
           is_unlocked: "%{name} is unlocked"
           unable_to_lock: "%{name} unable to be locked"
           lock: "%{name} locked"
-          desc: "Label: %{name}, state: %{state}"
-          desc_owner: "Label: %{name}, state: %{state}, owner: %{owner_name}"
+          desc: "%{name} is unlocked"
+          desc_owner: "%{name} is locked by %{owner_name} (taken %{time})"
+          desc_owner_queue: "%{name} is locked by %{owner_name} (taken %{time}). Next up: %{queue}"
           created: "Label %{name} created"
           exists: "%{name} already exists"
           deleted: "Label %{name} deleted"
@@ -88,3 +97,9 @@ en:
           does_not_have_resource: "Label %{label} does not have Resource %{resource}"
           no_resources: "%{name} has no resources, so it cannot be locked"
           dependency: 'Label unable to be locked, blocked on:'
+          now_locked_by: "%{name} now locked by %{owner} %{mention}"
+          removed_from_queue: "You have been removed from the queue for %{name}"
+          unknown_in_queue: "You weren't in the queue for %{name}"
+        user:
+          unknown: Unknown user
+          no_active_locks: That user has no active locks