turbot 0.0.2

data/lib/turbot/command.rb

@@ -0,0 +1,304 @@
+require 'turbot/helpers'
+require 'turbot/plugin'
+require 'turbot/version'
+require "optparse"
+require 'excon'
+
+module Turbot
+  module Command
+    class CommandFailed  < RuntimeError; end
+
+    extend Turbot::Helpers
+
+    def self.load
+      Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do |file|
+        require file
+      end
+      Turbot::Plugin.load!
+      unregister_commands_made_private_after_the_fact
+    end
+
+    def self.commands
+      @@commands ||= {}
+    end
+
+    def self.command_aliases
+      @@command_aliases ||= {}
+    end
+
+    def self.files
+      @@files ||= Hash.new {|hash,key| hash[key] = File.readlines(key).map {|line| line.strip}}
+    end
+
+    def self.namespaces
+      @@namespaces ||= {}
+    end
+
+    def self.register_command(command)
+      commands[command[:command]] = command
+    end
+
+    def self.unregister_commands_made_private_after_the_fact
+      commands.values \
+        .select { |c| c[:klass].private_method_defined? c[:method] } \
+        .each   { |c| commands.delete c[:command] }
+    end
+
+    def self.register_namespace(namespace)
+      namespaces[namespace[:name]] = namespace
+    end
+
+    def self.current_command
+      @current_command
+    end
+
+    def self.current_command=(new_current_command)
+      @current_command = new_current_command
+    end
+
+    def self.current_args
+      @current_args
+    end
+
+    def self.current_options
+      @current_options ||= {}
+    end
+
+    def self.global_options
+      @global_options ||= []
+    end
+
+    def self.invalid_arguments
+      @invalid_arguments
+    end
+
+    def self.shift_argument
+      # dup argument to get a non-frozen string
+      @invalid_arguments.shift.dup rescue nil
+    end
+
+    def self.validate_arguments!
+      unless invalid_arguments.empty?
+        arguments = invalid_arguments.map {|arg| "\"#{arg}\""}
+        if arguments.length == 1
+          message = "Invalid argument: #{arguments.first}"
+        elsif arguments.length > 1
+          message = "Invalid arguments: "
+          message << arguments[0...-1].join(", ")
+          message << " and "
+          message << arguments[-1]
+        end
+        $stderr.puts(format_with_bang(message))
+        run(current_command, ["--help"])
+        exit(1)
+      end
+    end
+
+    def self.warnings
+      @warnings ||= []
+    end
+
+    def self.display_warnings
+      unless warnings.empty?
+        $stderr.puts(warnings.map {|warning| " !    #{warning}"}.join("\n"))
+      end
+    end
+
+    def self.global_option(name, *args, &blk)
+      # args.sort.reverse gives -l, --long order
+      global_options << { :name => name.to_s, :args => args.sort.reverse, :proc => blk }
+    end
+
+    global_option :bot, "-b", "--bot APP" do |bot|
+      raise OptionParser::InvalidOption.new(bot) if bot == "pp"
+    end
+
+    global_option :org, "-o", "--org ORG" do |org|
+      raise OptionParser::InvalidOption.new(org) if org == "rg"
+    end
+    global_option :personal, "-p", "--personal"
+
+    global_option :confirm, "--confirm APP"
+    global_option :help,    "-h", "--help"
+    global_option :remote,  "-r", "--remote REMOTE"
+
+    def self.prepare_run(cmd, args=[])
+      command = parse(cmd)
+
+      if args.include?('-h') || args.include?('--help')
+        args.unshift(cmd) unless cmd =~ /^-.*/
+        cmd = 'help'
+        command = parse(cmd)
+      end
+
+      if cmd == '--version'
+        cmd = 'version'
+        command = parse(cmd)
+      end
+
+      @current_command = cmd
+      @anonymized_args, @normalized_args = [], []
+
+      opts = {}
+      invalid_options = []
+
+      parser = OptionParser.new do |parser|
+        # remove OptionParsers Officious['version'] to avoid conflicts
+        # see: https://github.com/ruby/ruby/blob/trunk/lib/optparse.rb#L814
+        parser.base.long.delete('version')
+        (global_options + (command && command[:options] || [])).each do |option|
+          parser.on(*option[:args]) do |value|
+            if option[:proc]
+              option[:proc].call(value)
+            end
+            opts[option[:name].gsub('-', '_').to_sym] = value
+            ARGV.join(' ') =~ /(#{option[:args].map {|arg| arg.split(' ', 2).first}.join('|')})/
+            @anonymized_args << "#{$1} _"
+            @normalized_args << "#{option[:args].last.split(' ', 2).first} _"
+          end
+        end
+      end
+
+      begin
+        parser.order!(args) do |nonopt|
+          invalid_options << nonopt
+          @anonymized_args << '!'
+          @normalized_args << '!'
+        end
+      rescue OptionParser::InvalidOption => ex
+        invalid_options << ex.args.first
+        @anonymized_args << '!'
+        @normalized_args << '!'
+        retry
+      end
+
+      args.concat(invalid_options)
+
+      @current_args = args
+      @current_options = opts
+      @invalid_arguments = invalid_options
+
+      @anonymous_command = [ARGV.first, *@anonymized_args].join(' ')
+      begin
+        usage_directory = "#{home_directory}/.turbot/usage"
+        FileUtils.mkdir_p(usage_directory)
+        usage_file = usage_directory << "/#{Turbot::VERSION}"
+        usage = if File.exists?(usage_file)
+          json_decode(File.read(usage_file))
+        else
+          {}
+        end
+        usage[@anonymous_command] ||= 0
+        usage[@anonymous_command] += 1
+        File.write(usage_file, json_encode(usage) + "\n")
+      rescue
+        # usage writing is not important, allow failures
+      end
+
+      if command
+        command_instance = command[:klass].new(args.dup, opts.dup)
+
+        if !@normalized_args.include?('--bot _') && (implied_bot = command_instance.bot rescue nil)
+          @normalized_args << '--bot _'
+        end
+        @normalized_command = [ARGV.first, @normalized_args.sort_by {|arg| arg.gsub('-', '')}].join(' ')
+
+        [ command_instance, command[:method] ]
+      else
+        error([
+          "`#{cmd}` is not a turbot command.",
+          suggestion(cmd, commands.keys + command_aliases.keys),
+          "See `turbot help` for a list of available commands."
+        ].compact.join("\n"))
+      end
+    end
+
+    def self.run(cmd, arguments=[])
+      begin
+        object, method = prepare_run(cmd, arguments.dup)
+        object.send(method)
+      rescue Interrupt, StandardError, SystemExit => error
+        # load likely error classes, as they may not be loaded yet due to defered loads
+        require 'rest_client'
+        raise(error)
+      end
+    rescue Turbot::API::Errors::Unauthorized, RestClient::Unauthorized
+      puts "Authentication failure"
+      if ENV['TURBOT_API_KEY']
+        exit 1
+      else
+        run "login"
+        retry
+      end
+    rescue Turbot::API::Errors::VerificationRequired, RestClient::PaymentRequired => e
+      retry if Turbot::Helpers.confirm_billing
+    rescue Turbot::API::Errors::NotFound => e
+      error extract_error(e.response.body) {
+        e.response.body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+      }
+    rescue RestClient::ResourceNotFound => e
+      error extract_error(e.http_body) {
+        e.http_body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+      }
+    rescue Turbot::API::Errors::Locked => e
+      bot = e.response.headers[:x_confirmation_required]
+      if confirm_command(bot, extract_error(e.response.body))
+        arguments << '--confirm' << bot
+        retry
+      end
+    rescue RestClient::Locked => e
+      bot = e.response.headers[:x_confirmation_required]
+      if confirm_command(bot, extract_error(e.http_body))
+        arguments << '--confirm' << bot
+        retry
+      end
+    rescue Turbot::API::Errors::Timeout, RestClient::RequestTimeout
+      error "API request timed out. Please try again, or contact support@turbot.com if this issue persists."
+    rescue Turbot::API::Errors::ErrorWithResponse => e
+      error extract_error(e.response.body)
+    rescue RestClient::RequestFailed => e
+      error extract_error(e.http_body)
+    rescue CommandFailed => e
+      error e.message
+    rescue OptionParser::ParseError
+      commands[cmd] ? run("help", [cmd]) : run("help")
+    rescue Excon::Errors::SocketError, SocketError => e
+      error("Unable to connect to Turbot API, please check internet connectivity and try again.")
+    ensure
+      display_warnings
+    end
+
+    def self.parse(cmd)
+      commands[cmd] || commands[command_aliases[cmd]]
+    end
+
+    def self.extract_error(body, options={})
+      default_error = block_given? ? yield : "Internal server error.\nRun `turbot status` to check for known platform issues."
+      parse_error_xml(body) || parse_error_json(body) || parse_error_plain(body) || default_error
+    end
+
+    def self.parse_error_xml(body)
+      xml_errors = REXML::Document.new(body).elements.to_a("//errors/error")
+      msg = xml_errors.map { |a| a.text }.join(" / ")
+      return msg unless msg.empty?
+    rescue Exception
+    end
+
+    def self.parse_error_json(body)
+      json = json_decode(body.to_s) rescue false
+      case json
+      when Array
+        json.first.join(' ') # message like [['base', 'message']]
+      when Hash
+        json['error'] || json['error_message'] || json['message'] # message like {'error' => 'message'}
+      else
+        nil
+      end
+    end
+
+    def self.parse_error_plain(body)
+      return unless body.respond_to?(:headers) && body.headers[:content_type].to_s.include?("text/plain")
+      body.to_s
+    end
+  end
+end

data/lib/turbot/deprecated/help.rb

@@ -0,0 +1,38 @@
+require "turbot/deprecated"
+
+module Turbot::Deprecated::Help
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  class HelpGroup < Array
+    attr_reader :title
+
+    def initialize(title)
+      @title = title
+    end
+
+    def command(name, description)
+      self << [name, description]
+    end
+
+    def space
+      self << ['', '']
+    end
+  end
+
+  module ClassMethods
+    def groups
+      @groups ||= []
+    end
+
+    def group(title, &block)
+      groups << begin
+        group = HelpGroup.new(title)
+        yield group
+        group
+      end
+    end
+  end
+end
+

data/lib/turbot/deprecated.rb

@@ -0,0 +1,5 @@
+require "turbot"
+
+module Turbot::Deprecated
+end
+

data/lib/turbot/distribution.rb

@@ -0,0 +1,9 @@
+module Turbot
+  module Distribution
+    def self.files
+      Dir[File.expand_path("../../../{bin,data,lib}/**/*", __FILE__)].select do |file|
+        File.file?(file)
+      end
+    end
+  end
+end

data/lib/turbot/errors.rb

@@ -0,0 +1,28 @@
+module Turbot
+  class API
+    module Errors
+      class Error < StandardError; end
+
+      class ErrorWithResponse < Error
+        attr_reader :response
+
+        def initialize(message, response=nil)
+          message = message << "\nbody: #{response.body.inspect}" if response
+          super message
+          @response = response
+        end
+      end
+
+      class Unauthorized < ErrorWithResponse; end
+      class VerificationRequired < ErrorWithResponse; end
+      class Forbidden < ErrorWithResponse; end
+      class NotFound < ErrorWithResponse; end
+      class Timeout < ErrorWithResponse; end
+      class Locked < ErrorWithResponse; end
+      class RateLimitExceeded < ErrorWithResponse; end
+      class RequestFailed < ErrorWithResponse; end
+      class NilApp < ErrorWithResponse; end
+      class MissingManifest < ErrorWithResponse; end
+    end
+  end
+end

data/lib/turbot/excon.rb

@@ -0,0 +1,11 @@
+module Excon
+
+  def self.get_with_redirect(url, options={})
+    res = Excon.get(url, options)
+    if [301, 302].include?(res.status)
+      return self.get_with_redirect(res.headers["Location"], options)
+    end
+    res
+  end
+
+end

data/lib/turbot/helpers/log_displayer.rb

@@ -0,0 +1,70 @@
+require "turbot/helpers"
+
+module Turbot::Helpers
+  class LogDisplayer
+
+    include Turbot::Helpers
+
+    attr_reader :api, :bot, :opts
+
+    def initialize(api, bot, opts)
+      @api, @bot, @opts = api, bot, opts
+    end
+
+    def display_logs
+      @assigned_colors = {}
+      @line_start = true
+      @token = nil
+
+      api.read_logs(bot, opts).each do |chunk|
+        unless chunk.empty?
+          if STDOUT.isatty && ENV.has_key?("TERM")
+            display(colorize(chunk))
+          else
+            display(chunk)
+          end
+        end
+      end
+    rescue Errno::EPIPE
+    rescue Interrupt => interrupt
+      if STDOUT.isatty && ENV.has_key?("TERM")
+        display("\e[0m")
+      end
+      raise(interrupt)
+    end
+
+    COLORS = %w( cyan yellow green magenta red )
+    COLOR_CODES = {
+      "red"     => 31,
+      "green"   => 32,
+      "yellow"  => 33,
+      "magenta" => 35,
+      "cyan"    => 36,
+    }
+
+    def colorize(chunk)
+      lines = []
+      chunk.split("\n").map do |line|
+        if parsed_line = parse_log(line)
+          header, identifier, body = parsed_line
+          @assigned_colors[identifier] ||= COLORS[@assigned_colors.size % COLORS.size]
+          lines << [
+            "\e[#{COLOR_CODES[@assigned_colors[identifier]]}m",
+            header,
+            "\e[0m",
+            body,
+          ].join("")
+        elsif not line.empty?
+          lines << line
+        end
+      end
+      lines.join("\n")
+    end
+
+    def parse_log(log)
+      return unless parsed = log.match(/^(.*?\[([\w-]+)([\d\.]+)?\]:)(.*)?$/)
+      [1, 2, 4].map { |i| parsed[i] }
+    end
+
+  end
+end

data/lib/turbot/helpers/pg_dump_restore.rb

@@ -0,0 +1,115 @@
+require 'uri'
+class PgDumpRestore
+  attr_reader :command
+
+  def initialize(source, target, command)
+    @source = URI.parse(source)
+    @target = URI.parse(target)
+    @command = command
+
+    fill_in_shorthand_uris!
+  end
+
+  def execute
+    prepare
+    run
+    verify
+  end
+
+  def prepare
+    if @target.host == 'localhost'
+      create_local_db
+    else
+      ensure_remote_db_empty
+    end
+  end
+
+  def verify
+    verify_extensions_match
+  end
+
+  def dump_restore_cmd
+    pg_restore = gen_pg_restore_command(@target)
+    pg_dump = gen_pg_dump_command(@source)
+    "#{pg_dump} | #{pg_restore}"
+  end
+
+  private
+
+  def create_local_db
+    dbname = @target.path[1..-1]
+    cdb_output = `createdb #{dbname} 2>&1`
+    if $?.exitstatus != 0
+      if cdb_output =~ /already exists/
+        command.error(cdb_output + "\nPlease drop the local database (`dropdb #{dbname}`) and try again.")
+      else
+        command.error(cdb_output + "\nUnable to create new local database. Ensure your local Postgres is working and try again.")
+      end
+    end
+  end
+
+  def ensure_remote_db_empty
+    sql = 'select count(*) = 0 from pg_stat_user_tables;'
+    result = exec_sql_on_uri(sql, @target)
+    unless result == " ?column? \n----------\n t\n(1 row)\n\n"
+      command.error("Remote database is not empty.\nPlease create a new database, or use `turbot pg:reset`")
+    end
+  end
+
+  def gen_pg_dump_command(uri)
+    # It is occasionally necessary to override PGSSLMODE, as when the server
+    # wasn't built to support SSL.
+    %{ env PGPASSWORD=#{uri.password} PGSSLMODE=prefer pg_dump --verbose -F c -Z 0 #{connstring(uri, :skip_d_flag)} }
+  end
+
+  def gen_pg_restore_command(uri)
+    %{ env PGPASSWORD=#{uri.password} pg_restore --verbose --no-acl --no-owner #{connstring(uri)} }
+  end
+
+  def connstring(uri, skip_d_flag=false)
+    database = uri.path[1..-1]
+    user = uri.user ? "-U #{uri.user}" : ""
+    %Q{#{user} -h #{uri.host} -p #{uri.port} #{skip_d_flag ? '' : '-d'} #{database} }
+  end
+
+  def fill_in_shorthand_uris!
+    [@target, @source].each do |uri|
+      uri.host ||= 'localhost'
+      uri.port ||= Integer(ENV['PGPORT'] || 5432)
+    end
+  end
+
+  def verify_extensions_match
+    # It's pretty common for local DBs to not have extensions available that
+    # are used by the remote bot, so take the final precaution of warning if
+    # the extensions available in the local database don't match. We don't
+    # report it if the difference is solely in the version of an extension
+    # used, though.
+    ext_sql = "SELECT extname FROM pg_extension ORDER BY extname;"
+    target_exts = exec_sql_on_uri(ext_sql, @target)
+    source_exts = exec_sql_on_uri(ext_sql, @source)
+    if target_exts != source_exts
+      command.error <<-EOM
+WARNING: Extensions in newly created target database differ from existing source database.
+
+Target extensions:
+#{target_exts}
+Source extensions:
+#{source_exts}
+HINT: You should review output to ensure that any errors
+ignored are acceptable - entire tables may have been missed, where a dependency
+could not be resolved. You may need to to install a postgresql-contrib package
+and retry.
+EOM
+    end
+  end
+
+  def exec_sql_on_uri(sql, uri)
+    command.send(:exec_sql_on_uri, sql, uri)
+  end
+
+  def run
+    system dump_restore_cmd
+  end
+end
+