lita-locker 0.5.3 → 0.7.0

data/lib/lita/handlers/locker_events.rb

@@ -0,0 +1,41 @@
+module Lita
+  module Handlers
+    # Event-related handlers
+    class LockerEvents < Handler
+      namespace 'Locker'
+
+      include ::Locker::Label
+      include ::Locker::Misc
+      include ::Locker::Regex
+      include ::Locker::Resource
+
+      on :lock_attempt, :lock_attempt
+      on :unlock_attempt, :unlock_attempt
+
+      def lock_attempt(payload)
+        label      = payload[:label]
+        user       = Lita::User.find_by_id(payload[:user_id])
+        request_id = payload[:request_id]
+
+        if label_exists?(label) && lock_label!(label, user, nil)
+          robot.trigger(:lock_success, request_id: request_id)
+        else
+          robot.trigger(:lock_failure, request_id: request_id)
+        end
+      end
+
+      def unlock_attempt(payload)
+        label      = payload[:label]
+        request_id = payload[:request_id]
+
+        if label_exists?(label) && unlock_label!(label)
+          robot.trigger(:unlock_success, request_id: request_id)
+        else
+          robot.trigger(:unlock_failure, request_id: request_id)
+        end
+      end
+
+      Lita.register_handler(LockerEvents)
+    end
+  end
+end

data/lib/lita/handlers/locker_http.rb

@@ -0,0 +1,30 @@
+module Lita
+  module Handlers
+    # HTTP-related handlers
+    class LockerHttp < Handler
+      namespace 'Locker'
+
+      include ::Locker::Label
+      include ::Locker::Misc
+      include ::Locker::Regex
+      include ::Locker::Resource
+
+      http.get '/locker/label/:name', :http_label_show
+      http.get '/locker/resource/:name', :http_resource_show
+
+      def http_label_show(request, response)
+        name = request.env['router.params'][:name]
+        response.headers['Content-Type'] = 'application/json'
+        response.write(label(name).to_json)
+      end
+
+      def http_resource_show(request, response)
+        name = request.env['router.params'][:name]
+        response.headers['Content-Type'] = 'application/json'
+        response.write(resource(name).to_json)
+      end
+
+      Lita.register_handler(LockerHttp)
+    end
+  end
+end

data/lib/lita/handlers/locker_labels.rb

@@ -0,0 +1,114 @@
+module Lita
+  module Handlers
+    # Label-related handlers
+    class LockerLabels < Handler
+      namespace 'Locker'
+
+      include ::Locker::Label
+      include ::Locker::Misc
+      include ::Locker::Regex
+      include ::Locker::Resource
+
+      route(
+        /^locker\slabel\slist$/,
+        :list,
+        command: true,
+        help: { t('help.label.list.syntax') => t('help.label.list.desc') }
+      )
+
+      route(
+        /^locker\slabel\screate\s#{LABEL_REGEX}$/,
+        :create,
+        command: true,
+        help: { t('help.label.create.syntax') => t('help.label.create.desc') }
+      )
+
+      route(
+        /^locker\slabel\sdelete\s#{LABEL_REGEX}$/,
+        :delete,
+        command: true,
+        help: { t('help.label.delete.syntax') => t('help.label.delete.desc') }
+      )
+
+      route(
+        /^locker\slabel\sshow\s#{LABEL_REGEX}$/,
+        :show,
+        command: true,
+        help: { t('help.label.show.syntax') => t('help.label.show.desc') }
+      )
+
+      route(
+        /^locker\slabel\sadd\s#{RESOURCE_REGEX}\sto\s#{LABEL_REGEX}$/,
+        :add,
+        command: true,
+        help: { t('help.label.add.syntax') => t('help.label.add.desc') }
+      )
+
+      route(
+        /^locker\slabel\sremove\s#{RESOURCE_REGEX}\sfrom\s#{LABEL_REGEX}$/,
+        :remove,
+        command: true,
+        help: { t('help.label.remove.syntax') => t('help.label.remove.desc') }
+      )
+
+      def list(response)
+        labels.sort.each do |n|
+          name = n.sub('label_', '')
+          l = label(name)
+          response.reply(t('label.desc', name: name, state: l['state']))
+        end
+      end
+
+      def create(response)
+        name = response.matches[0][0]
+        if create_label(name)
+          response.reply(t('label.created', name: name))
+        else
+          response.reply(t('label.exists', name: name))
+        end
+      end
+
+      def delete(response)
+        name = response.matches[0][0]
+        if delete_label(name)
+          response.reply(t('label.deleted', name: name))
+        else
+          response.reply(t('label.does_not_exist', name: name))
+        end
+      end
+
+      def show(response)
+        name = response.matches[0][0]
+        return response.reply(t('label.does_not_exist', name: name)) unless label_exists?(name)
+        members = label_membership(name)
+        return response.reply(t('label.has_no_resources', name: name)) unless members.count > 0
+        response.reply(t('label.resources', name: name, resources: members.join(', ')))
+      end
+
+      def add(response)
+        resource_name = response.matches[0][0]
+        label_name = response.matches[0][1]
+        return response.reply(t('label.does_not_exist', name: label_name)) unless label_exists?(label_name)
+        return response.reply(t('resource.does_not_exist', name: resource_name)) unless resource_exists?(resource_name)
+        add_resource_to_label(label_name, resource_name)
+        response.reply(t('label.resource_added', label: label_name, resource: resource_name))
+      end
+
+      def remove(response)
+        resource_name = response.matches[0][0]
+        label_name = response.matches[0][1]
+        return response.reply(t('label.does_not_exist', name: label_name)) unless label_exists?(label_name)
+        return response.reply(t('resource.does_not_exist', name: resource_name)) unless resource_exists?(resource_name)
+        members = label_membership(label_name)
+        if members.include?(resource_name)
+          remove_resource_from_label(label_name, resource_name)
+          response.reply(t('label.resource_removed', label: label_name, resource: resource_name))
+        else
+          response.reply(t('label.does_not_have_resource', label: label_name, resource: resource_name))
+        end
+      end
+
+      Lita.register_handler(LockerLabels)
+    end
+  end
+end

data/lib/lita/handlers/locker_misc.rb

@@ -0,0 +1,62 @@
+module Lita
+  module Handlers
+    # Misc Locker handlers
+    class LockerMisc < Handler
+      namespace 'Locker'
+
+      include ::Locker::Label
+      include ::Locker::Misc
+      include ::Locker::Regex
+      include ::Locker::Resource
+
+      route(
+        /^locker\sstatus\s#{LABEL_REGEX}$/,
+        :status,
+        command: true,
+        help: { t('help.status.syntax') => t('help.status.desc') }
+      )
+
+      route(
+        /^locker\slist\s#{USER_REGEX}$/,
+        :list,
+        command: true,
+        help: { t('help.list.syntax') => t('help.list.desc') }
+      )
+
+      def status(response)
+        name = response.matches[0][0]
+        if label_exists?(name)
+          l = label(name)
+          if l['owner_id'] && l['owner_id'] != ''
+            o = Lita::User.find_by_id(l['owner_id'])
+            response.reply(t('label.desc_owner', name: name,
+                                                 state: l['state'],
+                                                 owner_name: o.name))
+          else
+            response.reply(t('label.desc', name: name, state: l['state']))
+          end
+        elsif resource_exists?(name)
+          r = resource(name)
+          response.reply(t('resource.desc', name: name, state: r['state']))
+        else
+          response.reply(t('subject.does_not_exist', name: name))
+        end
+      end
+
+      def list(response)
+        username = response.match_data['username']
+        user = Lita::User.fuzzy_find(username)
+        return response.reply('Unknown user') unless user
+        l = user_locks(user)
+        return response.reply('That user has no active locks') unless l.size > 0
+        composed = ''
+        l.each do |label_name|
+          composed += "Label: #{label_name}\n"
+        end
+        response.reply(composed)
+      end
+
+      Lita.register_handler(LockerMisc)
+    end
+  end
+end

data/lib/lita/handlers/locker_resources.rb

@@ -0,0 +1,82 @@
+module Lita
+  module Handlers
+    # Resource-related handlers
+    class LockerResources < Handler
+      namespace 'Locker'
+
+      include ::Locker::Label
+      include ::Locker::Misc
+      include ::Locker::Regex
+      include ::Locker::Resource
+
+      route(
+        /^locker\sresource\slist$/,
+        :list,
+        command: true,
+        help: { t('help.resource.list.syntax') => t('help.resource.list.desc') }
+      )
+
+      route(
+        /^locker\sresource\screate\s#{RESOURCE_REGEX}$/,
+        :create,
+        command: true,
+        restrict_to: [:locker_admins],
+        help: {
+          t('help.resource.create.syntax') => t('help.resource.create.desc')
+        }
+      )
+
+      route(
+        /^locker\sresource\sdelete\s#{RESOURCE_REGEX}$/,
+        :delete,
+        command: true,
+        restrict_to: [:locker_admins],
+        help: {
+          t('help.resource.delete.syntax') => t('help.resource.delete.desc')
+        }
+      )
+
+      route(
+        /^locker\sresource\sshow\s#{RESOURCE_REGEX}$/,
+        :show,
+        command: true,
+        help: { t('help.resource.show.syntax') => t('help.resource.show.desc') }
+      )
+
+      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'])
+        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))
+        end
+      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))
+      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']))
+      end
+
+      Lita.register_handler(LockerResources)
+    end
+  end
+end

data/lib/locker/label.rb

@@ -0,0 +1,67 @@
+# Locker subsystem
+module Locker
+  # Label helpers
+  module Label
+    def label(name)
+      redis.hgetall("label_#{name}")
+    end
+
+    def labels
+      redis.keys('label_*')
+    end
+
+    def label_exists?(name)
+      redis.exists("label_#{name}")
+    end
+
+    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
+
+    def unlock_label!(name)
+      return false unless label_exists?(name)
+      key = "label_#{name}"
+      members = label_membership(name)
+      members.each do |m|
+        unlock_resource!(m)
+      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 delete_label(name)
+      label_key = "label_#{name}"
+      redis.del(label_key) if label_exists?(name)
+    end
+
+    def label_membership(name)
+      redis.smembers("membership_#{name}")
+    end
+
+    def add_resource_to_label(label, resource)
+      return unless label_exists?(label) && resource_exists?(resource)
+      redis.sadd("membership_#{label}", resource)
+    end
+
+    def remove_resource_from_label(label, resource)
+      return unless label_exists?(label) && resource_exists?(resource)
+      redis.srem("membership_#{label}", resource)
+    end
+  end
+end

data/lib/locker/misc.rb

@@ -0,0 +1,15 @@
+# Locker subsystem
+module Locker
+  # Misc helpers
+  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
+      end
+      owned
+    end
+  end
+end

data/lib/locker/regex.rb

@@ -0,0 +1,12 @@
+# Locker subsystem
+module Locker
+  # Regex definitions
+  module Regex
+    LABEL_REGEX    = /([\.\w\s-]+)/
+    RESOURCE_REGEX = /([\.\w-]+)/
+    COMMENT_REGEX  = /(\s\#.+)?/
+    LOCK_REGEX     = /\(lock\)\s/i
+    USER_REGEX     = /(?:@)?(?<username>[\w\s]+)/
+    UNLOCK_REGEX   = /(?:\(unlock\)|\(release\))\s/i
+  end
+end

data/lib/locker/resource.rb

@@ -0,0 +1,48 @@
+# Locker subsystem
+module Locker
+  # Resource helpers
+  module Resource
+    def resource(name)
+      redis.hgetall("resource_#{name}")
+    end
+
+    def resources
+      redis.keys('resource_*')
+    end
+
+    def resource_exists?(name)
+      redis.exists("resource_#{name}")
+    end
+
+    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
+
+    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 create_resource(name)
+      resource_key = "resource_#{name}"
+      redis.hset(resource_key, 'state', 'unlocked') unless
+        resource_exists?(name) || label_exists?(name)
+    end
+
+    def delete_resource(name)
+      resource_key = "resource_#{name}"
+      redis.del(resource_key) if resource_exists?(name)
+    end
+  end
+end