vmc 0.0.8 → 0.2.4

data/lib/vmc.rb

@@ -1,1590 +1,3 @@
-# Copyright 2010, VMware, Inc. Licensed under the
-# MIT license, please see the LICENSE file.  All rights reserved
+module VMC; end
 
-require 'rubygems'
-require 'pp'
-require 'vmc_base'
-require 'highline/import'
-
-module VMC
-
-  class Client < VMC::BaseClient
-
-    VERSION = "0.0.7"
-
-    attr_reader :host, :base_uri, :droplets_uri, :services_uri, :resources_uri, :token, :args
-
-    attr_accessor :puser
-
-    def setup_target_uris
-      get_host_target
-      @base_uri = "http://#{@host}"
-      @droplets_uri = "#{base_uri}/apps"
-      @services_uri = "#{base_uri}/services"
-      @resources_uri = "#{base_uri}/resources"
-    end
-
-    def check_target
-      get_token # Just load it if its around
-      @check = HTTPClient.get "#{base_uri}/info", nil, auth_hdr
-      error "\nERROR: Unable to contact target server: [#{@base_uri}]\n\n" if @check.status != 200
-      #display "\n[#{@base_uri}]\n\n"
-      check_puser if @puser
-    rescue
-      error "\nERROR: Unable to contact target server: [#{@base_uri}]\n\n"
-    end
-
-    def set_puser(puser)
-      @puser = puser
-    end
-
-    def check_puser
-      info_json = JSON.parse(@check.content)
-      username = info_json['user']
-      error "ERROR: Proxying to #{@puser} failed." unless (username && (username.downcase == @puser.downcase))
-    end
-
-    # ------- commands --------
-
-    # show version string
-    def version
-      display VERSION
-      exit 0
-    end
-
-    # Define a new cloud controller target
-    def target(host=nil)
-      unless host
-        display "\n[#{@base_uri}]\n\n"
-        return
-      end
-
-      target_host = host.gsub(/^http(s*):\/\//i, '')
-      try_host = "http://#{target_host}/info"
-      target_host_display = "http://#{target_host}"
-      display ''
-      begin
-        response = HTTPClient.get try_host
-        if response.status != 200
-          display "New Target host is not valid: '#{target_host_display}'"
-          show_response = ask "Would you like see the response [yN]? "
-          display response.content if show_response.upcase == 'Y'
-          exit(1)
-        end
-        response_json = JSON.parse(response.content)
-        error "New Target host is not valid: '#{target_host_display}'" unless
-          response_json['name'] && response_json['version'] && response_json['support'] && response_json['description']
-      rescue => e
-        display e
-        error "New Target host is not valid: '#{target_host_display}'"
-      end
-      write_host_target(target_host)
-      display "Succesfully targeted to [#{target_host_display}]\n\n"
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    # get information about this cloud
-    def info
-      info_json = JSON.parse(@check.content)
-
-      display "\n#{info_json['description']}"
-      display "For support visit #{info_json['support']}"
-      display ""
-      display "Target:   #{@base_uri} (v#{info_json['version']})"
-      display "Client:   v#{VERSION}"
-      if info_json['user']
-        display ''
-        display "User:     #{info_json['user']}"
-      end
-      if usage = info_json['usage'] and limits = info_json['limits']
-        tmem  = pretty_size(limits['memory']*1024*1024)
-        mem   = pretty_size(usage['memory']*1024*1024)
-        tser  = limits['services']
-        ser   = usage['services']
-        tapps = limits['apps'] || 0
-        apps  = usage['apps'] || 0
-
-        display "Usage:    Memory   (#{mem} of #{tmem} total)"
-        display "          Services (#{ser} of #{tser} total)"
-        display "          Apps     (#{apps} of #{tapps} total)" if limits['apps']
-      end
-      display ''
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    # register me as a user of this cloud
-    def register(email=nil,password=nil)
-      if not email and not password
-        puts "Register your account with an email account and password."
-        email = ask("Email: ")
-        password = ask("Password: ") {|q| q.echo = '*'}
-        password2 = ask("Verify Password: ") {|q| q.echo = '*'}
-        error "Passwords did not match, try again" if password != password2
-      end
-      get_token # Just load it if its around
-      register_internal(@base_uri, email, password, auth_hdr)
-      display "Registration completed"
-      # do an autologin also to setup token, avoiding login on next VMC command.
-      login_save_token(email, password) unless @token
-    rescue => e
-      error "Problem registering, #{e}"
-    end
-
-    def login(email=nil,password=nil)
-      if email and not password
-        tries = 0
-        begin
-          password = ask("Password: ") {|q| q.echo = '*'}
-          login_save_token(email, password)
-          display ""
-        rescue => e
-          display "Problem with login, #{e}, try again or register for an account."
-          retry if (tries += 1) < 3
-          exit 1
-        end
-      elsif !(email && password)
-        tries = 0
-        begin
-          email = ask("Email: ")
-          password = ask("Password: ") {|q| q.echo = '*'}
-          login_save_token(email, password)
-          display ""
-        rescue => e
-          display "Problem with login, #{e}, try again or register for an account."
-          retry if (tries += 1) < 3
-          exit 1
-        end
-      else
-        begin
-          login_save_token(email, password)
-          display ""
-        rescue => e
-          error "Problem with login, #{e}, try again or register for an account."
-        end
-      end
-    end
-
-    def logout
-      FileUtils.rm_f(token_file)
-      display "Succesfully logged out."
-    end
-
-    # Change the current users passwd
-    def passwd(password=nil)
-      check_for_token
-      user_info = JSON.parse(@check.content)
-      email = user_info['user']
-      puts "Changing password for #{email}\n\n"
-      if !password
-        password = ask("Password: ") {|q| q.echo = '*'}
-        password2 = ask("Verify Password: ") {|q| q.echo = '*'}
-        error "Passwords did not match, try again" if password != password2
-      end
-
-      response = get_user_internal(@base_uri, email, auth_hdr)
-      user_info = JSON.parse(response.content)
-      user_info['password'] = password
-      change_passwd_internal(@base_uri, user_info, auth_hdr)
-
-      display "Password succesfully changed."
-      # do an autologin also to setup token, avoiding login on next VMC command.
-      # only if not proxying
-      login_save_token(email, password) unless @puser
-      rescue => e
-        error "Problem changing password, #{e}"
-    end
-
-
-    def login_save_token(email, password)
-      # TODO: We should be url encoding email
-      @token = login_internal(@base_uri, email, password)
-      write_token
-    end
-
-    def target_file
-      "#{ENV['HOME']}/.vmc_target"
-    end
-
-    def get_host_target
-      return if @host
-      if File.exists? target_file
-        @host = File.read(target_file).strip!
-        ha = @host.split('.')
-        ha.shift
-        @suggest_url = ha.join('.')
-        @suggest_url = 'b29.me' if @suggest_url.empty?
-      else
-        @host = 'api.b29.me'
-        @suggest_url = 'b29.me'
-      end
-    end
-
-    def write_host_target(target_host)
-      File.open(target_file, 'w+') { |f| f.puts target_host }
-      FileUtils.chmod 0600, target_file
-    end
-
-    def token_file
-      "#{ENV['HOME']}/.vmc_token"
-    end
-
-    def instance_file
-      "#{ENV['HOME']}/.vmc_instances"
-    end
-
-    def get_token
-      return @token if @token
-      if File.exists?(token_file)
-        contents = File.read(token_file).strip
-        begin
-          tokens = JSON.parse(contents)
-          @token = tokens[@base_uri]
-        rescue
-          @token = contents
-          write_token
-        end
-      end
-    end
-
-    def check_for_token
-      return if get_token
-      display "Please Login:\n\n"
-      login
-      check_for_token
-    end
-
-    def write_token
-      contents = File.exists?(token_file) ? File.read(token_file).strip : nil
-      tokens = {}
-
-      if contents
-        begin
-          tokens = JSON.parse(contents)
-        rescue
-        end
-      end
-
-      tokens[@base_uri] = @token
-
-      File.open(token_file, 'w+') { |f| f.write(tokens.to_json) }
-      FileUtils.chmod 0600, token_file
-    end
-
-    def auth_hdr
-      auth = { 'AUTHORIZATION' => "#{@token}" }
-      auth['PROXY-USER'] = @puser if @puser
-      return auth
-    end
-
-    def display_services_banner
-      #display "#{'Name'.ljust(15)} #{'Service'.ljust(10)} #{'Version'.ljust(10)} #{'Plans'}"
-      #display "#{'----'.ljust(15)} #{'-------'.ljust(10)} #{'-------'.ljust(10)} #{'-----'}"
-      display "#{'Name'.ljust(15)} #{'Service'.ljust(10)}"
-      display "#{'----'.ljust(15)} #{'-------'.ljust(10)}"
-
-    end
-
-    def list_services(service_names, banner)
-      services = []
-      service_names.each { |service_name|
-        sn = URI.escape("#{services_uri}/#{service_name}")
-        response = HTTPClient.get(sn, nil, auth_hdr)
-        error "Problem getting services list" if response.status != 200
-        services << JSON.parse(response.content)
-      }
-
-      display(banner)
-
-      if services.empty?
-        display "None provisioned yet."
-      else
-        display_services_banner
-        services.each { |h|
-          display "#{h['name'].to_s.ljust(15)} ", false
-          display "#{h['vendor'].ljust(10)} "
-          #display "#{h['vendor'].ljust(10)} ", false
-          #display "#{h['version'].ljust(10)} ", false
-          #display "#{h['tier']}"
-        }
-      end
-    end
-
-    def app_list_services(appname=nil)
-      error "Application name required\nvmc app services <appname>" unless appname
-
-      response = HTTPClient.get "#{droplets_uri}/#{appname}", nil, auth_hdr
-      error "Application does not exist." if response.status == 404
-      return '' if response.status != 200
-      service_names = JSON.parse(response.content)['services']
-      service_names.empty? ? "None" : service_names.join(", ")
-    end
-
-    def user_list_services_helper
-      service_names = get_user_service_names
-      #list_services(service_names, "Provisioned Services:\n\n")
-      list_services(service_names, "\n======= Provisioned Services ========\n\n")
-    end
-
-    def get_user_service_names
-      service_names = []
-      response = HTTPClient.get "#{services_uri}", nil, auth_hdr
-      response_json = JSON.parse(response.content)
-      response_json.each { |service_desc| service_names << service_desc['name'] }
-      service_names
-    end
-
-    def services
-      check_for_token
-      response = HTTPClient.get "#{base_uri}/info/services", nil, auth_hdr
-      handle_response(response)
-      display "\n========== System Services ==========\n\n"
-      services = JSON.parse(response.content)
-      display_services_directory_banner
-      services.each { |service_type, value|
-        value.each { |vendor, version|
-          version.each { |version_str, service|
-            display "#{vendor.ljust(10)} ", false
-            display "#{version_str.ljust(5)} ", false
-            display "#{service['description']}"
-          }
-        }
-      }
-      display ""
-      user_list_services_helper
-      display ""
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def bind_service(service_name, appname)
-      display "Creating new service binding to '#{service_name}' for '#{appname}'."
-
-      # Now get the app and update it with the provisioned service
-      response = get_app_internal(droplets_uri, appname, auth_hdr)
-      appinfo = JSON.parse(response.content)
-      provisioned_service = appinfo['services']
-      provisioned_service = [] unless provisioned_service
-      provisioned_service << service_name
-      appinfo['services'] = provisioned_service
-      response = update_app_state_internal droplets_uri, appname, appinfo, auth_hdr
-      error "Problem updating application with new services" if response.status >= 400
-      display "Application '#{appname}' updated."
-      restart appname if appinfo['state'] == 'STARTED'
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def unbind_service(service_name, appname)
-      app_remove_service(appname, service_name)
-    end
-
-    def create_service(service, opts={})
-      check_for_token
-      response = HTTPClient.get "#{base_uri}/info/services", nil, auth_hdr
-      handle_response(response)
-      services = JSON.parse(response.content)
-      types = []
-      services.each {|k,v| types <<  v }
-      selection = nil
-      types.each { |t| selection = t if t[service] }
-      if ! selection
-        options = []
-        types.each {|t| options << t.keys }
-        options.flatten!
-        error("Service type must be one of: #{options.join(',')}") unless options.empty?
-        error("No selectable services at this time") if options.empty?
-      else
-        info = selection[service][selection[service].keys.first]
-        service_name = opts[:name] || "#{service}-#{fast_uuid[0..6]}"
-        service_type = info['type']
-        service_vendor = info['vendor']
-        service_tier = 'free'
-        service_version = info['version']
-
-        services = {
-          :name => service_name,
-          :type => service_type,
-          :vendor => service_vendor,
-          :tier => service_tier,
-          :version => service_version,
-          #:options => option_values
-        }
-
-        check_for_token
-        response = add_service_internal @services_uri, services, auth_hdr
-        handle_response(response)
-        display "Service '#{service_name}' provisioned."
-
-        if appname = opts[:bind]
-          display "Creating new service binding to '#{service_name}' for '#{appname}'."
-
-          # Now get the app and update it with the provisioned service
-          response = get_app_internal(droplets_uri, appname, auth_hdr)
-          handle_response(response)
-          appinfo = JSON.parse(response.content)
-          provisioned_service = appinfo['services']
-          provisioned_service = [] unless provisioned_service
-          provisioned_service << service_name
-          appinfo['services'] = provisioned_service
-          response = update_app_state_internal droplets_uri, appname, appinfo, auth_hdr
-          handle_response(response)
-          display "Application '#{appname}' updated."
-          restart appname if appinfo['state'] == 'STARTED'
-        end
-      end
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def delete_service(service)
-      check_for_token
-      user_remove_service_helper(service)
-    end
-
-    def user_remove_service_helper(service_name=nil)
-      available_services = get_user_service_names
-      error "No services to delete" if available_services.empty?
-
-      unless service_name
-        choose do |menu|
-          #menu.header = "The following services are provisioned"
-          menu.prompt = 'Please select the service you wish to delete: '
-          menu.select_by = :index
-          available_services.each { |key| menu.choice(key) { service_name = key } }
-        end
-      end
-
-      error "Error: Invalid service" unless available_services.include? service_name
-
-      remove_service_internal(services_uri, service_name, auth_hdr)
-      display("Successfully removed service: #{service_name}")
-    end
-
-    def user_add_service_helper(service_name_prefix, opts={})
-      service_type = opts[:type]
-      service_vendor = opts[:vendor]
-      service_version = opts[:version]
-      service_tier = opts[:tier]
-      service_name = opts[:name]
-      service_size = opts[:size]
-      response = HTTPClient.get "#{base_uri}/info/services", nil, auth_hdr
-      handle_response(response)
-
-      last_print = :none
-
-      services = JSON.parse(response.content)
-
-      available_services = {}
-      services.each do |type, vendors|
-        vendors.each do |vendor, versions|
-          versions.each do |version, entry|
-            tiers = entry["tiers"]
-            if tiers.size > 1
-              tier = tiers.has_key?("free") ? "free" : tiers.keys.first
-              entry["tiers"] = {tier => tiers[tier]}
-            end
-            available_services[vendor] = {:type => type, :version => version} if (service_type.nil? or service_type == type)
-          end
-        end
-      end
-
-      return nil if available_services.empty?
-
-      service_type_hash = nil
-      service_vendor = nil if (service_vendor and service_vendor.empty?)
-      unless service_vendor
-
-        if available_services.length == 1
-          service_vendor = available_services.keys.first
-          service_type_hash = services[available_services[service_vendor][:type]]
-
-          service_type = available_services[service_vendor][:type]
-          say("Single #{service_type} service available: #{service_vendor}")
-          last_print = :auto
-        else
-          puts "" if last_print == :auto
-          choose do |menu|
-            menu.header = "The following #{service_type} services are available"
-            menu.prompt = 'Please select one you wish to provision: '
-            menu.select_by = :index
-
-            available_services.each_key do |key|
-              menu.choice(key) do
-                service_type = available_services[key][:type]
-                service_type_hash = services[service_type]
-                service_vendor = key
-              end
-            end
-          end
-          last_print = :menu
-        end
-      end
-      error "Could not find vendor '#{service_vendor}' for #{service_type} services." unless service_type_hash[service_vendor]
-
-      service_vendor_hash = service_type_hash[service_vendor]
-
-      unless service_version
-        puts "" if last_print == :menu
-        if service_vendor_hash.length == 1
-          service_version = service_vendor_hash.first[0]
-          say("Single version available: #{service_version}")
-          last_print = :auto
-        else
-          puts "" if last_print == :auto
-          choose do |menu|
-            menu.header = "The following #{service_vendor} #{service_type} versions are available"
-            menu.prompt = 'Please select one you wish to provision: '
-            menu.select_by = :index
-
-            service_vendor_hash.each_key do |key|
-              menu.choice(key) { service_version = key }
-            end
-          end
-         last_print = :menu
-        end
-      end
-      error "Could not find version '#{service_version}' for #{service_vendor} #{service_type}." unless service_vendor_hash[service_version]
-
-      service_version_hash = service_vendor_hash[service_version]
-      service_tier = service_version_hash['tiers'].keys.first
-
-      service_tier_hash = service_version_hash['tiers'][service_tier]
-      options = service_tier_hash['options']
-
-      option_values = {}
-      if options
-        options.each do |k, v|
-
-          if service_size
-            option_values['size'] = service_size
-          else
-            puts "" if last_print == :menu
-            if v['type'] == 'value'
-              puts "" if last_print == :auto
-              choose do |menu|
-                menu.prompt = "#{k} (#{v['description']}): "
-                menu.select_by = :index
-
-
-                v['values'].each do |option|
-                  option_value = option
-                  menu.choice("#{option}") { option_values[k] = option_value }
-                end
-              end
-              last_print = :menu
-            end
-          end
-        end
-      end
-
-      default_service_name = "#{service_vendor}-#{fast_uuid[0..6]}"
-      if service_name.nil?
-        puts ""
-        service_name = ask("Specify the name of the service [#{default_service_name}]: ")
-        service_name = default_service_name if service_name.empty?
-      end
-
-      services = {
-        :name => service_name,
-        :type => service_type,
-        :vendor => service_vendor,
-        :tier => service_tier,
-        :version => service_version,
-        :options => option_values
-      }
-
-      check_for_token
-      response = add_service_internal @services_uri, services, auth_hdr
-      handle_response(response)
-      display "Service '#{service_vendor}' provisioned."
-
-      service_name
-    end
-
-
-    def app_add_service(opts={})
-      service_type = opts[:service]
-      service_vendor = opts[:vendor]
-      service_version = opts[:version]
-      service_tier = opts[:tier]
-      appname = opts[:appname]
-
-      error "Application name required\nvmc apps add-service <appname> [service] [vendor] [version] [tier]" unless appname
-
-      app_add_service_helper(appname, service_type, service_vendor, service_version, service_tier)
-
-      @appname = appname
-      restart
-    end
-
-    def app_add_service_helper(appname, service_type=nil, service_vendor=nil, service_version=nil, service_tier=nil)
-      check_for_token
-
-      # If we have a single arg, let's assume its a service name..
-      if service_type && !service_vendor && !service_version && !service_tier
-        service_name = service_type
-        service_type = nil
-      end
-
-      service_names = get_user_service_names
-
-      if service_name && (service_names.empty? || !service_names.include?(service_name))
-        service_name = nil
-      end
-
-      if !service_names.empty? && !service_name
-        list_services(get_user_service_names, "The following services have been provisioned for you:")
-        display ''
-        use_existing = ask "Would you like to use one of these [yN]? "
-        if use_existing.upcase == 'Y'
-          begin
-            service_name = ask "Which service (name)? "
-            if !service_names.include?(service_name)
-              display "Incorrect service name, please type again"
-              service_name = nil
-            end
-          end while !service_name
-        end
-      end
-
-      if !service_name
-        display "Let's provision a new service"
-        opts = {
-          :type => service_type,
-          :vendor => service_vendor,
-          :version => service_version,
-          :tier => service_tier
-        }
-        service_name = user_add_service_helper(appname, opts)
-      end
-
-      unless service_name
-        display "No services available to provision"
-        # Should we ask if they want to continue?
-        return
-      end
-
-      display "Creating new service binding to '#{service_name}' for '#{appname}'."
-
-      # Now get the app and update it with the provisioned service
-      response = get_app_internal(droplets_uri, appname, auth_hdr)
-      appinfo = JSON.parse(response.content)
-      provisioned_service = appinfo['services']
-      provisioned_service = [] unless provisioned_service
-      provisioned_service << service_name
-      appinfo['services'] = provisioned_service
-      response = update_app_state_internal droplets_uri, appname, appinfo, auth_hdr
-      handle_response(response)
-      display "Application '#{appname}' updated."
-    end
-
-    def format_price(amount, type, *rest)
-      case type
-      when 'flat'
-        return "$#{amount}/#{rest[0]}"
-      when 'metered'
-        raise "Not Implemented"
-      end
-    end
-
-    def app_remove_service(appname=nil, service_name=nil)
-      check_for_token
-
-      app_response = get_app_internal(droplets_uri, appname, auth_hdr)
-      appinfo = JSON.parse(app_response.content)
-      provisioned_service = appinfo['services']
-      provisioned_service = [] unless provisioned_service
-      provisioned_service.delete(service_name)
-      appinfo['services'] = provisioned_service
-      response = update_app_state_internal droplets_uri, appname, appinfo, auth_hdr
-      handle_response(response)
-      display "Application '#{appname}' updated"
-      display "Service #{service_name} removed."
-      @appname = appname
-      restart
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def list(first_arg=nil)
-      apps(first_arg)
-    end
-
-    def apps(first_arg=nil, opts={})
-      check_for_token
-
-      case first_arg
-        when "list" then list_apps
-        when nil then list_apps
-        when 'add-service' then app_add_service(opts)
-        when 'remove-service' then app_remove_service(opts[:appname], opts[:service_name])
-        when 'list-services' then app_list_services(opts[:appname])
-        else "Incorrect option #{first_arg}. Must be 'list' (default), 'services', 'add-service', or 'remove-service"
-      end
-    end
-
-    def health(d)
-      return 'N/A' unless (d and d['state'])
-
-      healthy_instances = d['runningInstances']
-      expected_instance = d['instances']
-      health = nil
-
-      if d['state'] == "STARTED" && expected_instance > 0 && healthy_instances
-        health = format("%.3f", healthy_instances.to_f / expected_instance).to_f
-      end
-
-      if health
-        if health == 1.0
-          health = "RUNNING"
-        else
-          health = "#{(health * 100).round}%"
-        end
-      else
-        if d['state'] == 'STOPPED'
-          health = 'STOPPED'
-        else
-          health = 'N/A'
-        end
-      end
-
-      health
-    end
-
-    def list_apps
-      droplets_full = get_apps_internal @droplets_uri, auth_hdr
-      if droplets_full.empty?
-        display "No applications available."
-        return
-      end
-
-      display "#{'APPNAME'.ljust 15} #{'HEALTH'.ljust 8} #{'INSTANCES'.ljust 10} #{'SERVICES'.ljust 25} #{'URL'.ljust 15}\n"
-      display "#{'-------'.ljust 15} #{'------'.ljust 8} #{'---------'.ljust 10} #{'--------'.ljust 25} #{'---'.ljust 15}\n"
-      droplets_full.each { |d|
-        display "#{d['name'].ljust 15} ", false
-        display "#{health(d).ljust 8} ", false
-        display "#{d['instances'].to_s.ljust 10} ", false
-        display "#{d['services'].join(", ").ljust(25)} ", false
-        #display "#{app_list_services(d['name']).ljust(25)} ", false
-        display "#{d['uris'].join(', ').ljust(15)}"
-      }
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    # opts = {:instances => [optional], :exec => [optional],
-    # :ignore_framework => [true/false/optional],
-    # :noframework => [true/false/optional],
-    # :appname => [optional],
-    # :url => [optional]}
-
-    def push(opts={})
-      instances = opts.delete(:instances) || 1
-      exec = opts.delete(:exec) || 'thin start'
-      ignore_framework = opts.delete(:noframework)
-      no_start = opts[:no_start]
-
-      path = opts[:path] || '.'
-      appname = opts[:appname]
-      url = opts[:url]
-      memswitch = opts[:mem]
-
-      check_for_token
-
-      # check if we have hit our app limit
-      check_app_limit
-
-      # check memsize here for capacity
-      check_has_capacity_for(mem_choice_to_quota(memswitch)) if memswitch
-
-      unless (appname && url)
-        unless opts[:path]
-          proceed = ask("Would you like to deploy from the current directory? [Yn]: ")
-          error "Push aborted" if proceed == 'n' || proceed == 'N'
-        end
-        appname = ask("Application Name: ") unless appname
-        error "Push aborted: Application Name required." if appname.empty?
-        url = ask("Application Deployed URL: '#{appname}.#{@suggest_url}'? ") unless url
-        url = "#{appname}.#{@suggest_url}" if url.empty?
-      end
-
-      response = get_app_internal(@droplets_uri, appname, auth_hdr)
-      error "Application #{appname} already exists, use update or delete." if response.status == 200
-
-      Dir.chdir(path) do
-        # Detect the appropriate framework.
-        framework = "http://b20nine.com/unknown"
-        mem = '256M'
-        unless ignore_framework
-          if File.exist?('config/environment.rb')
-            display "Rails application detected."
-            framework = "rails/1.0"
-          elsif Dir.glob('*.war').first
-            opt_war_file = Dir.glob('*.war').first
-            display "Java war file found, detecting framework..."
-
-            entries = []
-            Zip::ZipFile.foreach(opt_war_file) { |zentry| entries << zentry }
-            contents = entries.join("\n")
-
-            if contents =~ /WEB-INF\/grails-app/
-              display "Grails application detected."
-              framework = "grails/1.0"
-              mem = '512M'
-            elsif contents =~ /WEB-INF\/classes\/org\/springframework/
-              display "SpringSource application detected."
-              framework = "spring_web/1.0"
-              mem = '512M'
-            elsif contents =~ /WEB-INF\/lib\/spring-core.*\.jar/
-              display "SpringSource application detected."
-              framework = "spring_web/1.0"
-              mem = '512M'
-            else
-              display "Unknown J2EE Web Application"
-              framework = "spring_web/1.0"
-            end
-          elsif File.exist?('web.config')
-            display "ASP.NET application detected."
-            framework = "asp_web/1.0"
-          elsif !Dir.glob('*.rb').empty?
-            matched_file = nil
-            Dir.glob('*.rb').each do |fname|
-              next if matched_file
-              File.open(fname, 'r') do |f|
-                str = f.read # This might want to be limited
-                matched_file = fname if (str && str.match(/^\s*require\s*'sinatra'/i))
-              end
-            end
-            if matched_file && !File.exist?('config.ru')
-              display "Simple Sinatra application detected in #{matched_file}."
-              exec = "ruby #{matched_file}"
-            end
-            mem = '128M'
-          elsif !Dir.glob('*.js').empty?
-            # Fixme, make other files work too..
-            if File.exist?('app.js')
-              display "Node.js application detected."
-              framework = "nodejs/1.0"
-              mem = '64M'
-            end
-          end
-        end
-
-        mem = memswitch if memswitch
-        unless memswitch
-          choose do |menu|
-            menu.layout = :one_line
-            menu.prompt = "Memory Reservation [Default:#{mem}] "
-            menu.default = mem
-            mem_choices.each { |choice| menu.choice(choice) {  mem = choice } }
-          end
-        end
-
-        # Set to MB number
-        mem_quota = mem_choice_to_quota(mem)
-
-        # check memsize here for capacity
-        check_has_capacity_for(mem_quota)
-
-        manifest = {
-          :name => "#{appname}",
-          :staging => {
-            :model => framework,
-            :stack => exec
-          },
-          :uris => [url],
-          :instances => instances,
-          :resources => {
-            :memory => mem_quota
-          },
-        }
-
-        display "Uploading Application Information."
-
-        # Send the manifest to the cloud controller
-        response = create_app_internal(@droplets_uri, manifest, auth_hdr)
-        handle_response(response)
-
-        # Provision database here if needed.
-        if framework_needs_db?(framework)
-          proceed = ask("This framework usually needs a database, would you like to provision it? [Yn]: ")
-          if proceed != 'n' && proceed != 'N'
-            app_add_service_helper(appname, 'database', '')
-            provisioned_db = true
-          end
-        end
-
-        # Stage and upload the app bits.
-        display "Uploading Application."
-        upload_size = upload_app_bits(@resources_uri, @droplets_uri, appname, auth_hdr, opt_war_file, provisioned_db)
-        if upload_size > 1024*1024
-          upload_size  = (upload_size/(1024.0*1024.0)).round.to_s + 'M'
-        elsif upload_size > 0
-          upload_size  = (upload_size/1024.0).round.to_s + 'K'
-        end
-        display "\nUploaded Application '#{appname}' (#{upload_size})."
-
-        display "Push completed."
-        @push = true
-        @appname = appname
-        start unless no_start
-      end
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def delete(appname=nil, force=false)
-      error "Application name required, vmc delete <appname || --all> [--force]." unless appname
-
-      check_for_token
-
-      # wildcard behavior
-      apps = []
-      if appname == '--all'
-        droplets_full = get_apps_internal @droplets_uri, auth_hdr
-        apps = droplets_full.collect { |d| "#{d['name']}" }
-        apps.each { |app| delete_app(app, force) }
-      else
-        delete_app(appname, force)
-      end
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def delete_app(appname, force)
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      if response.status != 200
-        display "Application '#{appname}' does not exist."
-        return
-      end
-      appinfo = JSON.parse(response.content)
-      services_to_delete = []
-      app_services = appinfo['services']
-      app_services.each { |service|
-        del_service = 'Y' if force
-        del_service = ask("Application '#{appname}' uses '#{service}' service, would you like to delete it? [Yn]: ") unless force
-        services_to_delete << service unless (del_service == 'n' || del_service == 'N')
-      }
-      delete_app_internal @droplets_uri, appname, services_to_delete, auth_hdr
-      services_to_delete.each { |s| display "Service '#{s}' deleted."}
-      display "Application '#{appname}' deleted."
-    end
-
-    def stop(appname=nil)
-      appname ||= @appname
-      error "Application name required, vmc stop <appname>." unless appname
-
-      check_for_token
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      if response.status != 200
-        display "Application '#{appname}' does not exist, use push first."
-        return
-      end
-      appinfo = JSON.parse(response.content)
-      appinfo['state'] = 'STOPPED'
-      #display JSON.pretty_generate(appinfo)
-
-      hdrs = auth_hdr.merge({'content-type' => 'application/json'})
-      update_app_state_internal @droplets_uri, appname, appinfo, auth_hdr
-      display "Application '#{appname}' stopped."
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def start(appname=nil)
-      appname ||= @appname
-      error "Application name required, vmc start <appname>." unless appname
-
-      check_for_token
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      if response.status != 200
-        display"Application #{appname} does not exist, use push first."
-        return
-      end
-      appinfo = JSON.parse(response.content)
-      if (appinfo['state'] == 'STARTED')
-        display "Application '#{appname}' is already running."
-        return
-      end
-
-      appinfo['state'] = 'STARTED'
-
-      response = update_app_state_internal @droplets_uri, appname, appinfo, auth_hdr
-      handle_response(response)
-
-      count = 0
-      log_lines_displayed = 0
-      failed = false
-      display "Trying to start Application: '#{appname}'."
-      loop do
-        display ".", false unless count > 19
-        sleep 0.5
-        begin
-          if app_started_properly(appname, count > 6)
-            display ''
-            break;
-          elsif !crashes(appname, false).empty?
-            # Check for the existance of crashes
-            display "\n\nERROR - Application '#{appname}' failed to start, logs information below.\n\n"
-            grab_crash_logs(appname, '0', true)
-            if @push
-              display ''
-              should_delete = ask "Should I delete the application? (y/n)? "
-              delete_app(appname, false) if should_delete == 'Y' || should_delete == 'y'
-            end
-            failed = true
-            break
-          elsif count > 19
-            log_lines_displayed = grab_startup_tail(appname, log_lines_displayed)
-          end
-        rescue => e
-          display e.message, false
-        end
-        count += 1
-        if count > 600 # 5 minutes
-          error "\n\nApplication is taking too long to start, check your logs"
-          break
-        end
-      end
-
-      display("Application '#{appname}' started.") unless failed
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def restart(appname=nil)
-      appname ||= @appname
-      error "Application name required, vmc start <appname>." unless appname
-
-      stop(appname)
-      start(appname)
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def mem(appname, memsize=nil)
-      check_for_token
-
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      handle_response(response)
-
-      appinfo = JSON.parse(response.content)
-
-      mem = current_mem = mem_quota_to_choice(appinfo['resources']['memory'])
-
-      if ! memsize
-        choose do |menu|
-          menu.layout = :one_line
-          menu.prompt = "Update Memory Reservation? [Current:#{current_mem}] "
-          menu.default = current_mem
-          mem_choices.each { |choice| menu.choice(choice) {  memsize = choice } }
-        end
-      end
-
-      memsize = mem_choice_to_quota(memsize)
-      mem = mem_choice_to_quota(mem)
-
-      # check memsize here for capacity
-      check_has_capacity_for(memsize - mem)
-
-      mem = memsize
-
-      if (mem != current_mem)
-        appinfo['resources']['memory'] = mem
-        response = update_app_state_internal @droplets_uri, appname, appinfo, auth_hdr
-        handle_response(response)
-        display "Updated memory reservation to '#{mem_quota_to_choice(mem)}'."
-        restart appname if appinfo['state'] == 'STARTED'
-      end
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def update(appname=nil, canary=false)
-      error "Application name required, vmc update <appname>." unless appname
-
-      check_for_token
-
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      if response.status != 200
-        display "Application '#{appname}' does not exist, use push first."
-        return
-      end
-      appinfo = JSON.parse(response.content)
-
-      display "Uploading Application."
-      upload_app_bits(@resources_uri, @droplets_uri, appname, auth_hdr, Dir.glob('*.war').first)
-
-      unless canary
-        @appname = appname
-        display "Application updated."
-        restart appname if appinfo['state'] == 'STARTED'
-        return
-      end
-
-      response = update_app_internal @droplets_uri, appname, auth_hdr
-      handle_response(response)
-
-      last_state = 'NONE'
-      begin
-        response = get_update_app_status @droplets_uri, appname, auth_hdr
-
-        update_info = JSON.parse(response.content)
-        update_state = update_info['state']
-        if update_state != last_state
-          display('') unless last_state == 'NONE'
-          display("#{update_state.ljust(15)}", false)
-        else
-          display('.', false)
-        end
-
-        if update_state == 'SUCCEEDED' || update_state == 'CANARY_FAILED'
-          display('')
-          if update_state == 'CANARY_FAILED' && update_info['canary']
-            begin
-              map = File.open(instance_file, 'r') { |f| JSON.parse(f.read) }
-            rescue
-              map = {}
-            end
-
-            map["#{appname}-canary"] = update_info['canary']
-
-            File.open(instance_file, 'w') {|f| f.write(map.to_json)}
-            display("Debug the canary using 'vmc files #{appname} --instance #{appname}-canary'")
-          end
-          break
-        else
-          last_state = update_state
-        end
-        sleep(0.5)
-      end while true
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def change_instances(appinfo, appname, instances)
-      match = instances.match(/([+-])?\d+/)
-      error "Invalid number of instances '#{instances}', vmc instances <appname> <num>." unless match
-
-      instances = instances.to_i
-      current_instances = appinfo['instances']
-      new_instances = match.captures[0] ? current_instances + instances : instances
-      error "There must be at least 1 instance." if new_instances < 1
-
-      if current_instances == new_instances
-        display "Application '#{appname}' is already running #{new_instances} instance#{'s' if new_instances > 1}."
-        return
-      end
-
-      appinfo['instances'] = new_instances
-      response = update_app_state_internal @droplets_uri, appname, appinfo, auth_hdr
-
-      handle_response(response)
-
-      display "Scaled '#{appname}' #{new_instances > current_instances ? 'up' : 'down'} to " +
-              "#{new_instances} instance#{'s' if new_instances > 1}."
-    end
-
-    def get_instances(appname)
-      instances_info_envelope = get_app_instances_internal(@droplets_uri, appname, auth_hdr)
-
-      # Empty array is returned if there are no instances running.
-      error "No running instances for '#{appname}'" if instances_info_envelope.is_a?(Array)
-
-      instances_info = instances_info_envelope['instances']
-      display "#{'Index'.ljust 5} #{'State'.ljust 15} #{'Since'.ljust 20}\n"
-      display "#{'--'.ljust 5} #{'--------'.ljust 15} #{'-------------'.ljust 20}\n"
-
-      instances_info.each {|entry| entry[0] = entry[0].to_i}
-      instances_info = instances_info.sort {|a,b| a['index'] - b['index']}
-      instances_info.each do |entry|
-        display "#{entry['index'].to_s.ljust 5} #{entry['state'].ljust 15} #{Time.at(entry['since']).strftime("%m/%d/%Y %I:%M%p").ljust 20}\n"
-      end
-    end
-
-    def instances(appname=nil, instances=nil)
-      appname ||= @appname
-      error "Application name required, vmc instances <appname> [num | delta]." unless appname
-
-      check_for_token
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      handle_response(response)
-      appinfo = JSON.parse(response.content)
-
-      if instances
-        change_instances(appinfo, appname, instances) if instances
-      elsif
-        get_instances(appname)
-      end
-
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def crashes(appname=nil, print_results=true)
-      error "Application name required, vmc crashes <appname>." unless appname
-
-      check_for_token
-      response = get_app_crashes_internal @droplets_uri, appname, auth_hdr
-      if response.status == 404
-        display"Application #{appname} does not exist, use push first."
-        return []
-      elsif response.status != 200
-        display"Could not fetch application crashes."
-        return []
-      end
-      crashes = JSON.parse(response.content)['crashes']
-
-      instance_map = {}
-
-      if print_results
-        display "#{'Name'.ljust 10} #{'Id'.ljust 40} #{'Since'.ljust 20}\n"
-        display "#{'--'.ljust 10} #{'--------'.ljust 40} #{'-------------'.ljust 20}\n"
-      end
-
-      counter = 1
-
-      crashes = crashes.to_a.sort {|a,b| a['since'] - b['since']}
-      crashes.each do |crash|
-        name = "#{appname}-#{counter}"
-        display "#{name.ljust 10} #{crash['instance'].ljust 40} #{Time.at(crash['since']).strftime("%m/%d/%Y %I:%M%p").ljust 20}\n" if print_results
-        instance_map[name] = crash['instance']
-        counter +=1
-      end
-
-      File.open(instance_file, 'w') {|f| f.write(instance_map.to_json)}
-      crashes
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def map(appname=nil, url=nil)
-      error "Application name and url required, vmc map <appname> <url>." unless appname && url
-
-      check_for_token
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      error "Application #{appname} does not exist, use push first." if response.status != 200
-
-      appinfo = JSON.parse(response.content)
-
-      appinfo['uris'] << url
-
-      #display JSON.pretty_generate(appinfo)
-      response = update_app_state_internal @droplets_uri, appname, appinfo, auth_hdr
-      handle_response(response)
-      display "Map completed."
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def unmap(appname=nil, url=nil)
-      error "Application name and url required, vmc unmap <appname> <url>." unless appname && url
-
-      check_for_token
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      handle_response(response)
-
-      url = url.gsub(/^http(s*):\/\//i, '')
-      appinfo = JSON.parse(response.content)
-
-      if appinfo['uris'].delete(url) == nil
-        error "Error: You can only unmap a previously registered URL."
-      end
-
-      #display JSON.pretty_generate(appinfo)
-      update_app_state_internal @droplets_uri, appname, appinfo, auth_hdr
-
-      display "Unmap completed."
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def files(appname=nil, path=nil, instance=nil)
-      path ||= '/'
-      error "Application name required, vmc files <appname> <pathinfo> [--instance <instance>]." unless appname
-      check_for_token
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      if response.status != 200
-        display"Application #{appname} does not exist, use push first."
-        return
-      end
-      instance ||= '0'
-
-      begin
-        map = File.open(instance_file) {|f| JSON.parse(f.read)}
-        instance = map[instance] if map[instance]
-      rescue
-      end
-
-      response = get_app_files_internal @droplets_uri, appname, instance, path, auth_hdr
-      if response.status != 200 && response.status == 400
-        error "Information not available, either pathinfo is incorrect or instance index is out of bounds."
-      end
-      display response.content
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-    def log_file_paths
-      %w[logs/stderr.log logs/stdout.log logs/startup.log]
-    end
-
-    def grab_logs(appname, instance)
-      display "No information available" and return unless appname
-      instance ||= '0'
-      log_file_paths.each do |path|
-        response = get_app_files_internal @droplets_uri, appname, instance, path, auth_hdr
-        unless response.status != 200 || response.content.empty?
-          display "==== #{path} ====\n\n"
-          display response.content
-          display ''
-        end
-      end
-    end
-
-    def grab_crash_logs(appname, instance, was_staged=false)
-      display "No information available" and return unless appname
-
-      # stage crash info
-      crashes(appname, false) unless was_staged
-
-      instance ||= '0'
-      begin
-        map = File.open(instance_file) {|f| JSON.parse(f.read)}
-        instance = map[instance] if map[instance]
-      rescue
-      end
-
-      ['/logs/err.log', 'logs/stderr.log', 'logs/stdout.log', 'logs/startup.log'].each do |path|
-        response = get_app_files_internal @droplets_uri, appname, instance, path, auth_hdr
-        unless response.status != 200 || response.content.empty?
-          display "==== #{path} ====\n\n"
-          display response.content
-          display ''
-        end
-      end
-    end
-
-    def grab_startup_tail(appname, since = 0)
-      new_lines = 0
-      path = "logs/startup.log"
-      response = get_app_files_internal @droplets_uri, appname, '0', path, auth_hdr
-      unless response.status != 200 || response.content.empty?
-        display "\n==== displaying startup log ====\n\n" if since == 0
-        response_lines = response.content.split("\n")
-        lines = response_lines.size
-        tail = response_lines[since, lines] || []
-        new_lines = tail.size
-        display tail.join("\n") if new_lines > 0
-      end
-      since + new_lines
-    end
-
-    def app_started_properly(appname, error_on_health)
-      check_for_token
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      if response.status != 200
-        error "\nApplication '#{appname}'s state is undetermined,  not enough information available at this time."
-        return
-      end
-
-      droplet = JSON.parse(response.content)
-
-      case health(droplet)
-        when 'N/A'
-          # Health manager not running.
-          error "\nApplication '#{appname}'s state is undetermined,  not enough information available at this time." if error_on_health
-          return false
-        when 'RUNNING'
-          return true
-        else
-          return false
-      end
-    end
-
-    # Get the current logged in user
-    def user
-      info_json = JSON.parse(@check.content)
-      username = info_json['user'] || 'N/A'
-      display "[#{username}]"
-    end
-
-    def display_services_directory_banner
-      display "#{'Service'.ljust(10)} #{'Ver'.ljust(5)} #{'Description'}"
-      display "#{'-------'.ljust(10)} #{'---'.ljust(5)} #{'-----------'}"
-    end
-
-    # Get stats for application
-    def stats(appname=nil)
-      error "Application name required, vmc stats <appname>." unless appname
-      check_for_token
-      response = get_app_internal @droplets_uri, appname, auth_hdr
-      if response.status != 200
-        display"Application #{appname} does not exist, use push first."
-        return
-      end
-      response = get_app_stats_internal @droplets_uri, appname, auth_hdr
-      if response.status != 200 && response.status == 400
-        error "Information not available, is instance index out of bounds?"
-      end
-
-      display " #{'Instance '.ljust(10)} #{'CPU (Cores)'.ljust(15)} #{'Memory (limit)'.ljust(15)} #{'Disk (limit)'.ljust(15)} #{'Uptime '.ljust(5)}"
-      display " #{'---------'.ljust(10)} #{'-----------'.ljust(15)} #{'--------------'.ljust(15)} #{'------------'.ljust(15)} #{'------ '.ljust(5)}"
-
-      stats = JSON.parse(response.content).to_a
-
-      stats.each {|entry| entry[0] = entry[0].to_i}
-      stats = stats.sort {|a,b| a[0] - b[0]}
-      stats.each do |entry|
-        index, index_entry = entry
-        stat = index_entry['stats']
-        next unless stat
-        hp = "#{stat['host']}:#{stat['port']}"
-        uptime = uptime_string(stat['uptime'])
-        usage = stat['usage']
-        if usage
-          cpu   = usage['cpu']
-          mem   = (usage['mem'] * 1024) # mem comes in K's
-          disk  = usage['disk']
-        end
-
-        mem_quota = stat['mem_quota']
-        disk_quota = stat['disk_quota']
-
-        mem  = "#{pretty_size(mem)} (#{pretty_size(mem_quota, 0)})"
-        disk = "#{pretty_size(disk)} (#{pretty_size(disk_quota, 0)})"
-        cpu = cpu ? cpu.to_s : 'NA'
-        cpu = "#{cpu}% (#{stat['cores']})"
-
-        display " #{index.to_s.ljust(10)} #{cpu.ljust(15)} #{mem.ljust(15)} #{disk.ljust(15)} #{uptime.ljust(5)}"
-
-      end
-    rescue => e
-      error "Problem executing command, #{e}"
-    end
-
-
-    ##################################################################
-    # Non vmc Commands
-    ##################################################################
-
-    def handle_response(response)
-      return unless response
-      return if (response and response.status < 400)
-      error "Error: Unknown error in response from server." unless response.content
-      begin
-        error_json = JSON.parse(response.content)
-        error "Error: #{error_json['description']}"
-      rescue
-        response.content ||= "System error has occurred."
-        error "Error: #{response.content}"
-      end
-    end
-
-    def framework_needs_db?(framework)
-      return true if (framework == 'rails/1.0')
-      return true if (framework == 'grails/1.0')
-      return true if (framework == 'spring_web/1.0')
-      return true if (framework == "asp_web/1.0")
-      return false
-    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
-
-    def display(msg, nl=true)
-      if nl
-        puts(msg)
-      else
-        print(msg)
-        STDOUT.flush
-      end
-    end
-
-    def error(msg)
-      STDERR.puts(msg)
-      STDERR.puts('')
-      exit 1
-    end
-
-    def check_app_limit
-      info_json = JSON.parse(@check.content)
-      usage = info_json['usage']
-      limits = info_json['limits']
-      return unless usage and limits and limits['apps']
-      if limits['apps'] == usage['apps']
-        display "Not enough capacity for operation."
-        tapps = limits['apps'] || 0
-        apps  = usage['apps'] || 0
-        error "Current Usage: (#{apps} of #{tapps} total apps already in use)"
-      end
-    end
-
-    def check_has_capacity_for(mem_wanted)
-      info_json = JSON.parse(@check.content)
-      usage = info_json['usage']
-      limits = info_json['limits']
-      return unless usage and limits
-      available_for_use = limits['memory'].to_i - usage['memory'].to_i
-      if mem_wanted > available_for_use
-        info_json = JSON.parse(@check.content)
-        tmem = pretty_size(limits['memory']*1024*1024)
-        mem  = pretty_size(usage['memory']*1024*1024)
-        display "Not enough capacity for operation."
-        available = pretty_size(available_for_use * 1024 * 1024)
-        error "Current Usage: (#{mem} of #{tmem} total, #{available} available for use)"
-      end
-    end
-
-    def mem_choices
-      default = ['64M', '128M', '256M', '512M', '1G', '2G']
-      info_json = JSON.parse(@check.content)
-
-      return default unless info_json
-      return default unless (usage = info_json['usage'] and limits = info_json['limits'])
-
-      available_for_use = limits['memory'].to_i - usage['memory'].to_i
-      check_has_capacity_for(64) if available_for_use < 64
-      return ['64M'] if available_for_use < 128
-      return ['64M', '128M'] if available_for_use < 256
-      return ['64M', '128M', '256M'] if available_for_use < 512
-      return ['64M', '128M', '256M', '512M'] if available_for_use < 1024
-      return ['64M', '128M', '256M', '512M', '1G'] if available_for_use < 2048
-      return ['64M', '128M', '256M', '512M', '1G', '2G']
-    end
-
-    def mem_choice_to_quota(mem_choice)
-      (mem_choice =~ /(\d+)M/i) ? mem_quota = $1.to_i : mem_quota = mem_choice.to_i * 1024
-      mem_quota
-    end
-
-    def mem_quota_to_choice(mem)
-      if mem < 1024
-        mem_choice = "#{mem}M"
-      else
-        mem_choice = "#{(mem/1024).to_i}G"
-      end
-      mem_choice
-    end
-
-  end
-
-end
+require 'vmc/client'