pebblescape 0.0.1

data/lib/pebbles/auth.rb

@@ -0,0 +1,302 @@
+require "cgi"
+require "netrc"
+require "pebbles"
+require "pebbles/api"
+require "pebbles/helpers"
+
+class Pebbles::Auth
+  class << self
+    include Pebbles::Helpers
+
+    attr_accessor :credentials
+
+    def api
+      @api ||= begin
+        debug "Using API with key: #{password[0,6]}..."
+        Pebbles::API.new(default_params.merge(:api_key => password))
+      end
+    end
+
+    def login
+      delete_credentials
+      get_credentials
+    end
+
+    def logout
+      delete_credentials
+    end
+
+    # just a stub; will raise if not authenticated
+    def check
+      api.get_user
+    end
+
+    def default_host
+      "pebblesinspace.com"
+    end
+
+    def http_git_host
+      ENV['PEBBLES_HTTP_GIT_HOST'] || "git.#{host}"
+    end
+
+    def git_host
+      ENV['PEBBLES_GIT_HOST'] || host
+    end
+
+    def host
+      ENV['PEBBLES_HOST'] || default_host
+    end
+
+    def subdomains
+      %w(api git)
+    end
+
+    def reauthorize
+      @credentials = ask_for_and_save_credentials
+    end
+
+    def user    # :nodoc:
+      get_credentials[0]
+    end
+
+    def password    # :nodoc:
+      get_credentials[1]
+    end
+
+    def api_key(user=get_credentials[0], password=get_credentials[1])
+      @api ||= Pebbles::API.new(default_params)
+      api_key = @api.post_login(user, password).body["api_key"]
+      @api = nil
+      api_key
+    end
+
+    def get_credentials    # :nodoc:
+      @credentials ||= (read_credentials || ask_for_and_save_credentials)
+    end
+
+    def delete_credentials
+      return 
+      if netrc
+        subdomains.each do |sub|
+          netrc.delete("#{sub}.#{host}")
+        end
+        netrc.save
+      end
+      @api, @credentials = nil, nil
+    end
+
+    def netrc_path
+      default = Netrc.default_path
+      encrypted = default + ".gpg"
+      if File.exists?(encrypted)
+        encrypted
+      else
+        default
+      end
+    end
+
+    def netrc   # :nodoc:
+      @netrc ||= begin
+        File.exists?(netrc_path) && Netrc.read(netrc_path)
+      rescue => error
+        case error.message
+        when /^Permission bits for/
+          abort("#{error.message}.\nYou should run `chmod 0600 #{netrc_path}` so that your credentials are NOT accessible by others.")
+        when /EACCES/
+          error("Error reading #{netrc_path}\n#{error.message}\nMake sure this user can read/write this file.")
+        else
+          error("Error reading #{netrc_path}\n#{error.message}\nYou may need to delete this file and run `pebbles login` to recreate it.")
+        end
+      end
+    end
+
+    def read_credentials
+      if ENV['PEBBLES_API_KEY']
+        ['', ENV['PEBBLES_API_KEY']]
+      else
+        # read netrc credentials if they exist
+        if netrc
+          netrc["api.#{host}"]
+        end
+      end
+    end
+
+    def write_credentials
+      FileUtils.mkdir_p(File.dirname(netrc_path))
+      FileUtils.touch(netrc_path)
+      unless running_on_windows?
+        FileUtils.chmod(0600, netrc_path)
+      end
+      subdomains.each do |sub|
+        netrc["#{sub}.#{host}"] = self.credentials
+      end
+      netrc.save
+    end
+
+    def echo_off
+      with_tty do
+        system "stty -echo"
+      end
+    end
+
+    def echo_on
+      with_tty do
+        system "stty echo"
+      end
+    end
+
+    def ask_for_credentials
+      puts "Enter your Pebblescape credentials."
+
+      print "Email: "
+      user = ask
+
+      print "Password (typing will be hidden): "
+      password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
+      [user, api_key(user, password)]
+    end
+
+    def ask_for_password_on_windows
+      require "Win32API"
+      char = nil
+      password = ''
+
+      while char = Win32API.new("crtdll", "_getch", [ ], "L").Call do
+        break if char == 10 || char == 13 # received carriage return or newline
+        if char == 127 || char == 8 # backspace and delete
+          password.slice!(-1, 1)
+        else
+          # windows might throw a -1 at us so make sure to handle RangeError
+          (password << char.chr) rescue RangeError
+        end
+      end
+      puts
+      return password
+    end
+
+    def ask_for_password
+      begin
+        echo_off
+        password = ask
+        puts
+      ensure
+        echo_on
+      end
+      return password
+    end
+
+    def ask_for_and_save_credentials
+      @credentials = ask_for_credentials
+      debug "Logged in as #{@credentials[0]} with key: #{@credentials[1][0,6]}..."
+      write_credentials
+      check
+      @credentials
+    rescue Pebbles::API::Errors::Unauthorized => e
+      delete_credentials
+      display "Authentication failed."
+      warn "WARNING: PEBBLES_API_KEY is set to an invalid key." if ENV['PEBBLES_API_KEY']
+      retry if retry_login?
+      exit 1
+    rescue => e
+      delete_credentials
+      raise e
+    end
+
+    def associate_or_generate_ssh_key
+      unless File.exists?("#{home_directory}/.ssh/id_rsa.pub")
+        display "Could not find an existing public key at ~/.ssh/id_rsa.pub"
+        display "Would you like to generate one? [Yn] ", false
+        unless ask.strip.downcase =~ /^n/
+          display "Generating new SSH public key."
+          generate_ssh_key("#{home_directory}/.ssh/id_rsa")
+          associate_key("#{home_directory}/.ssh/id_rsa.pub")
+          return
+        end
+      end
+
+      chosen = ssh_prompt
+      associate_key(chosen) if chosen
+    end
+
+    def ssh_prompt
+      public_keys = Dir.glob("#{home_directory}/.ssh/*.pub").sort
+      case public_keys.length
+      when 0
+        error("No SSH keys found")
+        return nil
+      when 1
+        display "Found an SSH public key at #{public_keys.first}"
+        display "Would you like to upload it to Pebblescape? [Yn] ", false
+        return ask.strip.downcase =~ /^n/ ? nil : public_keys.first
+      else
+        display "Found the following SSH public keys:"
+        public_keys.each_with_index do |key, index|
+          display "#{index+1}) #{File.basename(key)}"
+        end
+        display "Which would you like to use with your Pebblescape account? ", false
+        choice = ask.to_i - 1
+        chosen = public_keys[choice]
+        if choice == -1 || chosen.nil?
+          error("Invalid choice")
+        end
+        return chosen
+      end
+    end
+
+    def generate_ssh_key(keyfile)
+      ssh_dir = File.dirname(keyfile)
+      FileUtils.mkdir_p ssh_dir, :mode => 0700
+      output = `ssh-keygen -t rsa -N "" -f \"#{keyfile}\" 2>&1`
+      if ! $?.success?
+        error("Could not generate key: #{output}")
+      end
+    end
+
+    def associate_key(key)
+      action("Uploading SSH public key #{key}") do
+        if File.exists?(key)
+          api.post_key(File.read(key))
+        else
+          error("Could not upload SSH public key: key file '" + key + "' does not exist")
+        end
+      end
+    end
+
+    def retry_login?
+      @login_attempts ||= 0
+      @login_attempts += 1
+      @login_attempts < 3
+    end
+
+    def base_host(host)
+      parts = URI.parse(full_host(host)).host.split(".")
+      return parts.first if parts.size == 1
+      parts[-2..-1].join(".")
+    end
+
+    def full_host(host)
+      scheme = debugging? ? 'http' : 'https'
+      (host =~ /^http/) ? host : "#{scheme}://api.#{host}"
+    end
+
+    def verify_host?(host)
+      return false if ENV["PEBBLES_SSL_VERIFY"] == "disable"
+      base_host(host) == "pebblesinspace.com"
+    end
+
+    protected
+
+    def default_params
+      uri = URI.parse(full_host(host))
+      params = {
+        :headers          => {'User-Agent' => Pebbles.user_agent},
+        :host             => uri.host,
+        :port             => uri.port.to_s,
+        :scheme           => uri.scheme,
+        :ssl_verify_peer  => verify_host?(host)
+      }
+
+      params
+    end
+  end
+end

data/lib/pebbles/cli.rb

@@ -0,0 +1,35 @@
+require 'pebbles'
+require 'pebbles/command'
+require 'pebbles/git'
+require 'pebbles/helpers'
+require 'excon'
+
+class Pebbles::CLI
+  extend Pebbles::Helpers
+
+  def self.start(*args)
+    $stdin.sync = true if $stdin.isatty
+    $stdout.sync = true if $stdout.isatty
+    Pebbles::Git.check_git_version
+    command = args.shift.strip rescue "help"
+    Pebbles::Command.load
+    Pebbles::Command.run(command, args)
+  rescue Errno::EPIPE => e
+    error(e.message)
+  rescue Interrupt => e
+    `stty icanon echo`
+    if ENV["PEBBLES_DEBUG"]
+      styled_error(e)
+    else
+      error("Command cancelled.", false)
+    end
+  rescue => error
+    if ENV["PEBBLES_DEBUG"]
+      raise
+    else
+      styled_error(error)
+    end
+    exit(1)
+  end
+
+end

data/lib/pebbles/command.rb

@@ -0,0 +1,256 @@
+require 'pebbles/helpers'
+require 'pebbles/version'
+require "optparse"
+
+module Pebbles
+  module Command
+    class CommandFailed  < RuntimeError; end
+
+    extend Pebbles::Helpers
+
+    def self.load
+      Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do |file|
+        require file
+      end
+      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.uniq.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 :app, "-a", "--app APP" do |app|
+      raise OptionParser::InvalidOption.new(app) if app == "api" || app == "git"
+    end
+    
+    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
+      @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('|')})/
+            @normalized_args << "#{option[:args].last.split(' ', 2).first} _"
+          end
+        end
+      end
+
+      begin
+        parser.order!(args) do |nonopt|
+          invalid_options << nonopt
+          @normalized_args << '!'
+        end
+      rescue OptionParser::InvalidOption => ex
+        invalid_options << ex.args.first
+        @normalized_args << '!'
+        retry
+      end
+
+      args.concat(invalid_options)
+
+      @current_args = args
+      @current_options = opts
+      @invalid_arguments = invalid_options
+
+      if command
+        command_instance = command[:klass].new(args.dup, opts.dup)
+
+        if !@normalized_args.include?('--app _') && (implied_app = command_instance.app rescue nil)
+          @normalized_args << '--app _'
+        end
+        @normalized_command = [ARGV.first, @normalized_args.sort_by {|arg| arg.gsub('-', '')}].join(' ')
+
+        [ command_instance, command[:method] ]
+      else
+        error([
+          "`#{cmd}` is not a pebbles command.",
+          "See `pebbles help` for a list of available commands."
+        ].compact.join("\n"))
+      end
+    end
+
+    def self.run(cmd, arguments=[])
+      object, method = prepare_run(cmd, arguments.dup)
+      object.send(method)
+    rescue Pebbles::API::Errors::Unauthorized => e
+      retry_login = handle_auth_error(e)
+      retry if retry_login
+    rescue Pebbles::API::Errors::NotFound => e
+      error extract_error(e.response.body) {
+        e.response.body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+      }
+    rescue Pebbles::API::Errors::Locked => e
+      app = e.response.headers[:x_confirmation_required]
+      if confirm_command(app, extract_error(e.response.body))
+        arguments << '--confirm' << app
+        retry
+      end
+    rescue Pebbles::API::Errors::Timeout
+      error "API request timed out. Please try again."
+    rescue Pebbles::API::Errors::Forbidden => e
+      error extract_error(e.response.body)
+    rescue Pebbles::API::Errors::ErrorWithResponse => e
+      error extract_error(e.response.body)
+    rescue CommandFailed => e
+      error e.message, false
+    rescue OptionParser::ParseError
+      commands[cmd] ? run("help", [cmd]) : run("help")
+    rescue Excon::Errors::SocketError, SocketError => e
+      error("Unable to connect to Pebblescape API, please check internet connectivity and try again.")
+    ensure
+      display_warnings
+    end
+
+    def self.handle_auth_error(e)
+      if ENV['PEBBLES_API_KEY']
+        puts "Authentication failure with PEBBLES_API_KEY"
+        exit 1
+      else
+        puts "Authentication failure"
+        run "login"
+        true
+      end
+    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."
+      parse_error_json(body) || parse_error_plain(body) || default_error
+    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