af 0.3.12

data/lib/cli/services_helper.rb

@@ -0,0 +1,78 @@
+
+module VMC::Cli
+  module ServicesHelper
+    def display_system_services(services=nil)
+      services ||= client.services_info
+
+      display "\n============== System Services ==============\n\n"
+
+      return display "No system services available" if services.empty?
+
+      displayed_services = []
+      services.each do |service_type, value|
+        value.each do |vendor, version|
+          version.each do |version_str, service|
+            displayed_services << [ vendor, version_str, service[:description] ]
+          end
+        end
+      end
+      displayed_services.sort! { |a, b| a.first.to_s <=> b.first.to_s}
+
+      services_table = table do |t|
+        t.headings = 'Service', 'Version', 'Description'
+        displayed_services.each { |s| t << s }
+      end
+      display services_table
+    end
+
+    def display_provisioned_services(services=nil)
+      services ||= client.services
+      display "\n=========== Provisioned Services ============\n\n"
+      display_provisioned_services_table(services)
+    end
+
+    def display_provisioned_services_table(services)
+      return unless services && !services.empty?
+      services_table = table do |t|
+        t.headings = 'Name', 'Service'
+        services.each do |service|
+          t << [ service[:name], service[:vendor] ]
+        end
+      end
+      display services_table
+    end
+
+    def create_service_banner(service, name, display_name=false)
+      sn = " [#{name}]" if display_name
+      display "Creating Service#{sn}: ", false
+      client.create_service(service, name)
+      display 'OK'.green
+    end
+
+    def bind_service_banner(service, appname, check_restart=true)
+      display "Binding Service: ", false
+      client.bind_service(service, appname)
+      display 'OK'.green
+      check_app_for_restart(appname) if check_restart
+    end
+
+    def unbind_service_banner(service, appname, check_restart=true)
+      display "Unbinding Service: ", false
+      client.unbind_service(service, appname)
+      display 'OK'.green
+      check_app_for_restart(appname) if check_restart
+    end
+
+    def random_service_name(service)
+      r = "%04x" % [rand(0x0100000)]
+      "#{service.to_s}-#{r}"
+    end
+
+    def check_app_for_restart(appname)
+      app = client.app_info(appname)
+      cmd = VMC::Cli::Command::Apps.new(@options)
+      cmd.restart(appname) if app[:state] == 'STARTED'
+    end
+
+  end
+end

data/lib/cli/usage.rb

@@ -0,0 +1,104 @@
+class VMC::Cli::Runner
+
+  def basic_usage
+    "Usage: af [options] command [<args>] [command_options]\n" +
+    "Try 'af help [command]' or 'af help options' for more information."
+  end
+
+  def display_usage
+    if @usage
+      say @usage_error if @usage_error
+      say "Usage: #{@usage}"
+      return
+    elsif @verb_usage
+      say @verb_usage
+      return
+    end
+    say command_usage
+  end
+
+  def command_usage
+    <<-USAGE
+
+#{basic_usage}
+
+Currently available af commands are:
+
+  Getting Started
+    target [url]                                 Reports current target or sets a new target
+    login  [email] [--email, --passwd]           Login
+    info                                         System and account information
+
+  Applications
+    apps                                         List deployed applications
+
+  Application Creation
+    push [appname]                               Create, push, map, and start a new application
+    push [appname] --path                        Push application from specified path
+    push [appname] --url                         Set the url for the application
+    push [appname] --instances <N>               Set the expected number <N> of instances
+    push [appname] --mem M                       Set the memory reservation for the application
+    push [appname] --runtime RUNTIME             Set the runtime to use for the application
+    push [appname] --no-start                    Do not auto-start the application
+
+  Application Operations
+    start <appname>                              Start the application
+    stop  <appname>                              Stop the application
+    restart <appname>                            Restart the application
+    delete <appname>                             Delete the application
+    rename <appname> <newname>                   Rename the application
+
+  Application Updates
+    update <appname> [--path]                    Update the application bits
+    mem <appname> [memsize]                      Update the memory reservation for an application
+    map <appname> <url>                          Register the application to the url
+    unmap <appname> <url>                        Unregister the application from the url
+    instances <appname> <num|delta>              Scale the application instances up or down
+
+  Application Information
+    crashes <appname>                            List recent application crashes
+    crashlogs <appname>                          Display log information for crashed applications
+    logs <appname> [--all]                       Display log information for the application
+    files <appname> [path] [--all]               Display directory listing or file download for [path]
+    stats <appname>                              Display resource usage for the application
+    instances <appname>                          List application instances
+
+  Application Environment
+    env <appname>                                List application environment variables
+    env-add <appname> <variable[=]value>         Add an environment variable to an application
+    env-del <appname> <variable>                 Delete an environment variable to an application
+
+  Services
+    services                                     Lists of services available and provisioned
+    create-service <service> [--name,--bind]     Create a provisioned service
+    create-service <service> <name>              Create a provisioned service and assign it <name>
+    create-service <service> <name> <app>        Create a provisioned service and assign it <name>, and bind to <app>
+    delete-service [servicename]                 Delete a provisioned service
+    bind-service <servicename> <appname>         Bind a service to an application
+    unbind-service <servicename> <appname>       Unbind service from the application
+    clone-services <src-app> <dest-app>          Clone service bindings from <src-app> application to <dest-app>
+
+  Administration
+    user                                         Display user account information
+    passwd                                       Change the password for the current user
+    logout                                       Logs current user out of the target system
+    add-user [--email, --passwd]                 Register a new user (requires admin privileges)
+    delete-user <user>                           Delete a user and all apps and services (requires admin privileges)
+
+  System
+    runtimes                                     Display the supported runtimes of the target system
+    frameworks                                   Display the recognized frameworks of the target system
+
+  Misc
+    aliases                                      List aliases
+    alias <alias[=]command>                      Create an alias for a command
+    unalias <alias>                              Remove an alias
+    targets                                      List known targets and associated authorization tokens
+
+  Help
+    help [command]                               Get general help or help on a specific command
+    help options                                 Get help on available options
+USAGE
+
+  end
+end

data/lib/cli/version.rb

@@ -0,0 +1,7 @@
+module VMC
+  module Cli
+    # This version number is used as the RubyGem release version.
+    # The internal VMC version number is VMC::VERSION.
+    VERSION = '0.3.12'
+  end
+end

data/lib/cli/zip_util.rb

@@ -0,0 +1,77 @@
+
+require 'zip/zipfilesystem'
+
+module VMC::Cli
+
+  class ZipUtil
+
+    PACK_EXCLUSION_GLOBS = ['..', '.', '*~', '#*#', '*.log']
+
+    class << self
+
+      def to_dev_null
+        if !!RUBY_PLATFORM['mingw'] || !!RUBY_PLATFORM['mswin32'] || !!RUBY_PLATFORM['cygwin']
+          'nul'
+        else
+          '/dev/null'
+        end
+      end
+
+      def entry_lines(file)
+        contents = nil
+        unless VMC::Cli::Config.nozip
+          contents = `unzip -l #{file} 2> #{to_dev_null}`
+          contents = nil if $? != 0
+        end
+        # Do Ruby version if told to or native version failed
+        unless contents
+          entries = []
+          Zip::ZipFile.foreach(file) { |zentry| entries << zentry }
+          contents = entries.join("\n")
+        end
+        contents
+      end
+
+      def unpack(file, dest)
+        unless VMC::Cli::Config.nozip
+          FileUtils.mkdir(dest)
+          `unzip -q #{file} -d #{dest} 2> #{to_dev_null}`
+          return unless $? != 0
+        end
+        # Do Ruby version if told to or native version failed
+        Zip::ZipFile.foreach(file) do |zentry|
+          epath = "#{dest}/#{zentry}"
+          dirname = File.dirname(epath)
+          FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
+          zentry.extract(epath) unless File.exists?(epath)
+        end
+      end
+
+      def get_files_to_pack(dir)
+        Dir.glob("#{dir}/**/*", File::FNM_DOTMATCH).select do |f|
+          process = true
+          PACK_EXCLUSION_GLOBS.each { |e| process = false if File.fnmatch(e, File.basename(f)) }
+          process && File.exists?(f)
+        end
+      end
+
+      def pack(dir, zipfile)
+        unless VMC::Cli::Config.nozip
+          excludes = PACK_EXCLUSION_GLOBS.map { |e| "\\#{e}" }
+          excludes = excludes.join(' ')
+          Dir.chdir(dir) do
+            `zip -y -q -r #{zipfile} . -x #{excludes} 2> #{to_dev_null}`
+            return unless $? != 0
+          end
+        end
+        # Do Ruby version if told to or native version failed
+        Zip::ZipFile::open(zipfile, true) do |zf|
+          get_files_to_pack(dir).each do |f|
+            zf.add(f.sub("#{dir}/",''), f)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/vmc.rb

@@ -0,0 +1,3 @@
+module VMC; end
+
+require 'vmc/client'

data/lib/vmc/client.rb

@@ -0,0 +1,451 @@
+# VMC client
+#
+# Example:
+#
+#   require 'vmc'
+#   client = VMC::Client.new('api.vcap.me')
+#   client.login(:user, :pass)
+#   client.create('myapplication', manifest)
+#   client.create_service('redis', 'my_redis_service', opts);
+#
+
+require 'rubygems'
+require 'json/pure'
+require 'open-uri'
+
+require File.expand_path('../const', __FILE__)
+
+class VMC::Client
+
+  def self.version
+    VMC::VERSION
+  end
+
+  attr_reader   :target, :host, :user, :proxy, :auth_token
+  attr_accessor :trace
+
+  # Error codes
+  VMC_HTTP_ERROR_CODES = [ 400, 403, 404, 500 ]
+
+  # Errors
+  class BadTarget <  RuntimeError; end
+  class AuthError <  RuntimeError; end
+  class TargetError < RuntimeError; end
+  class NotFound < RuntimeError; end
+  class BadResponse < RuntimeError; end
+  class HTTPException <  RuntimeError; end
+
+  # Initialize new client to the target_uri with optional auth_token
+  def initialize(target_url=VMC::DEFAULT_TARGET, auth_token=nil)
+    target_url = "http://#{target_url}" unless /^https?/ =~ target_url
+    target_url = target_url.gsub(/\/+$/, '')
+    @target =  target_url
+    @auth_token = auth_token
+  end
+
+  ######################################################
+  # Target info
+  ######################################################
+
+  # Retrieves information on the target cloud, and optionally the logged in user
+  def info
+    # TODO: Should merge for new version IMO, general, services, user_account
+    json_get(VMC::INFO_PATH)
+  end
+
+  def raw_info
+    http_get(VMC::INFO_PATH)
+  end
+
+  # Global listing of services that are available on the target system
+  def services_info
+    check_login_status
+    json_get(VMC::GLOBAL_SERVICES_PATH)
+  end
+
+  ######################################################
+  # Apps
+  ######################################################
+
+  def apps
+    check_login_status
+    json_get(VMC::APPS_PATH)
+  end
+
+  def create_app(name, manifest={})
+    check_login_status
+    app = manifest.dup
+    app[:name] = name
+    app[:instances] ||= 1
+    json_post(VMC::APPS_PATH, app)
+  end
+
+  def update_app(name, manifest)
+    check_login_status
+    json_put("#{VMC::APPS_PATH}/#{name}", manifest)
+  end
+
+  def upload_app(name, zipfile, resource_manifest=nil)
+    #FIXME, manifest should be allowed to be null, here for compatability with old cc's
+    resource_manifest ||= []
+    check_login_status
+    upload_data = {:_method => 'put'}
+    if zipfile
+      if zipfile.is_a? File
+        file = zipfile
+      else
+        file = File.new(zipfile, 'rb')
+      end
+      upload_data[:application] = file
+    end
+    upload_data[:resources] = resource_manifest.to_json if resource_manifest
+    http_post("#{VMC::APPS_PATH}/#{name}/application", upload_data)
+  end
+
+  def delete_app(name)
+    check_login_status
+    http_delete("#{VMC::APPS_PATH}/#{name}")
+  end
+
+  def app_info(name)
+    check_login_status
+    json_get("#{VMC::APPS_PATH}/#{name}")
+  end
+
+  def app_update_info(name)
+    check_login_status
+    json_get("#{VMC::APPS_PATH}/#{name}/update")
+  end
+
+  def app_stats(name)
+    check_login_status
+    stats_raw = json_get("#{VMC::APPS_PATH}/#{name}/stats")
+    stats = []
+    stats_raw.each_pair do |k, entry|
+      # Skip entries with no stats
+      next unless entry[:stats]
+      entry[:instance] = k.to_s.to_i
+      entry[:state] = entry[:state].to_sym if entry[:state]
+      stats << entry
+    end
+    stats.sort { |a,b| a[:instance] - b[:instance] }
+  end
+
+  def app_instances(name)
+    check_login_status
+    json_get("#{VMC::APPS_PATH}/#{name}/instances")
+  end
+
+  def app_crashes(name)
+    check_login_status
+    json_get("#{VMC::APPS_PATH}/#{name}/crashes")
+  end
+
+  # List the directory or download the actual file indicated by
+  # the path.
+  def app_files(name, path, instance=0)
+    check_login_status
+    url = "#{VMC::APPS_PATH}/#{name}/instances/#{instance}/files/#{path}"
+    url.gsub!('//', '/')
+    _, body, headers = http_get(url)
+    body
+  end
+
+  ######################################################
+  # Services
+  ######################################################
+
+  # listing of services that are available in the system
+  def services
+    check_login_status
+    json_get(VMC::SERVICES_PATH)
+  end
+
+  def create_service(service, name)
+    check_login_status
+    services = services_info
+    services ||= []
+    service_hash = nil
+
+    service = service.to_s
+
+    # FIXME!
+    services.each do |service_type, value|
+      value.each do |vendor, version|
+        version.each do |version_str, service_descr|
+          if service == service_descr[:vendor]
+            service_hash = {
+              :type => service_descr[:type], :tier => 'free',
+              :vendor => service, :version => version_str
+            }
+            break
+          end
+        end
+      end
+    end
+
+    raise TargetError, "Service [#{service}] is not a valid service choice" unless service_hash
+    service_hash[:name] = name
+    json_post(VMC::SERVICES_PATH, service_hash)
+  end
+
+  def delete_service(name)
+    check_login_status
+    svcs = services || []
+    names = svcs.collect { |s| s[:name] }
+    raise TargetError, "Service [#{name}] not a valid service" unless names.include? name
+    http_delete("#{VMC::SERVICES_PATH}/#{name}")
+  end
+
+  def bind_service(service, appname)
+    check_login_status
+    app = app_info(appname)
+    services = app[:services] || []
+    app[:services] = services << service
+    update_app(appname, app)
+  end
+
+  def unbind_service(service, appname)
+    check_login_status
+    app = app_info(appname)
+    services = app[:services] || []
+    services.delete(service)
+    app[:services] = services
+    update_app(appname, app)
+  end
+
+  ######################################################
+  # Resources
+  ######################################################
+
+  # Send in a resources manifest array to the system to have
+  # it check what is needed to actually send. Returns array
+  # indicating what is needed. This returned manifest should be
+  # sent in with the upload if resources were removed.
+  # E.g. [{:sha1 => xxx, :size => xxx, :fn => filename}]
+  def check_resources(resources)
+    check_login_status
+    status, body, headers = json_post(VMC::RESOURCES_PATH, resources)
+    json_parse(body)
+  end
+
+  ######################################################
+  # Validation Helpers
+  ######################################################
+
+  # Checks that the target is valid
+  def target_valid?
+    return false unless descr = info
+    return false unless descr[:name]
+    return false unless descr[:build]
+    return false unless descr[:version]
+    return false unless descr[:support]
+    true
+  rescue
+    false
+  end
+
+  # Checks that the auth_token is valid
+  def logged_in?
+    descr = info
+    if descr
+      return false unless descr[:user]
+      return false unless descr[:usage]
+      @user = descr[:user]
+      true
+    end
+  end
+
+  ######################################################
+  # User login/password
+  ######################################################
+
+  # login and return an auth_token
+  # Auth token can be retained and used in creating
+  # new clients, avoiding login.
+  def login(user, password)
+    status, body, headers = json_post("#{VMC::USERS_PATH}/#{user}/tokens", {:password => password})
+    response_info = json_parse(body)
+    if response_info
+      @user = user
+      @auth_token = response_info[:token]
+    end
+  end
+
+  # sets the password for the current logged user
+  def change_password(new_password)
+    check_login_status
+    user_info = json_get("#{VMC::USERS_PATH}/#{@user}")
+    if user_info
+      user_info[:password] = new_password
+      json_put("#{VMC::USERS_PATH}/#{@user}", user_info)
+    end
+  end
+
+  ######################################################
+  # System administration
+  ######################################################
+
+  def proxy=(proxy)
+    @proxy = proxy
+  end
+
+  def proxy_for(proxy)
+    @proxy = proxy
+  end
+
+  def users
+    check_login_status
+    json_get(VMC::USERS_PATH)
+  end
+
+  def add_user(user_email, password)
+    json_post(VMC::USERS_PATH, { :email => user_email, :password => password })
+  end
+
+  def delete_user(user_email)
+    check_login_status
+    http_delete("#{VMC::USERS_PATH}/#{user_email}")
+  end
+
+  ######################################################
+
+  private
+
+  def json_get(url)
+    status, body, headers = http_get(url, 'application/json')
+    json_parse(body)
+  rescue JSON::ParserError
+    raise BadResponse, "Can't parse response into JSON", body
+  end
+
+  def json_post(url, payload)
+    http_post(url, payload.to_json, 'application/json')
+  end
+
+  def json_put(url, payload)
+    http_put(url, payload.to_json, 'application/json')
+  end
+
+  def json_parse(str)
+    if str
+      JSON.parse(str, :symbolize_names => true)
+    end
+  end
+
+  require 'rest_client'
+
+  # HTTP helpers
+
+  def http_get(path, content_type=nil)
+    request(:get, path, content_type)
+  end
+
+  def http_post(path, body, content_type=nil)
+    request(:post, path, content_type, body)
+  end
+
+  def http_put(path, body, content_type=nil)
+    request(:put, path, content_type, body)
+  end
+
+  def http_delete(path)
+    request(:delete, path)
+  end
+
+  def request(method, path, content_type = nil, payload = nil, headers = {})
+    headers = headers.dup
+    headers['AUTHORIZATION'] = @auth_token if @auth_token
+    headers['PROXY-USER'] = @proxy if @proxy
+
+    if content_type
+      headers['Content-Type'] = content_type
+      headers['Accept'] = content_type
+    end
+
+    req = {
+      :method => method, :url => "#{@target}#{path}",
+      :payload => payload, :headers => headers
+    }
+    status, body, response_headers = perform_http_request(req)
+
+    if VMC_HTTP_ERROR_CODES.include?(status)
+      # FIXME, old cc returned 400 on not found for file access
+      err = (status == 404 || status == 400) ? NotFound : TargetError
+      raise err, parse_error_message(status, body)
+    else
+      return status, body, response_headers
+    end
+  rescue URI::Error, SocketError, Errno::ECONNREFUSED => e
+    raise BadTarget, "Cannot access target (%s)" % [ e.message ]
+  end
+
+  def perform_http_request(req)
+    proxy_uri = URI.parse(req[:url]).find_proxy()
+    RestClient.proxy = proxy_uri.to_s if proxy_uri
+
+    # Setup tracing if needed
+    unless trace.nil?
+      req[:headers]['X-VCAP-Trace'] = (trace == true ? '22' : trace)
+    end
+
+    result = nil
+    RestClient::Request.execute(req) do |response, request|
+      result = [ response.code, response.body, response.headers ]
+      unless trace.nil?
+        puts '>>>'
+        puts "PROXY: #{RestClient.proxy}" if RestClient.proxy
+        puts "REQUEST: #{req[:method]} #{req[:url]}"
+        puts "RESPONSE_HEADERS:"
+        response.headers.each do |key, value|
+            puts "    #{key} : #{value}"
+        end
+        puts "REQUEST_BODY: #{req[:payload]}" if req[:payload]
+        puts "RESPONSE: [#{response.code}]"
+        begin
+            puts JSON.pretty_generate(JSON.parse(response.body))
+        rescue
+            puts "#{response.body}"
+        end
+        puts '<<<'
+      end
+    end
+    result
+  rescue Net::HTTPBadResponse => e
+    raise BadTarget "Received bad HTTP response from target: #{e}"
+  rescue SystemCallError, RestClient::Exception => e
+    raise HTTPException, "HTTP exception: #{e.class}:#{e}"
+  end
+
+  def truncate(str, limit = 30)
+    etc = '...'
+    stripped = str.strip[0..limit]
+    if stripped.length > limit
+      stripped + etc
+    else
+      stripped
+    end
+  end
+
+  def parse_error_message(status, body)
+    parsed_body = json_parse(body.to_s)
+    if parsed_body && parsed_body[:code] && parsed_body[:description]
+      desc = parsed_body[:description].gsub("\"","'")
+      "Error #{parsed_body[:code]}: #{desc}"
+    else
+      "Error (HTTP #{status}): #{body}"
+    end
+  rescue JSON::ParserError
+    if body.nil? || body.empty?
+      "Error (#{status}): No Response Received"
+    else
+      body_out = trace ? body : truncate(body)
+      "Error (JSON #{status}): #{body_out}"
+    end
+  end
+
+  def check_login_status
+    raise AuthError unless @user || logged_in?
+  end
+
+end