vmc 0.4.0.beta.13 → 0.4.0.beta.14

data/vmc-ng/lib/vmc/cli/app.rb

@@ -40,10 +40,18 @@ module VMC
     input :framework, :desc => "Filter by framework regexp"
     input :url, :desc => "Filter by url regexp"
     def apps(input)
-      apps =
-        with_progress("Getting applications") do
-          client.apps
-        end
+      if v2?
+        space = client.current_space
+        apps =
+          with_progress("Getting applications in #{c(space.name, :name)}") do
+            space.apps
+          end
+      else
+        apps =
+          with_progress("Getting applications") do
+            client.apps
+          end
+      end
 
       if apps.empty? and !quiet?
         puts ""
@@ -107,34 +115,51 @@ module VMC
 
       name = input[:name] if input[:name]
 
-      detector = Detector.new(client, path)
-      frameworks = detector.all_frameworks
-      detected, default = detector.frameworks
-
-      app = client.app(name)
+      exists =
+        if v2?
+          client.current_space.apps.find { |a| a.name == name }
+        elsif client.app(name).exists?
+          client.app(name)
+        end
 
-      if app.exists?
-        upload_app(app, path)
-        invoke :restart, :name => app.name if input[:restart]
+      if exists
+        upload_app(exists, path)
+        invoke :restart, :name => exists.name if input[:restart]
         return
       end
 
+      detector = Detector.new(client, path)
+      frameworks = detector.all_frameworks
+      detected, default = detector.frameworks
+
+      app = client.app
+      app.name = name
+      app.space = client.current_space if v2?
       app.total_instances = input[:instances]
 
+      framework_names = frameworks.collect(&:name).sort
       if detected.empty?
-        framework = input[:framework, frameworks.keys.sort, nil]
+        framework_name = input[:framework, framework_names, nil]
       else
-        framework = input[:framework, detected.keys.sort + ["other"], default]
-        if framework == "other"
+        detected_names = detected.collect(&:name).sort
+        framework_name =
+          input[:framework, detected_names + ["other"], default]
+
+        if framework_name == "other"
           input.forget(:framework)
-          framework = input[:framework, frameworks.keys.sort, nil]
+          framework_name = input[:framework, framework_names, nil]
         end
       end
 
-      framework_runtimes =
-        frameworks[framework]["runtimes"].collect { |k| k["name"] }
+      framework = frameworks.find { |f| f.name == framework_name }
+
+      runtimes = v2? ? client.runtimes : framework.runtimes
+      runtime_name = input[:runtime, runtimes.collect(&:name).sort]
+      runtime = runtimes.find { |r| r.name == runtime_name }
 
-      runtime = input[:runtime, framework_runtimes.sort]
+      fail "Invalid framework '#{input[:framework]}'" unless framework
+
+      fail "Invalid runtime '#{input[:runtime]}'" unless runtime
 
       app.framework = framework
       app.runtime = runtime
@@ -155,7 +180,7 @@ module VMC
       app.memory = megabytes(input[:memory, framework, runtime])
 
       bindings = []
-      if input[:create_services] && !force?
+      if !v2? && input[:create_services] && !force?
         services = client.system_services
 
         while true
@@ -188,7 +213,7 @@ module VMC
         end
       end
 
-      if input[:bind_services] && !force?
+      if !v2? && input[:bind_services] && !force?
         services = client.services.collect(&:name)
 
         while true
@@ -776,7 +801,7 @@ module VMC
 
       puts "#{c(a.name, :name)}: #{status}"
 
-      puts "  platform: #{b(a.framework)} on #{b(a.runtime)}"
+      puts "  platform: #{b(a.framework.name)} on #{b(a.runtime.name)}"
 
       print "  usage: #{b(human_size(a.memory * 1024 * 1024, 0))}"
       print " #{c(IS_UTF8 ? "\xc3\x97" : "x", :dim)} #{b(a.total_instances)}"
@@ -793,6 +818,10 @@ module VMC
     end
 
     def upload_app(app, path)
+      if v2?
+        fail "V2 API currently does not support uploading or starting apps."
+      end
+
       with_progress("Uploading #{c(app.name, :name)}") do
         app.upload(path)
       end
@@ -922,5 +951,49 @@ module VMC
         end
       end
     end
+
+    def usage(used, limit)
+      "#{b(human_size(used))} of #{b(human_size(limit, 0))}"
+    end
+
+    def percentage(num, low = 50, mid = 70)
+      color =
+        if num <= low
+          :good
+        elsif num <= mid
+          :warning
+        else
+          :bad
+        end
+
+      c(format("%.1f\%", num), color)
+    end
+
+    def megabytes(str)
+      if str =~ /T$/i
+        str.to_i * 1024 * 1024
+      elsif str =~ /G$/i
+        str.to_i * 1024
+      elsif str =~ /M$/i
+        str.to_i
+      elsif str =~ /K$/i
+        str.to_i / 1024
+      else # assume megabytes
+        str.to_i
+      end
+    end
+
+    def human_size(num, precision = 1)
+      sizes = ["G", "M", "K"]
+      sizes.each.with_index do |suf, i|
+        pow = sizes.size - i
+        unit = 1024 ** pow
+        if num >= unit
+          return format("%.#{precision}f%s", num / unit, suf)
+        end
+      end
+
+      format("%.#{precision}fB", num)
+    end
   end
 end

data/vmc-ng/lib/vmc/cli/start.rb

@@ -10,100 +10,89 @@ module VMC
       :desc => "List supported services"
     input :frameworks, :type => :boolean,
       :desc => "List supported frameworks"
+    input(:all, :type => :boolean, :alias => "-a",
+          :desc => "Show all information")
     def info(input)
-      info =
-        with_progress("Getting target information") do
-          client.info
-        end
-
-      authorized = !!info["frameworks"]
-
-      if input[:runtimes]
-        raise NotAuthorized unless authorized
+      all = input[:all]
 
-        runtimes = {}
-        info["frameworks"].each do |_, f|
-          f["runtimes"].each do |r|
-            runtimes[r["name"]] = r
+      if all || input[:runtimes]
+        runtimes =
+          with_progress("Getting runtimes") do
+            client.runtimes
           end
-        end
-
-        runtimes = runtimes.values.sort_by { |x| x["name"] }
+      end
 
-        if quiet?
-          runtimes.each do |r|
-            puts r["name"]
+      if all || input[:services]
+        services =
+          with_progress("Getting services") do
+            client.services
           end
-          return
-        end
-
-        runtimes.each do |r|
-          puts ""
-          puts "#{c(r["name"], :name)}:"
-          puts "  version: #{b(r["version"])}"
-          puts "  description: #{b(r["description"])}"
-        end
+      end
 
-        return
+      if all || input[:frameworks]
+        frameworks =
+          with_progress("Getting frameworks") do
+            client.frameworks
+          end
       end
 
-      if input[:services]
-        raise NotAuthorized unless authorized
+      info = client.info
 
-        services = client.system_services
+      showing_any = runtimes || services || frameworks
 
-        if quiet?
-          services.each do |name, _|
-            puts name
-          end
+      unless !all && showing_any
+        puts "" if showing_any
+        puts info[:description]
+        puts ""
+        puts "target: #{b(client.target)}"
+        puts "  version: #{info[:version]}"
+        puts "  support: #{info[:support]}"
 
-          return
+        if user = client.current_user
+          puts ""
+          puts "user: #{b(user.email || user.id)}"
         end
+      end
 
-        services.each do |name, meta|
+      if runtimes
+        unless quiet?
           puts ""
-          puts "#{c(name, :name)}:"
-          puts "  versions: #{meta[:versions].join ", "}"
-          puts "  description: #{meta[:description]}"
-          puts "  type: #{meta[:type]}"
+          puts "runtimes:"
         end
 
-        return
+        puts "  #{c("none", :dim)}" if runtimes.empty? && !quiet?
+
+        runtimes.each.with_index do |r, i|
+          display_runtime(r)
+          puts "" unless quiet? || i + 1 == runtimes.size
+        end
       end
 
-      if input[:frameworks]
-        raise NotAuthorized unless authorized
+      if services
+        unless quiet?
+          puts ""
+          puts "services:"
+        end
 
-        puts "" unless quiet?
+        puts "  #{c("none", :dim)}" if services.empty? && !quiet?
 
-        info["frameworks"].each do |name, _|
-          puts name
+        services.each.with_index do |s, i|
+          display_service(s)
+          puts "" unless quiet? || i + 1 == services.size
         end
-
-        return
       end
 
-      puts ""
+      if frameworks
+        unless quiet?
+          puts ""
+          puts "frameworks:"
+        end
 
-      puts info["description"]
-      puts ""
-      puts "target: #{b(client.target)}"
-      puts "  version: #{info["version"]}"
-      puts "  support: #{info["support"]}"
+        puts "  #{c("none", :dim)}" if frameworks.empty? && !quiet?
 
-      if info["user"]
-        puts ""
-        puts "user: #{b(info["user"])}"
-        puts "  usage:"
-
-        limits = info["limits"]
-        info["usage"].each do |k, v|
-          m = limits[k]
-          if k == "memory"
-            puts "    #{k}: #{usage(v * 1024 * 1024, m * 1024 * 1024)}"
-          else
-            puts "    #{k}: #{b(v)} of #{b(m)} limit"
-          end
+        frameworks.each.with_index do |f, i|
+          display_framework(f)
+          puts "" unless quiet? || i + 1 == frameworks.size
         end
       end
     end
@@ -113,72 +102,132 @@ module VMC
     group :start
     input :url, :argument => :optional,
       :desc => "Target URL to switch to"
+    input(:organization, :aliases => ["--org", "-o"],
+          :desc => "Organization") { |choices|
+      ask("Organization", :choices => choices)
+    }
+    input(:space, :alias => "-s", :desc => "Space") { |choices|
+      ask("Space", :choices => choices)
+    }
     def target(input)
-      if !input.given?(:url)
+      if !input.given?(:url) && !input.given?(:organization) &&
+          !input.given?(:space)
         display_target
+        puts "Organization: #{c(client.current_organization.name, :name)}"
+        puts "Space: #{c(client.current_space.name, :name)}"
         return
       end
 
-      target = sane_target_url(input[:url])
-      display = c(target.sub(/https?:\/\//, ""), :name)
-      with_progress("Setting target to #{display}") do
-        unless force?
-          # check that the target is valid
-          CFoundry::Client.new(target).info
+      if input.given?(:url)
+        target = sane_target_url(input[:url])
+        display = c(target.sub(/https?:\/\//, ""), :name)
+        with_progress("Setting target to #{display}") do
+          set_target(target)
         end
 
-        set_target(target)
+        return if force?
+      end
+
+      return unless v2?
+
+      unless client.logged_in?
+        invoke :login
+        @client = nil
       end
+
+      info = target_info
+
+      select_org_and_space(input, info)
+
+      save_target_info(info)
     end
 
 
     desc "List known targets."
     group :start, :hidden => true
     def targets(input)
-      tokens.each do |target, auth|
+      targets.each do |target, _|
         puts target
+        # TODO: print org/space
       end
     end
 
 
+    def ask_prompt(type, label)
+      if type == "password"
+        options = { :echo => "*", :forget => true }
+      else
+        options = {}
+      end
+
+      ask(label, options)
+    end
+
+    def ask_prompts(credentials, prompts)
+      prompts.each do |name, meta|
+        type, label = meta
+        credentials[name] ||= ask_prompt(type, label)
+      end
+    end
+
     desc "Authenticate with the target"
     group :start
-    input(:email, :argument => true, :desc => "Account email") {
-      ask("Email")
-    }
+    input :username, :alias => "--email", :argument => :optional,
+      :desc => "Account email"
     input :password, :desc => "Account password"
-    # TODO: implement new authentication scheme
+    input(:organization, :aliases => ["--org", "-o"],
+          :desc => "Organization") { |choices|
+      ask("Organization", :choices => choices)
+    }
+    input(:space, :alias => "-s", :desc => "Space") { |choices|
+      ask("Space", :choices => choices)
+    }
     def login(input)
       unless quiet?
         display_target
         puts ""
       end
 
-      email = input[:email]
-      password = input[:password]
+      credentials =
+        { :username => input[:username],
+          :password => input[:password]
+        }
+
+      prompts = client.login_prompts
+
+      # ask username first
+      if prompts.key? :username
+        type, label = prompts.delete :username
+        credentials[:username] ||= ask_prompt(type, label)
+      end
+
+      info = target_info
 
       authenticated = false
       failed = false
       until authenticated
         unless force?
-          if failed || !password
-            password = ask("Password", :echo => "*", :forget => true)
-          end
+          ask_prompts(credentials, prompts)
         end
 
         with_progress("Authenticating") do |s|
           begin
-            save_token(client.login(email, password))
+            info[:token] = client.login(credentials)
             authenticated = true
           rescue CFoundry::Denied
             return if force?
 
             s.fail do
               failed = true
+              credentials.delete(:password)
             end
           end
         end
       end
+
+      select_org_and_space(input, info) if v2?
+
+      save_target_info(info)
     ensure
       exit_status 1 if not authenticated
     end
@@ -188,7 +237,7 @@ module VMC
     group :start
     def logout(input)
       with_progress("Logging out") do
-        remove_token
+        remove_target_info
       end
     end
 
@@ -248,5 +297,97 @@ module VMC
         puts "Target: #{c(client.target, :name)}"
       end
     end
+
+    def display_runtime(r)
+      if quiet?
+        puts r.name
+      else
+        puts "  #{c(r.name, :name)}:"
+
+        puts "    description: #{b(r.description)}" if r.description
+
+        # TODO: probably won't have this in final version
+        apps = r.apps.collect { |a| c(a.name, :name) }
+        app_list = apps.empty? ? c("none", :dim) : apps.join(", ")
+        puts "    apps: #{app_list}"
+      end
+    end
+
+    def display_service(s)
+      if quiet?
+        puts s.label
+      else
+        puts "  #{c(s.label, :name)}:"
+        puts "    description: #{s.description}"
+        puts "    version: #{s.version}"
+        puts "    provider: #{s.provider}"
+      end
+    end
+
+    def display_framework(f)
+      if quiet?
+        puts f.name
+      else
+        puts "  #{c(f.name, :name)}:"
+        puts "    description: #{b(f.description)}" if f.description
+
+        # TODO: probably won't show this in final version; just for show
+        apps = f.apps.collect { |a| c(a.name, :name) }
+        puts "    apps: #{apps.empty? ? c("none", :dim) : apps.join(", ")}"
+      end
+    end
+
+    def org_valid?(id, user = client.current_user)
+      return false unless id
+      client.organization(id).users.include? user
+    rescue CFoundry::APIError
+      false
+    end
+
+    def space_valid?(id, user = client.current_user)
+      return false unless id
+      client.space(id).developers.include? user
+    rescue CFoundry::APIError
+      false
+    end
+
+    def select_org_and_space(input, info)
+      if input.given?(:organization) || !org_valid?(info[:organization])
+        orgs = client.current_user.organizations
+        fail "No organizations!" if orgs.empty?
+
+        if orgs.size == 1 && !input.given?(:organization)
+          org = orgs.first
+        else
+          org_name = input[:organization, orgs.collect(&:name).sort]
+          org = orgs.find { |o| o.name == org_name }
+          fail "Unknown organization '#{org_name}'" unless org
+        end
+
+        info[:organization] = org.id
+      else
+        org = client.current_organization
+      end
+
+      # switching org probably means switching space
+      if input.given?(:organization) || input.given?(:space) || \
+            !space_valid?(info[:space])
+        spaces = client.current_user.spaces.select do |s|
+          s.organization.id == org.id
+        end
+
+        fail "No spaces!" if spaces.empty?
+
+        if spaces.size == 1 && !input.given?(:space)
+          space = spaces.first
+        else
+          space_name = input[:space, spaces.collect(&:name).sort]
+          space = spaces.find { |s| s.name == space_name }
+          fail "Unknown space '#{space_name}'" unless space
+        end
+
+        info[:space] = space.id
+      end
+    end
   end
 end

data/vmc-ng/lib/vmc/cli.rb

@@ -40,7 +40,7 @@ module VMC
       option(:script)
     }
 
-    option(:script, :alias => "-s", :type => :boolean,
+    option(:script, :type => :boolean,
            :desc => "Shortcut for --quiet and --force") {
       !$stdout.tty?
     }
@@ -183,7 +183,7 @@ module VMC
       @client = nil
     end
 
-    def tokens
+    def targets_info
       new_toks = File.expand_path(VMC::TOKENS_FILE)
       old_toks = File.expand_path(VMC::OLD_TOKENS_FILE)
 
@@ -196,11 +196,17 @@ module VMC
       end
     end
 
-    def client_token
-      tokens[client_target]
+    def target_info
+      info = targets_info[client_target]
+
+      if info.is_a? String
+        { :token => info }
+      else
+        info || {}
+      end
     end
 
-    def save_tokens(ts)
+    def save_targets(ts)
       ensure_config_dir
 
       File.open(File.expand_path(VMC::TOKENS_FILE), "w") do |io|
@@ -208,69 +214,59 @@ module VMC
       end
     end
 
-    def save_token(token)
-      ts = tokens
-      ts[client_target] = token
-      save_tokens(ts)
+    def save_target_info(info)
+      ts = targets_info
+      ts[client_target] = info
+      save_targets(ts)
     end
 
-    def remove_token
-      ts = tokens
+    def remove_target_info
+      ts = target_info
       ts.delete client_target
-      save_tokens(ts)
+      save_targets(ts)
+    end
+
+    def v2?
+      client.is_a?(CFoundry::V2::Client)
     end
 
     def client
       return @client if @client
 
-      @client = CFoundry::Client.new(client_target, client_token)
+      info = target_info
+
+      @client =
+        case info[:version]
+        when 2
+          CFoundry::V2::Client.new(client_target, info[:token])
+        when 1
+          CFoundry::V1::Client.new(client_target, info[:token])
+        else
+          CFoundry::Client.new(client_target, info[:token])
+        end
+
       @client.proxy = option(:proxy)
       @client.trace = option(:trace)
-      @client
-    end
-
-    def usage(used, limit)
-      "#{b(human_size(used))} of #{b(human_size(limit, 0))}"
-    end
 
-    def percentage(num, low = 50, mid = 70)
-      color =
-        if num <= low
-          :good
-        elsif num <= mid
-          :warning
+      info[:version] ||=
+        case @client
+        when CFoundry::V2::Client
+          2
         else
-          :bad
+          1
         end
 
-      c(format("%.1f\%", num), color)
-    end
-
-    def megabytes(str)
-      if str =~ /T$/i
-        str.to_i * 1024 * 1024
-      elsif str =~ /G$/i
-        str.to_i * 1024
-      elsif str =~ /M$/i
-        str.to_i
-      elsif str =~ /K$/i
-        str.to_i / 1024
-      else # assume megabytes
-        str.to_i
+      if org = info[:organization]
+        @client.current_organization = @client.organization(org)
       end
-    end
 
-    def human_size(num, precision = 1)
-      sizes = ["G", "M", "K"]
-      sizes.each.with_index do |suf, i|
-        pow = sizes.size - i
-        unit = 1024 ** pow
-        if num >= unit
-          return format("%.#{precision}f%s", num / unit, suf)
-        end
+      if space = info[:space]
+        @client.current_space = @client.space(space)
       end
 
-      format("%.#{precision}fB", num)
+      save_target_info(info)
+
+      @client
     end
   end
 end

data/vmc-ng/lib/vmc/detect.rb

@@ -6,8 +6,7 @@ module VMC
     end
 
     def all_frameworks
-      info = @client.info
-      info["frameworks"] || {}
+      @client.frameworks
     end
 
     def find_top(entries)
@@ -30,16 +29,14 @@ module VMC
     end
 
     def frameworks
-      info = @client.info
-
-      matches = {}
-      all_frameworks.each do |name, meta|
+      matches = []
+      all_frameworks.each do |framework|
         matched = false
 
         # e.g. standalone has no detection
-        next if meta["detection"].nil?
+        next if framework.detection.nil?
 
-        meta["detection"].first.each do |file, match|
+        framework.detection.first.each do |file, match|
           files =
             if File.file? @path
               if File.fnmatch(file, @path)
@@ -76,13 +73,11 @@ module VMC
           end
         end
 
-        if matched
-          matches[name] = meta
-        end
+        matches << framework if matched
       end
 
       if matches.size == 1
-        default = matches.keys.first
+        default = matches.first
       end
 
       [matches, default]

data/vmc-ng/lib/vmc/version.rb

@@ -1,3 +1,3 @@
 module VMC
-  VERSION = "0.4.0.beta.13"
+  VERSION = "0.4.0.beta.14"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: vmc
 version: !ruby/object:Gem::Version 
-  hash: 62196473
+  hash: 62196479
   prerelease: 6
   segments: 
   - 0
   - 4
   - 0
   - beta
-  - 13
-  version: 0.4.0.beta.13
+  - 14
+  version: 0.4.0.beta.14
 platform: ruby
 authors: 
 - VMware
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-03 00:00:00 Z
+date: 2012-07-13 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json_pure
@@ -252,9 +252,9 @@ dependencies:
         hash: 19
         segments: 
         - 0
-        - 2
-        - 2
-        version: 0.2.2
+        - 3
+        - 0
+        version: 0.3.0
   type: :runtime
   version_requirements: *id014
 - !ruby/object:Gem::Dependency