vmc 0.4.0.beta.9 → 0.4.0.beta.10

data/vmc/lib/cli/commands/services.rb

@@ -0,0 +1,180 @@
+require "uuidtools"
+
+module VMC::Cli::Command
+
+  class Services < Base
+    include VMC::Cli::ServicesHelper
+    include VMC::Cli::TunnelHelper
+
+    def services
+      ss = client.services_info
+      ps = client.services
+      ps.sort! {|a, b| a[:name] <=> b[:name] }
+
+      if @options[:json]
+        services = { :system => ss, :provisioned => ps }
+        return display JSON.pretty_generate(services)
+      end
+      display_system_services(ss)
+      display_provisioned_services(ps)
+    end
+
+    def create_service(service=nil, name=nil, appname=nil)
+      unless no_prompt || service
+        services = client.services_info
+        err 'No services available to provision' if services.empty?
+        service = ask(
+          "Which service would you like to provision?",
+          { :indexed => true,
+            :choices =>
+              services.values.collect { |type|
+                type.keys.collect(&:to_s)
+              }.flatten
+          }
+        )
+      end
+      name = @options[:name] unless name
+      unless name
+        name = random_service_name(service)
+        picked_name = true
+      end
+      create_service_banner(service, name, picked_name)
+      appname = @options[:bind] unless appname
+      bind_service_banner(name, appname) if appname
+    end
+
+    def delete_service(service=nil)
+      unless no_prompt || service
+        user_services = client.services
+        err 'No services available to delete' if user_services.empty?
+        service = ask(
+          "Which service would you like to delete?",
+          { :indexed => true,
+            :choices => user_services.collect { |s| s[:name] }
+          }
+        )
+      end
+      err "Service name required." unless service
+      display "Deleting service [#{service}]: ", false
+      client.delete_service(service)
+      display 'OK'.green
+    end
+
+    def bind_service(service, appname)
+      bind_service_banner(service, appname)
+    end
+
+    def unbind_service(service, appname)
+      unbind_service_banner(service, appname)
+    end
+
+    def clone_services(src_app, dest_app)
+      begin
+        src  = client.app_info(src_app)
+        dest = client.app_info(dest_app)
+      rescue
+      end
+
+      err "Application '#{src_app}' does not exist" unless src
+      err "Application '#{dest_app}' does not exist" unless dest
+
+      services = src[:services]
+      err 'No services to clone' unless services && !services.empty?
+      services.each { |service| bind_service_banner(service, dest_app, false) }
+      check_app_for_restart(dest_app)
+    end
+
+    def tunnel(service=nil, client_name=nil)
+      unless defined? Caldecott
+        display "To use `vmc tunnel', you must first install Caldecott:"
+        display ""
+        display "\tgem install caldecott"
+        display ""
+        display "Note that you'll need a C compiler. If you're on OS X, Xcode"
+        display "will provide one. If you're on Windows, try DevKit."
+        display ""
+        display "This manual step will be removed in the future."
+        display ""
+        err "Caldecott is not installed."
+      end
+
+      ps = client.services
+      err "No services available to tunnel to" if ps.empty?
+
+      unless service
+        choices = ps.collect { |s| s[:name] }.sort
+        service = ask(
+          "Which service to tunnel to?",
+          :choices => choices,
+          :indexed => true
+        )
+      end
+
+      info = ps.select { |s| s[:name] == service }.first
+
+      err "Unknown service '#{service}'" unless info
+
+      port = pick_tunnel_port(@options[:port] || 10000)
+
+      raise VMC::Client::AuthError unless client.logged_in?
+
+      if not tunnel_pushed?
+        display "Deploying tunnel application '#{tunnel_appname}'."
+        auth = UUIDTools::UUID.random_create.to_s
+        push_caldecott(auth)
+        bind_service_banner(service, tunnel_appname, false)
+        start_caldecott
+      else
+        auth = tunnel_auth
+      end
+
+      if not tunnel_healthy?(auth)
+        display "Redeploying tunnel application '#{tunnel_appname}'."
+
+        # We don't expect caldecott not to be running, so take the
+        # most aggressive restart method.. delete/re-push
+        client.delete_app(tunnel_appname)
+        invalidate_tunnel_app_info
+
+        push_caldecott(auth)
+        bind_service_banner(service, tunnel_appname, false)
+        start_caldecott
+      end
+
+      if not tunnel_bound?(service)
+        bind_service_banner(service, tunnel_appname)
+      end
+
+      conn_info = tunnel_connection_info info[:vendor], service, auth
+      display_tunnel_connection_info(conn_info)
+      display "Starting tunnel to #{service.bold} on port #{port.to_s.bold}."
+      start_tunnel(port, conn_info, auth)
+
+      clients = get_clients_for(info[:vendor])
+
+      if clients.empty?
+        client_name ||= "none"
+      else
+        client_name ||= ask(
+          "Which client would you like to start?",
+          :choices => ["none"] + clients.keys,
+          :indexed => true
+        )
+      end
+
+      if client_name == "none"
+        wait_for_tunnel_end
+      else
+        wait_for_tunnel_start(port)
+        unless start_local_prog(clients, client_name, conn_info, port)
+          err "'#{client_name}' execution failed; is it in your $PATH?"
+        end
+      end
+    end
+
+    def get_clients_for(type)
+      conf = VMC::Cli::Config.clients
+      conf[type] || {}
+    end
+  end
+end

data/vmc/lib/cli/commands/user.rb

@@ -0,0 +1,65 @@
+module VMC::Cli::Command
+
+  class User < Base
+
+    def info
+      info = client_info
+      username = info[:user] || 'N/A'
+      return display JSON.pretty_generate([username]) if @options[:json]
+      display "\n[#{username}]"
+    end
+
+    def login(email=nil)
+      email    = @options[:email] unless email
+      password = @options[:password]
+      tries ||= 0
+
+      unless no_prompt
+        display "Attempting login to [#{target_url}]" if target_url
+        email ||= ask("Email")
+        password ||= ask("Password", :echo => "*")
+      end
+
+      err "Need a valid email" unless email
+      err "Need a password" unless password
+      login_and_save_token(email, password)
+      say "Successfully logged into [#{target_url}]".green
+    rescue VMC::Client::TargetError
+      display "Problem with login, invalid account or password when attempting to login to '#{target_url}'".red
+      retry if (tries += 1) < 3 && prompt_ok && !@options[:password]
+      exit 1
+    rescue => e
+      display "Problem with login to '#{target_url}', #{e}, try again or register for an account.".red
+      exit 1
+    end
+
+    def logout
+      VMC::Cli::Config.remove_token_file
+      say "Successfully logged out of [#{target_url}]".green
+    end
+
+    def change_password(password=nil)
+      info = client_info
+      email = info[:user]
+      err "Need to be logged in to change password." unless email
+      say "Changing password for '#{email}'\n"
+      unless no_prompt
+        password = ask "New Password", :echo => "*"
+        password2 = ask "Verify Password", :echo => "*"
+        err "Passwords did not match, try again" if password != password2
+      end
+      err "Password required" unless password
+      client.change_password(password)
+      say "\nSuccessfully changed password".green
+    end
+
+    private
+
+    def login_and_save_token(email, password)
+      token = client.login(email, password)
+      VMC::Cli::Config.store_token(token, @options[:token_file])
+    end
+
+  end
+
+end

data/vmc/lib/cli/config.rb

@@ -0,0 +1,173 @@
+require "yaml"
+require 'fileutils'
+
+require 'rubygems'
+require 'json/pure'
+
+module VMC::Cli
+  class Config
+
+    DEFAULT_TARGET  = 'api.vcap.me'
+
+    TARGET_FILE    = '~/.vmc_target'
+    TOKEN_FILE     = '~/.vmc_token'
+    INSTANCES_FILE = '~/.vmc_instances'
+    ALIASES_FILE   = '~/.vmc_aliases'
+    CLIENTS_FILE   = '~/.vmc_clients'
+    MICRO_FILE     = '~/.vmc_micro'
+
+    STOCK_CLIENTS = File.expand_path("../../../config/clients.yml", __FILE__)
+
+    class << self
+      attr_accessor :colorize
+      attr_accessor :output
+      attr_accessor :trace
+      attr_accessor :nozip
+
+      def target_url
+        return @target_url if @target_url
+        target_file = File.expand_path(TARGET_FILE)
+        if File.exists? target_file
+          @target_url = lock_and_read(target_file).strip
+        else
+          @target_url  = DEFAULT_TARGET
+        end
+        @target_url = "http://#{@target_url}" unless /^https?/ =~ @target_url
+        @target_url = @target_url.gsub(/\/+$/, '')
+        @target_url
+      end
+
+      def base_of(url)
+        url.sub(/^[^\.]+\./, "")
+      end
+
+      def suggest_url
+        @suggest_url ||= base_of(target_url)
+      end
+
+      def store_target(target_host)
+        target_file = File.expand_path(TARGET_FILE)
+        lock_and_write(target_file, target_host)
+      end
+
+      def all_tokens(token_file_path=nil)
+        token_file = File.expand_path(token_file_path || TOKEN_FILE)
+        return nil unless File.exists? token_file
+        contents = lock_and_read(token_file).strip
+        JSON.parse(contents)
+      end
+
+      alias :targets :all_tokens
+
+      def auth_token(token_file_path=nil)
+        return @token if @token
+        tokens = all_tokens(token_file_path)
+        @token = tokens[target_url] if tokens
+      end
+
+      def remove_token_file
+        FileUtils.rm_f(File.expand_path(TOKEN_FILE))
+      end
+
+      def store_token(token, token_file_path=nil)
+        tokens = all_tokens(token_file_path) || {}
+        tokens[target_url] = token
+        token_file = File.expand_path(token_file_path || TOKEN_FILE)
+        lock_and_write(token_file, tokens.to_json)
+      end
+
+      def instances
+        instances_file = File.expand_path(INSTANCES_FILE)
+        return nil unless File.exists? instances_file
+        contents = lock_and_read(instances_file).strip
+        JSON.parse(contents)
+      end
+
+      def store_instances(instances)
+        instances_file = File.expand_path(INSTANCES_FILE)
+        lock_and_write(instances_file, instances.to_json)
+      end
+
+      def aliases
+        aliases_file = File.expand_path(ALIASES_FILE)
+        # bacward compatible
+        unless File.exists? aliases_file
+          old_aliases_file = File.expand_path('~/.vmc-aliases')
+          FileUtils.mv(old_aliases_file, aliases_file) if File.exists? old_aliases_file
+        end
+        aliases = YAML.load_file(aliases_file) rescue {}
+      end
+
+      def store_aliases(aliases)
+        aliases_file = File.expand_path(ALIASES_FILE)
+        File.open(aliases_file, 'wb') {|f| f.write(aliases.to_yaml)}
+      end
+
+      def micro
+        micro_file = File.expand_path(MICRO_FILE)
+        return {} unless File.exists? micro_file
+        contents = lock_and_read(micro_file).strip
+        JSON.parse(contents)
+      end
+
+      def store_micro(micro)
+        micro_file = File.expand_path(MICRO_FILE)
+        lock_and_write(micro_file, micro.to_json)
+      end
+
+      def deep_merge(a, b)
+        merge = proc do |_, old, new|
+          if new.is_a?(Hash) and old.is_a?(Hash)
+            old.merge(new, &merge)
+          else
+            new
+          end
+        end
+
+        a.merge(b, &merge)
+      end
+
+      def clients
+        return @clients if @clients
+
+        stock = YAML.load_file(STOCK_CLIENTS)
+        clients = File.expand_path CLIENTS_FILE
+        if File.exists? clients
+          user = YAML.load_file(clients)
+          @clients = deep_merge(stock, user)
+        else
+          @clients = stock
+        end
+      end
+
+      def lock_and_read(file)
+        File.open(file, File::RDONLY) {|f|
+          if defined? JRUBY_VERSION
+            f.flock(File::LOCK_SH)
+          else
+            f.flock(File::LOCK_EX)
+          end
+          contents = f.read
+          f.flock(File::LOCK_UN)
+          contents
+        }
+      end
+
+      def lock_and_write(file, contents)
+        File.open(file, File::RDWR | File::CREAT, 0600) {|f|
+          f.flock(File::LOCK_EX)
+          f.rewind
+          f.puts contents
+          f.flush
+          f.truncate(f.pos)
+          f.flock(File::LOCK_UN)
+        }
+      end
+    end
+
+    def initialize(work_dir = Dir.pwd)
+      @work_dir = work_dir
+    end
+
+  end
+end

data/vmc/lib/cli/console_helper.rb

@@ -0,0 +1,160 @@
+require 'net/telnet'
+require 'readline'
+
+module VMC::Cli
+  module ConsoleHelper
+
+    def console_connection_info(appname)
+      app = client.app_info(appname)
+      fw = VMC::Cli::Framework.lookup_by_framework(app[:staging][:model])
+      if !fw.console
+        err "'#{appname}' is a #{fw.name} application.  " +
+          "Console access is not supported for #{fw.name} applications."
+      end
+      instances_info_envelope = client.app_instances(appname)
+      instances_info_envelope = {} if instances_info_envelope.is_a?(Array)
+
+      instances_info = instances_info_envelope[:instances] || []
+      err "No running instances for [#{appname}]" if instances_info.empty?
+
+      entry = instances_info[0]
+      if !entry[:console_port]
+        begin
+          client.app_files(appname, '/app/cf-rails-console')
+          err "Console port not provided for [#{appname}].  Try restarting the app."
+        rescue VMC::Client::TargetError, VMC::Client::NotFound
+          err "Console access not supported for [#{appname}]. " +
+            "Please redeploy your app to enable support."
+        end
+      end
+      conn_info = {'hostname' => entry[:console_ip], 'port' => entry[:console_port]}
+    end
+
+    def start_local_console(port, appname)
+      auth_info = console_credentials(appname)
+      display "Connecting to '#{appname}' console: ", false
+      prompt = console_login(auth_info, port)
+      display "OK".green
+      display "\n"
+      initialize_readline
+      run_console prompt
+    end
+
+    def console_login(auth_info, port)
+      if !auth_info["username"] || !auth_info["password"]
+        err "Unable to verify console credentials."
+      end
+      @telnet_client = telnet_client(port)
+      prompt = nil
+      err_msg = "Login attempt timed out."
+      5.times do
+        begin
+          results = @telnet_client.login("Name"=>auth_info["username"],
+            "Password"=>auth_info["password"])
+          lines = results.sub("Login: Password: ", "").split("\n")
+          last_line = lines.pop
+          if last_line =~ /[$%#>] \z/n
+            prompt = last_line
+          elsif last_line =~ /Login failed/
+            err_msg = last_line
+          end
+          break
+        rescue TimeoutError
+          sleep 1
+        rescue EOFError
+          #This may happen if we login right after app starts
+          close_console
+          sleep 5
+          @telnet_client = telnet_client(port)
+        end
+        display ".", false
+      end
+      unless prompt
+        close_console
+        err err_msg
+      end
+      prompt
+    end
+
+    def send_console_command(cmd)
+      results = @telnet_client.cmd(cmd)
+      results.split("\n")
+    end
+
+    def console_credentials(appname)
+      content = client.app_files(appname, '/app/cf-rails-console/.consoleaccess', '0')
+      YAML.load(content)
+    end
+
+    def close_console
+      @telnet_client.close
+    end
+
+    def console_tab_completion_data(cmd)
+      begin
+        results = @telnet_client.cmd("String"=> cmd + "\t", "Match"=>/\S*\n$/, "Timeout"=>10)
+        results.chomp.split(",")
+      rescue TimeoutError
+        [] #Just return empty results if timeout occurred on tab completion
+      end
+    end
+
+    private
+    def telnet_client(port)
+      Net::Telnet.new({"Port"=>port, "Prompt"=>/[$%#>] \z|Login failed/n, "Timeout"=>30, "FailEOF"=>true})
+    end
+
+    def readline_with_history(prompt)
+      line = Readline::readline(prompt)
+      return nil if line == nil || line == 'quit' || line == 'exit'
+      Readline::HISTORY.push(line) if not line =~ /^\s*$/ and Readline::HISTORY.to_a[-1] != line
+      line
+    end
+
+    def run_console(prompt)
+      prev = trap("INT")  { |x| exit_console; prev.call(x); exit }
+      prev = trap("TERM") { |x| exit_console; prev.call(x); exit }
+      loop do
+        cmd = readline_with_history(prompt)
+        if(cmd == nil)
+          exit_console
+          break
+        end
+        prompt = send_console_command_display_results(cmd, prompt)
+      end
+    end
+
+    def exit_console
+      #TimeoutError expected, as exit doesn't return anything
+      @telnet_client.cmd("String"=>"exit","Timeout"=>1) rescue TimeoutError
+      close_console
+    end
+
+    def send_console_command_display_results(cmd, prompt)
+      begin
+        lines = send_console_command cmd
+        #Assumes the last line is a prompt
+        prompt = lines.pop
+        lines.each {|line| display line if line != cmd}
+      rescue TimeoutError
+        display "Timed out sending command to server.".red
+      rescue EOFError
+        err "The console connection has been terminated.  Perhaps the app was stopped or deleted?"
+      end
+      prompt
+    end
+
+    def initialize_readline
+      if Readline.respond_to?("basic_word_break_characters=")
+        Readline.basic_word_break_characters= " \t\n`><=;|&{("
+      end
+      Readline.completion_append_character = nil
+      #Assumes that sending a String ending with tab will return a non-empty
+      #String of comma-separated completion options, terminated by a new line
+      #For example, "app.\t" might result in "to_s,nil?,etc\n"
+      Readline.completion_proc = proc {|s|
+        console_tab_completion_data s
+      }
+    end
+  end
+end