vmc 0.4.0.beta.12 → 0.4.0.beta.13

data/vmc-ng/bin/vmc

@@ -2,13 +2,10 @@
 # vim: ft=ruby
 
 require "rubygems"
-require "thor"
 
 require "vmc"
 require "vmc/plugin"
 
 VMC::Plugin.load_all
 
-$exit_status = 0
 VMC::CLI.start(ARGV)
-exit($exit_status)

data/vmc-ng/lib/vmc.rb

@@ -1,2 +1,7 @@
 require "vmc/version"
+
 require "vmc/cli"
+require "vmc/cli/start"
+require "vmc/cli/app"
+require "vmc/cli/service"
+require "vmc/cli/user"

data/vmc-ng/lib/vmc/cli.rb

@@ -1,428 +1,276 @@
-require "vmc/cli/command"
-
-VMC::Command.groups(
-  [:start, "Getting Started"],
-  [:apps, "Applications",
-    [:manage, "Management"],
-    [:info, "Information"]],
-  [:services, "Services",
-    [:manage, "Management"]],
-  [:admin, "Administration",
-    [:user, "User Management"]])
-
-require "vmc/cli/app"
-require "vmc/cli/service"
-require "vmc/cli/user"
+require "yaml"
 
-module VMC
-  class CLI < App # subclass App since we operate on Apps by default
-    desc "service SUBCOMMAND ...ARGS", "Service management"
-    subcommand "service", Service
-
-    desc "user SUBCOMMAND ...ARGS", "User management"
-    subcommand "user", User
-
-    desc "info", "Display information on the current target, user, etc."
-    group :start
-    flag :runtimes, :default => false
-    flag :services, :default => false
-    flag :frameworks, :default => false
-    def info
-      info =
-        with_progress("Getting target information") do
-          client.info
-        end
+require "mothership"
+require "mothership/pretty"
+require "mothership/progress"
 
-      authorized = !!info["frameworks"]
+require "cfoundry"
 
-      if input(:runtimes)
-        raise NotAuthorized unless authorized
+require "vmc/constants"
+require "vmc/errors"
 
-        runtimes = {}
-        info["frameworks"].each do |_, f|
-          f["runtimes"].each do |r|
-            runtimes[r["name"]] = r
-          end
-        end
+require "vmc/cli/help"
+require "vmc/cli/interactive"
 
-        runtimes = runtimes.values.sort_by { |x| x["name"] }
 
-        if simple_output?
-          runtimes.each do |r|
-            puts r["name"]
-          end
-          return
-        end
+$vmc_asked_auth = false
 
-        runtimes.each do |r|
-          puts ""
-          puts "#{c(r["name"], :name)}:"
-          puts "  version: #{b(r["version"])}"
-          puts "  description: #{b(r["description"])}"
-        end
-
-        return
-      end
-
-      if input(:services)
-        raise NotAuthorized unless authorized
-
-        services = client.system_services
-
-        if simple_output?
-          services.each do |name, _|
-            puts name
-          end
+module VMC
+  class CLI < Mothership
+    include VMC::Interactive
+    include Mothership::Pretty
+    include Mothership::Progress
 
-          return
-        end
+    option :help, :alias => "-h", :type => :boolean,
+      :desc => "Show command usage & instructions"
 
-        services.each do |name, meta|
-          puts ""
-          puts "#{c(name, :name)}:"
-          puts "  versions: #{meta[:versions].join ", "}"
-          puts "  description: #{meta[:description]}"
-          puts "  type: #{meta[:type]}"
-        end
+    option :proxy, :alias => "-u", :value => :email,
+      :desc => "Act as another user (admin only)"
 
-        return
-      end
+    option :version, :alias => "-v", :type => :boolean,
+      :desc => "Print version number"
 
-      if input(:frameworks)
-        raise NotAuthorized unless authorized
+    option(:force, :alias => "-f", :type => :boolean,
+           :desc => "Skip interaction when possible") {
+      option(:script)
+    }
 
-        puts "" unless simple_output?
+    option(:quiet, :alias => "-q", :type => :boolean,
+           :desc => "Simplify output format") {
+      option(:script)
+    }
 
-        info["frameworks"].each do |name, _|
-          puts name
-        end
+    option(:script, :alias => "-s", :type => :boolean,
+           :desc => "Shortcut for --quiet and --force") {
+      !$stdout.tty?
+    }
 
-        return
-      end
+    option(:color, :type => :boolean, :default => true,
+           :desc => "Use colorful output") {
+      !option(:quiet)
+    }
 
-      puts ""
+    option :trace, :alias => "-t", :type => :boolean,
+      :desc => "Show API requests and responses"
 
-      puts info["description"]
-      puts ""
-      puts "target: #{b(client.target)}"
-      puts "  version: #{info["version"]}"
-      puts "  support: #{info["support"]}"
 
-      if info["user"]
-        puts ""
-        puts "user: #{b(info["user"])}"
-        puts "  usage:"
-
-        limits = info["limits"]
-        info["usage"].each do |k, v|
-          m = limits[k]
-          if k == "memory"
-            puts "    #{k}: #{usage(v * 1024 * 1024, m * 1024 * 1024)}"
-          else
-            puts "    #{k}: #{b(v)} of #{b(m)} limit"
-          end
-        end
+    def default_action
+      if option(:version)
+        puts "vmc #{VERSION}"
+      else
+        super
       end
     end
 
-    desc "target [URL]", "Set or display the current target cloud"
-    group :start
-    def target(url = nil)
-      if url.nil?
-        display_target
-        return
-      end
+    def execute(cmd, argv)
+      if option(:help)
+        invoke :help, :command => cmd.name.to_s
+      else
+        super
+      end
+    rescue Interrupt
+      exit_status 130
+    rescue Mothership::Error
+      raise
+    rescue UserError => e
+      err e.message
+    rescue CFoundry::Denied => e
+      if !$vmc_asked_auth && e.error_code == 200
+        $vmc_asked_auth = true
 
-      target = sane_target_url(url)
-      display = c(target.sub(/https?:\/\//, ""), :name)
-      with_progress("Setting target to #{display}") do
-        unless force?
-          # check that the target is valid
-          CFoundry::Client.new(target).info
-        end
+        puts ""
+        puts c("Not authenticated! Try logging in:", :warning)
 
-        set_target(target)
-      end
-    end
+        invoke :login
+        @client = nil
 
-    desc "login [EMAIL]", "Authenticate with the target"
-    group :start
-    flag(:email) {
-      ask("Email")
-    }
-    flag(:password)
-    # TODO: implement new authentication scheme
-    def login(email = nil)
-      unless simple_output?
-        display_target
-        puts ""
+        retry
       end
 
-      email ||= input(:email)
-      password = input(:password)
+      err "Denied: #{e.description}"
+    rescue Exception => e
+      msg = e.class.name
+      msg << ": #{e}" unless e.to_s.empty?
+      err msg
 
-      authenticated = false
-      failed = false
-      until authenticated
-        unless force?
-          if failed || !password
-            password = ask("Password", :echo => "*", :forget => true)
-          end
-        end
+      ensure_config_dir
 
-        with_progress("Authenticating") do |s|
-          begin
-            save_token(client.login(email, password))
-            authenticated = true
-          rescue CFoundry::Denied
-            return if force?
+      File.open(File.expand_path(VMC::CRASH_FILE), "w") do |f|
+        f.puts "Time of crash:"
+        f.puts "  #{Time.now}"
+        f.puts ""
+        f.puts msg
+        f.puts ""
 
-            s.fail do
-              failed = true
-            end
+        vmc_dir = File.expand_path("../../../..", __FILE__) + "/"
+        e.backtrace.each do |loc|
+          if loc =~ /\/gems\//
+            f.puts loc.sub(/.*\/gems\//, "")
+          else
+            f.puts loc.sub(vmc_dir, "")
           end
         end
       end
-    ensure
-      $exit_status = 1 if not authenticated
     end
 
-    desc "logout", "Log out from the target"
-    group :start
-    def logout
-      with_progress("Logging out") do
-        remove_token
-      end
+    def quiet?
+      option(:quiet)
     end
 
-    desc "register [EMAIL]", "Create a user and log in"
-    group :start, :hidden => true
-    flag(:email) {
-      ask("Email")
-    }
-    flag(:password) {
-      ask("Password", :echo => "*", :forget => true)
-    }
-    flag(:verify_password) {
-      ask("Confirm Password", :echo => "*", :forget => true)
-    }
-    flag(:no_login, :type => :boolean)
-    def register(email = nil)
-      unless simple_output?
-        puts "Target: #{c(client_target, :name)}"
-        puts ""
-      end
-
-      email ||= input(:email)
-      password ||= input(:password)
-
-      if !force? && password != input(:verify_password)
-        fail "Passwords do not match."
-      end
-
-      with_progress("Creating user") do
-        client.register(email, password)
-      end
-
-      unless input(:skip_login)
-        with_progress("Logging in") do
-          save_token(client.login(email, password))
-        end
-      end
+    def force?
+      option(:force)
     end
 
-    desc "apps", "List your applications"
-    group :apps
-    flag :name, :desc => "Filter by name regexp"
-    flag :runtime, :desc => "Filter by runtime regexp"
-    flag :framework, :desc => "Filter by framework regexp"
-    flag :url, :desc => "Filter by url regexp"
-    def apps
-      apps =
-        with_progress("Getting applications") do
-          client.apps
-        end
+    def color_enabled?
+      option(:color)
+    end
 
-      if apps.empty? and !simple_output?
-        puts ""
-        puts "No applications."
-        return
+    def err(msg, exit_status = 1)
+      if quiet?
+        $stderr.puts(msg)
+      else
+        puts c(msg, :error)
       end
 
-      apps.each.with_index do |a, num|
-        display_app(a) if app_matches(a)
-      end
+      exit_status 1
     end
 
-    desc "services", "List your services"
-    group :services
-    flag :name, :desc => "Filter by name regexp"
-    flag :app, :desc => "Filter by bound application regexp"
-    flag :type, :desc => "Filter by service type regexp"
-    flag :vendor, :desc => "Filter by service vendor regexp"
-    flag :tier, :desc => "Filter by service tier regexp"
-    def services
-      services =
-        with_progress("Getting services") do
-          client.services
-        end
-
-      puts "" unless simple_output?
-
-      if services.empty? and !simple_output?
-        puts "No services."
-      end
+    def fail(msg)
+      raise UserError, msg
+    end
 
-      if app = options[:app]
-        apps = client.apps
-        services.reject! do |s|
-          apps.none? { |a| a.services.include? s.name }
-        end
+    def sane_target_url(url)
+      unless url =~ /^https?:\/\//
+        url = "http://#{url}"
       end
 
-      services.each do |s|
-        display_service(s) if service_matches(s)
-      end
+      url.gsub(/\/$/, "")
     end
 
-    desc "users", "List all users"
-    group :admin, :hidden => true
-    def users
-      users =
-        with_progress("Getting users") do
-          client.users
-        end
+    def target_file
+      one_of(VMC::TARGET_FILE, VMC::OLD_TARGET_FILE)
+    end
 
-      users.each do |u|
-        display_user(u)
-      end
+    def tokens_file
+      one_of(VMC::TOKENS_FILE, VMC::OLD_TOKENS_FILE)
     end
 
-    desc "help [COMMAND]", "Usage instructions"
-    flag :all, :default => false
-    group :start
-    def help(task = nil)
-      if options[:version]
-        puts "vmc #{VERSION}"
-        return
+    def one_of(*paths)
+      paths.each do |p|
+        exp = File.expand_path(p)
+        return exp if File.exist? exp
       end
 
-      if task
-        self.class.task_help(@shell, task)
-      else
-        unless input(:all)
-          puts "Showing basic command set. Pass --all to list all commands."
-          puts ""
-        end
+      paths.first
+    end
 
-        self.class.print_help_groups(input(:all))
-      end
+    def client_target
+      File.read(target_file).chomp
     end
 
-    desc "colors", "Show color configuration"
-    group :start, :hidden => true
-    def colors
-      user_colors.each do |n, c|
-        puts "#{n}: #{c(c.to_s, n)}"
-      end
+    def ensure_config_dir
+      config = File.expand_path(VMC::CONFIG_DIR)
+      Dir.mkdir(config) unless File.exist? config
     end
 
-    private
+    def set_target(url)
+      ensure_config_dir
 
-    def app_matches(a)
-      if name = options[:name]
-        return false if a.name !~ /#{name}/
+      File.open(File.expand_path(VMC::TARGET_FILE), "w") do |f|
+        f.write(sane_target_url(url))
       end
 
-      if runtime = options[:runtime]
-        return false if a.runtime !~ /#{runtime}/
-      end
+      @client = nil
+    end
 
-      if framework = options[:framework]
-        return false if a.framework !~ /#{framework}/
-      end
+    def tokens
+      new_toks = File.expand_path(VMC::TOKENS_FILE)
+      old_toks = File.expand_path(VMC::OLD_TOKENS_FILE)
 
-      if url = options[:url]
-        return false if a.urls.none? { |u| u =~ /#{url}/ }
+      if File.exist? new_toks
+        YAML.load_file(new_toks)
+      elsif File.exist? old_toks
+        JSON.load(File.read(old_toks))
+      else
+        {}
       end
+    end
 
-      true
+    def client_token
+      tokens[client_target]
     end
 
-    IS_UTF8 = !!(ENV["LC_ALL"] || ENV["LC_CTYPE"] || ENV["LANG"])["UTF-8"]
+    def save_tokens(ts)
+      ensure_config_dir
 
-    def display_app(a)
-      if simple_output?
-        puts a.name
-        return
+      File.open(File.expand_path(VMC::TOKENS_FILE), "w") do |io|
+        YAML.dump(ts, io)
       end
+    end
 
-      puts ""
-
-      status = app_status(a)
-
-      puts "#{c(a.name, :name)}: #{status}"
-
-      puts "  platform: #{b(a.framework)} on #{b(a.runtime)}"
-
-      print "  usage: #{b(human_size(a.memory * 1024 * 1024, 0))}"
-      print " #{c(IS_UTF8 ? "\xc3\x97" : "x", :dim)} #{b(a.total_instances)}"
-      print " instance#{a.total_instances == 1 ? "" : "s"}"
-      puts ""
-
-      unless a.urls.empty?
-        puts "  urls: #{a.urls.collect { |u| b(u) }.join(", ")}"
-      end
+    def save_token(token)
+      ts = tokens
+      ts[client_target] = token
+      save_tokens(ts)
+    end
 
-      unless a.services.empty?
-        puts "  services: #{a.services.collect { |s| b(s) }.join(", ")}"
-      end
+    def remove_token
+      ts = tokens
+      ts.delete client_target
+      save_tokens(ts)
     end
 
-    def service_matches(s)
-      if name = options[:name]
-        return false if s.name !~ /#{name}/
-      end
+    def client
+      return @client if @client
 
-      if type = options[:type]
-        return false if s.type !~ /#{type}/
-      end
+      @client = CFoundry::Client.new(client_target, client_token)
+      @client.proxy = option(:proxy)
+      @client.trace = option(:trace)
+      @client
+    end
 
-      if vendor = options[:vendor]
-        return false if s.vendor !~ /#{vendor}/
-      end
+    def usage(used, limit)
+      "#{b(human_size(used))} of #{b(human_size(limit, 0))}"
+    end
 
-      if tier = options[:tier]
-        return false if s.tier !~ /#{tier}/
-      end
+    def percentage(num, low = 50, mid = 70)
+      color =
+        if num <= low
+          :good
+        elsif num <= mid
+          :warning
+        else
+          :bad
+        end
 
-      true
+      c(format("%.1f\%", num), color)
     end
 
-    def display_service(s)
-      if simple_output?
-        puts s.name
-      else
-        puts "#{c(s.name, :name)}: #{s.vendor} v#{s.version}"
+    def megabytes(str)
+      if str =~ /T$/i
+        str.to_i * 1024 * 1024
+      elsif str =~ /G$/i
+        str.to_i * 1024
+      elsif str =~ /M$/i
+        str.to_i
+      elsif str =~ /K$/i
+        str.to_i / 1024
+      else # assume megabytes
+        str.to_i
       end
     end
 
-    def display_user(u)
-      if simple_output?
-        puts u.email
-      else
-        puts ""
-        puts "#{c(u.email, :name)}:"
-        puts "  admin?: #{c(u.admin?, u.admin? ? :yes : :no)}"
+    def human_size(num, precision = 1)
+      sizes = ["G", "M", "K"]
+      sizes.each.with_index do |suf, i|
+        pow = sizes.size - i
+        unit = 1024 ** pow
+        if num >= unit
+          return format("%.#{precision}f%s", num / unit, suf)
+        end
       end
-    end
 
-    def display_target
-      if simple_output?
-        puts client.target
-      else
-        puts "Target: #{c(client.target, :name)}"
-      end
+      format("%.#{precision}fB", num)
     end
   end
 end