lita-enhance 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d328609e647b18fe537f7456b95728754019f40f
+  data.tar.gz: 6a90c0ca0b0e92da38d212caa14b9477d5548e05
+SHA512:
+  metadata.gz: 74f55095d74a7c740dde25093af30f70e8919237549fdfdc8a6c88537c322e9d5c8b847bfc0a92e8298b491098143f4d8024e5f8dd0c6e9c0ee6388376d352b0
+  data.tar.gz: 4ce5807e836c8a5c448439a873f4b7f8252ba7e5904cc06d6a973917f75fea0f37806ae89a5b150f95c7366e0995aad9a9fdada3f72a67a3ba04aac5f66187d1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.ruby-version
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+cache: bundler
+language: ruby
+rvm:
+- 2.1
+- 2.0
+services:
+  - redis-server
+sudo: false

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem 'travis'

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 PagerDuty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# lita-enhance
+
+Enhances text that contains opaque machine identifiers by replacing them with that machine's hostname.
+
+```
+you> enhance 10.214.0.1
+lita> *box01*
+```
+
+Text that is enhanced is returned in the same format that is passed in, which makes enhancing log lines or CLI output nice to view.
+
+```
+you> enhance Finished hinted handoff of 8826 rows to endpoint /192.168.100.1
+lita> Finished hinted handoff of 8826 rows to endpoint /*box01*
+
+you> enhance tcp        0      0 10.214.0.1:ssh       10.214.0.2:4997     ESTABLISHED
+lita> tcp        0      0 *box01*:ssh             *box02*:4997     ESTABLISHED
+```
+
+You can increase the level of enhancement to add more machine details to the output.
+
+```
+you> enhance 10.214.0.1
+lita> *box01*
+
+you> enhance lvl:2 10.214.0.1
+lita> *box01 (us-west-2)*
+```
+
+Machine details are obtained by indexing database of machine assets. Right now only Chef servers are indexed. Results are indexed every 15 minutes by default. Old machines are left in the index so you can identify them even after they have been torn down.
+
+```
+you> enhance lvl:2 old-box01
+lita> ¿old-box01 (us-east-1)?
+```
+
+[And for fun](https://www.youtube.com/watch?v=Vxq9yj2pVWk), you can implicitly enhance previously enhanced text by just sending ```enhance```. The string to enhance is retained separately in each room that the enhance string was sent.
+
+```
+you> enhance 10.214.0.1
+lita> *box01*
+
+you> enhance
+lita> *box01 (us-west-2)*
+```
+
+## Installation
+
+Add lita-enhance to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-enhance"
+```
+
+## Configuration
+
+```ruby
+# Configure one or more knife files for the Chef server that lita-enhance should index
+config.handlers.enhance.knife_configs = {
+  'staging' => 'knife-staging.rb',
+  'production' => 'knife-production.rb'
+}
+
+# How often to refresh enhance's index in seconds. Default is 15 minutes.
+config.handlers.enhance.refresh_interval = 15 * 60
+
+# How long in seconds to remember messages to implicitly enhance. Default is 1 week.
+config.handlers.enhance.blurry_message_ttl = 7 * 24 * 60 * 60
+```
+
+## Usage
+
+```
+# Enhance IP addresses (public and private) with the machine's name if it is known
+enhance 54.189.200.22
+enhance 10.214.0.1
+
+# Enhance EC2 host names
+enhance ec2-54-189-200-22.us-west-2.compute.amazonaws.com
+enhance ip-10-214-13-102.us-west-2.compute.internal
+
+# Enhance host names (short & long)
+enhance box01
+enhance box01.example.com
+
+# Enhance EC2 instance IDs
+enhance i-123456
+
+# Enhance MAC addresses
+enhance 22:00:0a:00:32:23
+```
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/lita-enhance.rb

@@ -0,0 +1,7 @@
+require "lita"
+
+Lita.load_locales Dir[File.expand_path(
+  File.join("..", "..", "locales", "*.yml"), __FILE__
+)]
+
+require "lita/handlers/enhance"

data/lib/lita/handlers/enhance.rb

@@ -0,0 +1,209 @@
+require 'thread'
+
+require 'lita/handlers/enhance/chef_indexer'
+require 'lita/handlers/enhance/node'
+require 'lita/handlers/enhance/enhancer'
+require 'lita/handlers/enhance/session'
+
+module Lita
+  module Handlers
+    class Enhance < Handler
+      on :loaded, :setup_background_refresh
+
+      route(
+        /^refresh enhance$/,
+        :refresh,
+        command: true
+      )
+
+      route(
+        /^enhance stats$/,
+        :stats,
+        command: true
+      )
+
+      route(
+        /\Aenhance(\slvl:([0-9]))?(\s(.*))?\z/m,
+        :enhance,
+        command: true,
+        help: {
+          'enhance <anything>' => 'Enhances details in your text. https://www.youtube.com/watch?v=Vxq9yj2pVWk'
+        }
+      )
+
+      def self.default_config(config)
+        config.knife_configs = {}
+        if File.exist?('~/.chef/knife.rb')
+          config.knife_configs['default'] = '~/.chef/knife.rb'
+        end
+
+        config.refresh_interval = 15 * 60
+        config.add_quote = true
+
+        # How long to remember the previously enhanced message for.
+        config.blurry_message_ttl = 7 * 24 * 60 * 60 # seconds
+      end
+
+      def setup_background_refresh(payload)
+        @@chef_indexer = ChefIndexer.new(redis, config.knife_configs)
+        @@enhancers = Enhancer.all.map do |enhancer_klass|
+          enhancer_klass.new(redis)
+        end
+
+        bg_refresh = proc do
+          begin
+            lock_and_refresh_index
+          rescue => e
+            # Keep error from killing background thread
+            log.error { "#{e.message}\n#{e.backtrace.join("\n")}" }
+          end
+        end
+
+        log.info { "Will refresh enhance index every #{config.refresh_interval} seconds" }
+        after(0, &bg_refresh)
+        every(config.refresh_interval, &bg_refresh)
+      end
+
+      def refresh(response)
+        response.reply(t 'refresh.queued')
+
+        after(0) do
+          begin
+            lock_and_refresh_index
+            response.reply(success(t 'refresh.success'))
+          rescue => e
+            response.reply(failed(t 'refresh.failed'))
+            log.info { "#{e.message}\n#{e.backtrace.join("\n")}" }
+          end
+        end
+      end
+
+      def enhance(response)
+        level = response.matches[0][1]
+        level = level.to_i if level
+
+        blurry_string = response.matches[0][3]
+        return if blurry_string == "stats"
+
+        key = last_message_key(response)
+        level_key = key + ":level"
+
+        session = Session.new(redis, key, config.blurry_message_ttl)
+
+        if blurry_string && !blurry_string.empty?
+          level = 1 unless level
+        else
+          blurry_string = session.last_message
+        end
+
+        unless blurry_string
+          response.reply(failed(t 'enhance.message_required'))
+          return
+        end
+
+        level = session.last_level + 1 unless level
+
+        if level > max_level
+          response.reply(failed(t 'enhance.level_too_high', max_level: max_level))
+          return
+        elsif level < 1
+          response.reply(failed(t 'enhance.level_too_low', max_level: max_level))
+          return
+        end
+
+        enhanced_message = session.enhance!(blurry_string, level)
+
+        if enhanced_message != blurry_string
+          response.reply(mono(enhanced_message))
+        else
+          response.reply(no_change(t 'enhance.nothing_to_enhance'))
+        end
+      end
+
+      def stats(response)
+        INDEX_MUTEX.synchronize do
+          response_msg = t('stats.last_refreshed', last_refreshed: (@@chef_indexer.last_refreshed.to_s || 'never'))
+          response_msg += "\n" + t('stats.refresh_frequency', refresh_mins: ('%.2f' % (config.refresh_interval / 60.0)))
+          @@enhancers.each do |e|
+            response_msg += "\n#{e}"
+          end
+          response.reply(response_msg)
+        end
+      end
+
+      private
+        # This mutex must be obtained to refresh the index
+        REFRESH_MUTEX = Mutex.new unless defined?(REFRESH_MUTEX)
+
+        # This mutex must be obtains to update the index with new data, or to use the index to enhance some text
+        INDEX_MUTEX   = Mutex.new unless defined?(INDEX_MUTEX)
+
+        def lock_and_refresh_index
+          REFRESH_MUTEX.synchronize do
+            @@chef_indexer.refresh
+          end
+        end
+
+        def last_message_key(response)
+          response.message.source.room || response.message.source.user.id
+        end
+
+        def max_level
+          @@enhancers.map {|x| x.max_level }.max
+        end
+
+        def adapter
+          if Lita.respond_to?(:config)
+            Lita.config.robot.adapter
+          elsif robot.respond_to?(:config)
+            robot.config.robot.adapter
+          else
+            :unknown
+          end
+        end
+
+        # Calls out that this message was successful via adapter specific messaging
+        def success(message)
+          case adapter
+          when :hipchat
+            "(successful) #{message}"
+          else
+            message
+          end
+        end
+
+        # Calls out that the action failed via adapter specific messaging
+        def failed(message)
+          case adapter
+          when :hipchat
+            "(failed) #{message}"
+          else
+            message
+          end
+        end
+
+        # Calls out that action resulted in no change via adapter specific messaging
+        def no_change(message)
+          case adapter
+          when :hipchat
+            "(nothingtodohere) #{message}"
+          else
+            message
+          end
+        end
+
+        # Attempts to render the message using a monospaced font via adapter specific messaging
+        def mono(message)
+          case adapter
+          when :hipchat
+            "/quote #{message}"
+          else
+            message
+          end
+        end
+    end
+
+
+    Lita.register_handler(Enhance)
+  end
+end

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

@@ -0,0 +1,133 @@
+require 'chef'
+
+module Lita
+  module Handlers
+    class Enhance < Handler
+      # This class is responsible for indexing Chef servers to extract
+      # enhanceable data to populate the enhance indices.
+      class ChefIndexer
+        attr_reader :last_refreshed
+
+        attr_reader :redis, :knife_configs
+
+        def initialize(redis, knife_configs)
+          @redis = redis
+          @knife_configs = knife_configs
+        end
+
+        def refresh
+          log.debug { "Refreshing enhance index..." }
+
+          self.knife_configs.each do |_, config_path|
+            index(config_path, @enhancers)
+          end
+
+          @last_refreshed = Time.now
+
+          log.debug { "Refreshed enhance index" }
+
+          # Refreshing the index pulls a lot of large objects into memory,
+          # forcing a GC run to ensure that our heap doesn't grow aggressively.
+          GC.start
+
+          nil
+        end
+
+        def index_chef_node(chef_node)
+          node = node_from_chef_node(chef_node)
+          node.store!(redis)
+
+          index_hostname(chef_node, node)
+          index_instanceid(chef_node, node)
+          index_ip(chef_node, node)
+          index_mac_address(chef_node, node)
+        end
+
+        def node_from_chef_node(chef_node)
+          Node.new.tap do |n|
+            n.name = chef_node.name
+            n.dc = if chef_node['ec2']
+                     chef_node['ec2']['placement_availability_zone']
+                   elsif chef_node['cloud']
+                     chef_node['cloud']['provider']
+                   end
+            n.environment = chef_node.environment
+            n.fqdn = chef_node['fqdn']
+            n.last_seen_at = Time.now
+          end
+        end
+
+        private
+
+        def index(chef_config_path, enhancers)
+          log.debug { "Indexing #{chef_config_path}" }
+
+          Chef::Config.from_file(File.expand_path(chef_config_path))
+          query = Chef::Search::Query.new
+
+          query.search("node", "*:*") do |chef_node|
+            index_chef_node(chef_node)
+          end
+        end
+
+        def index_hostname(chef_node, node)
+          enhancer = HostnameEnhancer.new(redis)
+
+          enhancer.index(chef_node['fqdn'], node)
+
+          if chef_node['cloud']
+            enhancer.index(chef_node['cloud']['local_hostname'], node)
+            enhancer.index(chef_node['cloud']['public_hostname'], node)
+          end
+
+          if chef_node['cloud_v2']
+            enhancer.index(chef_node['cloud_v2']['local_hostname'], node)
+            enhancer.index(chef_node['cloud_v2']['public_hostname'], node)
+          end
+        end
+
+        def index_instanceid(chef_node, node)
+          enhancer = InstanceIdEnhancer.new(redis)
+
+          if chef_node['ec2']
+            enhancer.index(chef_node['ec2']['instance_id'], node)
+          end
+        end
+
+        def index_ip(chef_node, node)
+          enhancer = IpEnhancer.new(redis)
+
+          enhancer.index(chef_node['ipaddress'], node)
+
+          if chef_node['cloud']
+            enhancer.index(chef_node['cloud']['local_ipv4'], node)
+            enhancer.index(chef_node['cloud']['public_ipv4'], node)
+          end
+
+          if chef_node['cloud_v2']
+            if chef_node['cloud_v2']['public_ipv4_addrs']
+              ips = chef_node['cloud_v2']['public_ipv4_addrs']
+              ips.each {|ip| enhancer.index(ip, node) }
+            end
+            if chef_node['cloud_v2']['local_ipv4_addrs']
+              ips = chef_node['cloud_v2']['local_ipv4_addrs']
+              ips.each {|ip| enhancer.index(ip, node) }
+            end
+          end
+        end
+
+        def index_mac_address(chef_node, node)
+          enhancer = MacAddressEnhancer.new(redis)
+
+          if chef_node['macaddress']
+            enhancer.index(chef_node['macaddress'], node)
+          end
+        end
+
+        def log
+          Lita.logger
+        end
+      end
+    end
+  end
+end