trucker-cli 0.0.1

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

@@ -0,0 +1,66 @@
+require "cf/cli/app/base"
+
+module CF::App
+  class Stats < Base
+    desc "Display application instance status"
+    group :apps, :info
+    input :app, :desc => "Application to get the stats for",
+          :argument => true, :from_given => by_name(:app)
+    def stats
+      app = input[:app]
+      stats =
+        with_progress("Getting stats for #{c(app.name, :name)}") do |s|
+          begin
+            app.stats
+          rescue CFoundry::StatsError
+            s.fail do
+              err "Application #{b(app.name)} is not running."
+              return
+            end
+          end
+        end
+
+      line unless quiet?
+
+      table(
+        %w{instance cpu memory disk},
+        stats.sort_by { |idx, _| idx.to_i }.collect { |idx, info|
+          idx = c("\##{idx}", :instance)
+
+          if info[:state] == "DOWN"
+            [idx, c("down", :bad)]
+          else
+            stats = info[:stats]
+            usage = stats[:usage]
+
+            if usage
+              [ idx,
+                "#{percentage(usage[:cpu])}",
+                "#{usage(usage[:mem], stats[:mem_quota])}",
+                "#{usage(usage[:disk], stats[:disk_quota])}"
+              ]
+            else
+              [idx, c("n/a", :neutral)]
+            end
+          end
+        })
+    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 usage(used, limit)
+      "#{b(human_size(used))} of #{b(human_size(limit, 0))}"
+    end
+  end
+end

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,9 @@
+require "cf/cli"
+
+module CF
+  module Domain
+    class Base < CLI
+      include LoginRequirements
+    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,104 @@
+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
+
+      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! if event != :up
+
+        # 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/login_requirements.rb

@@ -0,0 +1,13 @@
+module LoginRequirements
+  def precondition
+    check_logged_in
+
+    unless client.current_organization
+      fail "Please select an organization with 'truck target --organization ORGANIZATION_NAME'. (Get organization names from 'truck orgs'.)"
+    end
+
+    unless client.current_space
+      fail "Please select a space with 'truck target --space SPACE_NAME'. (Get space names from 'truck spaces'.)"
+    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,36 @@
+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
+    input :find_if_exists, :desc => "Use an existing organization if one already exists with the given name", :default => false
+    def create_org
+      org = client.organization
+      org.name = input[:name]
+      org.users = [client.current_user] if input[:add_self]
+
+      begin
+        with_progress("Creating organization #{c(org.name, :name)}") { org.create! }
+      rescue CFoundry::OrganizationNameTaken
+        raise unless input[:find_if_exists]
+        org = client.organization_by_name(input[:name])
+      end
+
+      if input[:target]
+        invoke :target, :organization => org
+      end
+    end
+
+    private
+
+    def ask_name
+      ask("Name")
+    end
+  end
+end