bub_bot 0.2.1

data/lib/bub_bot/server_manager.rb

@@ -0,0 +1,76 @@
+require 'bub_bot/redis_connection'
+
+class BubBot::ServerManager
+  ROOT_KEY = 'bub_server_list'.freeze
+
+  # Options:
+  # - duration (1.hour)
+  # - server_name (cannoli)
+  # - user (kevin)
+  #
+  # All options required.  Do your own defaulting, you lazy bum!
+  def take(options)
+    puts 'takin'
+
+    server_name, duration, user = options.values_at(:server_name, :duration, :user)
+    expires_at = duration.from_now
+
+    data = {
+      'user' => user,
+      'expires_at' => expires_at
+    }
+    redis.hset(ROOT_KEY, server_name, data.to_json)
+
+    data.merge(server: server_name)
+  end
+
+  def release(server_name)
+    redis.hdel(ROOT_KEY, server_name)
+  end
+
+  def names
+    known_server_names
+  end
+
+  def list
+    claims = redis.hgetall(ROOT_KEY).to_h
+
+    known_server_names.each_with_object({}) do |server_name, claim_map|
+      claim_map[server_name] =
+        if claim = claims[server_name]
+          claim_data = JSON.parse(claim)
+          expires_at = DateTime.parse(claim_data['expires_at'])
+
+          # Filter out expired claims
+          if expires_at > Time.now
+            claim_data['expires_at'] = expires_at
+            claim_data
+          else
+            {}
+          end
+        else
+          {}
+        end
+    end
+  end
+
+  def claimed_by(username)
+    list
+      .select { |server, claim_data| claim_data['user'] == username }
+      .keys
+  end
+
+  def first_unclaimed
+    list.key({})
+  end
+
+  private
+
+  def known_server_names
+    BubBot.configuration.servers
+  end
+
+  def redis
+    BubBot::RedisConnection.instance
+  end
+end

data/lib/bub_bot/slack/client.rb

@@ -0,0 +1,15 @@
+require 'singleton'
+
+# Just a simple wrapper around a slack connection.  Call .instance on this, then
+# call anything you'd normally call on a Slack Client on object on this instead.  Eg
+# `Client.instance.chat_postMessage`.
+class BubBot::Slack::Client
+  include Singleton
+  def method_missing(method, *args, &block)
+    client.respond_to?(method) ? client.public_send(method, *args, &block) : super
+  end
+
+  def client
+    @client ||= Slack::Web::Client.new(token: BubBot.configuration.bot_oauth_token)
+  end
+end

data/lib/bub_bot/slack/command.rb

@@ -0,0 +1,100 @@
+require 'bub_bot/server_manager.rb'
+require 'bub_bot/deploy_manager.rb'
+require 'slack-ruby-client'
+
+class BubBot::Slack::Command
+  def self.can_handle?(command)
+    aliases.include?(command)
+  end
+
+  def self.aliases
+    # Guess the command name from the class name
+    [self.name.demodulize.downcase]
+  end
+
+  def initialize(options)
+    @options = options
+    puts "initialized a command"
+  end
+
+  def run
+    name = self.class.name
+    raise "Your command #{name} needs to implement 'run'"
+  end
+
+  private
+
+  def servers
+    @@servers ||= BubBot::ServerManager.new
+  end
+
+  def deployer
+    @@deployer ||= BubBot::DeployManager.new
+  end
+
+  def client
+    BubBot::Slack::Client.instance
+  end
+
+  def source_user_id
+    @options['user']
+  end
+
+  def source_user_name
+    # TODO: cache these, since it's probably the same few people most of the time.
+    client.users_info(user: source_user_id)&.dig('user', 'name')
+  end
+
+  def tokens
+    @tokens ||= @options['text'].split(' ')
+  end
+
+  # Takes either a string or some options
+  def respond(options)
+    BubBot::Slack::Response.new(options, client)
+  end
+
+  def bot_name
+    BubBot.configuration.bot_name
+  end
+
+  # Returns an iterator over the token list that returns nil when out of tokens.
+  #
+  # Eg if the tokens are `aaa bbb ccc`:
+  #
+  # iterator = create_token_iterator
+  # iterator.next # aaa
+  # iterator.next # bbb
+  # iterator.next # ccc
+  # iterator.next # nil
+  #
+  # A good way to use this is for parsing order-agnostic commands:
+  #
+  # iterator = create_token_iterator
+  # while token = iterator.next
+  #   if token == 'bake'
+  #     recipe = iterator.next
+  #     raise "bad recipe" unless %w(bread cookies).include?(recipe)
+  #     bake(iterator.next)
+  #   elsif token == 'order'
+  #     raise 'missing type' unless food_type = iterator.next
+  #     raise 'missing when' unless when = iterator.next
+  #     order(food_type, when)
+  #   end
+  # end
+  #
+  # Warning: don't use to_a on this iterator - it'll result in an infinite loop.
+  # In retrospect, this was a bad pattern.  TODO: refactor this.
+  def create_token_iterator
+    unsafe_iterator = tokens.each
+
+    return Enumerator.new do |yielder|
+      loop do
+        yielder.yield unsafe_iterator.next
+      end
+      loop do
+        yielder.yield nil
+      end
+    end
+  end
+end

data/lib/bub_bot/slack/command_parser.rb

@@ -0,0 +1,37 @@
+module BubBot::Slack
+end
+
+require 'bub_bot/slack/command'
+Dir[File.dirname(__FILE__) + '/commands/*.rb'].each {|file| require file }
+
+class BubBot::Slack::CommandParser
+  def self.get_command(string_input)
+    puts "Parsing #{string_input}"
+    #puts "options: #{command_classes}"
+
+    # Strip the bot name out
+    string_input.sub!(/^#{BubBot.configuration.bot_name} /, '')
+
+    command = string_input.split(' ').first
+
+    if command
+      command_classes.find do |command_class|
+        command_class.can_handle?(command)
+      end
+    else
+      nil
+    end
+  end
+
+  def self.command_classes
+
+    # Get all the classes under BubBot::Slack::Command::*
+    @_command_classes ||= BubBot::Slack::Command.constants.map do |constant|
+      (BubBot::Slack::Command.to_s + "::" + constant.to_s).safe_constantize
+    end.select do |constant|
+
+      # Get only the constants that are classes and inherit from Command
+      constant.is_a?(Class) && constant < BubBot::Slack::Command
+    end
+  end
+end

data/lib/bub_bot/slack/commands/claim.rb

@@ -0,0 +1,89 @@
+require 'action_view'
+require 'action_view/helpers'
+
+class BubBot::Slack::Command::Claim < BubBot::Slack::Command
+  include ActionView::Helpers::DateHelper
+
+  DEFAULT_DURATION = 1.hour.freeze
+  INCREMENTS = %w(minute hour day week month)
+
+  # bub take cannoli for 20 minutes deploy master
+  def self.aliases
+    %w(claim take gimmee canhaz)
+  end
+
+  def run
+    server = duration = deploy = nil
+    iterator = create_token_iterator
+
+    # Skip the command name itself
+    iterator.next
+
+    while token = iterator.peek
+      if token == 'for'
+        puts 'got for'
+        iterator.next
+        duration = parse_duration(iterator)
+      elsif token.to_i > 0
+        puts 'got int'
+        duration = parse_duration(iterator)
+      elsif servers.names.include?(token)
+        puts 'got server'
+        server = iterator.next
+      elsif token == 'deploy'
+        puts 'got deploy'
+        raise RespondableError.new('Use the new deploy command to deploy, not the take command.')
+      else
+        raise RespondableError.new("I'm not sure what '#{token}' means.")
+      end
+    end
+
+    # Default to the first unclaimed server if no server was specified.  If there
+    # are no unclaimed servers, error.
+    unless server
+      unless server = servers.first_unclaimed
+        raise RespondableError.new("No available servers.")
+      end
+    end
+
+    duration ||= DEFAULT_DURATION
+
+    take_options = {
+      server_name: server,
+      duration: duration,
+      user: source_user_name
+    }.compact
+
+    result = servers.take(take_options)
+
+    time_ago = time_ago_in_words(result['expires_at'])
+    respond("#{source_user_name} has #{server} for the next #{time_ago}")
+  end
+
+  private
+
+  def parse_duration(iterator)
+    value = iterator.next.to_i
+    unless increment = iterator.next
+      raise RespondableError.new("Missing increment.  Do you mean '#{value} hours'?")
+    end
+    unless valid_increments.include?(increment)
+      raise RespondableError.new("I don't know the increment '#{increment}'.  Try one of these instead: #{INCREMENTS.join(', ')}")
+    end
+
+    # 5.minutes
+    value.public_send(increment)
+  end
+
+  def should_deploy?
+    false # todo: parse from command, also support buttons
+  end
+
+  def valid_increments
+    @@valid_increments ||= INCREMENTS.reduce([]) do |valid, increment|
+      valid << increment + 's'
+      valid << increment
+      valid
+    end
+  end
+end

data/lib/bub_bot/slack/commands/deploy.rb

@@ -0,0 +1,123 @@
+class BubBot::Slack::Command::Deploy < BubBot::Slack::Command
+  def self.aliases
+    %w(deploy ship push)
+  end
+
+  # bub deploy cannoli core kk_foo
+  def run
+    puts 'deploying'
+    server = nil
+    deploys = {}
+    iterator = create_token_iterator
+
+    # Skip the command name itself
+    iterator.next
+
+    while token = iterator.peek
+      puts "token loop #{token}"
+      if token == 'and'
+        iterator.next
+        next
+      end
+
+      # TODO: strip trailing commas (need to do this in the iterator)
+      #token = token.sub!(/,$/, '')
+
+      if servers.names.include?(token)
+        puts 'servers.names'
+        server = iterator.next
+
+      # Handle 'kk_some_fix [to] core'
+      elsif branches.include?(token)
+        puts 'branches.include'
+        
+        branch = iterator.next
+        target = iterator.next
+
+        # Skip connector words
+        target = iterator.next if %w(to on with).include?(target)
+
+        deploys[target] = branch
+
+      # Handle 'core kk_some_fix'
+      elsif targets.include?(token)
+        puts 'else targets.inclue'
+        target = iterator.next
+        branch = iterator.next
+        deploys[target] = branch
+      else
+        raise RespondableError.new("I didn't recognize #{token}")
+      end
+    end
+
+    # Validate all the potential deploys before we start
+    deploys.each do |target, branch|
+      puts 'deploys.each'
+      # TODO: infer targets, etc
+      unless targets.include?(target)
+        raise RespondableError.new("Unknown deploy target #{token}. Try one of #{targets.join(', ')}")
+      end
+      unless branches(target).include?(branch)
+        raise RespondableError.new("Deploy target #{target} doesn't have a branch named #{branch}.  Maybe you forgot to push that branch?")
+      end
+    end
+
+    server = servers.first_unclaimed unless server
+
+    unless server
+      return respond('No servers available')
+    end
+
+    unless deploys.any?
+      return respond("Please specify a target and a branch, eg `#{bot_name} deploy #{server} core kk_add_lasers`");
+    end
+
+    # TODO:
+    # - default to deploying develop
+
+    claim_data = servers.list[server]
+
+    if claim_data['user'] && claim_data['user'] != source_user_name
+      raise RespondableError.new("Server already claimed by #{claim_data['user']}.  Use the 'take' command first to override their claim.")
+    elsif
+      # Extend our current claim on this server to 1 hour from now unless we
+      # already have it claimed for longer
+      if !claim_data['expires_at'] || claim_data['expires_at'] < 1.hour.from_now
+        servers.take(
+          user: source_user_name,
+          duration: 1.hour,
+          server_name: server
+        )
+      end
+    end
+
+    message_segments = deploys.map do |target, branch|
+      "branch '#{branch}' to target '#{target}'"
+    end
+    respond("Deploying on server #{server}: #{message_segments.join('; ')}").deliver
+
+    deploys.each do |target, branch|
+      deployer.deploy(server, target, branch)
+    end
+
+    respond("Finished deploying on server #{server}: #{message_segments.join('; ')}");
+  end
+
+  # All known branches for the given target.  Returns all branches for *all*
+  # targets if target is nil.
+  def branches(target = nil)
+    puts 'deploy.branches'
+    @_branch_cache ||= {}
+    if target == nil
+      targets.flat_map do |target|
+        branches(target)
+      end
+    else
+      @_branch_cache[target] ||= deployer.branches(target)
+    end
+  end
+
+  def targets
+    deployer.target_names
+  end
+end

data/lib/bub_bot/slack/commands/echo.rb

@@ -0,0 +1,5 @@
+class BubBot::Slack::Command::Echo < BubBot::Slack::Command
+  def run
+    respond(@options[:text])
+  end
+end

data/lib/bub_bot/slack/commands/list.rb

@@ -0,0 +1,26 @@
+require 'action_view'
+require 'action_view/helpers'
+
+class BubBot::Slack::Command::List < BubBot::Slack::Command
+  include ActionView::Helpers::DateHelper
+
+  def self.aliases
+    %w(list status all wazup)
+  end
+
+  def run
+    list_strings = servers.list.map do |server, claim|
+      if claim['expires_at']
+        time_ago = time_ago_in_words(claim['expires_at'])
+        "#{server}: *#{claim['user']}'s* for the next #{time_ago}"
+      else
+        "#{server}: *free*"
+      end
+    end
+
+    respond(list_strings.join("\n"))
+  end
+
+  private
+
+end

data/lib/bub_bot/slack/commands/release.rb

@@ -0,0 +1,26 @@
+class BubBot::Slack::Command::Release < BubBot::Slack::Command
+  def run
+    puts "Running release"
+    servers_to_release = tokens.drop(1)
+    puts "servers_to_release: #{servers_to_release}"
+
+    my_servers = servers.claimed_by(source_user_name)
+    servers_to_release = 
+      if servers_to_release.empty?
+        my_servers
+      else
+        servers_to_release & my_servers
+      end
+
+    if (unknown_servers = servers_to_release - servers.names).any?
+      raise RespondableError.new("Unknown server(s): #{unknown_servers.join(', ')}.  Nothing released.")
+    end
+
+    servers_to_release.each do |server|
+      servers.release(server)
+    end
+
+    released = servers_to_release.any? ? servers_to_release.join(', ') : 'nothing'
+    respond("Released #{released}")
+  end
+end

data/lib/bub_bot/slack/response.rb

@@ -0,0 +1,21 @@
+class BubBot::Slack::Response
+  attr_accessor :text
+
+  def initialize(options, client)
+    @text = options.is_a?(String) ? options : options[:text]
+    @client = client
+  end
+
+  def deliver
+    body = {
+      text: text,
+      username: BubBot.configuration.bot_name
+    }
+    # TODO: configure channel
+    @client.chat_postMessage(channel: '#' + channel, text: text, as_user: true)
+  end
+
+  def channel
+    BubBot.configuration.slack_channel
+  end
+end

data/lib/bub_bot/version.rb

@@ -0,0 +1,3 @@
+module BubBot
+  VERSION = "0.2.1"
+end

data/lib/bub_bot/web_server.rb

@@ -0,0 +1,92 @@
+require 'bub_bot/slack/command_parser'
+require 'bub_bot/slack/response'
+require 'bub_bot/slack/client'
+require 'faraday'
+
+class BubError < StandardError
+end
+
+# An error that should should result in a user-facing response (and not a non-200
+# http response code)
+class RespondableError < StandardError
+end
+
+class BubBot::WebServer
+  def call(env)
+    puts ' --- Got request ---'
+
+    # Ignore retries for now.
+    if env['HTTP_X_SLACK_RETRY_NUM']
+      puts "Ignoring retry: #{env['HTTP_X_SLACK_RETRY_NUM']}, because #{env['HTTP_X_SLACK_RETRY_REASON']}"
+      return [200, {}, ['ok']]
+    end
+
+    request = Rack::Request.new(env)
+
+    # For easily checking if the server's up
+    if request.path == '/' && request.get?
+      return [200, {}, ['ok']]
+
+    # When slack sends us a challenge request
+    elsif request.path == '/' && request.post?
+      params = parse_params(request)
+      return [200, {}, [params[:challenge]]] if params[:challenge]
+
+      event = params[:event]
+
+      # Skip messages from bots
+      return [200, {}, []] if event[:subtype] == 'bot_message'
+
+      # Make sure this is in the form of 'bub foo'
+      unless event[:text].starts_with?(BubBot.configuration.bot_name + ' ')
+        puts "skipping non-bub message"
+        return [200, {}, []]
+      end
+
+      command = BubBot::Slack::CommandParser.get_command(event[:text])
+
+      puts " --- Running command #{command}"
+
+      # Slack will retry any message that takes longer than 3 seconds to complete,
+      # so do all message processing in a thread.
+      command_thread = Thread.new do
+        response =
+          begin
+            if command
+              command.new(event).run
+            else
+              BubBot::Slack::Response.new("unknown command", slack_client)
+            end
+          rescue RespondableError => e
+            BubBot::Slack::Response.new(e.message, slack_client)
+          end
+
+        response.deliver
+      end
+      command_thread.abort_on_exception = true
+
+      return [200, {}, []]
+
+    #elsif request.path == '/heroku_hook' && request.post?
+      #HerokuInterface.new.handle_heroku_webhook(request.body.read)
+      #return [200, {}, []]
+    else
+      raise BubError, "Failed request: #{request.request_method} #{request.path}"
+      err 'invalid request'
+    end
+  rescue BubError => e
+    puts "Err: #{e.message}"
+    return [400, {}, [e.message]]
+  end
+
+  private
+
+  def parse_params(request)
+    JSON.parse(request.body.read)
+      .with_indifferent_access
+  end
+
+  def slack_client
+    BubBot::Slack::Client.instance
+  end
+end

data/lib/bub_bot.rb

@@ -0,0 +1,54 @@
+require 'rack'
+require 'bub_bot/version'
+require 'bub_bot/web_server'
+require 'bub_bot/configuration'
+require 'bub_bot/cli'
+require 'pry-byebug'
+require 'active_support'
+require 'active_support/core_ext'
+
+module BubBot
+  class << self
+    attr_accessor :configuration
+    # From a config.ru file you can do `run BubBot`.  TODO: maybe not.  That would
+    # skip the running background thread.
+    #
+    # Handle an individual web request.  You shouldn't call this method directly.
+    # Instead, give BubBot to Rack and let it call this method.
+    def call(env)
+      (@web_server ||= WebServer.new).call(env)
+    end
+
+    # This method starts a listening web server.  Call from the cli or wherever
+    # else you want to kick off a running BubBot process.
+    def start
+      puts 'Booting BubBot'
+      Thread.new do
+        loop do
+          #puts "Checking for servers to shutdown"
+          # TODO: actually do that ^
+          sleep 10# * 60
+        end
+      end
+
+      app = Rack::Builder.new do
+        # if development (TODO)
+          use Rack::Reloader
+        # end
+        run BubBot
+      end.to_app
+
+      Rack::Handler::Thin.run(app, BubBot.configuration.rack_options_hash)
+    end
+
+    # Used for setting config options:
+    #   BubBot.configure do |config|
+    #     config.bot_name 'lillian'
+    #     config.redis_host 'localhost:6379'
+    #   end
+    def configure
+      self.configuration ||= Configuration.new
+      yield configuration
+    end
+  end
+end