vmc 0.0.4 → 0.0.5

data/lib/vmc.rb

@@ -0,0 +1,1588 @@
+# Copyright 2010, VMware, Inc. Licensed under the
+# MIT license, please see the LICENSE file.  All rights reserved
+
+require 'rubygems'
+require 'pp'
+require 'vmc_base'
+require 'highline/import'
+
+module VMC
+
+  class Client < VMC::BaseClient
+
+    VERSION = 0.999
+
+    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 to use one of these (y/n)? "
+          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 (y/n)? "
+        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 > 9
+        sleep 1
+        begin
+          if app_started_properly(appname)
+            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 > 9
+            log_lines_displayed = grab_startup_tail(appname, log_lines_displayed)
+          end
+        rescue => e
+          display e.message, false
+        end
+        count += 1
+        if count > 300 # 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)
+      check_for_token
+      response = get_app_internal @droplets_uri, appname, auth_hdr
+      if response.status != 200
+        error "Application '#{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 "Application '#{appname}'s state is undetermined,  not enough information available at this time."
+        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 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']
+      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)
+
+      default unless info_json
+      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