cf 0.1.5 → 0.6.0.rc1

data/Rakefile

@@ -1 +1,12 @@
-require "bundler/gem_tasks"
+require "rake"
+require "rspec/core/rake_task"
+
+specfile, _ = Dir["*.gemspec"]
+SPEC = Gem::Specification.load(specfile)
+CURRENT_VERSION = SPEC.version.to_s.freeze
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+# looking for a way to push gems? check out the new frontend-release git repo!
+# git@github.com:pivotal-vmware/frontend-release.git

data/bin/cf

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

data/lib/cf.rb

@@ -1,2 +1,8 @@
 require "cf/version"
+
 require "cf/cli"
+
+command_files = "../cf/cli/{app,route,domain,organization,space,service,start,user}/*.rb"
+Dir[File.expand_path(command_files, __FILE__)].each do |file|
+  require file unless File.basename(file) == 'base.rb'
+end

data/lib/cf/cli.rb

@@ -1,270 +1,469 @@
-require "cf/cli/command"
-require "cf/cli/app"
-require "cf/cli/service"
-require "cf/cli/user"
+require "yaml"
+require "socket"
+require "net/http"
+require "multi_json"
+require "fileutils"
+
+require "mothership"
+
+require "cfoundry"
+
+require "cf/constants"
+require "cf/errors"
+require "cf/spacing"
+
+require "cf/cli/help"
+require "cf/cli/interactive"
+
+
+$cf_asked_auth = false
 
 module CF
-  class CLI < App # subclass App since we operate on Apps by default
-    class_option :proxy, :aliases => "-u", :desc => "Proxy user"
+  class CLI < Mothership
+    include CF::Interactive
+    include CF::Spacing
 
-    class_option :verbose,
-      :type => :boolean, :aliases => "-v", :desc => "Verbose"
+    option :help, :desc => "Show command usage", :alias => "-h",
+      :default => false
 
-    class_option :force,
-      :type => :boolean, :aliases => "-f", :desc => "Force (no interaction)"
+    option :proxy, :desc => "Run this command as another user (admin)", :alias => "-u",
+      :value => :email
 
-    class_option :simple_output,
-      :type => :boolean, :desc => "Simplified output format."
+    option :version, :desc => "Print version number", :alias => "-v",
+      :default => false
 
-    class_option :script, :type => :boolean, :aliases => "-s",
-      :desc => "--simple-output and --force"
+    option :verbose, :desc => "Print extra information", :alias => "-V",
+      :default => false
 
-    class_option :color, :type => :boolean, :desc => "Colored output"
+    option :force, :desc => "Skip interaction when possible", :alias => "-f",
+      :type => :boolean, :default => proc { input[:script] }
 
-    desc "service SUBCOMMAND ...ARGS", "Manage your services"
-    subcommand "service", Service
+    option :debug, :desc => "Print full stack trace (instead of crash log)",
+           :type => :boolean, :default => false
 
-    desc "user SUBCOMMAND ...ARGS", "User management"
-    subcommand "user", User
+    option :quiet, :desc => "Simplify output format", :alias => "-q",
+      :type => :boolean, :default => proc { input[:script] }
 
-    desc "info", "Display information on the current target, user, et."
-    flag(:runtimes)
-    flag(:services)
-    def info
-      info =
-        with_progress("Getting target information") do
-          client.info
-        end
+    option :script, :desc => "Shortcut for --quiet and --force",
+      :type => :boolean, :default => proc { !$stdout.tty? }
 
-      if input(:runtimes)
-        runtimes = {}
-        info["frameworks"].each do |_, f|
-          f["runtimes"].each do |r|
-            runtimes[r["name"]] = r
-          end
-        end
+    option :color, :desc => "Use colorful output",
+      :type => :boolean, :default => proc { !input[:quiet] }
 
-        runtimes = runtimes.values.sort_by { |x| x["name"] }
+    option :trace, :desc => "Show API traffic", :alias => "-t",
+      :default => false
 
-        if simple_output?
-          runtimes.each do |r|
-            puts r["name"]
-          end
-          return
-        end
 
-        runtimes.each do |r|
-          puts ""
-          puts "#{c(r["name"], :blue)}:"
-          puts "  version: #{b(r["version"])}"
-          puts "  description: #{b(r["description"])}"
-        end
+    def default_action
+      if input[:version]
+        line "cf #{VERSION}"
+      else
+        super
+      end
+    end
 
-        return
+    def check_target
+      unless client && client.target
+        fail "Please select a target with 'cf target'."
       end
+    end
 
-      if input(:services)
-        services = {}
-        client.system_services.each do |_, svcs|
-          svcs.each do |name, versions|
-            services[name] = versions.values
-          end
+    def check_logged_in
+      unless client.logged_in?
+        if force?
+          fail "Please log in with 'cf login'."
+        else
+          line c("Please log in first to proceed.", :warning)
+          line
+          invoke :login
+          invalidate_client
         end
+      end
+    end
 
-        if simple_output?
-          services.each do |name, _|
-            puts name
-          end
+    def precondition
+      check_target
+      check_logged_in
 
-          return
-        end
+      unless client.current_organization
+        fail "Please select an organization with 'cf target --ask-org'."
+      end
 
-        services.each do |name, versions|
-          puts ""
-          puts "#{c(name, :blue)}:"
-          puts "  versions: #{versions.collect { |v| v["version"] }.join ", "}"
-          puts "  description: #{versions[0]["description"]}"
-          puts "  type: #{versions[0]["type"]}"
-        end
+      unless client.current_space
+        fail "Please select a space with 'cf target --ask-space'."
+      end
+    end
 
-        return
+    def wrap_errors
+      yield
+    rescue CFoundry::Timeout => e
+      err(e.message)
+    rescue Interrupt
+      exit_status 130
+    rescue Mothership::Error
+      raise
+    rescue UserError => e
+      log_error(e)
+      err e.message
+    rescue SystemExit
+      raise
+    rescue CFoundry::Forbidden, CFoundry::InvalidAuthToken => e
+      if !$cf_asked_auth
+        $cf_asked_auth = true
+
+        line
+        line c("Not authenticated! Try logging in:", :warning)
+
+        # TODO: there's no color here; global flags not being passed
+        # through (mothership bug?)
+        invoke :login
+
+        retry
       end
 
-      puts ""
+      log_error(e)
 
-      puts info["description"]
-      puts ""
-      puts "target: #{b(client.target)}"
-      puts "  version: #{info["version"]}"
-      puts "  support: #{info["support"]}"
+      err "Denied: #{e.description}"
 
-      if info["user"]
-        puts ""
-        puts "user: #{b(info["user"])}"
-        puts "  usage:"
+    rescue Exception => e
+      log_error(e)
 
-        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"
+      msg = e.class.name
+      msg << ": #{e}" unless e.to_s.empty?
+      msg << "\nFor more information, see #{CF::CRASH_FILE}"
+      err msg
+
+      raise if debug?
+    end
+
+    def execute(cmd, argv, global = {})
+      if input[:help]
+        invoke :help, :command => cmd.name.to_s
+      else
+        wrap_errors do
+          @command = cmd
+          precondition
+
+          save_token_if_it_changes do
+            super
           end
         end
       end
     end
 
-    desc "target [URL]", "Set or display the current target cloud"
-    def target(url = nil)
-      if url.nil?
-        display_target
-        return
-      end
+    def save_token_if_it_changes
+      return yield unless client && client.token
 
-      target = sane_target_url(url)
-      display = c(target.sub(/https?:\/\//, ""), :blue)
-      with_progress("Setting target to #{display}") do
-        unless force?
-          # check that the target is valid
-          CFoundry::Client.new(target).info
-        end
+      before_token = client.token
+
+      yield
 
-        set_target(target)
+      after_token = client.token
+
+      return unless after_token
+
+      if before_token != after_token
+        info = target_info
+        info[:token] = after_token.auth_header
+        save_target_info(info)
       end
     end
 
-    desc "login [EMAIL]", "Authenticate with the target"
-    flag(:email) {
-      ask("Email")
-    }
-    flag(:password)
-    # TODO: implement new authentication scheme
-    def login(email = nil)
-      unless simple_output?
-        display_target
-        puts ""
-      end
+    def log_error(e)
+      ensure_config_dir
 
-      email ||= input(:email)
-      password = input(:password)
+      msg = e.class.name
+      msg << ": #{e}" unless e.to_s.empty?
 
-      authenticated = false
-      failed = false
-      until authenticated
-        unless force?
-          if failed || !password
-            password = ask("Password", :echo => "*", :forget => true)
-          end
+      crash_file = File.expand_path(CF::CRASH_FILE)
+
+      FileUtils.mkdir_p(File.dirname(crash_file))
+
+      File.open(crash_file, "w") do |f|
+        f.puts "Time of crash:"
+        f.puts "  #{Time.now}"
+        f.puts ""
+        f.puts msg
+        f.puts ""
+
+        if e.respond_to?(:request_trace)
+          f.puts "<<<"
+          f.puts e.request_trace
         end
 
-        with_progress("Authenticating") do |s|
-          begin
-            save_token(client.login(email, password))
-            authenticated = true
-          rescue CFoundry::Denied
-            return if force?
+        if e.respond_to?(:response_trace)
+          f.puts e.response_trace
+          f.puts ">>>"
+          f.puts ""
+        end
 
-            s.fail do
-              failed = true
-            end
+        cf_dir = File.expand_path("../../../..", __FILE__) + "/"
+        e.backtrace.each do |loc|
+          if loc =~ /\/gems\//
+            f.puts loc.sub(/.*\/gems\//, "")
+          else
+            f.puts loc.sub(cf_dir, "")
           end
         end
       end
-    ensure
-      $exit_status = 1 if not authenticated
     end
 
-    desc "logout", "Log out from the target"
-    def logout
-      with_progress("Logging out") do
-        remove_token
-      end
+    def quiet?
+      input[:quiet]
     end
 
-    desc "register [EMAIL]", "Create a user and log in"
-    flag(:email) {
-      ask("Email")
-    }
-    flag(:password) {
-      ask("Password", :echo => "*", :forget => true)
-    }
-    flag(:no_login, :type => :boolean)
-    def register(email = nil)
-      unless simple_output?
-        puts "Target: #{c(client_target, :blue)}"
-        puts ""
-      end
+    def force?
+      input[:force]
+    end
+
+    def debug?
+      !!input[:debug]
+    end
+
+    def color_enabled?
+      input[:color]
+    end
+
+    def verbose?
+      input[:verbose]
+    end
+
+    def user_colors
+      return @user_colors if @user_colors
 
-      email ||= input(:email)
-      password = input(:password)
+      colors = File.expand_path(COLORS_FILE)
 
-      with_progress("Creating user") do
-        client.register(email, password)
+      @user_colors = super.dup
+
+      # most terminal schemes are stupid, so use cyan instead
+      @user_colors.each do |k, v|
+        if v == :blue
+          @user_colors[k] = :cyan
+        end
       end
 
-      unless input(:skip_login)
-        with_progress("Logging in") do
-          save_token(client.login(email, password))
+      if File.exists?(colors)
+        YAML.load_file(colors).each do |k, v|
+          @user_colors[k.to_sym] = v.to_sym
         end
       end
+
+      @user_colors
+    end
+
+    def err(msg, status = 1)
+      $stderr.puts c(msg, :error)
+      exit_status status
+    end
+
+    def fail(msg)
+      raise UserError, msg
+    end
+
+    def table(headers, rows)
+      tabular(
+        !quiet? && headers.collect { |h| h && b(h) },
+        *rows)
+    end
+
+    def name_list(xs)
+      if xs.empty?
+        d("none")
+      else
+        xs.collect { |x| c(x.name, :name) }.join(", ")
+      end
     end
 
-    desc "services", "List your services"
-    def services
-      services =
-        with_progress("Getting services") do
-          client.services
+    def sane_target_url(url)
+      unless url =~ /^https?:\/\//
+        begin
+          TCPSocket.new(url, Net::HTTP.https_default_port)
+          url = "https://#{url}"
+        rescue Errno::ECONNREFUSED, SocketError, Timeout::Error
+          url = "http://#{url}"
         end
+      end
+
+      url.gsub(/\/$/, "")
+    end
+
+    def target_file
+      one_of(CF::TARGET_FILE, CF::OLD_TARGET_FILE)
+    end
 
-      puts "" unless simple_output?
+    def tokens_file
+      one_of(CF::TOKENS_FILE, CF::OLD_TOKENS_FILE)
+    end
 
-      if services.empty? and !simple_output?
-        puts "No services."
+    def one_of(*paths)
+      paths.each do |p|
+        exp = File.expand_path(p)
+        return exp if File.exist? exp
       end
 
-      services.each do |s|
-        display_service(s)
+      File.expand_path(paths.first)
+    end
+
+    def client_target
+      if File.exists?(target_file)
+        File.read(target_file).chomp
       end
     end
 
-    desc "users", "List all users"
-    def users
-      users =
-        with_progress("Getting users") do
-          client.users
+    def ensure_config_dir
+      config = File.expand_path(CF::CONFIG_DIR)
+      FileUtils.mkdir_p(config) unless File.exist? config
+    end
+
+    def set_target(url)
+      ensure_config_dir
+
+      File.open(File.expand_path(CF::TARGET_FILE), "w") do |f|
+        f.write(sane_target_url(url))
+      end
+
+      invalidate_client
+    end
+
+    def targets_info
+      new_toks = File.expand_path(CF::TOKENS_FILE)
+      old_toks = File.expand_path(CF::OLD_TOKENS_FILE)
+
+      info =
+        if File.exist? new_toks
+          YAML.load_file(new_toks)
+        elsif File.exist? old_toks
+          MultiJson.load(File.read(old_toks))
         end
 
-      users.each do |u|
-        display_user(u)
+      info ||= {}
+
+      normalize_targets_info(info)
+    end
+
+    def normalize_targets_info(info_by_url)
+      info_by_url.reduce({}) do |hash, pair|
+        key, value = pair
+        hash[key] = value.is_a?(String) ? { :token => value } : value
+        hash
       end
     end
 
-    private
+    def target_info(target = client_target)
+      targets_info[target] || {}
+    end
 
-    def display_service(s)
-      if simple_output?
-        puts s.name
-      else
-        puts "#{c(s.name, :blue)}: #{s.vendor} v#{s.version}"
+    def save_targets(ts)
+      ensure_config_dir
+
+      File.open(File.expand_path(CF::TOKENS_FILE), "w") do |io|
+        YAML.dump(ts, io)
       end
     end
 
-    def display_user(u)
-      if simple_output?
-        puts u.email
-      else
-        puts ""
-        puts "#{c(u.email, :blue)}:"
-        puts "  admin?: #{c(u.admin?, u.admin? ? :green : :red)}"
+    def save_target_info(info, target = client_target)
+      ts = targets_info
+      ts[target] = info
+      save_targets(ts)
+    end
+
+    def remove_target_info(target = client_target)
+      ts = targets_info
+      ts.delete target
+      save_targets(ts)
+    end
+
+    def invalidate_client
+      @@client = nil
+      client
+    end
+
+    def client(target = client_target)
+      return @@client if defined?(@@client) && @@client
+      return unless target
+
+      info = target_info(target)
+      token = info[:token] && CFoundry::AuthToken.from_hash(info)
+
+      @@client =
+        case info[:version]
+        when 2
+          fail "User switching not implemented." if input[:proxy]
+          CFoundry::V2::Client.new(target, token)
+        when 1
+          CFoundry::V1::Client.new(target, token)
+        else
+          CFoundry::Client.new(target, token)
+        end
+
+      unless @@client.is_a?(CFoundry::V2::Client)
+        # TODO
+        fail "V1 targets are no longer supported."
+      end
+
+      @@client.proxy = input[:proxy]
+      @@client.trace = input[:trace]
+
+      uri = URI.parse(target)
+      @@client.log = File.expand_path("#{LOGS_DIR}/#{uri.host}.log")
+
+      unless info.key? :version
+        info[:version] = @@client.version
+        save_target_info(info, target)
+      end
+
+      if org = info[:organization]
+        @@client.current_organization = @@client.organization(org)
+      end
+
+      if space = info[:space]
+        @@client.current_space = @@client.space(space)
       end
+
+      @@client
+    rescue CFoundry::InvalidTarget
     end
 
-    def display_target
-      if simple_output?
-        puts client.target
-      else
-        puts "Target: #{c(client.target, :blue)}"
+    def fail_unknown(display, name)
+      fail("Unknown #{display} '#{name}'.")
+    end
+
+    class << self
+      def client
+        @@client
+      end
+
+      def client=(c)
+        @@client = c
+      end
+
+      private
+
+      def find_by_name(display, &blk)
+        proc { |name, *args|
+          choices, _ = args
+          choices ||= instance_exec(&blk) if block_given?
+
+          choices.find { |c| c.name == name } ||
+            fail_unknown(display, name)
+        }
+      end
+
+      def by_name(what, display = what)
+        proc { |name, *_|
+          client.send(:"#{what}_by_name", name) ||
+            fail_unknown(display, name)
+        }
+      end
+
+      def find_by_name_insensitive(display, &blk)
+        proc { |name, *args|
+          choices, _ = args
+          choices ||= instance_exec(&blk) if block_given?
+
+          choices.find { |c| c.name.upcase == name.upcase } ||
+            fail_unknown(display, name)
+        }
       end
     end
   end