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

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

@@ -1,227 +0,0 @@
-require 'rubygems'
-require 'interact'
-require 'terminal-table/import'
-
-module VMC::Cli
-
-  module Command
-
-    class Base
-      include Interactive
-
-      attr_reader :no_prompt, :prompt_ok
-
-      MANIFEST = "manifest.yml"
-
-      def initialize(options={})
-        @options = options.dup
-        @no_prompt = @options[:noprompts]
-        @prompt_ok = !no_prompt
-
-        # Suppress colorize on Windows systems for now.
-        if WINDOWS
-          VMC::Cli::Config.colorize = false
-        end
-
-        @path = @options[:path] || '.'
-
-        load_manifest manifest_file if manifest_file
-      end
-
-      def manifest_file
-        return @options[:manifest] if @options[:manifest]
-        return @manifest_file if @manifest_file
-
-        where = File.expand_path(@path)
-        while true
-          if File.exists?(File.join(where, MANIFEST))
-            @manifest_file = File.join(where, MANIFEST)
-            break
-          elsif File.basename(where) == "/"
-            @manifest_file = nil
-            break
-          else
-            where = File.expand_path("../", where)
-          end
-        end
-
-        @manifest_file
-      end
-
-      def load_manifest_structure(file)
-        manifest = YAML.load_file file
-
-        Array(manifest["inherit"]).each do |p|
-          manifest = merge_parent(manifest, p)
-        end
-
-        if apps = manifest["applications"]
-          apps.each do |k, v|
-            abs = File.expand_path(k, file)
-            if Dir.pwd.start_with? abs
-              manifest = merge_manifest(manifest, v)
-            end
-          end
-        end
-
-        manifest
-      end
-
-      def resolve_manifest(manifest)
-        if apps = manifest["applications"]
-          apps.each_value do |v|
-            resolve_lexically(v, [manifest])
-          end
-        end
-
-        resolve_lexically(manifest, [manifest])
-      end
-
-      def load_manifest(file)
-        @manifest = load_manifest_structure(file)
-        resolve_manifest(@manifest)
-      end
-
-      def merge_parent(child, path)
-        file = File.expand_path("../" + path, manifest_file)
-        merge_manifest(child, load_manifest_structure(file))
-      end
-
-      def merge_manifest(child, parent)
-        merge = proc do |_, old, new|
-          if new.is_a?(Hash) and old.is_a?(Hash)
-            old.merge(new, &merge)
-          else
-            new
-          end
-        end
-
-        parent.merge(child, &merge)
-      end
-
-      def resolve_lexically(val, ctx = [@manifest])
-        case val
-        when Hash
-          val.each_value do |v|
-            resolve_lexically(v, [val] + ctx)
-          end
-        when Array
-          val.each do |v|
-            resolve_lexically(v, ctx)
-          end
-        when String
-          val.gsub!(/\$\{([[:alnum:]\-]+)\}/) do
-            resolve_symbol($1, ctx)
-          end
-        end
-
-        nil
-      end
-
-      def resolve_symbol(sym, ctx)
-        case sym
-        when "target-base"
-          target_base(ctx)
-
-        when "target-url"
-          target_url(ctx)
-
-        when "random-word"
-          "%04x" % [rand(0x0100000)]
-
-        else
-          found = find_symbol(sym, ctx)
-
-          if found
-            resolve_lexically(found, ctx)
-            found
-          else
-            err(sym, "Unknown symbol in manifest: ")
-          end
-        end
-      end
-
-      def find_symbol(sym, ctx)
-        ctx.each do |h|
-          if val = resolve_in(h, sym)
-            return val
-          end
-        end
-
-        nil
-      end
-
-      def resolve_in(hash, *where)
-        find_in_hash(hash, ["properties"] + where) ||
-          find_in_hash(hash, ["applications", @application] + where) ||
-          find_in_hash(hash, where)
-      end
-
-      def manifest(*where)
-        resolve_in(@manifest, *where)
-      end
-
-      def find_in_hash(hash, where)
-        what = hash
-        where.each do |x|
-          return nil unless what.is_a?(Hash)
-          what = what[x]
-        end
-
-        what
-      end
-
-      def target_url(ctx = [])
-        find_symbol("target", ctx) ||
-          (@client && @client.target) ||
-          VMC::Cli::Config.target_url
-      end
-
-      def target_base(ctx = [])
-        VMC::Cli::Config.base_of(find_symbol("target", ctx) || target_url)
-      end
-
-      # Inject a client to help in testing.
-      def client(cli=nil)
-        @client ||= cli
-        return @client if @client
-        @client = VMC::Client.new(target_url, auth_token)
-        @client.trace = VMC::Cli::Config.trace if VMC::Cli::Config.trace
-        @client.proxy_for @options[:proxy] if @options[:proxy]
-        @client
-      end
-
-      def client_info
-        @client_info ||= client.info
-      end
-
-      def auth_token
-        @auth_token = VMC::Cli::Config.auth_token(@options[:token_file])
-      end
-
-      def runtimes_info
-        return @runtimes if @runtimes
-        info = client_info
-        @runtimes = {}
-        if info[:frameworks]
-          info[:frameworks].each_value do |f|
-            next unless f[:runtimes]
-            f[:runtimes].each { |r| @runtimes[r[:name]] = r}
-          end
-        end
-        @runtimes
-      end
-
-      def frameworks_info
-        return @frameworks if @frameworks
-        info = client_info
-        @frameworks = []
-        if info[:frameworks]
-          info[:frameworks].each_value { |f| @frameworks << [f[:name]] }
-        end
-        @frameworks
-      end
-    end
-  end
-end
-

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

@@ -1,56 +0,0 @@
-module VMC::Cli::Command
-  class Manifest < Base
-    include VMC::Cli::ManifestHelper
-
-    def initialize(options)
-      super
-
-      # don't resolve any of the manifest template stuff
-      if manifest_file
-        @manifest = load_manifest_structure manifest_file
-      else
-        @manifest = {}
-      end
-    end
-
-    def edit
-      build_manifest
-      save_manifest
-    end
-
-    def extend(which)
-      parent = load_manifest_structure which
-      @manifest = load_manifest_structure which
-
-      build_manifest
-
-      simplify(@manifest, parent)
-
-      @manifest["inherit"] ||= []
-      @manifest["inherit"] << which
-
-      save_manifest(ask("Save where?"))
-    end
-
-    private
-
-    def simplify(child, parent)
-      return unless child.is_a?(Hash) and parent.is_a?(Hash)
-
-      child.reject! do |k, v|
-        if v == parent[k]
-          puts "rejecting #{k}"
-          true
-        else
-          simplify(v, parent[k])
-          false
-        end
-      end
-    end
-
-    def build_manifest
-      @application = ask("Configure for which application?", :default => ".")
-      interact true
-    end
-  end
-end

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

@@ -1,115 +0,0 @@
-module VMC::Cli::Command
-  class Micro < Base
-
-    def initialize(args)
-      super(args)
-    end
-
-    def offline(mode)
-      command('offline')
-    end
-
-    def online(mode)
-      command('online')
-    end
-
-    def status(mode)
-      command('status')
-    end
-
-    def command(cmd)
-      config = build_config
-      switcher(config).send(cmd)
-      store_config(config)
-    end
-
-    def switcher(config)
-      case Micro.platform
-      when :darwin
-        switcher = VMC::Micro::Switcher::Darwin.new(config)
-      when :linux
-        switcher = VMC::Micro::Switcher::Linux.new(config)
-      when :windows
-        switcher = VMC::Micro::Switcher::Windows.new(config)
-      when :dummy # for testing only
-        switcher = VMC::Micro::Switcher::Dummy.new(config)
-      else
-        err "unsupported platform: #{Micro.platform}"
-      end
-    end
-
-    # Returns the configuration needed to run the micro related subcommands.
-    # First loads saved config from file (if there is any), then overrides
-    # loaded values with command line arguments, and finally tries to guess
-    # in case neither was used:
-    #   vmx       location of micro.vmx file
-    #   vmrun     location of vmrun command
-    #   password  password for vcap user (in the guest vm)
-    #   platform  current platform
-    def build_config
-      conf = VMC::Cli::Config.micro # returns {} if there isn't a saved config
-
-      override(conf, 'vmx', true) do
-        locate_vmx(Micro.platform)
-      end
-
-      override(conf, 'vmrun', true) do
-        VMC::Micro::VMrun.locate(Micro.platform)
-      end
-
-      override(conf, 'password') do
-        @password = ask("Please enter your Micro Cloud Foundry VM password (vcap user) password", :echo => "*")
-      end
-
-      conf['platform'] = Micro.platform
-
-      conf
-    end
-
-    # Save the cleartext password if --save is supplied.
-    # Note: it is due to vix we have to use a cleartext password :(
-    # Only if --password is used and not --save is the password deleted from the
-    # config file before it is stored to disk.
-    def store_config(config)
-      if @options[:save]
-        warn("cleartext password saved in: #{VMC::Cli::Config::MICRO_FILE}")
-      elsif @options[:password] || @password
-        config.delete('password')
-      end
-
-      VMC::Cli::Config.store_micro(config)
-    end
-
-    # override with command line arguments and yield the block in case the option isn't set
-    def override(config, option, escape=false, &blk)
-      # override if given on the command line
-      if opt = @options[option.to_sym]
-        opt = VMC::Micro.escape_path(opt) if escape
-        config[option] = opt
-      end
-      config[option] = yield unless config[option]
-    end
-
-    def locate_vmx(platform)
-      paths = YAML.load_file(VMC::Micro.config_file('paths.yml'))
-      vmx_paths = paths[platform.to_s]['vmx']
-      vmx = VMC::Micro.locate_file('micro.vmx', 'micro', vmx_paths)
-      err "Unable to locate micro.vmx, please supply --vmx option" unless vmx
-      vmx
-    end
-
-    def self.platform
-      case RUBY_PLATFORM
-      when /darwin/  # x86_64-darwin11.2.0
-        :darwin
-      when /linux/   # x86_64-linux
-        :linux
-      when /mingw|mswin32|cygwin/ # i386-mingw32
-        :windows
-      else
-        RUBY_PLATFORM
-      end
-    end
-
-  end
-end

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

@@ -1,129 +0,0 @@
-module VMC::Cli::Command
-
-  class Misc < Base
-    def version
-      say "vmc #{VMC::Cli::VERSION}"
-    end
-
-    def target
-      return display JSON.pretty_generate({:target => target_url}) if @options[:json]
-      banner "[#{target_url}]"
-    end
-
-    def targets
-      targets = VMC::Cli::Config.targets
-      return display JSON.pretty_generate(targets) if @options[:json]
-      return display 'None specified' if targets.empty?
-      targets_table = table do |t|
-        t.headings = 'Target', 'Authorization'
-        targets.each { |target, token| t << [target, token] }
-      end
-      display "\n"
-      display targets_table
-    end
-
-    alias :tokens :targets
-
-    def set_target(target_url)
-      target_url = "http://#{target_url}" unless /^https?/ =~ target_url
-      target_url = target_url.gsub(/\/+$/, '')
-      client = VMC::Client.new(target_url)
-      unless client.target_valid?
-        if prompt_ok
-          display "Host is not available or is not valid: '#{target_url}'".red
-          show_response = ask "Would you like see the response?",
-                              :default => false
-          display "\n<<<\n#{client.raw_info}\n>>>\n" if show_response
-        end
-        exit(false)
-      else
-        VMC::Cli::Config.store_target(target_url)
-        say "Successfully targeted to [#{target_url}]".green
-      end
-    end
-
-    def info
-      info = client_info
-      return display JSON.pretty_generate(info) if @options[:json]
-
-      display "\n#{info[:description]}"
-      display "For support visit #{info[:support]}"
-      display ""
-      display "Target:   #{target_url} (v#{info[:version]})"
-      display "Client:   v#{VMC::Cli::VERSION}"
-      if info[:user]
-        display ''
-        display "User:     #{info[:user]}"
-      end
-      if usage = info[:usage] and limits = info[:limits]
-        tmem  = pretty_size(limits[:memory]*1024*1024)
-        mem   = pretty_size(usage[:memory]*1024*1024)
-        tser  = limits[:services]
-        ser   = usage[:services]
-        tapps = limits[:apps] || 0
-        apps  = usage[:apps]  || 0
-        display "Usage:    Memory   (#{mem} of #{tmem} total)"
-        display "          Services (#{ser} of #{tser} total)"
-        display "          Apps     (#{apps} of #{tapps} total)" if limits[:apps]
-      end
-    end
-
-    def runtimes
-      raise VMC::Client::AuthError unless client.logged_in?
-      return display JSON.pretty_generate(runtimes_info) if @options[:json]
-      return display "No Runtimes" if runtimes_info.empty?
-      rtable = table do |t|
-        t.headings = 'Name', 'Description', 'Version'
-        runtimes_info.each_value { |rt| t << [rt[:name], rt[:description], rt[:version]] }
-      end
-      display "\n"
-      display rtable
-    end
-
-    def frameworks
-      raise VMC::Client::AuthError unless client.logged_in?
-      return display JSON.pretty_generate(frameworks_info) if @options[:json]
-      return display "No Frameworks" if frameworks_info.empty?
-      rtable = table do |t|
-        t.headings = ['Name']
-        frameworks_info.each { |f| t << f }
-      end
-      display "\n"
-      display rtable
-    end
-
-    def aliases
-      aliases = VMC::Cli::Config.aliases
-      return display JSON.pretty_generate(aliases) if @options[:json]
-      return display "No Aliases" if aliases.empty?
-      atable = table do |t|
-        t.headings = 'Alias', 'Command'
-        aliases.each { |k,v| t << [k, v] }
-      end
-      display "\n"
-      display atable
-    end
-
-    def alias(k, v=nil)
-      k,v = k.split('=') unless v
-      aliases = VMC::Cli::Config.aliases
-      aliases[k] = v
-      VMC::Cli::Config.store_aliases(aliases)
-      display "Successfully aliased '#{k}' to '#{v}'".green
-    end
-
-    def unalias(key)
-      aliases = VMC::Cli::Config.aliases
-      if aliases.has_key?(key)
-        aliases.delete(key)
-        VMC::Cli::Config.store_aliases(aliases)
-        display "Successfully unaliased '#{key}'".green
-      else
-        display "Unknown alias '#{key}'".red
-      end
-    end
-
-  end
-
-end
-

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

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