cf 0.1.5 → 0.6.0.rc1

data/lib/cf/cli/app/stop.rb

@@ -0,0 +1,27 @@
+require "cf/cli/app/base"
+
+module CF::App
+  class Stop < Base
+    desc "Stop an application"
+    group :apps, :manage
+    input :apps, :desc => "Applications to start", :argument => :splat,
+          :singular => :app, :from_given => by_name(:app)
+    input :all, :desc => "Stop all applications", :default => false
+    def stop
+      apps = input[:all] ? client.apps : input[:apps]
+      fail "No applications given." if apps.empty?
+
+      apps.each do |app|
+        with_progress("Stopping #{c(app.name, :name)}") do |s|
+          if app.stopped?
+            s.skip do
+              err "Application is not running."
+            end
+          end
+
+          app.stop!
+        end
+      end
+    end
+  end
+end

data/lib/cf/cli/domain/base.rb

@@ -0,0 +1,8 @@
+require "cf/cli"
+
+module CF
+  module Domain
+    class Base < CLI
+    end
+  end
+end

data/lib/cf/cli/domain/domains.rb

@@ -0,0 +1,40 @@
+require "cf/cli/domain/base"
+
+module CF::Domain
+  class Domains < Base
+    desc "List domains in a space"
+    group :domains
+    input :space, :desc => "Space to list the domains from",
+          :argument => :optional, :default => proc { client.current_space },
+          :from_given => by_name(:space)
+    input :all, :desc => "List all domains", :default => false
+    def domains
+      space = input[:space]
+
+      domains =
+        if input[:all]
+          with_progress("Getting all domains") do
+            client.domains
+          end
+        else
+          with_progress("Getting domains in #{c(space.name, :name)}") do
+            space.domains
+          end
+        end
+
+      line unless quiet?
+
+      table(
+        %w{name owner},
+        domains.sort_by(&:name).collect { |r|
+          [c(r.name, :name),
+           if org = r.owning_organization
+             c(org.name, :name)
+           else
+             d("none")
+           end
+          ]
+        })
+    end
+  end
+end

data/lib/cf/cli/domain/map.rb

@@ -0,0 +1,55 @@
+require "cf/cli/domain/base"
+
+module CF::Domain
+  class Map < Base
+    desc "Map a domain to an organization or space"
+    group :domains
+    input :name, :desc => "Domain to map", :argument => :required
+    input :organization, :desc => "Organization to map the domain to",
+          :aliases => %w{--org -o},
+          :default => proc { client.current_organization },
+          :from_given => by_name(:organization)
+    input :space, :desc => "Space to map the domain to",
+          :default => proc { client.current_space },
+          :from_given => by_name(:space)
+    input :shared, :desc => "Create a shared domain", :default => false
+    def map_domain
+      domain = client.domain_by_name(input[:name])
+
+      given_org = input.has?(:organization)
+      given_space = input.has?(:space)
+
+      org = input[:organization]
+      space = input[:space]
+
+      given_space = true unless given_org || given_space
+
+      unless domain
+        domain = client.domain
+        domain.name = input[:name]
+        domain.owning_organization = org unless input[:shared]
+        domain.wildcard = true
+
+        with_progress("Creating domain #{c(domain.name, :name)}") do
+          domain.create!
+          org.add_domain(domain) if org && !given_org && !given_space
+        end
+      end
+
+      if given_space
+        add_domain(domain, space.organization)
+        add_domain(domain, space)
+      elsif given_org
+        add_domain(domain, org)
+      end
+    end
+
+    private
+
+    def add_domain(domain, target)
+      with_progress("Mapping #{c(domain.name, :name)} to #{c(target.name, :name)}") do
+        target.add_domain(domain)
+      end
+    end
+  end
+end

data/lib/cf/cli/domain/unmap.rb

@@ -0,0 +1,56 @@
+require "cf/cli/domain/base"
+
+module CF::Domain
+  class Unmap < Base
+    desc "Unmap a domain from an organization or space"
+    group :domains
+    input :domain, :desc => "Domain to unmap", :argument => :required,
+          :from_given => by_name("domain")
+    input :organization, :desc => "Organization to unmap the domain from",
+          :aliases => %w{--org -o},
+          :default => proc { client.current_organization },
+          :from_given => by_name(:organization)
+    input :space, :desc => "Space to unmap the domain from",
+          :default => proc { client.current_space },
+          :from_given => by_name(:space)
+    input :delete, :desc => "Delete domain", :type => :boolean
+    input :really, :type => :boolean, :forget => true, :hidden => true,
+          :default => proc { force? || interact }
+    def unmap_domain
+      domain = input[:domain]
+
+      given_org = input.has?(:organization)
+      given_space = input.has?(:space)
+
+      org = input[:organization]
+      space = input[:space]
+
+      if input[:delete]
+        return unless input[:really, domain.name, :name]
+
+        with_progress("Deleting domain #{c(domain.name, :name)}") do
+          domain.delete!
+        end
+
+        return
+      end
+
+      given_space = true unless given_org || given_space
+
+      remove_domain(domain, space) if given_space
+      remove_domain(domain, org) if given_org
+    end
+
+    private
+
+    def remove_domain(domain, target)
+      with_progress("Unmapping #{c(domain.name, :name)} from #{c(target.name, :name)}") do
+        target.remove_domain(domain)
+      end
+    end
+
+    def ask_really(name, color)
+      ask("Really delete #{c(name, color)}?", :default => false)
+    end
+  end
+end

data/lib/cf/cli/help.rb

@@ -0,0 +1,15 @@
+require "mothership/help"
+
+Mothership::Help.groups(
+  [:start, "Getting Started"],
+  [:apps, "Applications",
+    [:manage, "Management"],
+    [:info, "Information"]],
+  [:services, "Services",
+    [:manage, "Management"]],
+  [:organizations, "Organizations"],
+  [:spaces, "Spaces"],
+  [:routes, "Routes"],
+  [:domains, "Domains"],
+  [:admin, "Administration",
+    [:user, "User Management"]])

data/lib/cf/cli/interactive.rb

@@ -0,0 +1,105 @@
+require "interact"
+require "interact/pretty"
+require "interact/progress"
+
+module CF
+  module Interactive
+    include ::Interactive::Rewindable
+    include Interact::Pretty
+    include Interact::Progress
+
+    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)}: #{show_choice(o, options)}"
+      end
+    end
+
+    def input_state(options)
+      if options.key? :default
+        answer = show_default(options)
+      end
+
+      CFState.new(options, answer)
+    end
+
+    def show_default(options)
+      case options[:default]
+      when true
+        "y"
+      when false
+        "n"
+      when nil
+        ""
+      else
+        show_choice(options[:default], options)
+      end
+    end
+
+    def prompt(question, options)
+      value = show_default(options)
+
+      print "#{question}"
+      print c("> ", :prompt)
+
+      unless value.empty?
+        print "#{d(value) + "\b" * value.size}"
+      end
+    end
+
+    def handler(event, state)
+      ans = state.answer
+      pos = state.position
+
+      exit if event == :eof
+
+      if state.default?
+        if event.is_a?(Array) and event[0] == :key
+          # initial non-movement keypress clears default answer
+          clear_input(state)
+        else
+          # wipe away any coloring
+          redraw_input(state)
+        end
+
+        state.clear_default!
+
+        # tab with a default accepts it and moves to the end
+        if event == :tab
+          state.goto(ans.size)
+        else
+          super
+        end
+      else
+        super
+      end
+
+      print "\n" if event == :enter
+    end
+
+    class CFState < ::Interactive::InputState
+      def initialize(options = {}, answer = nil, position = 0)
+        @options = options
+        @answer = answer || ""
+        @default = options.key? :default
+        @position = position
+        @done = false
+      end
+
+      def clear_default!
+        @default = false
+      end
+
+      def default?
+        @default
+      end
+    end
+  end
+end

data/lib/cf/cli/organization/base.rb

@@ -0,0 +1,12 @@
+require "cf/cli"
+
+module CF
+  module Organization
+    class Base < CLI
+      def precondition
+        check_target
+        check_logged_in
+      end
+    end
+  end
+end

data/lib/cf/cli/organization/create.rb

@@ -0,0 +1,32 @@
+require "cf/cli/organization/base"
+
+module CF::Organization
+  class Create < Base
+    desc "Create an organization"
+    group :organizations
+    input :name, :desc => "Organization name", :argument => :optional
+    input :target, :desc => "Switch to the organization after creation",
+          :alias => "-t", :default => true
+    input :add_self, :desc => "Add yourself to the organization",
+          :default => true
+    def create_org
+      org = client.organization
+      org.name = input[:name]
+      org.users = [client.current_user] if input[:add_self]
+
+      with_progress("Creating organization #{c(org.name, :name)}") do
+        org.create!
+      end
+
+      if input[:target]
+        invoke :target, :organization => org
+      end
+    end
+
+    private
+
+    def ask_name
+      ask("Name")
+    end
+  end
+end

data/lib/cf/cli/organization/delete.rb

@@ -0,0 +1,73 @@
+require "cf/cli/organization/base"
+
+module CF::Organization
+  class Delete < Base
+    desc "Delete an organization"
+    group :organizations
+    input :organization, :desc => "Organization to delete",
+          :aliases => %w{--org -o}, :argument => :optional,
+          :from_given => by_name(:organization)
+    input :recursive, :desc => "Delete recursively", :alias => "-r",
+          :default => false, :forget => true
+    input :warn, :desc => "Show warning if it was the last org",
+          :default => true
+    input :really, :type => :boolean, :forget => true, :hidden => true,
+          :default => proc { force? || interact }
+    def delete_org
+      org = input[:organization]
+      return unless input[:really, org]
+
+      spaces = org.spaces
+      unless spaces.empty?
+        unless force?
+          line "This organization is not empty!"
+          line
+          line "spaces: #{name_list(spaces)}"
+          line
+
+          return unless input[:recursive]
+        end
+
+        spaces.each do |s|
+          invoke :delete_space, :space => s, :really => true,
+                 :recursive => true, :warn => false
+        end
+      end
+
+      is_current = org == client.current_organization
+
+      with_progress("Deleting organization #{c(org.name, :name)}") do
+        org.delete!
+      end
+
+      if orgs.size == 1
+        return unless input[:warn]
+
+        line
+        line c("There are no longer any organizations.", :warning)
+        line "You may want to create one with #{c("create-org", :good)}."
+      elsif is_current
+        invalidate_target
+        invoke :target
+      end
+    end
+
+    private
+
+    def ask_organization
+      orgs = client.organizations
+      fail "No organizations." if orgs.empty?
+
+      ask("Which organization", :choices => orgs.sort_by(&:name),
+          :display => proc(&:name))
+    end
+
+    def ask_really(org)
+      ask("Really delete #{c(org.name, :name)}?", :default => false)
+    end
+
+    def ask_recursive
+      ask "Delete #{c("EVERYTHING", :bad)}?", :default => false
+    end
+  end
+end

data/lib/cf/cli/organization/org.rb

@@ -0,0 +1,45 @@
+require "cf/cli/organization/base"
+
+module CF::Organization
+  class Org < Base
+    desc "Show organization information"
+    group :organizations
+    input :organization, :desc => "Organization to show",
+          :aliases => %w{--org -o}, :argument => :optional,
+          :from_given => by_name(:organization),
+          :default => proc { client.current_organization }
+    input :full, :desc => "Show full information for spaces, domains, etc.",
+          :default => false
+    def org
+      org = input[:organization]
+
+      unless org
+        return if quiet?
+        fail "No current organization."
+      end
+
+      if quiet?
+        puts org.name
+        return
+      end
+
+      line "#{c(org.name, :name)}:"
+
+      indented do
+        line "domains: #{name_list(org.domains)}"
+
+        if input[:full]
+          line "spaces:"
+
+          spaced(org.spaces(:depth => 2)) do |s|
+            indented do
+              invoke :space, :space => s
+            end
+          end
+        else
+          line "spaces: #{name_list(org.spaces)}"
+        end
+      end
+    end
+  end
+end