vmcu 0.3.17

data/lib/cli/commands/base.rb

@@ -0,0 +1,238 @@
+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 = [])
+        if VMC::Cli::Config.uhuru_target
+          (VMC::Cli::Config.uhuru_target[:cloud_domain] || target_url).sub(/\A[^\/]*\/\//, "").sub(/\/.*\z/, "")
+        else
+          VMC::Cli::Config.base_of(find_symbol("target", ctx) || target_url)
+        end
+      end
+
+      # Inject a client to help in testing.
+      def client(cli=nil)
+        @client ||= cli
+        return @client if @client
+        if VMC::Cli::Config.uhuru_target
+          uhuru_target = VMC::Cli::Config.uhuru_target
+          @client = VMC::Client.new(target_url, uhuru_target[:token])
+          @client.via_uhuru_cloud = true
+          @client.cloud_team = uhuru_target[:cloud_team]
+          @client.proxy_realm = uhuru_target[:realm] if uhuru_target[:realm]
+        else
+          @client = VMC::Client.new(target_url, auth_token)
+        end
+        @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/lib/cli/commands/manifest.rb

@@ -0,0 +1,56 @@
+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/lib/cli/commands/micro.rb

@@ -0,0 +1,115 @@
+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/lib/cli/commands/misc.rb

@@ -0,0 +1,277 @@
+module VMC::Cli::Command
+
+  class Misc < Base
+    def version
+      say "vmcu #{VMC::Cli::VERSION}"
+    end
+
+    def target
+      return uhuru_target if VMC::Cli::Config.uhuru_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(/\/+$/, '')
+
+      uhuru_targets = VMC::Cli::Config.all_uhuru_targets || {}
+
+      client = VMC::Client.new(target_url)
+      client.trace = VMC::Cli::Config.trace if VMC::Cli::Config.trace
+
+      unless client.target_valid?
+        unless client.uhuru_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)
+
+          new_uhuru_target = uhuru_targets[target_url.to_sym] || {}
+          VMC::Cli::Config.store_uhuru_target(
+              target_url,
+              new_uhuru_target
+          )
+          say "Successfully targeted to Uhuru App Cloud [#{target_url}]".green
+
+        end
+      else
+        VMC::Cli::Config.store_target(target_url)
+        say "Successfully targeted to [#{target_url}]".green
+      end
+    end
+
+    def set_cloud_team(cloud_team = nil)
+      err "Must be targeted to a Uhuru App Cloud to use cloud teams" unless client.via_uhuru_cloud
+
+      client.proxy_realm = @options[:realm]
+
+      detailed_cloud_teams = nil
+      unless no_prompt || cloud_team
+
+        err "No cloud team found for your UhuruApp account" if (detailed_cloud_teams ||= client.get_detailed_cloud_teams).length == 0
+
+        detailed_cloud_teams.each{|cloud_team|
+          cloud_team[:CloudEntity] ||= client.get_cloud_entity((cloud_team[:Cloud] || cloud_team[:CloudTeamCloud])[:Id])
+        }
+
+        cloud_team_chosen = ask(
+          "\nWhich cloud team would you like to target to?",
+          { :indexed => true,
+            #:choices => (detailed_cloud_teams ||= client.get_detailed_cloud_teams).collect { |cloud_team| {:Name => cloud_team[:Name], :Id => cloud_team[:Id]}}
+            :choices => (detailed_cloud_teams ||= client.get_detailed_cloud_teams).collect { |cloud_team|
+              "#{cloud_team[:Name]} \t[Cloud: #{cloud_team[:CloudEntity][:Name]}] \t[Cloud Team Id: #{cloud_team[:Id]}]"
+            }
+          }
+        )
+
+        cloud_team_desc = detailed_cloud_teams.select{|i| cloud_team_chosen.index i[:Id]}.first
+        cloud_team_id = cloud_team = cloud_team_desc[:Id]
+      end
+      err "Cloud team Id or Name required." unless cloud_team
+
+      # if it matches a GUID format
+      unless cloud_team =~ /\A\{?\w{8}-\w{4}-\w{4}-\w{4}-\w{12}\}?\z/
+        found_cloud_team = (detailed_cloud_teams ||= client.get_detailed_cloud_teams).select { |i|
+          i[:Name] == cloud_team
+        }
+
+        err "Could not find a cloud team with name \"#{cloud_team}\"" if found_cloud_team.length == 0
+        cloud_team_desc = found_cloud_team.first
+        cloud_team_id = cloud_team_desc[:Id]
+      else
+        cloud_team_id = cloud_team
+      end
+
+      client.cloud_team = cloud_team_id
+      cloud_team_desc ||= client.get_cloud_team(cloud_team_id)
+      cloud_team_desc[:CloudEntity] ||= client.get_cloud_entity((cloud_team_desc[:Cloud] || cloud_team_desc[:CloudTeamCloud])[:Id])
+
+      new_uhuru_target = VMC::Cli::Config.all_uhuru_targets[target_url.to_sym] || {}
+      new_uhuru_target[:cloud_team] = cloud_team_id
+      new_uhuru_target[:cloud_domain] = cloud_team_desc[:CloudEntity][:Domain]
+      new_uhuru_target[:realm] = @options[:realm]
+      VMC::Cli::Config.store_uhuru_target(
+          target_url,
+          new_uhuru_target
+      )
+
+
+      display  "\nTargeted to UhuruApp Cloud:\t[#{target_url}]\n Cloud Team:\t\t\t[#{cloud_team_desc[:Name]}]\n Cloud Team Id:\t\t\t[#{new_uhuru_target[:cloud_team]}]\n Cloud Foundry domain:\t\t[#{new_uhuru_target[:cloud_domain]}]"
+
+    end
+
+    def import_from_registry
+      require 'win32/registry'
+      keyname = 'Software\Uhuru\CloudTargets'
+      access = Win32::Registry::KEY_READ
+      reg_targets = []
+
+      Win32::Registry::HKEY_CURRENT_USER.open(keyname, access) do |reg|
+        reg.each{|k|
+          t = reg[k]
+          if t[0] == 'isUhuruApi'
+            reg_targets << {:uhuruApi => true,
+                            :target_url => t[2],
+                            :auth_token => t[3],
+                            :cloud_team => t[4],
+                            # todo: get the cloud_domain
+                            :cloud_domain => t[6],
+                            :desc => "Uhuru AppCloud [#{t[2]}] / #{t[5]}"
+            }
+          end
+          if t[0] == 'notUhuruApi'
+            reg_targets << {:uhuruApi => false,
+                            :target_url => t[2],
+                            :auth_token => t[4],
+                            :desc => "Cloud Foundry  [#{t[2]}] / #{t[3]}"
+            }
+          end
+
+        }
+      end
+
+      selected_target_desc = ask(
+          "Which target to import?",
+          {
+              :indexed => true,
+              :choices => reg_targets.collect{|t| "#{t[:desc]}" }
+          }
+      )
+
+      selected_target = reg_targets.select{|t| selected_target_desc.index(t[:desc]) }.first
+
+      if selected_target[:uhuruApi]
+        VMC::Cli::Config.store_uhuru_target(
+            selected_target[:target_url],
+            {
+                :token => selected_target[:auth_token],
+                :cloud_team => selected_target[:cloud_team],
+                :cloud_domain => selected_target[:cloud_domain]
+            }
+        )
+
+        VMC::Cli::Config.store_target(selected_target[:target_url])
+      else
+        VMC::Cli::Config.store_target(selected_target[:target_url])
+        VMC::Cli::Config.store_uhuru_target(
+            selected_target[:target_url],
+            nil
+        )
+        VMC::Cli::Config.store_token(selected_target[:auth_token], @options[:token_file])
+      end
+
+      display "Targeted to #{selected_target[:desc]}"
+    end
+
+    def uhuru_target
+      return display JSON.pretty_generate(VMC::Cli::Config.uhuru_target) if @options[:json]
+      banner "Uhuru AppCloud [#{VMC::Cli::Config.target_url}]"
+    end
+
+    def info
+      display "\nUsing Uhuru AppCloud [#{VMC::Cli::Config.target_url}]" if VMC::Cli::Config.uhuru_target
+
+      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
+