nimbu 0.1

data/lib/nimbu/client/rendezvous.rb

@@ -0,0 +1,76 @@
+require "timeout"
+require "socket"
+require "uri"
+require "nimbu/client"
+require "nimbu/helpers"
+
+class Nimbu::Client::Rendezvous
+  attr_reader :rendezvous_url, :connect_timeout, :activity_timeout, :input, :output, :on_connect
+
+  def initialize(opts)
+    @rendezvous_url = opts[:rendezvous_url]
+    @connect_timeout = opts[:connect_timeout]
+    @activity_timeout = opts[:activity_timeout]
+    @input = opts[:input]
+    @output = opts[:output]
+  end
+
+  def on_connect(&blk)
+    @on_connect = blk if block_given?
+    @on_connect
+  end
+
+  def start
+    uri = URI.parse(rendezvous_url)
+    host, port, secret = uri.host, uri.port, uri.path[1..-1]
+
+    ssl_socket = Timeout.timeout(connect_timeout) do
+      ssl_context = OpenSSL::SSL::SSLContext.new
+      if ((host =~ /nimbu\.com$/) && !(ENV["HEROKU_SSL_VERIFY"] == "disable"))
+        ssl_context.ca_file = File.expand_path("../../../../data/cacert.pem", __FILE__)
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+      tcp_socket = TCPSocket.open(host, port)
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+      ssl_socket.connect
+      ssl_socket.puts(secret)
+      ssl_socket.readline
+      ssl_socket
+    end
+
+    on_connect.call if on_connect
+
+    readables = [input, ssl_socket].compact
+
+    begin
+      loop do
+        if o = IO.select(readables, nil, nil, activity_timeout)
+          if (input && (o.first.first == input))
+            begin
+              data = input.readpartial(10000)
+            rescue EOFError
+              readables.delete(input)
+              next
+            end
+            ssl_socket.write(data)
+            ssl_socket.flush
+          elsif (o.first.first == ssl_socket)
+            begin
+              data = ssl_socket.readpartial(10000)
+            rescue EOFError
+              break
+            end
+            output.write(data)
+          end
+        else
+          raise(Timeout::Error.new)
+        end
+      end
+    rescue Interrupt
+      ssl_socket.write("\003")
+      ssl_socket.flush
+      retry
+    rescue Errno::EIO
+    end
+  end
+end

data/lib/nimbu/command.rb

@@ -0,0 +1,189 @@
+require 'nimbu/helpers'
+require 'nimbu/version'
+require "optparse"
+
+module Nimbu
+  module Command
+    class CommandFailed  < RuntimeError; end
+
+    extend Nimbu::Helpers
+
+    def self.load
+      Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do |file|
+        require file
+      end
+    end
+
+    def self.commands
+      @@commands ||= {}
+    end
+
+    def self.command_aliases
+      @@command_aliases ||= {}
+    end
+
+    def self.namespaces
+      @@namespaces ||= {}
+    end
+
+    def self.register_command(command)
+      commands[command[:command]] = command
+    end
+
+    def self.register_namespace(namespace)
+      namespaces[namespace[:name]] = namespace
+    end
+
+    def self.current_command
+      @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.global_option(name, *args)
+      global_options << { :name => name, :args => args }
+    end
+
+    global_option :app,     "--app APP", "-a"
+    global_option :confirm, "--confirm APP"
+    global_option :help,    "--help", "-h"
+    global_option :remote,  "--remote REMOTE"
+
+    def self.prepare_run(cmd, args=[])
+      command = parse(cmd)
+
+      unless command
+        if %w( -v --version ).include?(cmd)
+          display Nimbu::VERSION
+          exit
+        end
+
+        output_with_bang("`#{cmd}` is not a nimbu command.")
+
+        distances = {}
+        (commands.keys + command_aliases.keys).each do |suggestion|
+          distance = string_distance(cmd, suggestion)
+          distances[distance] ||= []
+          distances[distance] << suggestion
+        end
+
+        if distances.keys.min < 4
+          suggestions = distances[distances.keys.min].sort
+          if suggestions.length == 1
+            output_with_bang("Perhaps you meant `#{suggestions.first}`.")
+          else
+            output_with_bang("Perhaps you meant #{suggestions[0...-1].map {|suggestion| "`#{suggestion}`"}.join(', ')} or `#{suggestions.last}`.")
+          end
+        end
+
+        output_with_bang("See `nimbu help` for additional details.")
+        exit(1)
+      end
+
+      @current_command = cmd
+
+      opts = {}
+      invalid_options = []
+
+      parser = OptionParser.new do |parser|
+        global_options.each do |global_option|
+          parser.on(*global_option[:args]) do |value|
+            opts[global_option[:name]] = value
+          end
+        end
+        command[:options].each do |name, option|
+          parser.on("-#{option[:short]}", "--#{option[:long]}", option[:desc]) do |value|
+            opts[name.gsub("-", "_").to_sym] = value
+          end
+        end
+      end
+
+      begin
+        parser.order!(args) do |nonopt|
+          invalid_options << nonopt
+        end
+      rescue OptionParser::InvalidOption => ex
+        invalid_options << ex.args.first
+        retry
+      end
+
+      raise OptionParser::ParseError if opts[:help]
+
+      args.concat(invalid_options)
+
+      @current_args = args
+      @current_options = opts
+
+      [ command[:klass].new(args.dup, opts.dup), command[:method] ]
+    end
+
+    def self.run(cmd, arguments=[])
+      object, method = prepare_run(cmd, arguments.dup)
+      object.send(method)
+    rescue RestClient::Unauthorized
+      puts "Authentication failure"
+      unless ENV['HEROKU_API_KEY'] 
+        run "login"
+        retry
+      end
+    rescue RestClient::PaymentRequired => e
+      retry if run('account:confirm_billing', arguments.dup)
+    rescue RestClient::ResourceNotFound => e
+      error extract_error(e.http_body) {
+        e.http_body =~ /^[\w\s]+ not found$/ ? e.http_body : "Resource not found"
+      }
+    rescue RestClient::Locked => e
+      app = e.response.headers[:x_confirmation_required]
+      if confirm_command(app, extract_error(e.response.body))
+        arguments << '--confirm' << app
+        retry
+      end
+    rescue RestClient::RequestFailed => e
+      error extract_error(e.http_body)
+    rescue RestClient::RequestTimeout
+      error "API request timed out. Please try again, or contact support@nimbu.com if this issue persists."
+    rescue CommandFailed => e
+      error e.message
+    rescue OptionParser::ParseError => ex
+      commands[cmd] ? run("help", [cmd]) : run("help")
+    rescue Interrupt => e
+      error "\n[canceled]"
+    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 'nimbu 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
+      json ? json['error'] : nil
+    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/nimbu/command/auth.rb

@@ -0,0 +1,38 @@
+require "nimbu/command/base"
+
+# authentication (login, logout)
+#
+class Nimbu::Command::Auth < Nimbu::Command::Base
+
+  # auth:login
+  #
+  # log in with your nimbu credentials
+  #
+  def login
+    Nimbu::Auth.login
+    display "Authentication successful."
+  end
+
+  alias_command "login", "auth:login"
+
+  # auth:logout
+  #
+  # clear local authentication credentials
+  #
+  def logout
+    Nimbu::Auth.logout
+    display "Local credentials cleared."
+  end
+
+  alias_command "logout", "auth:logout"
+
+  # auth:token
+  #
+  # display your api token
+  #
+  def token
+    display Nimbu::Auth.api_key
+  end
+
+end
+

data/lib/nimbu/command/base.rb

@@ -0,0 +1,212 @@
+require "fileutils"
+require "nimbu/auth"
+require "nimbu/client/rendezvous"
+require "nimbu/command"
+
+class Nimbu::Command::Base
+  include Nimbu::Helpers
+
+  def self.namespace
+    self.to_s.split("::").last.downcase
+  end
+
+  attr_reader :args
+  attr_reader :options
+
+  def initialize(args=[], options={})
+    @args = args
+    @options = options
+  end
+
+  def app
+    @app ||= if options[:app].is_a?(String)
+      if confirm_mismatch?
+        raise Nimbu::Command::CommandFailed, "Mismatch between --app and --confirm"
+      end
+      options[:app]
+    elsif options[:confirm].is_a?(String)
+      options[:confirm]
+    elsif app_from_dir = extract_app_in_dir(Dir.pwd)
+      app_from_dir
+    else
+      raise Nimbu::Command::CommandFailed, "No app specified.\nRun this command from an app folder or specify which app to use with --app <app name>"
+    end
+  end
+
+
+  def nimbu
+    Nimbu::Auth.client
+  end
+
+protected
+
+  def self.inherited(klass)
+    return if klass == Nimbu::Command::Base
+
+    help = extract_help_from_caller(caller.first)
+
+    Nimbu::Command.register_namespace(
+      :name => klass.namespace,
+      :description => help.split("\n").first
+    )
+  end
+
+  def self.method_added(method)
+    return if self == Nimbu::Command::Base
+    return if private_method_defined?(method)
+    return if protected_method_defined?(method)
+
+    help = extract_help_from_caller(caller.first)
+    resolved_method = (method.to_s == "index") ? nil : method.to_s
+    command = [ self.namespace, resolved_method ].compact.join(":")
+    banner = extract_banner(help) || command
+    permute = !banner.index("*")
+    banner.gsub!("*", "")
+
+    Nimbu::Command.register_command(
+      :klass       => self,
+      :method      => method,
+      :namespace   => self.namespace,
+      :command     => command,
+      :banner      => banner,
+      :help        => help,
+      :summary     => extract_summary(help),
+      :description => extract_description(help),
+      :options     => extract_options(help),
+      :permute     => permute
+    )
+  end
+
+  def self.alias_command(new, old)
+    raise "no such command: #{old}" unless Nimbu::Command.commands[old]
+    Nimbu::Command.command_aliases[new] = old
+  end
+
+  def extract_app
+    output_with_bang "Command::Base#extract_app has been deprecated. Please use Command::Base#app instead.  #{caller.first}"
+    app
+  end
+
+  #
+  # Parse the caller format and identify the file and line number as identified
+  # in : http://www.ruby-doc.org/core/classes/Kernel.html#M001397.  This will
+  # look for a colon followed by a digit as the delimiter.  The biggest
+  # complication is windows paths, which have a color after the drive letter.
+  # This regex will match paths as anything from the beginning to a colon
+  # directly followed by a number (the line number).
+  #
+  # Examples of the caller format :
+  # * c:/Ruby192/lib/.../lib/nimbu/command/addons.rb:8:in `<module:Command>'
+  # * c:/Ruby192/lib/.../nimbu-2.0.1/lib/nimbu/command/pg.rb:96:in `<class:Pg>'
+  # * /Users/ph7/...../xray-1.1/lib/xray/thread_dump_signal_handler.rb:9
+  #
+  def self.extract_help_from_caller(line)
+    # pull out of the caller the information for the file path and line number
+    if line =~ /^(.+?):(\d+)/
+      return extract_help($1, $2)
+    end
+    raise "unable to extract help from caller: #{line}"
+  end
+
+  def self.extract_help(file, line)
+    buffer = []
+    lines  = File.read(file).split("\n")
+
+    catch(:done) do
+      (line.to_i-2).downto(0) do |i|
+        case lines[i].strip[0..0]
+          when "", "#" then buffer << lines[i]
+          else throw(:done)
+        end
+      end
+    end
+
+    buffer.map! do |line|
+      line.strip.gsub(/^#/, "")
+    end
+
+    buffer.reverse.join("\n").strip
+  end
+
+  def self.extract_banner(help)
+    help.split("\n").first
+  end
+
+  def self.extract_summary(help)
+    extract_description(help).split("\n").first
+  end
+
+  def self.extract_description(help)
+    lines = help.split("\n").map { |l| l.strip }
+    lines.shift
+    lines.reject do |line|
+      line =~ /^-(.+)#(.+)/
+    end.join("\n").strip
+  end
+
+  def self.extract_options(help)
+    help.split("\n").map { |l| l.strip }.select do |line|
+      line =~ /^-(.+)#(.+)/
+    end.inject({}) do |hash, line|
+      description = line.split("#", 2).last.strip
+      long  = line.match(/--([A-Za-z\- ]+)/)[1].strip
+      short = line.match(/-([A-Za-z ])/)[1].strip
+      hash.update(long.split(" ").first => { :desc => description, :short => short, :long => long })
+    end
+  end
+
+  def extract_option(name, default=true)
+    key = name.gsub("--", "").to_sym
+    return unless options[key]
+    value = options[key] || default
+    block_given? ? yield(value) : value
+  end
+
+  def confirm_mismatch?
+    options[:confirm] && (options[:confirm] != options[:app])
+  end
+
+  def extract_app_in_dir(dir)
+    return unless remotes = git_remotes(dir)
+
+    if remote = options[:remote]
+      remotes[remote]
+    elsif remote = extract_app_from_git_config
+      remotes[remote]
+    else
+      apps = remotes.values.uniq
+      return apps.first if apps.size == 1
+    end
+  end
+
+  def extract_app_from_git_config
+    remote = git("config nimbu.remote")
+    remote == "" ? nil : remote
+  end
+
+  def git_remotes(base_dir=Dir.pwd)
+    remotes = {}
+    original_dir = Dir.pwd
+    Dir.chdir(base_dir)
+
+    git("remote -v").split("\n").each do |remote|
+      name, url, method = remote.split(/\s/)
+      if url =~ /^git@#{nimbu.host}:([\w\d-]+)\.git$/
+        remotes[name] = $1
+      end
+    end
+
+    Dir.chdir(original_dir)
+    remotes
+  end
+
+  def escape(value)
+    nimbu.escape(value)
+  end
+end
+
+module Nimbu::Command
+  unless const_defined?(:BaseWithApp)
+    BaseWithApp = Base
+  end
+end