olympe 0.1

data/lib/cli/tunnel_helper.rb

@@ -0,0 +1,336 @@
+# 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(infra)
+      random_service_name(tunnel_appname(infra))
+    end
+
+    def tunnel_appname(infra)
+      infra ? "caldecott-#{infra}" : "caldecott"
+    end
+
+    def tunnel_app_info(infra)
+      begin
+        client.app_info(tunnel_appname(infra))
+      rescue => e
+        nil
+      end
+    end
+
+    def tunnel_auth(infra)
+      tunnel_app_info(infra)[:env].each do |e|
+        name, val = e.split("=", 2)
+        return val if name == "CALDECOTT_AUTH"
+      end
+      nil
+    end
+
+    def tunnel_url(infra)
+
+      tun_url = tunnel_app_info(infra)[: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 url
+        end
+      end
+
+      err "Cannot determine URL for #{tun_url}"
+    end
+
+    def invalidate_tunnel_app_info(infra)
+    end
+
+    def tunnel_pushed?(infra)
+      not tunnel_app_info(infra).nil?
+    end
+
+    def tunnel_healthy?(token,infra)
+      return false unless tunnel_app_info(infra)[:state] == 'STARTED'
+
+      begin
+        response = RestClient.get(
+          "#{tunnel_url(infra)}/info",
+          "Auth-Token" => token
+        )
+        info = JSON.parse(response)
+        if info["version"] == HELPER_VERSION
+          true
+        else
+          stop_caldecott(infra)
+          false
+        end
+      rescue RestClient::Exception
+        stop_caldecott(infra)
+        false
+      end
+    end
+
+    def tunnel_bound?(service,infra)
+      tunnel_app_info(infra)[:services].include?(service)
+    end
+
+    def tunnel_connection_info(type, service, token, infra)
+      display "Getting tunnel connection info: ", false
+      response = nil
+      10.times do
+        begin
+          response = RestClient.get(tunnel_url(infra) + "/" + VMC::Client.path("services", service), "Auth-Token" => token)
+          break
+        rescue RestClient::Exception => e
+          puts "Error infra: #{infra}, url: #{tunnel_url(infra)}"
+          display tunnel_url(infra)
+          puts e.message.red
+          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)
+      info["infra"] = infra
+      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, infra)
+      @local_tunnel_thread = Thread.new do
+        Caldecott::Client.start({
+          :local_port => local_port,
+          :tun_url => tunnel_url(infra),
+          :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,infra)
+      manifest = {
+          :name => tunnel_appname(infra),
+          :staging => {:framework => "sinatra", :runtime => "ruby18" },
+          :uris => ["#{tunnel_uniquename(infra)}.#{client.base_for_infra(infra)}"],
+          :instances => 1,
+          :resources => {:memory => 64},
+          :env => ["CALDECOTT_AUTH=#{token}"]
+        }
+      manifest[:infra] = { :provider => infra } if infra 
+
+      client.create_app(
+        tunnel_appname(infra),
+        manifest
+      )
+
+      apps_cmd.send(:upload_app_bits, tunnel_appname(infra), HELPER_APP, infra)
+
+      invalidate_tunnel_app_info(infra)
+    end
+
+    def stop_caldecott(infra)
+      apps_cmd.stop(tunnel_appname(infra))
+
+      invalidate_tunnel_app_info(infra)
+    end
+
+    def start_caldecott(infra)
+      apps_cmd.start(tunnel_appname(infra))
+
+      invalidate_tunnel_app_info(infra)
+    end
+
+    private
+
+    def apps_cmd
+      a = Command::Apps.new(@options)
+      a.client client
+      a
+    end
+    
+  end
+end

data/lib/cli/usage.rb

@@ -0,0 +1,125 @@
+class VMC::Cli::Runner
+
+  def basic_usage
+    "Usage: olympe [options] command [<args>] [command_options]\n" +
+    "Try 'olympe help [command]' or 'olympe 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 olympe 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] --infra                       Push application to specified infrastructure
+    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
+    clone <src-app> <dest-app> [infra]           Clone the application and services
+
+  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 Download
+    pull <appname> [path]                        Downloads last pushed source to <appname> or [path]
+    download <appname> [path]                    Downloads last pushed source to zipfile
+
+  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> --infra     		     Create a provisioned service on a specified infrastructure
+    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>
+    export-service <service>                     Export the data from a service
+    import-service <service> <url>               Import data into a service
+    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
+    infras                                       Display the available infrastructures
+
+  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 ~/.olympe_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/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.18.11' 
+  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 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/lib/cli.rb

@@ -0,0 +1,48 @@
+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"
+    autoload :FileHelper,     "#{ROOT}/cli/file_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"