af 0.3.13.beta.5 → 0.3.16.1

data/lib/cli/commands/user.rb

@@ -15,6 +15,7 @@ module VMC::Cli::Command
       tries ||= 0
 
       unless no_prompt
+        display "Attempting login to [#{target_url}]" if target_url
         email ||= ask("Email")
         password ||= ask("Password", :echo => "*")
       end
@@ -24,11 +25,11 @@ module VMC::Cli::Command
       login_and_save_token(email, password)
       say "Successfully logged into [#{target_url}]".green
     rescue VMC::Client::TargetError
-      display "Problem with login, invalid account or password.".red
+      display "Problem with login, invalid account or password when attempting to login to '#{target_url}'".red
       retry if (tries += 1) < 3 && prompt_ok && !@options[:password]
       exit 1
     rescue => e
-      display "Problem with login, #{e}, try again or register for an account.".red
+      display "Problem with login to '#{target_url}', #{e}, try again or register for an account.".red
       exit 1
     end
 
@@ -56,7 +57,7 @@ module VMC::Cli::Command
 
     def login_and_save_token(email, password)
       token = client.login(email, password)
-      VMC::Cli::Config.store_token(token)
+      VMC::Cli::Config.store_token(token, @options[:token_file])
     end
 
   end

data/lib/cli/config.rb

@@ -7,13 +7,16 @@ require 'json/pure'
 module VMC::Cli
   class Config
 
-    DEFAULT_TARGET  = 'api.aws.af.cm'
-    DEFAULT_SUGGEST = 'aws.af.cm'
+    DEFAULT_TARGET  = 'api.appfog.com'
 
     TARGET_FILE    = '~/.af_target'
     TOKEN_FILE     = '~/.af_token'
     INSTANCES_FILE = '~/.af_instances'
     ALIASES_FILE   = '~/.af_aliases'
+    CLIENTS_FILE   = '~/.af_clients'
+    MICRO_FILE     = '~/.af_micro'
+
+    STOCK_CLIENTS = File.expand_path("../../../config/clients.yml", __FILE__)
 
     class << self
       attr_accessor :colorize
@@ -25,23 +28,21 @@ module VMC::Cli
         return @target_url if @target_url
         target_file = File.expand_path(TARGET_FILE)
         if File.exists? target_file
-          @target_url = lock_and_read(target_file).strip!
-          ha = @target_url.split('.')
-          ha.shift
-          @suggest_url = ha.join('.')
-          @suggest_url = DEFAULT_SUGGEST if @suggest_url.empty?
+          @target_url = lock_and_read(target_file).strip
         else
           @target_url  = DEFAULT_TARGET
-          @suggest_url = DEFAULT_SUGGEST
         end
         @target_url = "http://#{@target_url}" unless /^https?/ =~ @target_url
         @target_url = @target_url.gsub(/\/+$/, '')
         @target_url
       end
 
+      def base_of(url)
+        url.sub(/^[^\.]+\./, "")
+      end
+
       def suggest_url
-        target_url
-        @suggest_url
+        @suggest_url ||= "aws.af.cm"
       end
 
       def store_target(target_host)
@@ -49,8 +50,8 @@ module VMC::Cli
         lock_and_write(target_file, target_host)
       end
 
-      def all_tokens
-        token_file = File.expand_path(TOKEN_FILE)
+      def all_tokens(token_file_path=nil)
+        token_file = File.expand_path(token_file_path || TOKEN_FILE)
         return nil unless File.exists? token_file
         contents = lock_and_read(token_file).strip
         JSON.parse(contents)
@@ -58,9 +59,9 @@ module VMC::Cli
 
       alias :targets :all_tokens
 
-      def auth_token
+      def auth_token(token_file_path=nil)
         return @token if @token
-        tokens = all_tokens
+        tokens = all_tokens(token_file_path)
         @token = tokens[target_url] if tokens
       end
 
@@ -68,10 +69,10 @@ module VMC::Cli
         FileUtils.rm_f(File.expand_path(TOKEN_FILE))
       end
 
-      def store_token(token)
-        tokens = all_tokens || {}
+      def store_token(token, token_file_path=nil)
+        tokens = all_tokens(token_file_path) || {}
         tokens[target_url] = token
-        token_file = File.expand_path(TOKEN_FILE)
+        token_file = File.expand_path(token_file_path || TOKEN_FILE)
         lock_and_write(token_file, tokens.to_json)
       end
 
@@ -102,9 +103,50 @@ module VMC::Cli
         File.open(aliases_file, 'wb') {|f| f.write(aliases.to_yaml)}
       end
 
+      def micro
+        micro_file = File.expand_path(MICRO_FILE)
+        return {} unless File.exists? micro_file
+        contents = lock_and_read(micro_file).strip
+        JSON.parse(contents)
+      end
+
+      def store_micro(micro)
+        micro_file = File.expand_path(MICRO_FILE)
+        lock_and_write(micro_file, micro.to_json)
+      end
+
+      def deep_merge(a, b)
+        merge = proc do |_, old, new|
+          if new.is_a?(Hash) and old.is_a?(Hash)
+            old.merge(new, &merge)
+          else
+            new
+          end
+        end
+
+        a.merge(b, &merge)
+      end
+
+      def clients
+        return @clients if @clients
+
+        stock = YAML.load_file(STOCK_CLIENTS)
+        clients = File.expand_path CLIENTS_FILE
+        if File.exists? clients
+          user = YAML.load_file(clients)
+          @clients = deep_merge(stock, user)
+        else
+          @clients = stock
+        end
+      end
+
       def lock_and_read(file)
-        File.open(file, "r") {|f|
-          f.flock(File::LOCK_EX)
+        File.open(file, File::RDONLY) {|f|
+          if defined? JRUBY_VERSION
+            f.flock(File::LOCK_SH)
+          else
+            f.flock(File::LOCK_EX)
+          end
           contents = f.read
           f.flock(File::LOCK_UN)
           contents

data/lib/cli/console_helper.rb

@@ -0,0 +1,157 @@
+require 'net/telnet'
+require 'readline'
+
+module VMC::Cli
+  module ConsoleHelper
+
+    def console_connection_info(appname)
+      app = client.app_info(appname)
+      fw = VMC::Cli::Framework.lookup_by_framework(app[:staging][:model])
+      if !fw.console
+        err "'#{appname}' is a #{fw.name} application.  " +
+          "Console access is not supported for #{fw.name} applications."
+      end
+      instances_info_envelope = client.app_instances(appname)
+      instances_info_envelope = {} if instances_info_envelope.is_a?(Array)
+
+      instances_info = instances_info_envelope[:instances] || []
+      err "No running instances for [#{appname}]" if instances_info.empty?
+
+      entry = instances_info[0]
+      if !entry[:console_port]
+        begin
+          client.app_files(appname, '/app/cf-rails-console')
+          err "Console port not provided for [#{appname}].  Try restarting the app."
+        rescue VMC::Client::TargetError, VMC::Client::NotFound
+          err "Console access not supported for [#{appname}]. " +
+            "Please redeploy your app to enable support."
+        end
+      end
+      conn_info = {'hostname' => entry[:console_ip], 'port' => entry[:console_port]}
+    end
+
+    def start_local_console(port, appname)
+      auth_info = console_credentials(appname)
+      display "Connecting to '#{appname}' console: ", false
+      prompt = console_login(auth_info, port)
+      display "OK".green
+      display "\n"
+      initialize_readline
+      run_console prompt
+    end
+
+    def console_login(auth_info, port)
+      if !auth_info["username"] || !auth_info["password"]
+        err "Unable to verify console credentials."
+      end
+      @telnet_client = telnet_client(port)
+      prompt = nil
+      err_msg = "Login attempt timed out."
+      5.times do
+        begin
+          results = @telnet_client.login("Name"=>auth_info["username"],
+            "Password"=>auth_info["password"]) {|line|
+            if line =~ /[$%#>] \z/n
+              prompt = line
+            elsif line =~ /Login failed/
+              err_msg = line
+            end
+          }
+          break
+        rescue TimeoutError
+          sleep 1
+        rescue EOFError
+          #This may happen if we login right after app starts
+          close_console
+          sleep 5
+          @telnet_client = telnet_client(port)
+        end
+        display ".", false
+      end
+      unless prompt
+        close_console
+        err err_msg
+      end
+      prompt
+    end
+
+    def send_console_command(cmd)
+      results = @telnet_client.cmd(cmd)
+      results.split("\n")
+    end
+
+    def console_credentials(appname)
+      content = client.app_files(appname, '/app/cf-rails-console/.consoleaccess', '0')
+      YAML.load(content)
+    end
+
+    def close_console
+      @telnet_client.close
+    end
+
+    def console_tab_completion_data(cmd)
+      begin
+        results = @telnet_client.cmd("String"=> cmd + "\t", "Match"=>/\S*\n$/, "Timeout"=>10)
+        results.chomp.split(",")
+      rescue TimeoutError
+        [] #Just return empty results if timeout occurred on tab completion
+      end
+    end
+
+    private
+    def telnet_client(port)
+      Net::Telnet.new({"Port"=>port, "Prompt"=>/[$%#>] \z|Login failed/n, "Timeout"=>30, "FailEOF"=>true})
+    end
+
+    def readline_with_history(prompt)
+      line = Readline.readline(prompt, true)
+      return '' if line.nil?
+      #Don't keep blank or repeat commands in history
+      if line =~ /^\s*$/ or Readline::HISTORY.to_a[-2] == line
+        Readline::HISTORY.pop
+      end
+      line
+    end
+
+    def run_console(prompt)
+      while(cmd = readline_with_history(prompt))
+        if(cmd == "exit" || cmd == "quit")
+          #TimeoutError expected, as exit doesn't return anything
+          @telnet_client.cmd("String"=>cmd,"Timeout"=>1) rescue TimeoutError
+          close_console
+          break
+        end
+        if !cmd.empty?
+          prompt = send_console_command_display_results(cmd, prompt)
+        end
+      end
+    end
+
+    def send_console_command_display_results(cmd, prompt)
+      begin
+        lines = send_console_command cmd
+        #Assumes the last line is a prompt
+        prompt = lines.pop
+        lines.each {|line| display line if line != cmd}
+      rescue TimeoutError
+        display "Timed out sending command to server.".red
+      rescue EOFError
+        err "The console connection has been terminated.  Perhaps the app was stopped or deleted?"
+      end
+      prompt
+    end
+
+    def initialize_readline
+      if Readline.respond_to?("basic_word_break_characters=")
+        Readline.basic_word_break_characters= " \t\n`><=;|&{("
+      end
+      Readline.completion_append_character = nil
+      #Assumes that sending a String ending with tab will return a non-empty
+      #String of comma-separated completion options, terminated by a new line
+      #For example, "app.\t" might result in "to_s,nil?,etc\n"
+      Readline.completion_proc = proc {|s|
+        console_tab_completion_data s
+      }
+    end
+  end
+end

data/lib/cli/core_ext.rb

@@ -68,334 +68,6 @@ module VMCExtensions
     return sprintf("%.#{prec}fM", size/(1024.0*1024.0)) if size < (1024*1024*1024)
     return sprintf("%.#{prec}fG", size/(1024.0*1024.0*1024.0))
   end
-
-  # general-purpose interaction
-  #
-  # `question' is the prompt (without ": " at the end)
-  # `options' is a hash containing:
-  #   :input - the input source (defaults to STDIN)
-  #   :default - the default value, also used to attempt type conversion
-  #              of the answer (e.g. numeric/boolean)
-  #   :choices - a list of strings to choose from
-  #   :indexed - whether to allow choosing from `:choices' by their index,
-  #              best for when there are many choices
-  #   :echo - a string to echo when showing the input;
-  #           used for things like censoring password inpt
-  #   :callback - a block used to override certain actions
-  #
-  #               takes 4 arguments:
-  #                 action: the event, e.g. :up or [:key, X] where X is a
-  #                         string containing a single character
-  #                 answer: the current answer to the question; you'll
-  #                         probably mutate this
-  #                 position: the current offset from the start of the
-  #                           answer string, e.g. when typing in the middle
-  #                           of the input, this will be where you insert
-  #                           characters
-  #                 echo: the :echo option above, may be nil
-  #
-  #               the block should return the updated `position', or nil if
-  #               it didn't handle the event
-  def ask(question, options = {})
-    default = options[:default]
-    choices = options[:choices]
-    indexed = options[:indexed]
-    callback = options[:callback]
-    input = options[:input] || STDIN
-    echo = options[:echo]
-
-    if choices
-      VMCExtensions.ask_choices(input, question, default, choices, indexed, echo, &callback)
-    else
-      VMCExtensions.ask_default(input, question, default, echo, &callback)
-    end
-  end
-
-  ESCAPES = {
-    "[A" => :up, "H" => :up,
-    "[B" => :down, "P" => :down,
-    "[C" => :right, "M" => :right,
-    "[D" => :left, "K" => :left,
-    "[3~" => :delete, "S" => :delete,
-    "[H" => :home, "G" => :home,
-    "[F" => :end, "O" => :end
-  }
-
-  def handle_action(which, ans, pos, echo = nil)
-    if block_given?
-      res = yield which, ans, pos, echo
-      return res unless res.nil?
-    end
-
-    case which
-    when :up
-      # nothing
-
-    when :down
-      # nothing
-
-    when :tab
-      # nothing
-
-    when :right
-      unless pos == ans.size
-        display censor(ans[pos .. pos], echo), false
-        return pos + 1
-      end
-
-    when :left
-      unless pos == 0
-        display "\b", false
-        return pos - 1
-      end
-
-    when :delete
-      unless pos == ans.size
-        ans.slice!(pos, 1)
-        if WINDOWS
-          rest = ans[pos .. -1]
-          display(censor(rest, echo) + " \b" + ("\b" * rest.size), false)
-        else
-          display("\e[P", false)
-        end
-      end
-
-    when :home
-      display("\b" * pos, false)
-      return 0
-
-    when :end
-      display(censor(ans[pos .. -1], echo), false)
-      return ans.size
-
-    when :backspace
-      if pos > 0
-        ans.slice!(pos - 1, 1)
-
-        if WINDOWS
-          rest = ans[pos - 1 .. -1]
-          display("\b" + censor(rest, echo) + " \b" + ("\b" * rest.size), false)
-        else
-          display("\b\e[P", false)
-        end
-
-        return pos - 1
-      end
-
-    when :interrupt
-      raise Interrupt.new
-
-    when :eof
-      return false if ans.empty?
-
-    when :kill_word
-      if pos > 0
-        start = /[^\s]*\s*$/ =~ ans[0 .. pos]
-        length = pos - start
-        ans.slice!(start, length)
-        display("\b" * length + " " * length + "\b" * length, false)
-        return start
-      end
-
-    when Array
-      case which[0]
-      when :key
-        c = which[1]
-        rest = ans[pos .. -1]
-
-        ans.insert(pos, c)
-
-        display(censor(c + rest, echo) + ("\b" * rest.size), false)
-
-        return pos + 1
-      end
-    end
-
-    pos
-  end
-
-  def censor(str, with)
-    return str unless with
-    with * str.size
-  end
-
-  # ask a simple question, maybe with a default answer
-  #
-  # reads character-by-character, handling backspaces, and sending each
-  # character to a block if provided
-  def self.ask_default(input, question, default = nil, echo = nil, &callback)
-    while true
-      prompt(question, default)
-
-      ans = ""
-      pos = 0
-      escaped = false
-      escape_seq = ""
-
-      with_char_io(input) do
-        until pos == false or (c = get_character(input)) =~ /[\r\n]/
-          if c == "\e" || c == "\xE0"
-            escaped = true
-          elsif escaped
-            escape_seq << c
-
-            if cmd = ESCAPES[escape_seq]
-              pos = handle_action(cmd, ans, pos, echo, &callback)
-              escaped, escape_seq = false, ""
-            elsif ESCAPES.select { |k, v| k.start_with? escape_seq }.empty?
-              escaped, escape_seq = false, ""
-            end
-          elsif c == "\177" or c == "\b" # backspace
-            pos = handle_action(:backspace, ans, pos, echo, &callback)
-          elsif c == "\x01"
-            pos = handle_action(:home, ans, pos, echo, &callback)
-          elsif c == "\x03"
-            pos = handle_action(:interrupt, ans, pos, echo, &callback)
-          elsif c == "\x04"
-            pos = handle_action(:eof, ans, pos, echo, &callback)
-          elsif c == "\x05"
-            pos = handle_action(:end, ans, pos, echo, &callback)
-          elsif c == "\x17"
-            pos = handle_action(:kill_word, ans, pos, echo, &callback)
-          elsif c == "\t"
-            pos = handle_action(:tab, ans, pos, echo, &callback)
-          elsif c < " "
-            # ignore
-          else
-            pos = handle_action([:key, c], ans, pos, echo, &callback)
-          end
-        end
-      end
-
-      display "\n", false
-
-      if ans.empty?
-        return default unless default.nil?
-      else
-        return match_type(ans, default)
-      end
-    end
-  end
-
-  def self.ask_choices(input, question, default, choices, indexed = false, echo = nil, &callback)
-    msg = question.dup
-
-    if indexed
-      choices.each.with_index do |o, i|
-        say "#{i + 1}: #{o}"
-      end
-    else
-      msg << " (#{choices.collect(&:inspect).join ", "})"
-    end
-
-    while true
-      ans = ask_default(input, msg, default, echo, &callback)
-
-      matches = choices.select { |x| x.start_with? ans }
-
-      if matches.size == 1
-        return matches.first
-      elsif indexed and ans =~ /^\d+$/ and res = choices.to_a[ans.to_i - 1]
-        return res
-      elsif matches.size > 1
-        warn "Please disambiguate: #{matches.join " or "}?"
-      else
-        warn "Unknown answer, please try again!"
-      end
-    end
-  end
-
-  # display a question and show the default value
-  def self.prompt(question, default = nil)
-    msg = question.dup
-
-    case default
-    when true
-      msg << " [Yn]"
-    when false
-      msg << " [yN]"
-    else
-      msg << " [#{default.inspect}]" if default
-    end
-
-    display "#{msg}: ", false
-  end
-
-  # try to make `str' be the same class as `x'
-  def self.match_type(str, x)
-    case x
-    when Integer
-      str.to_i
-    when true, false
-      str.upcase.start_with? "Y"
-    else
-      str
-    end
-  end
-
-  # definitions for reading character-by-character
-  begin
-    require "Win32API"
-
-    def self.with_char_io(input)
-      yield
-    end
-
-    def self.get_character(input)
-      if input == STDIN
-        begin
-          Win32API.new("msvcrt", "_getch", [], "L").call.chr
-        rescue
-          Win32API.new("crtdll", "_getch", [], "L").call.chr
-        end
-      else
-        input.getc.chr
-      end
-    end
-  rescue LoadError
-    begin
-      require "termios"
-
-      def self.with_char_io(input)
-        return yield unless input.tty?
-
-        before = Termios.getattr(input)
-
-        new = before.dup
-        new.c_lflag &= ~(Termios::ECHO | Termios::ICANON)
-        new.c_cc[Termios::VMIN] = 1
-
-        begin
-          Termios.setattr(input, Termios::TCSANOW, new)
-          yield
-        ensure
-          Termios.setattr(input, Termios::TCSANOW, before)
-        end
-      end
-
-      def self.get_character(input)
-        input.getc.chr
-      end
-    rescue LoadError
-      # set tty modes for the duration of a block, restoring them afterward
-      def self.with_char_io(input)
-        return yield unless input.tty?
-
-        begin
-          before = `stty -g`
-          system("stty raw -echo -icanon isig")
-          yield
-        ensure
-          system("stty #{before}")
-        end
-      end
-
-      # this assumes we're wrapped in #with_stty
-      def self.get_character(input)
-        input.getc.chr
-      end
-    end
-  end
 end
 
 module VMCStringExtensions