lita-enhance 0.9.0

data/lib/lita/handlers/enhance/enhancer.rb

@@ -0,0 +1,58 @@
+require 'weakref'
+
+module Lita
+  module Handlers
+    class Enhance < Handler
+      class Enhancer
+        @@subclasses = []
+
+        @@current = %w(* *)
+        @@old = %w(¿ ?)
+
+        def self.all
+          @@subclasses.select! {|x| x.weakref_alive? }
+          @@subclasses
+        end
+
+        def self.inherited(subclass)
+          @@subclasses << WeakRef.new(subclass)
+        end
+
+        attr_reader :redis
+
+        def initialize(redis)
+          @redis = redis
+        end
+
+        def render(node, level)
+          "#{start_mark(node)}#{node.render(level)}#{end_mark(node)}"
+        end
+
+        def max_level
+          5
+        end
+
+        private
+        def start_mark(node)
+          node.old? ? @@old.first : @@current.first
+        end
+
+        def end_mark(node)
+          node.old? ? @@old.last : @@current.last
+        end
+      end
+
+      class Substitution < Struct.new(:range, :new_text)
+        def overlap?(other)
+          range.cover?(other.range.begin) || other.range.cover?(range.end)
+        end
+      end
+
+      require 'lita/handlers/enhance/enhancers/instance_id_enhancer'
+      require 'lita/handlers/enhance/enhancers/ip_enhancer'
+      require 'lita/handlers/enhance/enhancers/hostname_enhancer'
+      require 'lita/handlers/enhance/enhancers/mac_address_enhancer'
+    end
+  end
+end
+

data/lib/lita/handlers/enhance/enhancers/hostname_enhancer.rb

@@ -0,0 +1,72 @@
+require 'lita/handlers/enhance/node_index'
+require 'lita/handlers/enhance/enhancer'
+
+module Lita
+  module Handlers
+    class Enhance
+      class HostnameEnhancer < Enhancer
+        HOSTNAME_REGEX = /\b(?:(?:(?:[a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)+(?:[A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9]))\b/
+
+        def initialize(redis)
+          super
+          @nodes_by_hostname = NodeIndex.new(redis, 'nodes_by_hostname')
+          @nodes_by_short_hostname = NodeIndex.new(redis, 'nodes_by_short_hostname')
+        end
+
+        def index(hostname, node)
+          map_hostname_to_node(hostname, node)
+        end
+
+        def enhance!(string, level)
+          substitutions = []
+          string.scan(HOSTNAME_REGEX) do
+            match = Regexp.last_match
+            hostname = match.to_s
+            range = (match.begin(0)...match.end(0))
+
+            node = @nodes_by_hostname[hostname]
+            if node
+              new_text = render(node, level)
+              substitutions << Substitution.new(range, new_text)
+            end
+          end
+          string.scan(short_hostname_regex) do
+            match = Regexp.last_match
+            hostname = match.to_s
+            range = (match.begin(0)...match.end(0))
+
+            node = @nodes_by_short_hostname[hostname]
+            if node
+              new_text = render(node, level)
+              sub = Substitution.new(range, new_text)
+              unless substitutions.any? {|s| s.overlap?(sub) }
+                substitutions << Substitution.new(range, new_text)
+              end
+            end
+          end
+
+          substitutions
+        end
+
+        def short_hostname_regex
+          @short_hostname_regex ||= /\b(?<!\*)#{Regexp.union(@nodes_by_short_hostname.keys)}\b(?<!\*)/
+        end
+
+        def to_s
+          "#{self.class.name}: #{@nodes_by_short_hostname.size} short hostnames, #{@nodes_by_hostname.size} long hostnames indexed"
+        end
+
+        private
+
+        def map_hostname_to_node(hostname, node)
+          return if hostname.nil?
+
+          short_hostname = hostname.split('.')[0]
+
+          @nodes_by_hostname[hostname] = node
+          @nodes_by_short_hostname[short_hostname] = node
+        end
+      end
+    end
+  end
+end

data/lib/lita/handlers/enhance/enhancers/instance_id_enhancer.rb

@@ -0,0 +1,40 @@
+require 'lita/handlers/enhance/node_index'
+
+module Lita
+  module Handlers
+    class Enhance
+      class InstanceIdEnhancer < Enhancer
+        INSTANCE_ID_REGEX = /i-[0-9a-f]{8}/
+
+        def initialize(redis)
+          super
+          @nodes_by_instance_id = NodeIndex.new(redis, 'nodes_by_instance_id')
+        end
+
+        def index(instance_id, node)
+          @nodes_by_instance_id[instance_id] = node
+        end
+
+        def enhance!(string, level)
+          substitutions = []
+          string.scan(INSTANCE_ID_REGEX) do
+            match = Regexp.last_match
+            instance_id = match.to_s
+            range = (match.begin(0)...match.end(0))
+
+            node = @nodes_by_instance_id[instance_id]
+            if node
+              new_text = render(node, level)
+              substitutions << Substitution.new(range, new_text)
+            end
+          end
+          substitutions
+        end
+
+        def to_s
+          "#{self.class.name}: #{@nodes_by_instance_id.size} instance IDs indexed"
+        end
+      end
+    end
+  end
+end

data/lib/lita/handlers/enhance/enhancers/ip_enhancer.rb

@@ -0,0 +1,40 @@
+require 'lita/handlers/enhance/node_index'
+
+module Lita
+  module Handlers
+    class Enhance
+      class IpEnhancer < Enhancer
+        IP_REGEX = /(?:[0-9]{1,3}\.){3}[0-9]{1,3}/
+
+        def initialize(redis)
+          super
+          @nodes_by_ip = NodeIndex.new(redis, 'nodes_by_ip')
+        end
+
+        def index(ip, node)
+          @nodes_by_ip[ip] = node
+        end
+
+        def enhance!(string, level)
+          substitutions = []
+          string.scan(IP_REGEX) do 
+            match = Regexp.last_match
+            ip = match.to_s
+            range = (match.begin(0)...match.end(0))
+
+            node = @nodes_by_ip[ip]
+            if node
+              new_text = render(node, level)
+              substitutions << Substitution.new(range, new_text)
+            end
+          end
+          substitutions
+        end
+
+        def to_s
+          "#{self.class.name}: #{@nodes_by_ip.size} IPs indexed"
+        end
+      end
+    end
+  end
+end

data/lib/lita/handlers/enhance/enhancers/mac_address_enhancer.rb

@@ -0,0 +1,42 @@
+require 'lita/handlers/enhance/node_index'
+
+module Lita
+  module Handlers
+    class Enhance
+      class MacAddressEnhancer < Enhancer
+        # TODO: enhance unknown MAC address with OUI names http://standards.ieee.org/develop/regauth/oui/oui.txt
+
+        MAC_ADDRESS_REGEX = /([0-9a-f]{2}:){5}[0-9a-f]{2}/i
+
+        def initialize(redis)
+          super
+          @nodes_by_mac_address = NodeIndex.new(redis, 'nodes_by_mac_address')
+        end
+
+        def index(mac_address, node)
+          @nodes_by_mac_address[mac_address.downcase] = node
+        end
+
+        def enhance!(string, level)
+          substitutions = []
+          string.scan(MAC_ADDRESS_REGEX) do
+            match = Regexp.last_match
+            mac_address = match.to_s
+            range = (match.begin(0)...match.end(0))
+
+            node = @nodes_by_mac_address[mac_address.downcase]
+            if node
+              new_text = render(node, level)
+              substitutions << Substitution.new(range, new_text)
+            end
+          end
+          substitutions
+        end
+
+        def to_s
+          "#{self.class.name}: #{@nodes_by_mac_address.size} MAC addresses indexed"
+        end
+      end
+    end
+  end
+end

data/lib/lita/handlers/enhance/node.rb

@@ -0,0 +1,57 @@
+module Lita
+  module Handlers
+    class Enhance < Handler
+      class Node
+        attr_accessor :name, :dc, :environment, :fqdn, :last_seen_at
+
+        # Creates a new Node instance and loads its data from Redis
+        def self.load(redis, name)
+          node = nil
+
+          node_data_json = redis.hget('nodes', name)
+          if node_data_json
+            node_data = JSON.parse(node_data_json)
+            node = self.from_json(node_data)
+          end
+
+          node
+        end
+
+        # Stores this node in Redis for later retrieval
+        def store!(redis)
+          node_data_json = JSON.generate(self.as_json)
+          redis.hset('nodes', self.name, node_data_json)
+        end
+
+        def self.from_json(json)
+          self.new.tap do |node|
+            %w(name dc environment fqdn).each do |field|
+              node.send("#{field}=", json[field])
+            end
+            node.last_seen_at = Time.parse(json['last_seen_at']) if json['last_seen_at']
+          end
+        end
+
+        def as_json
+          {name: name, dc: dc, environment: environment, fqdn: fqdn, last_seen_at: last_seen_at}
+        end
+
+        def render(level)
+          case level
+          when 1 then name
+          when 2 then "#{name} (#{dc})"
+          when 3 then "#{name} (#{dc}, #{environment})"
+          when 4 then "#{name} (#{dc}, #{environment}, last seen #{last_seen_at})"
+          when 5 then "#{fqdn} (#{dc}, #{environment}, last seen #{last_seen_at})"
+          end
+        end
+
+        # True if this node appears to be gone away because we haven't seen it
+        # for a while.
+        def old?
+          last_seen_at < (Time.now - 6 * 60 * 60)
+        end
+      end
+    end
+  end
+end

data/lib/lita/handlers/enhance/node_index.rb

@@ -0,0 +1,41 @@
+module Lita
+  module Handlers
+    class Enhance < Handler
+      # Instances of this class represent indexes of nodes based on identifying
+      # facets of that node.  Nodes are added to the index where the key is the
+      # term that we're indexing on, and the value is the node that matches
+      # that term.
+      #
+      # Nodes can then be later found in the index.
+      class NodeIndex
+        attr_reader :redis, :index_name
+
+        def initialize(redis, index_name)
+          @redis = redis
+          @index_name = index_name
+        end
+
+        # Adds a node to the index
+        def []=(key, node)
+          redis.hset(index_name, key, node.name)
+        end
+
+        # Finds a node in the index. A Node object is return if found, otherwise nil is returned.
+        def [](key)
+          node_name = redis.hget(index_name, key)
+          Node.load(redis, node_name)
+        end
+
+        # Returns the number of keys that are stored in this index.
+        def size
+          redis.hlen(index_name)
+        end
+
+        # Returns all the keys that defined in this index.
+        def keys
+          redis.hkeys(index_name)
+        end
+      end
+    end
+  end
+end

data/lib/lita/handlers/enhance/session.rb

@@ -0,0 +1,77 @@
+module Lita
+  module Handlers
+    class Enhance < Handler
+      # Represents a session of message enhancing. This class is the entry
+      # point into logic for enhancing a string. Since state is stored in
+      # Redis, a new session can be created for each interaction.
+      class Session
+        # A redis namespace under which we will store our data
+        attr_reader :redis
+
+        # The key by which the previous enhanced messages should be remembered.
+        attr_reader :last_message_key
+
+        # How long to remember previous messages (in seconds)
+        attr_reader :last_message_ttl
+
+        def initialize(redis, last_message_key, last_message_ttl)
+          @redis = redis
+          @last_message_key = last_message_key
+          @last_message_ttl = last_message_ttl
+        end
+
+        # Returns the last level of enhancement that was performed in this
+        # session. Using this value it is possible to implicitly raise the
+        # level.
+        def last_level
+          last_level_raw = redis.get(last_level_key)
+          last_level_raw && last_level_raw.to_i
+        end
+
+        # Returns the last user supplied message that was enhanced for this
+        # session. Using this value, it is possible to re-enhance this string.
+        def last_message
+          redis.get(last_message_key)
+        end
+
+        # Enhances message at the supplied level.
+        def enhance!(message, level)
+          log.debug { "Enhancing (level: #{level}):\n#{message}" }
+
+          redis.setex(last_message_key, last_message_ttl, message)
+          redis.setex(last_level_key, last_message_ttl, level)
+
+          @enhancers = Enhancer.all.map do |enhancer_klass|
+            enhancer_klass.new(redis)
+          end
+
+          substitutions = @enhancers.flat_map do |e|
+            e.enhance!(message, level)
+          end
+
+          enhanced_message = message.dup
+
+          substitutions.sort! {|a,b| a.range.begin <=> b.range.begin }
+
+          current_offset = 0
+          substitutions.each do |sub|
+            enhanced_message[sub.range.begin + current_offset, sub.range.size] = sub.new_text
+
+            current_offset += sub.new_text.length - sub.range.size
+          end
+
+          enhanced_message
+        end
+
+        private
+        def log
+          Lita.logger
+        end
+
+        def last_level_key
+          last_message_key + ":level"
+        end
+      end
+    end
+  end
+end

data/lita-enhance.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |spec|
+  spec.name          = "lita-enhance"
+  spec.version       = "0.9.0"
+  spec.authors       = ["Doug Barth"]
+  spec.email         = ["doug@pagerduty.com"]
+  spec.description   = %q{A Lita handler that enhances text by replacing opaque identifiers with Chef node names}
+  spec.summary       = %q{A Lita handler that enhances text by replacing opaque identifiers with Chef node names}
+  spec.homepage      = "https://github.com/PagerDuty/lita-enhance"
+  spec.license       = "MIT"
+  spec.metadata      = { "lita_plugin_type" => "handler" }
+
+  spec.files         = `git ls-files`.split($/)
+  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", ">= 3.1"
+  spec.add_runtime_dependency "chef", ">= 11.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ">= 3.0.0.beta2"
+end