vmc 0.4.0.beta.6 → 0.4.0.beta.7

data/vmc/lib/cli/services_helper.rb

@@ -0,0 +1,84 @@
+
+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 [#{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 [#{service}]: ", false
+      client.unbind_service(service, appname)
+      display 'OK'.green
+      check_app_for_restart(appname) if check_restart
+    end
+
+    def delete_service_banner(service)
+      display "Deleting service [#{service}]: ", false
+      client.delete_service(service)
+      display 'OK'.green
+    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/vmc/lib/cli/tunnel_helper.rb

@@ -0,0 +1,332 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+
+require 'addressable/uri'
+
+begin
+  require 'caldecott'
+rescue LoadError
+end
+
+module VMC::Cli
+  module TunnelHelper
+    PORT_RANGE = 10
+
+    HELPER_APP = File.expand_path("../../../caldecott_helper", __FILE__)
+
+    # bump this AND the version info reported by HELPER_APP/server.rb
+    # this is to keep the helper in sync with any updates here
+    HELPER_VERSION = '0.0.4'
+
+    def tunnel_uniquename
+      random_service_name(tunnel_appname)
+    end
+
+    def tunnel_appname
+      "caldecott"
+    end
+
+    def tunnel_app_info
+      return @tun_app_info if @tunnel_app_info
+      begin
+        @tun_app_info = client.app_info(tunnel_appname)
+      rescue => e
+        @tun_app_info = nil
+      end
+    end
+
+    def tunnel_auth
+      tunnel_app_info[:env].each do |e|
+        name, val = e.split("=", 2)
+        return val if name == "CALDECOTT_AUTH"
+      end
+      nil
+    end
+
+    def tunnel_url
+      return @tunnel_url if @tunnel_url
+
+      tun_url = tunnel_app_info[:uris][0]
+
+      ["https", "http"].each do |scheme|
+        url = "#{scheme}://#{tun_url}"
+        begin
+          RestClient.get(url)
+
+        # https failed
+        rescue Errno::ECONNREFUSED
+
+        # we expect a 404 since this request isn't auth'd
+        rescue RestClient::ResourceNotFound
+          return @tunnel_url = url
+        end
+      end
+
+      err "Cannot determine URL for #{tun_url}"
+    end
+
+    def invalidate_tunnel_app_info
+      @tunnel_url = nil
+      @tunnel_app_info = nil
+    end
+
+    def tunnel_pushed?
+      not tunnel_app_info.nil?
+    end
+
+    def tunnel_healthy?(token)
+      return false unless tunnel_app_info[:state] == 'STARTED'
+
+      begin
+        response = RestClient.get(
+          "#{tunnel_url}/info",
+          "Auth-Token" => token
+        )
+
+        info = JSON.parse(response)
+        if info["version"] == HELPER_VERSION
+          true
+        else
+          stop_caldecott
+          false
+        end
+      rescue RestClient::Exception
+        stop_caldecott
+        false
+      end
+    end
+
+    def tunnel_bound?(service)
+      tunnel_app_info[:services].include?(service)
+    end
+
+    def tunnel_connection_info(type, service, token)
+      display "Getting tunnel connection info: ", false
+      response = nil
+      10.times do
+        begin
+          response = RestClient.get(tunnel_url + "/" + VMC::Client.path("services", service), "Auth-Token" => token)
+          break
+        rescue RestClient::Exception
+          sleep 1
+        end
+
+        display ".", false
+      end
+
+      unless response
+        err "Expected remote tunnel to know about #{service}, but it doesn't"
+      end
+
+      display "OK".green
+
+      info = JSON.parse(response)
+      case type
+      when "rabbitmq"
+        uri = Addressable::URI.parse info["url"]
+        info["hostname"] = uri.host
+        info["port"] = uri.port
+        info["vhost"] = uri.path[1..-1]
+        info["user"] = uri.user
+        info["password"] = uri.password
+        info.delete "url"
+
+      # we use "db" as the "name" for mongo
+      # existing "name" is junk
+      when "mongodb"
+        info["name"] = info["db"]
+        info.delete "db"
+
+      # our "name" is irrelevant for redis
+      when "redis"
+        info.delete "name"
+      end
+
+      ['hostname', 'port', 'password'].each do |k|
+        err "Could not determine #{k} for #{service}" if info[k].nil?
+      end
+
+      info
+    end
+
+    def display_tunnel_connection_info(info)
+      display ''
+      display "Service connection info: "
+
+      to_show = [nil, nil, nil] # reserved for user, pass, db name
+      info.keys.each do |k|
+        case k
+        when "host", "hostname", "port", "node_id"
+          # skip
+        when "user", "username"
+          # prefer "username" over "user"
+          to_show[0] = k unless to_show[0] == "username"
+        when "password"
+          to_show[1] = k
+        when "name"
+          to_show[2] = k
+        else
+          to_show << k
+        end
+      end
+      to_show.compact!
+
+      align_len = to_show.collect(&:size).max + 1
+
+      to_show.each do |k|
+        # TODO: modify the server services rest call to have explicit knowledge
+        # about the items to return.  It should return all of them if
+        # the service is unknown so that we don't have to do this weird
+        # filtering.
+        display "  #{k.ljust align_len}: ", false
+        display "#{info[k]}".yellow
+      end
+      display ''
+    end
+
+    def start_tunnel(local_port, conn_info, auth)
+      @local_tunnel_thread = Thread.new do
+        Caldecott::Client.start({
+          :local_port => local_port,
+          :tun_url => tunnel_url,
+          :dst_host => conn_info['hostname'],
+          :dst_port => conn_info['port'],
+          :log_file => STDOUT,
+          :log_level => ENV["VMC_TUNNEL_DEBUG"] || "ERROR",
+          :auth_token => auth,
+          :quiet => true
+        })
+      end
+
+      at_exit { @local_tunnel_thread.kill }
+    end
+
+
+
+    def pick_tunnel_port(port)
+      original = port
+
+      PORT_RANGE.times do |n|
+        begin
+          TCPSocket.open('localhost', port)
+          port += 1
+        rescue
+          return port
+        end
+      end
+
+      grab_ephemeral_port
+    end
+
+    def grab_ephemeral_port
+      socket = TCPServer.new('0.0.0.0', 0)
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+      Socket.do_not_reverse_lookup = true
+      port = socket.addr[1]
+      socket.close
+      return port
+    end
+
+    def wait_for_tunnel_start(port)
+      10.times do |n|
+        begin
+          client = TCPSocket.open('localhost', port)
+          display '' if n > 0
+          client.close
+          return true
+        rescue => e
+          display "Waiting for local tunnel to become available", false if n == 0
+          display '.', false
+          sleep 1
+        end
+      end
+      err "Could not connect to local tunnel."
+    end
+
+    def wait_for_tunnel_end
+      display "Open another shell to run command-line clients or"
+      display "use a UI tool to connect using the displayed information."
+      display "Press Ctrl-C to exit..."
+      @local_tunnel_thread.join
+    end
+
+    def resolve_symbols(str, info, local_port)
+      str.gsub(/\$\{\s*([^\}]+)\s*\}/) do
+        case $1
+        when "host"
+          # TODO: determine proper host
+          "localhost"
+        when "port"
+          local_port
+        when "user", "username"
+          info["username"]
+        else
+          info[$1] || ask($1)
+        end
+      end
+    end
+
+    def start_local_prog(clients, command, info, port)
+      client = clients[File.basename(command)]
+
+      cmdline = "#{command} "
+
+      case client
+      when Hash
+        cmdline << resolve_symbols(client["command"], info, port)
+        client["environment"].each do |e|
+          if e =~ /([^=]+)=(["']?)([^"']*)\2/
+            ENV[$1] = resolve_symbols($3, info, port)
+          else
+            err "Invalid environment variable: #{e}"
+          end
+        end
+      when String
+        cmdline << resolve_symbols(client, info, port)
+      else
+        err "Unknown client info: #{client.inspect}."
+      end
+
+      display "Launching '#{cmdline}'"
+      display ''
+
+      system(cmdline)
+    end
+
+    def push_caldecott(token)
+      client.create_app(
+        tunnel_appname,
+        { :name => tunnel_appname,
+          :staging => {:framework => "sinatra"},
+          :uris => ["#{tunnel_uniquename}.#{target_base}"],
+          :instances => 1,
+          :resources => {:memory => 64},
+          :env => ["CALDECOTT_AUTH=#{token}"]
+        }
+      )
+
+      apps_cmd.send(:upload_app_bits, tunnel_appname, HELPER_APP)
+
+      invalidate_tunnel_app_info
+    end
+
+    def stop_caldecott
+      apps_cmd.stop(tunnel_appname)
+
+      invalidate_tunnel_app_info
+    end
+
+    def start_caldecott
+      apps_cmd.start(tunnel_appname)
+
+      invalidate_tunnel_app_info
+    end
+
+    private
+
+    def apps_cmd
+      a = Command::Apps.new(@options)
+      a.client client
+      a
+    end
+  end
+end

data/vmc/lib/cli/usage.rb

@@ -0,0 +1,115 @@
+class VMC::Cli::Runner
+
+  def basic_usage
+    "Usage: vmc [options] command [<args>] [command_options]\n" +
+    "Try 'vmc help [command]' or 'vmc 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 vmc 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] --debug [MODE]                Push application and start in a debug mode
+    push [appname] --no-start                    Do not auto-start the application
+
+  Application Operations
+    start <appname> [--debug [MODE]]             Start the application
+    stop  <appname>                              Stop the application
+    restart <appname> [--debug [MODE]]           Restart the application
+    delete <appname>                             Delete the application
+
+  Application Updates
+    update <appname> [--path,--debug [MODE]]     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>
+    tunnel <servicename> [--port]                Create a local tunnel to a service
+    tunnel <servicename> <clientcmd>             Create a local tunnel to a service and start a local client
+
+  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
+
+  Micro Cloud Foundry
+    micro status                                 Display Micro Cloud Foundry VM status
+    micro offline                                Configure Micro Cloud Foundry VM for offline mode
+    micro online                                 Configure Micro Cloud Foundry VM for online mode
+      [--vmx file]                               Path to micro.vmx
+      [--vmrun executable]                       Path to vmrun executable
+      [--password cleartext]                     Cleartext password for guest VM vcap user
+      [--save]                                   Save cleartext password in ~/.vmc_micro
+
+  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