vmc 0.4.0.beta.8 → 0.4.0.beta.9

data/vmc/lib/cli/tunnel_helper.rb

@@ -1,332 +0,0 @@
-# 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

@@ -1,115 +0,0 @@
-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

data/vmc/lib/cli/version.rb

@@ -1,7 +0,0 @@
-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.18'
-  end
-end

data/vmc/lib/cli/zip_util.rb

@@ -1,77 +0,0 @@
-
-require 'zip/zipfilesystem'
-
-module VMC::Cli
-
-  class ZipUtil
-
-    PACK_EXCLUSION_GLOBS = ['..', '.', '*~', '#*#', '*.log']
-
-    class << self
-
-      def to_dev_null
-        if WINDOWS
-          '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/vmc/lib/cli.rb

@@ -1,47 +0,0 @@
-require "rbconfig"
-
-ROOT = File.expand_path(File.dirname(__FILE__))
-WINDOWS = !!(RbConfig::CONFIG['host_os'] =~ /mingw|mswin32|cygwin/)
-
-module VMC
-  autoload :Client,           "#{ROOT}/vmc/client"
-  autoload :Micro,            "#{ROOT}/vmc/micro"
-
-  module Micro
-    module Switcher
-      autoload :Base,         "#{ROOT}/vmc/micro/switcher/base"
-      autoload :Darwin,       "#{ROOT}/vmc/micro/switcher/darwin"
-      autoload :Dummy,        "#{ROOT}/vmc/micro/switcher/dummy"
-      autoload :Linux,        "#{ROOT}/vmc/micro/switcher/linux"
-      autoload :Windows,      "#{ROOT}/vmc/micro/switcher/windows"
-    end
-    autoload :VMrun,          "#{ROOT}/vmc/micro/vmrun"
-  end
-
-  module Cli
-    autoload :Config,         "#{ROOT}/cli/config"
-    autoload :Framework,      "#{ROOT}/cli/frameworks"
-    autoload :Runner,         "#{ROOT}/cli/runner"
-    autoload :ZipUtil,        "#{ROOT}/cli/zip_util"
-    autoload :ServicesHelper, "#{ROOT}/cli/services_helper"
-    autoload :TunnelHelper,   "#{ROOT}/cli/tunnel_helper"
-    autoload :ManifestHelper, "#{ROOT}/cli/manifest_helper"
-    autoload :ConsoleHelper,  "#{ROOT}/cli/console_helper"
-
-    module Command
-      autoload :Base,         "#{ROOT}/cli/commands/base"
-      autoload :Admin,        "#{ROOT}/cli/commands/admin"
-      autoload :Apps,         "#{ROOT}/cli/commands/apps"
-      autoload :Micro,        "#{ROOT}/cli/commands/micro"
-      autoload :Misc,         "#{ROOT}/cli/commands/misc"
-      autoload :Services,     "#{ROOT}/cli/commands/services"
-      autoload :User,         "#{ROOT}/cli/commands/user"
-      autoload :Manifest,     "#{ROOT}/cli/commands/manifest"
-    end
-
-  end
-end
-
-require "#{ROOT}/cli/version"
-require "#{ROOT}/cli/core_ext"
-require "#{ROOT}/cli/errors"