udn 0.3.23.0.pre

data/lib/cli/manifest_helper.rb

@@ -0,0 +1,323 @@
+require "set"
+
+module VMC::Cli::ManifestHelper
+  include VMC::Cli::ServicesHelper
+
+  DEFAULTS = {
+    "url" => "${name}.${target-base}",
+    "mem" => "128M",
+    "instances" => 1
+  }
+
+  MANIFEST = "manifest.yml"
+
+  YES_SET = Set.new(["y", "Y", "yes", "YES"])
+
+  # take a block and call it once for each app to push/update.
+  # with @application and @app_info set appropriately
+  def each_app(panic=true)
+    if @manifest and all_apps = @manifest["applications"]
+      where = File.expand_path(@path)
+      single = false
+
+      all_apps.each do |path, info|
+        app = File.expand_path("../" + path, manifest_file)
+        if where.start_with?(app)
+          @application = app
+          @app_info = info
+          yield info["name"]
+          single = true
+          break
+        end
+      end
+
+      unless single
+        if where == File.expand_path("../", manifest_file)
+          ordered_by_deps(all_apps).each do |path, info|
+            app = File.expand_path("../" + path, manifest_file)
+            @application = app
+            @app_info = info
+            yield info["name"]
+          end
+        else
+          err "Path '#{@path}' is not known to manifest '#{manifest_file}'."
+        end
+      end
+    else
+      @application = @path
+      @app_info = @manifest
+      if @app_info
+        yield @app_info["name"]
+      elsif panic
+        err "No applications."
+      end
+    end
+
+    nil
+  ensure
+    @application = nil
+    @app_info = nil
+  end
+
+  def interact(many=false)
+    @manifest ||= {}
+    configure_app(many)
+  end
+
+  def target_manifest
+    @options[:manifest] || MANIFEST
+  end
+
+  def save_manifest(save_to = nil)
+    save_to ||= target_manifest
+
+    File.open(save_to, "w") do |f|
+      f.write @manifest.to_yaml
+    end
+
+    say "Manifest written to #{save_to}."
+  end
+
+  def configure_app(many=false)
+    name = manifest("name") ||
+      set(ask("Application Name", :default => manifest("name")), "name")
+
+
+
+    if manifest "framework"
+      framework = VMC::Cli::Framework.lookup_by_framework manifest("framework","name")
+    elsif @options[:framework]
+      framework = VMC::Cli::Framework.new(@options[:framework])
+    else
+      framework = detect_framework
+      set framework.name, "framework", "name"
+      set(
+        { "mem" => framework.mem,
+          "description" => framework.description,
+          "exec" => framework.exec
+        },
+        "framework",
+        "info"
+      )
+    end
+
+    default_runtime = manifest "runtime"
+    if not default_runtime
+      default_runtime = framework.default_runtime(@application)
+      set(detect_runtime(default_runtime), "runtime") if framework.prompt_for_runtime?
+    end
+    default_command = manifest "command"
+    set ask("Start Command", :default => default_command), "command" if framework.require_start_command?
+
+    url_template = manifest("url") || DEFAULTS["url"]
+    url_resolved = url_template.dup
+    resolve_lexically(url_resolved)
+
+    if !framework.require_url?
+      url_resolved = "None"
+    end
+    url = ask("Application Deployed URL", :default => url_resolved)
+
+    if url == url_resolved && url != "None"
+      url = url_template
+    end
+
+    # common error case is for prompted users to answer y or Y or yes or
+    # YES to this ask() resulting in an unintended URL of y. Special
+    # case this common error
+    url = url_resolved if YES_SET.member? url
+
+    if(url == "None")
+      url = nil
+    end
+
+    set url, "url"
+
+    default_mem = manifest("mem")
+    default_mem = framework.memory(manifest("runtime")) if not default_mem
+    set ask(
+      "Memory reservation",
+      :default =>
+          default_mem ||
+          DEFAULTS["mem"],
+      :choices => ["128M", "256M", "512M", "1G", "2G"]
+    ), "mem"
+
+    set ask(
+      "How many instances?",
+      :default => manifest("instances") || DEFAULTS["instances"]
+    ), "instances"
+
+    unless manifest "services"
+      user_services = client.services
+      user_services.sort! {|a, b| a[:name] <=> b[:name] }
+
+      unless user_services.empty?
+        if ask "Bind existing services to '#{name}'?", :default => false
+          bind_services(user_services)
+        end
+      end
+
+      services = client.services_info
+      unless services.empty?
+        if ask "Create services to bind to '#{name}'?", :default => false
+          create_services(services.values.collect(&:keys).flatten)
+        end
+      end
+    end
+
+    if many and ask("Configure for another application?", :default => false)
+      @application = ask "Application path?"
+      configure_app
+    end
+  end
+
+  def set(what, *where)
+    where.unshift "applications", @application
+
+    which = @manifest
+    where.each_with_index do |k, i|
+      if i + 1 == where.size
+        which[k] = what
+      else
+        which = (which[k] ||= {})
+      end
+    end
+
+    what
+  end
+
+  # Detect the appropriate framework.
+  def detect_framework(prompt_ok = true)
+    framework = VMC::Cli::Framework.detect(@application, frameworks_info)
+    framework_correct = ask("Detected a #{framework}, is this correct?", :default => true) if prompt_ok && framework
+    if prompt_ok && (framework.nil? || !framework_correct)
+      display "#{"[WARNING]".yellow} Can't determine the Application Type." unless framework
+      framework = nil if !framework_correct
+      framework = VMC::Cli::Framework.lookup(
+        ask(
+          "Select Application Type",
+          :indexed => true,
+          :default => framework,
+          :choices => VMC::Cli::Framework.known_frameworks(frameworks_info)
+        )
+      )
+      display "Selected #{framework}"
+    end
+
+    framework
+  end
+
+  # Detect the appropriate runtime.
+  def detect_runtime(default, prompt_ok=true)
+    runtime = nil
+    runtime_keys=[]
+    runtimes_info.keys.each {|runtime_key| runtime_keys << runtime_key.dup }
+    runtime_keys.sort!
+    if prompt_ok
+      runtime =  ask(
+          "Select Runtime",
+          :indexed => true,
+          :default => default,
+          :choices => runtime_keys
+      )
+      display "Selected #{runtime}"
+    end
+    runtime
+  end
+
+  def bind_services(user_services, chosen = 0)
+    svcname = ask(
+      "Which one?",
+      :indexed => true,
+      :choices => user_services.collect { |p| p[:name] })
+
+    svc = user_services.find { |p| p[:name] == svcname }
+
+    set svc[:vendor], "services", svcname, "type"
+
+    if chosen + 1 < user_services.size && ask("Bind another?", :default => false)
+      bind_services(user_services, chosen + 1)
+    end
+  end
+
+  def create_services(services)
+    svcs = services.collect(&:to_s).sort!
+
+    configure_service(
+      ask(
+        "What kind of service?",
+        :indexed => true,
+        :choices => svcs
+      )
+    )
+
+    if ask "Create another?", :default => false
+      create_services(services)
+    end
+  end
+
+  def configure_service(vendor)
+    default_name = random_service_name(vendor)
+    name = ask "Specify the name of the service", :default => default_name
+    configure_plan(vendor, name)
+    set vendor, "services", name, "type"
+  end
+
+  def configure_plan(service, name)
+    plans = service_plans(service)
+
+    case plans.size
+    when 0
+      plan = nil
+    when 1
+      plan = plans[0]
+    else
+      plan = ask(
+        "Which plan?",
+        :indexed => true,
+        :choices => plans
+      )
+    end
+
+    set(plan, "services", name, "plan") if plan
+  end
+
+  private
+    def ordered_by_deps(apps, abspaths = nil, processed = Set[])
+      unless abspaths
+        abspaths = {}
+        apps.each do |p, i|
+          ep = File.expand_path("../" + p, manifest_file)
+          abspaths[ep] = i
+        end
+      end
+
+      ordered = []
+      apps.each do |path, info|
+        epath = File.expand_path("../" + path, manifest_file)
+
+        if deps = info["depends-on"]
+          dep_apps = {}
+          deps.each do |dep|
+            edep = File.expand_path("../" + dep, manifest_file)
+
+            err "Circular dependency detected." if processed.include? edep
+
+            dep_apps[dep] = abspaths[edep]
+          end
+
+          processed.add(epath)
+
+          ordered += ordered_by_deps(dep_apps, abspaths, processed)
+          ordered << [path, info]
+        elsif not processed.include? epath
+          ordered << [path, info]
+          processed.add(epath)
+        end
+      end
+
+      ordered
+    end
+
+end

data/lib/cli/runner.rb

@@ -0,0 +1,556 @@
+
+require 'optparse'
+
+require File.dirname(__FILE__) + '/usage'
+
+class VMC::Cli::Runner
+
+  attr_reader   :namespace
+  attr_reader   :action
+  attr_reader   :args
+  attr_reader   :options
+
+  def self.run(args)
+    new(args).run
+  end
+
+  def initialize(args=[])
+    @args = args
+    @options = { :colorize => true }
+    @exit_status = true
+  end
+
+  # Collect all the available options for all commands
+  # Some duplicates exists to capture all scenarios
+  def parse_options!
+    opts_parser = OptionParser.new do |opts|
+      opts.banner = "\nAvailable options:\n\n"
+
+      opts.on('--email EMAIL')     { |email| @options[:email] = email }
+      opts.on('--user EMAIL')      { |email| @options[:email] = email }
+      opts.on('--passwd PASS')     { |pass|  @options[:password] = pass }
+      opts.on('--pass PASS')       { |pass|  @options[:password] = pass }
+      opts.on('--password PASS')   { |pass|  @options[:password] = pass }
+      opts.on('--token-file TOKEN_FILE')     { |token_file|  @options[:token_file] = token_file }
+      opts.on('--app NAME')        { |name|  @options[:name] = name }
+      opts.on('--name NAME')       { |name|  @options[:name] = name }
+      opts.on('--plan NAME')       { |name|  @options[:plan] = name }
+      opts.on('--bind BIND')       { |bind|  @options[:bind] = bind }
+      opts.on('--instance INST')   { |inst|  @options[:instance] = inst }
+      opts.on('--instances INST')  { |inst|  @options[:instances] = inst }
+      opts.on('--url URL')         { |url|   @options[:url] = url }
+      opts.on('--mem MEM')         { |mem|   @options[:mem] = mem }
+      opts.on('--path PATH')       { |path|  @options[:path] = path }
+      opts.on('--no-start')        {         @options[:nostart] = true }
+      opts.on('--nostart')         {         @options[:nostart] = true }
+      opts.on('--force')           {         @options[:force] = true }
+      opts.on('--all')             {         @options[:all] = true }
+
+      # generic tracing and debugging
+      opts.on('-t [TKEY]')         { |tkey|  @options[:trace] = tkey || true }
+      opts.on('--trace [TKEY]')    { |tkey|  @options[:trace] = tkey || true }
+
+      # start application in debug mode
+      opts.on('-d [MODE]')         { |mode|  @options[:debug] = mode || "run" }
+      opts.on('--debug [MODE]')    { |mode|  @options[:debug] = mode || "run" }
+
+      # override manifest file
+      opts.on('-m FILE')           { |file|  @options[:manifest] = file }
+      opts.on('--manifest FILE')   { |file|  @options[:manifest] = file }
+
+      opts.on('-q', '--quiet')     {         @options[:quiet] = true }
+
+      # micro cloud options
+      opts.on('--vmx FILE')        { |file|  @options[:vmx] = file }
+      opts.on('--vmrun FILE')      { |file|  @options[:vmrun] = file }
+      opts.on('--save')            {         @options[:save] = true }
+
+      # Don't use builtin zip
+      opts.on('--no-zip')          {         @options[:nozip] = true }
+      opts.on('--nozip')           {         @options[:nozip] = true }
+
+      opts.on('--no-resources')    {         @options[:noresources] = true }
+      opts.on('--noresources')     {         @options[:noresources] = true }
+
+      opts.on('--no-color')        {         @options[:colorize] = false }
+      opts.on('--verbose')         {         @options[:verbose] = true }
+
+      opts.on('-n','--no-prompt')  {         @options[:noprompts] = true }
+      opts.on('--noprompt')        {         @options[:noprompts] = true }
+      opts.on('--non-interactive') {         @options[:noprompts] = true }
+
+      opts.on('--prefix')          {         @options[:prefixlogs] = true }
+      opts.on('--prefix-logs')     {         @options[:prefixlogs] = true }
+      opts.on('--prefixlogs')      {         @options[:prefixlogs] = true }
+
+      opts.on('--json')            {         @options[:json] = true }
+
+      opts.on('-v', '--version')   {         set_cmd(:misc, :version) }
+      opts.on('-h', '--help')      {         puts "#{command_usage}\n"; exit }
+
+      opts.on('--port PORT')       { |port|  @options[:port] = port }
+
+      opts.on('--runtime RUNTIME') { |rt|    @options[:runtime] = rt }
+
+      opts.on('--timeout TIMEOUT') { |t|
+        if t.to_i > 0
+          @options[:timeout] = t.to_i
+          puts "Set timeout: #{t} sec"
+        else
+          @options[:timeout] = 120
+        end
+      }
+      opts.on('-f FRAMEWORK', '--framework FRAMEWORK') { |fw| @options[:framework] = fw }
+
+      # deprecated
+      opts.on('--exec EXEC')       { |exec|  @options[:exec] = exec }
+      opts.on('--noframework')     {         @options[:noframework] = true }
+      opts.on('--canary')          {         @options[:canary] = true }
+
+      # Proxying for another user, requires admin privileges
+      opts.on('-u PROXY')          { |proxy| @options[:proxy] = proxy }
+
+      opts.on_tail('--options')    {          puts "#{opts}\n"; exit }
+
+      # For Cloudn RDB
+      opts.on('--DBName DBNAME')           { |exec|  @options[:DBName] = exec }
+      opts.on('--MasterUsername USER')     { |exec|  @options[:MasterUsername] = exec }
+      opts.on('--MasterUserPassword PASS') { |exec|  @options[:MasterUserPassword] = exec }
+    end
+    instances_delta_arg = check_instances_delta!
+    @args = opts_parser.parse!(@args)
+    @args.concat instances_delta_arg
+    convert_options!
+    self
+  end
+
+  def check_instances_delta!
+    return unless @args
+    instance_args = @args.select { |arg| /^[-]\d+$/ =~ arg } || []
+    @args.delete_if { |arg| instance_args.include? arg}
+    instance_args
+  end
+
+  def display_help
+    puts command_usage
+    exit
+  end
+
+  def convert_options!
+    # make sure certain options are valid and in correct form.
+    @options[:instances] = Integer(@options[:instances]) if @options[:instances]
+  end
+
+  def set_cmd(namespace, action, args_range=0)
+    return if @help_only
+    unless args_range == "*" || args_range.is_a?(Range)
+      args_range = (args_range.to_i..args_range.to_i)
+    end
+
+    if args_range == "*" || args_range.include?(@args.size)
+      @namespace = namespace
+      @action    = action
+    else
+      @exit_status = false
+      if @args.size > args_range.last
+        usage_error("Too many arguments for [#{action}]: %s" % [ @args[args_range.last..-1].map{|a| "'#{a}'"}.join(', ') ])
+      else
+        usage_error("Not enough arguments for [#{action}]")
+      end
+    end
+  end
+
+  def parse_command!
+    # just return if already set, happends with -v, -h
+    return if @namespace && @action
+
+    verb = @args.shift
+    case verb
+
+    when 'version'
+      usage('vmc version')
+      set_cmd(:misc, :version)
+
+    when 'target'
+      usage('vmc target [url] [--url]')
+      if @args.size == 1
+        set_cmd(:misc, :set_target, 1)
+      else
+        set_cmd(:misc, :target)
+      end
+
+    when 'targets'
+      usage('vmc targets')
+      set_cmd(:misc, :targets)
+
+    when 'tokens'
+      usage('vmc tokens')
+      set_cmd(:misc, :tokens)
+
+    when 'info'
+      usage('vmc info')
+      set_cmd(:misc, :info)
+
+    when 'runtimes'
+      usage('vmc runtimes')
+      set_cmd(:misc, :runtimes)
+
+    when 'frameworks'
+      usage('vmc frameworks')
+      set_cmd(:misc, :frameworks)
+
+    when 'user'
+      usage('vmc user')
+      set_cmd(:user, :info)
+
+    when 'login'
+      usage('vmc login [email] [--email EMAIL] [--passwd PASS]')
+      if @args.size == 1
+        set_cmd(:user, :login, 1)
+      else
+        set_cmd(:user, :login)
+      end
+
+    when 'logout'
+      usage('vmc logout')
+      set_cmd(:user, :logout)
+
+    when 'passwd'
+      usage('vmc passwd')
+      if @args.size == 1
+        set_cmd(:user, :change_password, 1)
+      else
+        set_cmd(:user, :change_password)
+      end
+
+    when 'add-user', 'add_user', 'create_user', 'create-user', 'register'
+      usage('vmc add-user [user] [--email EMAIL] [--passwd PASS]')
+      if @args.size == 1
+        set_cmd(:admin, :add_user, 1)
+      else
+        set_cmd(:admin, :add_user)
+      end
+
+    when 'delete-user', 'delete_user', 'unregister'
+      usage('vmc delete-user <user>')
+      set_cmd(:admin, :delete_user, 1)
+
+    when 'users'
+      usage('vmc users')
+      set_cmd(:admin, :users)
+
+    when 'apps'
+      usage('vmc apps')
+      set_cmd(:apps, :apps)
+
+    when 'list'
+      usage('vmc list')
+      set_cmd(:apps, :list)
+
+    when 'start'
+      usage('vmc start <appname>')
+      set_cmd(:apps, :start, @args.size == 1 ? 1 : 0)
+
+    when 'stop'
+      usage('vmc stop <appname>')
+      set_cmd(:apps, :stop, @args.size == 1 ? 1 : 0)
+
+    when 'restart'
+      usage('vmc restart <appname>')
+      set_cmd(:apps, :restart, @args.size == 1 ? 1 : 0)
+
+    when 'mem'
+      usage('vmc mem <appname> [memsize]')
+      if @args.size == 2
+        set_cmd(:apps, :mem, 2)
+      else
+        set_cmd(:apps, :mem, 1)
+      end
+
+    when 'stats'
+      usage('vmc stats <appname>')
+      set_cmd(:apps, :stats, @args.size == 1 ? 1 : 0)
+
+    when 'map'
+      usage('vmc map <appname> <url>')
+      set_cmd(:apps, :map, 2)
+
+    when 'unmap'
+      usage('vmc unmap <appname> <url>')
+      set_cmd(:apps, :unmap, 2)
+
+    when 'delete'
+      usage('vmc delete <appname>')
+      if @options[:all] && @args.size == 0
+        set_cmd(:apps, :delete)
+      else
+        set_cmd(:apps, :delete, 1)
+      end
+
+    when 'files'
+      usage('vmc files <appname> [path] [--instance N] [--all] [--prefix]')
+      if @args.size == 1
+        set_cmd(:apps, :files, 1)
+      else
+        set_cmd(:apps, :files, 2)
+      end
+
+    when 'logs'
+      usage('vmc logs <appname> [--instance N] [--all] [--prefix]')
+      set_cmd(:apps, :logs, 1)
+
+    when 'instances', 'scale'
+      if @args.size > 1
+        usage('vmc instances <appname> <num|delta>')
+        set_cmd(:apps, :instances, 2)
+      else
+        usage('vmc instances <appname>')
+        set_cmd(:apps, :instances, 1)
+      end
+
+    when 'crashes'
+      usage('vmc crashes <appname>')
+      set_cmd(:apps, :crashes, 1)
+
+    when 'crashlogs'
+      usage('vmc crashlogs <appname>')
+      set_cmd(:apps, :crashlogs, 1)
+
+    when 'push'
+      usage('vmc push [appname] [--path PATH] [--url URL] [--instances N] [--mem] [--runtime RUNTIME] [--no-start]')
+      if @args.size == 1
+        set_cmd(:apps, :push, 1)
+      else
+        set_cmd(:apps, :push, 0)
+      end
+
+    when 'update'
+      usage('vmc update <appname> [--path PATH]')
+      set_cmd(:apps, :update, @args.size == 1 ? 1 : 0)
+
+    when 'services'
+      usage('vmc services')
+      set_cmd(:services, :services)
+
+    when 'env'
+      usage('vmc env <appname>')
+      set_cmd(:apps, :environment, 1)
+
+    when 'env-add'
+      usage('vmc env-add <appname> <variable[=]value>')
+      if @args.size == 2
+        set_cmd(:apps, :environment_add, 2)
+      elsif @args.size == 3
+        set_cmd(:apps, :environment_add, 3)
+      end
+
+    when 'env-del'
+      usage('vmc env-del <appname> <variable>')
+      set_cmd(:apps, :environment_del, 2)
+
+    when 'create-service', 'create_service'
+      usage('vmc create-service [service] [servicename] [plan] [appname] [--name servicename] [--bind appname] [--plan plan]')
+      set_cmd(:services, :create_service) if @args.size == 0
+      set_cmd(:services, :create_service, 1) if @args.size == 1
+      set_cmd(:services, :create_service, 2) if @args.size == 2
+      set_cmd(:services, :create_service, 3) if @args.size == 3
+      set_cmd(:services, :create_service, 4) if @args.size == 4
+
+    when 'register-service', 'register_service'
+      usage('vmc register-service [external] [type] [credentials] [appname] [--name servicename] [--bind appname] [--plan plan]')
+      set_cmd(:services, :register_service) if @args.size == 0
+      set_cmd(:services, :register_service, 1) if @args.size == 1
+      set_cmd(:services, :register_service, 2) if @args.size == 2
+      set_cmd(:services, :register_service, 3) if @args.size == 3
+      set_cmd(:services, :register_service, 4) if @args.size == 4
+
+    when 'delete-service', 'delete_service'
+      usage('vmc delete-service <service>')
+      if @args.size == 1
+        set_cmd(:services, :delete_service, 1)
+      else
+        set_cmd(:services, :delete_service)
+      end
+
+    when 'bind-service', 'bind_service'
+      usage('vmc bind-service <servicename> <appname>')
+      set_cmd(:services, :bind_service, 2)
+
+    when 'unbind-service', 'unbind_service'
+      usage('vmc unbind-service <servicename> <appname>')
+      set_cmd(:services, :unbind_service, 2)
+
+    when 'clone-services'
+      usage('vmc clone-services <src-app> <dest-app>')
+      set_cmd(:services, :clone_services, 2)
+
+    when 'aliases'
+      usage('vmc aliases')
+      set_cmd(:misc, :aliases)
+
+    when 'alias'
+      usage('vmc alias <alias[=]command>')
+      if @args.size == 1
+        set_cmd(:misc, :alias, 1)
+      elsif @args.size == 2
+        set_cmd(:misc, :alias, 2)
+      end
+
+    when 'unalias'
+      usage('vmc unalias <alias>')
+      set_cmd(:misc, :unalias, 1)
+
+    when 'tunnel'
+      usage('vmc tunnel [servicename] [clientcmd] [--port port]')
+      set_cmd(:services, :tunnel, 0) if @args.size == 0
+      set_cmd(:services, :tunnel, 1) if @args.size == 1
+      set_cmd(:services, :tunnel, 2) if @args.size == 2
+
+    when 'rails-console'
+      usage('vmc rails-console <appname>')
+      set_cmd(:apps, :console, 1)
+
+    when 'micro'
+      usage('vmc micro <online|offline|status> [--password password] [--save] [--vmx file] [--vmrun executable]')
+      if %w[online offline status].include?(@args[0])
+          set_cmd(:micro, @args[0].to_sym, 1)
+      end
+
+    when 'help'
+      display_help if @args.size == 0
+      @help_only = true
+      parse_command!
+
+    when 'usage'
+      display basic_usage
+      exit(true)
+
+    when 'options'
+      # Simulate --options
+      @args = @args.unshift('--options')
+      parse_options!
+
+    when 'manifest'
+      usage('vmc manifest')
+      set_cmd(:manifest, :edit)
+
+    when 'extend-manifest'
+      usage('vmc extend-manifest')
+      set_cmd(:manifest, :extend, 1)
+
+    else
+      if verb
+        display "vmc: Unknown command [#{verb}]"
+        display basic_usage
+        exit(false)
+      end
+    end
+  end
+
+  def process_aliases!
+    return if @args.empty?
+    aliases = VMC::Cli::Config.aliases
+    aliases.each_pair do |k,v|
+      if @args[0] == k
+        display "[#{@args[0]} aliased to #{aliases.invert[key]}]" if @options[:verbose]
+        @args[0] = v
+        break;
+      end
+    end
+  end
+
+  def usage(msg = nil)
+    @usage = msg if msg
+    @usage
+  end
+
+  def usage_error(msg = nil)
+    @usage_error = msg if msg
+    @usage_error
+  end
+
+  def run
+
+    trap('TERM') { print "\nTerminated\n"; exit(false)}
+
+    parse_options!
+
+    @options[:colorize] = false unless STDOUT.tty?
+
+    VMC::Cli::Config.colorize   = @options.delete(:colorize)
+    VMC::Cli::Config.nozip      = @options.delete(:nozip)
+    VMC::Cli::Config.trace      = @options.delete(:trace)
+    VMC::Cli::Config.output   ||= STDOUT unless @options[:quiet]
+
+    process_aliases!
+    parse_command!
+
+    if @namespace && @action
+      cmd = VMC::Cli::Command.const_get(@namespace.to_s.capitalize)
+      cmd.new(@options).send(@action, *@args.collect(&:dup))
+    elsif @help_only || @usage
+      display_usage
+    else
+      display basic_usage
+      exit(false)
+    end
+
+  rescue OptionParser::InvalidOption => e
+    puts(e.message.red)
+    puts("\n")
+    puts(basic_usage)
+    @exit_status = false
+  rescue OptionParser::AmbiguousOption => e
+    puts(e.message.red)
+    puts("\n")
+    puts(basic_usage)
+    @exit_status = false
+  rescue VMC::Client::AuthError => e
+    if VMC::Cli::Config.auth_token.nil?
+      puts "Login Required".red
+    else
+      puts "Not Authorized".red
+    end
+    @exit_status = false
+  rescue VMC::Client::TargetError, VMC::Client::NotFound, VMC::Client::BadTarget  => e
+    puts e.message.red
+    @exit_status = false
+  rescue VMC::Client::HTTPException => e
+    puts e.message.red
+    @exit_status = false
+  rescue VMC::Cli::GracefulExit => e
+    # Redirected commands end up generating this exception (kind of goto)
+  rescue VMC::Cli::CliExit => e
+    puts e.message.red
+    @exit_status = false
+  rescue VMC::Cli::CliError => e
+    say("Error #{e.error_code}: #{e.message}".red)
+    @exit_status = false
+  rescue SystemExit => e
+    @exit_status = e.success?
+  rescue SyntaxError => e
+    puts e.message.red
+    puts e.backtrace
+    @exit_status = false
+  rescue Interrupt => e
+    say("\nInterrupted".red)
+    @exit_status = false
+  rescue Exception => e
+    puts e.message.red
+    puts e.backtrace
+    @exit_status = false
+  ensure
+    say("\n")
+    @exit_status == true if @exit_status.nil?
+    if @options[:verbose]
+      if @exit_status
+        puts "[#{@namespace}:#{@action}] SUCCEEDED".green
+      else
+        puts "[#{@namespace}:#{@action}] FAILED".red
+      end
+      say("\n")
+    end
+    exit(@exit_status)
+  end
+
+end