vmc 0.4.0.beta.12 → 0.4.0.beta.13

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

@@ -0,0 +1,12 @@
+require "mothership/help"
+
+Mothership::Help.groups(
+  [:start, "Getting Started"],
+  [:apps, "Applications",
+    [:manage, "Management"],
+    [:info, "Information"]],
+  [:services, "Services",
+    [:manage, "Management"]],
+  [:admin, "Administration",
+    [:user, "User Management"]])
+

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

@@ -0,0 +1,101 @@
+require "interact"
+
+module VMC
+  module Interactive
+    include ::Interactive::Rewindable
+
+    def ask(question, options = {})
+      if force? and options.key?(:default)
+        options[:default]
+      else
+        super
+      end
+    end
+
+    def list_choices(choices, options)
+      choices.each_with_index do |o, i|
+        puts "#{c(i + 1, :number)}: #{o}"
+      end
+    end
+
+    def input_state(options)
+      CFState.new(options)
+    end
+
+    def prompt(question, options)
+      value =
+        case options[:default]
+        when true
+          "y"
+        when false
+          "n"
+        when nil
+          ""
+        else
+          options[:default].to_s
+        end
+
+      print "#{question}"
+      print c("> ", :prompt)
+
+      unless value.empty?
+        print "#{c(value, :default) + "\b" * value.size}"
+      end
+    end
+
+    def handler(which, state)
+      ans = state.answer
+      pos = state.position
+
+      if state.default?
+        if which.is_a?(Array) and which[0] == :key
+          # initial non-movement keypress clears default answer
+          clear_input(state)
+        else
+          # wipe away any coloring
+          redraw_input(state)
+        end
+
+        state.clear_default!
+      end
+
+      super
+
+      print "\n" if which == :enter
+    end
+
+    class CFState < ::Interactive::InputState
+      def initialize(options = {}, answer = nil, position = 0)
+        @options = options
+
+        if answer
+          @answer = answer
+        elsif options[:default]
+          case options[:default]
+          when true
+            @answer = "y"
+          when false
+            @answer = "n"
+          else
+            @answer = options[:default].to_s
+          end
+
+          @default = true
+        else
+          @answer = ""
+        end
+
+        @position = position
+        @done = false
+      end
+
+      def clear_default!
+        @default = false
+      end
+
+      def default?
+        @default
+      end
+    end
+  end
+end

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

@@ -1,32 +1,68 @@
-require "vmc/cli/command"
+require "vmc/cli"
 
 module VMC
-  class Service < Command
-    desc "create", "Create a service"
+  class Service < CLI
+    desc "List your services"
+    group :services
+    input :name, :desc => "Filter by name regexp"
+    input :app, :desc => "Filter by bound application regexp"
+    input :type, :desc => "Filter by service type regexp"
+    input :vendor, :desc => "Filter by service vendor regexp"
+    input :tier, :desc => "Filter by service tier regexp"
+    def services(input)
+      services =
+        with_progress("Getting services") do
+          client.services
+        end
+
+      puts "" unless quiet?
+
+      if services.empty? and !quiet?
+        puts "No services."
+      end
+
+      if app = input[:app]
+        apps = client.apps
+        services.reject! do |s|
+          apps.none? { |a| a.services.include? s.name }
+        end
+      end
+
+      services.each do |s|
+        display_service(s) if service_matches(s, input)
+      end
+    end
+
+
+    desc "Create a service"
     group :services, :manage
-    flag(:vendor) { |choices|
+    input(:vendor, :argument => true,
+          :desc => "What kind of service (e.g. redis, mysql)") { |choices|
       ask "What kind?", :choices => choices
     }
-    flag(:version) { |choices|
-      ask "Which version?", :choices => choices
-    }
-    flag(:name) { |vendor|
+    input(:name, :argument => true,
+          :desc => "Local name for the service") { |vendor|
       random = sprintf("%x", rand(1000000))
       ask "Name?", :default => "#{vendor}-#{random}"
     }
-    def create
+    input(:version, :desc => "Version of the service") { |choices|
+      ask "Which version?", :choices => choices
+    }
+    input :bind, :alias => "--app",
+      :desc => "Application to immediately bind to"
+    def create_service(input)
       services = client.system_services
 
-      vendor = input(:vendor, services.keys)
+      vendor = input[:vendor, services.keys.sort]
       meta = services[vendor]
 
       if meta[:versions].size == 1
         version = meta[:versions].first
       else
-        version = input(:version, meta[:versions])
+        version = input[:version, meta[:versions]]
       end
 
-      service = client.service(input(:name, meta[:vendor]))
+      service = client.service(input[:name, meta[:vendor]])
       service.type = meta[:type]
       service.vendor = meta[:vendor]
       service.version = version
@@ -35,56 +71,68 @@ module VMC
       with_progress("Creating service #{c(service.name, :name)}") do
         service.create!
       end
+
+      if app = input[:bind]
+        invoke :bind_service, :name => service.name, :app => app
+      end
     end
 
-    desc "bind", "Bind a service to an application"
+
+    desc "Bind a service to an application"
     group :services, :manage
-    flag(:name) { |choices|
+    input(:name, :argument => true,
+          :desc => "Service to bind") { |choices|
       ask "Which service?", :choices => choices
     }
-    flag(:app) { |choices|
+    input(:app, :argument => true,
+          :desc => "Application to bind to") { |choices|
       ask "Which application?", :choices => choices
     }
-    def bind(name = nil, appname = nil)
-      name ||= input(:name, client.services.collect(&:name))
-      appname ||= input(:app, client.apps.collect(&:name))
+    def bind_service(input)
+      name = input[:name, client.services.collect(&:name)]
+      appname = input[:app, client.apps.collect(&:name)]
 
       with_progress("Binding #{c(name, :name)} to #{c(appname, :name)}") do
         client.app(appname).bind(name)
       end
     end
 
-    desc "unbind", "Unbind a service from an application"
+
+    desc "Unbind a service from an application"
     group :services, :manage
-    flag(:name) { |choices|
+    input(:name, :argument => true,
+          :desc => "Service to unbind") { |choices|
       ask "Which service?", :choices => choices
     }
-    flag(:app) { |choices|
+    input(:app, :argument => true,
+          :desc => "Application to unbind from") { |choices|
       ask "Which application?", :choices => choices
     }
-    def unbind(name = nil, appname = nil)
-      appname ||= input(:app, client.apps.collect(&:name))
+    def unbind_service(input)
+      appname = input[:app, client.apps.collect(&:name)]
 
       app = client.app(appname)
-      name ||= input(:name, app.services)
+      name = input[:name, app.services]
 
       with_progress("Unbinding #{c(name, :name)} from #{c(appname, :name)}") do
         app.unbind(name)
       end
     end
 
-    desc "delete", "Delete a service"
+
+    desc "Delete a service"
     group :services, :manage
-    flag(:really) { |name, color|
-      force? || ask("Really delete #{c(name, color)}?", :default => false)
-    }
-    flag(:name) { |choices|
+    input(:name, :argument => true,
+          :desc => "Service to delete") { |choices|
       ask "Delete which service?", :choices => choices
     }
-    flag(:all, :default => false)
-    def delete(name = nil)
-      if input(:all)
-        return unless input(:really, "ALL SERVICES", :bad)
+    input(:really, :type => :boolean) { |name, color|
+      force? || ask("Really delete #{c(name, color)}?", :default => false)
+    }
+    input :all, :default => false, :desc => "Delete all services"
+    def delete_service(input)
+      if input[:all]
+        return unless input[:really, "ALL SERVICES", :bad]
 
         with_progress("Deleting all services") do
           client.services.collect(&:delete!)
@@ -93,20 +141,50 @@ module VMC
         return
       end
 
-      unless name
+      if input.given? :name
+        name = input[:name]
+      else
         services = client.services
         fail "No services." if services.empty?
 
-        name = input(:name, services.collect(&:name))
+        name = input[:name, services.collect(&:name)]
       end
 
-      return unless input(:really, name, :name)
+      return unless input[:really, name, :name]
 
       with_progress("Deleting #{c(name, :name)}") do
         client.service(name).delete!
       end
-    ensure
-      forget(:really)
+    end
+
+    private
+
+    def service_matches(s, options)
+      if name = options[:name]
+        return false if s.name !~ /#{name}/
+      end
+
+      if type = options[:type]
+        return false if s.type !~ /#{type}/
+      end
+
+      if vendor = options[:vendor]
+        return false if s.vendor !~ /#{vendor}/
+      end
+
+      if tier = options[:tier]
+        return false if s.tier !~ /#{tier}/
+      end
+
+      true
+    end
+
+    def display_service(s)
+      if quiet?
+        puts s.name
+      else
+        puts "#{c(s.name, :name)}: #{s.vendor} v#{s.version}"
+      end
     end
   end
 end

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

@@ -0,0 +1,252 @@
+require "vmc/cli"
+
+module VMC
+  class Start < CLI
+    desc "Display information on the current target, user, etc."
+    group :start
+    input :runtimes, :type => :boolean,
+      :desc => "List supported runtimes"
+    input :services, :type => :boolean,
+      :desc => "List supported services"
+    input :frameworks, :type => :boolean,
+      :desc => "List supported frameworks"
+    def info(input)
+      info =
+        with_progress("Getting target information") do
+          client.info
+        end
+
+      authorized = !!info["frameworks"]
+
+      if input[:runtimes]
+        raise NotAuthorized unless authorized
+
+        runtimes = {}
+        info["frameworks"].each do |_, f|
+          f["runtimes"].each do |r|
+            runtimes[r["name"]] = r
+          end
+        end
+
+        runtimes = runtimes.values.sort_by { |x| x["name"] }
+
+        if quiet?
+          runtimes.each do |r|
+            puts r["name"]
+          end
+          return
+        end
+
+        runtimes.each do |r|
+          puts ""
+          puts "#{c(r["name"], :name)}:"
+          puts "  version: #{b(r["version"])}"
+          puts "  description: #{b(r["description"])}"
+        end
+
+        return
+      end
+
+      if input[:services]
+        raise NotAuthorized unless authorized
+
+        services = client.system_services
+
+        if quiet?
+          services.each do |name, _|
+            puts name
+          end
+
+          return
+        end
+
+        services.each do |name, meta|
+          puts ""
+          puts "#{c(name, :name)}:"
+          puts "  versions: #{meta[:versions].join ", "}"
+          puts "  description: #{meta[:description]}"
+          puts "  type: #{meta[:type]}"
+        end
+
+        return
+      end
+
+      if input[:frameworks]
+        raise NotAuthorized unless authorized
+
+        puts "" unless quiet?
+
+        info["frameworks"].each do |name, _|
+          puts name
+        end
+
+        return
+      end
+
+      puts ""
+
+      puts info["description"]
+      puts ""
+      puts "target: #{b(client.target)}"
+      puts "  version: #{info["version"]}"
+      puts "  support: #{info["support"]}"
+
+      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
+        end
+      end
+    end
+
+
+    desc "Set or display the current target cloud"
+    group :start
+    input :url, :argument => :optional,
+      :desc => "Target URL to switch to"
+    def target(input)
+      if !input.given?(:url)
+        display_target
+        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
+        end
+
+        set_target(target)
+      end
+    end
+
+
+    desc "List known targets."
+    group :start, :hidden => true
+    def targets(input)
+      tokens.each do |target, auth|
+        puts target
+      end
+    end
+
+
+    desc "Authenticate with the target"
+    group :start
+    input(:email, :argument => true, :desc => "Account email") {
+      ask("Email")
+    }
+    input :password, :desc => "Account password"
+    # TODO: implement new authentication scheme
+    def login(input)
+      unless quiet?
+        display_target
+        puts ""
+      end
+
+      email = input[:email]
+      password = input[:password]
+
+      authenticated = false
+      failed = false
+      until authenticated
+        unless force?
+          if failed || !password
+            password = ask("Password", :echo => "*", :forget => true)
+          end
+        end
+
+        with_progress("Authenticating") do |s|
+          begin
+            save_token(client.login(email, password))
+            authenticated = true
+          rescue CFoundry::Denied
+            return if force?
+
+            s.fail do
+              failed = true
+            end
+          end
+        end
+      end
+    ensure
+      exit_status 1 if not authenticated
+    end
+
+
+    desc "Log out from the target"
+    group :start
+    def logout(input)
+      with_progress("Logging out") do
+        remove_token
+      end
+    end
+
+
+    desc "Create a user and log in"
+    group :start, :hidden => true
+    input(:email, :argument => true, :desc => "Desired email") {
+      ask("Email")
+    }
+    input(:password, :desc => "Desired password") {
+      ask("Password", :echo => "*", :forget => true)
+    }
+    input(:verify, :desc => "Repeat password") {
+      ask("Confirm Password", :echo => "*", :forget => true)
+    }
+    input :login, :type => :boolean, :default => true,
+      :desc => "Automatically log in?"
+    def register(input)
+      unless quiet?
+        puts "Target: #{c(client_target, :name)}"
+        puts ""
+      end
+
+      email = input[:email]
+      password = input[:password]
+
+      if !force? && password != input[:verify]
+        fail "Passwords do not match."
+      end
+
+      with_progress("Creating user") do
+        client.register(email, password)
+      end
+
+      if input[:login]
+        with_progress("Logging in") do
+          save_token(client.login(email, password))
+        end
+      end
+    end
+
+
+    desc "Show color configuration"
+    group :start, :hidden => true
+    def colors(input)
+      user_colors.each do |n, c|
+        puts "#{n}: #{c(c.to_s, n)}"
+      end
+    end
+
+    private
+
+    def display_target
+      if quiet?
+        puts client.target
+      else
+        puts "Target: #{c(client.target, :name)}"
+      end
+    end
+  end
+end