vmc 0.4.0.beta.8 → 0.4.0.beta.9

data/vmc/lib/cli/commands/user.rb

@@ -1,65 +0,0 @@
-module VMC::Cli::Command
-
-  class User < Base
-
-    def info
-      info = client_info
-      username = info[:user] || 'N/A'
-      return display JSON.pretty_generate([username]) if @options[:json]
-      display "\n[#{username}]"
-    end
-
-    def login(email=nil)
-      email    = @options[:email] unless email
-      password = @options[:password]
-      tries ||= 0
-
-      unless no_prompt
-        display "Attempting login to [#{target_url}]" if target_url
-        email ||= ask("Email")
-        password ||= ask("Password", :echo => "*")
-      end
-
-      err "Need a valid email" unless email
-      err "Need a password" unless password
-      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 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 to '#{target_url}', #{e}, try again or register for an account.".red
-      exit 1
-    end
-
-    def logout
-      VMC::Cli::Config.remove_token_file
-      say "Successfully logged out of [#{target_url}]".green
-    end
-
-    def change_password(password=nil)
-      info = client_info
-      email = info[:user]
-      err "Need to be logged in to change password." unless email
-      say "Changing password for '#{email}'\n"
-      unless no_prompt
-        password = ask "New Password", :echo => "*"
-        password2 = ask "Verify Password", :echo => "*"
-        err "Passwords did not match, try again" if password != password2
-      end
-      err "Password required" unless password
-      client.change_password(password)
-      say "\nSuccessfully changed password".green
-    end
-
-    private
-
-    def login_and_save_token(email, password)
-      token = client.login(email, password)
-      VMC::Cli::Config.store_token(token, @options[:token_file])
-    end
-
-  end
-
-end

data/vmc/lib/cli/config.rb

@@ -1,173 +0,0 @@
-require "yaml"
-require 'fileutils'
-
-require 'rubygems'
-require 'json/pure'
-
-module VMC::Cli
-  class Config
-
-    DEFAULT_TARGET  = 'api.vcap.me'
-
-    TARGET_FILE    = '~/.vmc_target'
-    TOKEN_FILE     = '~/.vmc_token'
-    INSTANCES_FILE = '~/.vmc_instances'
-    ALIASES_FILE   = '~/.vmc_aliases'
-    CLIENTS_FILE   = '~/.vmc_clients'
-    MICRO_FILE     = '~/.vmc_micro'
-
-    STOCK_CLIENTS = File.expand_path("../../../config/clients.yml", __FILE__)
-
-    class << self
-      attr_accessor :colorize
-      attr_accessor :output
-      attr_accessor :trace
-      attr_accessor :nozip
-
-      def target_url
-        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
-        else
-          @target_url  = DEFAULT_TARGET
-        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
-        @suggest_url ||= base_of(target_url)
-      end
-
-      def store_target(target_host)
-        target_file = File.expand_path(TARGET_FILE)
-        lock_and_write(target_file, target_host)
-      end
-
-      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)
-      end
-
-      alias :targets :all_tokens
-
-      def auth_token(token_file_path=nil)
-        return @token if @token
-        tokens = all_tokens(token_file_path)
-        @token = tokens[target_url] if tokens
-      end
-
-      def remove_token_file
-        FileUtils.rm_f(File.expand_path(TOKEN_FILE))
-      end
-
-      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_path || TOKEN_FILE)
-        lock_and_write(token_file, tokens.to_json)
-      end
-
-      def instances
-        instances_file = File.expand_path(INSTANCES_FILE)
-        return nil unless File.exists? instances_file
-        contents = lock_and_read(instances_file).strip
-        JSON.parse(contents)
-      end
-
-      def store_instances(instances)
-        instances_file = File.expand_path(INSTANCES_FILE)
-        lock_and_write(instances_file, instances.to_json)
-      end
-
-      def aliases
-        aliases_file = File.expand_path(ALIASES_FILE)
-        # bacward compatible
-        unless File.exists? aliases_file
-          old_aliases_file = File.expand_path('~/.vmc-aliases')
-          FileUtils.mv(old_aliases_file, aliases_file) if File.exists? old_aliases_file
-        end
-        aliases = YAML.load_file(aliases_file) rescue {}
-      end
-
-      def store_aliases(aliases)
-        aliases_file = File.expand_path(ALIASES_FILE)
-        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, 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
-        }
-      end
-
-      def lock_and_write(file, contents)
-        File.open(file, File::RDWR | File::CREAT, 0600) {|f|
-          f.flock(File::LOCK_EX)
-          f.rewind
-          f.puts contents
-          f.flush
-          f.truncate(f.pos)
-          f.flock(File::LOCK_UN)
-        }
-      end
-    end
-
-    def initialize(work_dir = Dir.pwd)
-      @work_dir = work_dir
-    end
-
-  end
-end

data/vmc/lib/cli/console_helper.rb

@@ -1,160 +0,0 @@
-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"])
-          lines = results.sub("Login: Password: ", "").split("\n")
-          last_line = lines.pop
-          if last_line =~ /[$%#>] \z/n
-            prompt = last_line
-          elsif last_line =~ /Login failed/
-            err_msg = last_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)
-      return nil if line == nil || line == 'quit' || line == 'exit'
-      Readline::HISTORY.push(line) if not line =~ /^\s*$/ and Readline::HISTORY.to_a[-1] != line
-      line
-    end
-
-    def run_console(prompt)
-      prev = trap("INT")  { |x| exit_console; prev.call(x); exit }
-      prev = trap("TERM") { |x| exit_console; prev.call(x); exit }
-      loop do
-        cmd = readline_with_history(prompt)
-        if(cmd == nil)
-          exit_console
-          break
-        end
-        prompt = send_console_command_display_results(cmd, prompt)
-      end
-    end
-
-    def exit_console
-      #TimeoutError expected, as exit doesn't return anything
-      @telnet_client.cmd("String"=>"exit","Timeout"=>1) rescue TimeoutError
-      close_console
-    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/vmc/lib/cli/core_ext.rb

@@ -1,122 +0,0 @@
-module VMCExtensions
-
-  def say(message)
-    VMC::Cli::Config.output.puts(message) if VMC::Cli::Config.output
-  end
-
-  def header(message, filler = '-')
-    say "\n"
-    say message
-    say filler.to_s * message.size
-  end
-
-  def banner(message)
-    say "\n"
-    say message
-  end
-
-  def display(message, nl=true)
-    if nl
-      say message
-    else
-      if VMC::Cli::Config.output
-        VMC::Cli::Config.output.print(message)
-        VMC::Cli::Config.output.flush
-      end
-    end
-  end
-
-  def clear(size=80)
-    return unless VMC::Cli::Config.output
-    VMC::Cli::Config.output.print("\r")
-    VMC::Cli::Config.output.print(" " * size)
-    VMC::Cli::Config.output.print("\r")
-    #VMC::Cli::Config.output.flush
-  end
-
-  def err(message, prefix='Error: ')
-    raise VMC::Cli::CliExit, "#{prefix}#{message}"
-  end
-
-  def warn(msg)
-    say "#{"[WARNING]".yellow} #{msg}"
-  end
-
-  def quit(message = nil)
-    raise VMC::Cli::GracefulExit, message
-  end
-
-  def blank?
-    self.to_s.blank?
-  end
-
-  def uptime_string(delta)
-    num_seconds = delta.to_i
-    days = num_seconds / (60 * 60 * 24);
-    num_seconds -= days * (60 * 60 * 24);
-    hours = num_seconds / (60 * 60);
-    num_seconds -= hours * (60 * 60);
-    minutes = num_seconds / 60;
-    num_seconds -= minutes * 60;
-    "#{days}d:#{hours}h:#{minutes}m:#{num_seconds}s"
-  end
-
-  def pretty_size(size, prec=1)
-    return 'NA' unless size
-    return "#{size}B" if size < 1024
-    return sprintf("%.#{prec}fK", size/1024.0) if size < (1024*1024)
-    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
-end
-
-module VMCStringExtensions
-
-  def red
-    colorize("\e[0m\e[31m")
-  end
-
-  def green
-    colorize("\e[0m\e[32m")
-  end
-
-  def yellow
-    colorize("\e[0m\e[33m")
-  end
-
-  def bold
-    colorize("\e[0m\e[1m")
-  end
-
-  def colorize(color_code)
-    if VMC::Cli::Config.colorize
-      "#{color_code}#{self}\e[0m"
-    else
-      self
-    end
-  end
-
-  def blank?
-    self =~ /^\s*$/
-  end
-
-  def truncate(limit = 30)
-    return "" if self.blank?
-    etc = "..."
-    stripped = self.strip[0..limit]
-    if stripped.length > limit
-      stripped.gsub(/\s+?(\S+)?$/, "") + etc
-    else
-      stripped
-    end
-  end
-
-end
-
-class Object
-  include VMCExtensions
-end
-
-class String
-  include VMCStringExtensions
-end

data/vmc/lib/cli/errors.rb

@@ -1,19 +0,0 @@
-module VMC::Cli
-
-  class CliError < StandardError
-    def self.error_code(code = nil)
-      define_method(:error_code) { code }
-    end
-  end
-
-  class UnknownCommand       < CliError; error_code(100); end
-  class TargetMissing        < CliError; error_code(102); end
-  class TargetInaccessible   < CliError; error_code(103); end
-
-  class TargetError          < CliError; error_code(201); end
-  class AuthError            < TargetError; error_code(202); end
-
-  class CliExit              < CliError; error_code(400); end
-  class GracefulExit         < CliExit;  error_code(401); end
-
-end