cloulu 0.0.0 → 0.1.1

data/lib/vmc/cli/app/start.rb

@@ -0,0 +1,143 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Start < Base
+    APP_CHECK_LIMIT = 60
+
+    desc "Start an application"
+    group :apps, :manage
+    input :apps, :desc => "Applications to start", :argument => :splat,
+          :singular => :app, :from_given => by_name(:app)
+    input :debug_mode, :desc => "Debug mode to start in", :aliases => "-d"
+    input :all, :desc => "Start all applications", :default => false
+    def start
+      apps = input[:all] ? client.apps : input[:apps]
+      fail "No applications given." if apps.empty?
+
+      spaced(apps) do |app|
+        app = filter(:start_app, app)
+
+        switch_mode(app, input[:debug_mode])
+
+        if app.started?
+          err "Application #{b(app.name)} is already started."
+          next
+        end
+
+        log = start_app(app)
+        stream_start_log(log) if log
+        check_application(app)
+
+        if app.debug_mode && !quiet?
+          line
+          invoke :instances, :app => app
+        end
+      end
+    end
+
+    private
+
+    def start_app(app)
+      log = nil
+      with_progress("Starting #{c(app.name, :name)}") do
+        app.start!(true) do |url|
+          log = url
+        end
+      end
+      log
+    end
+
+    def stream_start_log(log)
+      offset = 0
+
+      while true
+        begin
+          client.stream_url(log + "&tail&tail_offset=#{offset}") do |out|
+            offset += out.size
+            print out
+          end
+        rescue Timeout::Error
+        end
+      end
+    rescue CFoundry::APIError
+    end
+
+    # set app debug mode, ensuring it's valid, and shutting it down
+    def switch_mode(app, mode)
+      mode = nil if mode == "none"
+      mode = "run" if mode == "" # no value given
+
+      return false if app.debug == mode
+
+      if mode.nil?
+        with_progress("Removing debug mode") do
+          app.debug = nil
+          app.stop! if app.started?
+        end
+
+        return true
+      end
+
+      with_progress("Switching mode to #{c(mode, :name)}") do |s|
+        app.debug = mode
+        app.stop! if app.started?
+      end
+    end
+
+    def check_application(app)
+      if app.debug == "suspend"
+        line "Application is in suspended debugging mode."
+        line "It will wait for you to attach to it before starting."
+        return
+      end
+
+      line "Checking #{c(app.name, :name)}..."
+
+      seconds = 0
+      while instances = app.instances
+        indented { print_instances_summary(instances) }
+
+        if all_instances_running?(instances)
+          line "#{c("OK", :good)}"
+          return
+        end
+
+        if any_instance_flapping?(instances) || seconds == APP_CHECK_LIMIT
+          err "Application failed to start."
+          return
+        end
+
+        sleep 1
+        seconds += 1
+      end
+    end
+
+    def all_instances_running?(instances)
+      instances.all? { |i| i.state == "RUNNING" }
+    end
+
+    def any_instance_flapping?(instances)
+      instances.any? { |i| i.state == "FLAPPING" }
+    end
+
+    def print_instances_summary(instances)
+      counts = Hash.new { 0 }
+      instances.each do |i|
+        counts[i.state] += 1
+      end
+
+      states = []
+      %w{RUNNING STARTING DOWN FLAPPING}.each do |state|
+        if (num = counts[state]) > 0
+          states << "#{b(num)} #{c(state.downcase, state_color(state))}"
+        end
+      end
+
+      total = instances.count
+      running = counts["RUNNING"].to_s.rjust(total.to_s.size)
+
+      ratio = "#{running}#{d("/")}#{total} instances:"
+      line "#{ratio} #{states.join(", ")}"
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require "vmc/cli/app/base"
+
+module VMC::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/vmc/cli/app/stop.rb

@@ -0,0 +1,27 @@
+require "vmc/cli/app/base"
+
+module VMC::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/vmc/cli/help.rb

@@ -0,0 +1,11 @@
+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/lib/vmc/cli/interactive.rb

@@ -0,0 +1,105 @@
+require "interact"
+require "interact/pretty"
+require "interact/progress"
+
+module VMC
+  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/vmc/cli/route/base.rb

@@ -0,0 +1,12 @@
+require "vmc/cli/v2_check_cli"
+
+module VMC
+  module Route
+    class Base < V2CheckCLI
+      def precondition
+        super
+        #fail "This command is v2-only." unless v2?
+      end
+    end
+  end
+end

data/lib/vmc/cli/route/map.rb

@@ -0,0 +1,82 @@
+require "vmc/cli/route/base"
+
+module VMC::Route
+  class Map < Base
+    def precondition
+      fail_on_v2
+    end
+
+    desc "Add a URL mapping"
+    group :apps, :info
+    input :app, :desc => "Application to add the URL to",
+          :argument => :optional, :from_given => by_name(:app)
+    input :host, :desc => "Host name for the route",
+          :argument => :optional, :default => ""
+    input :domain, :desc => "Domain to add the route to",
+          :argument => true,
+          :from_given => proc { |name, space|
+            if v2?
+              space.domain_by_name(name) ||
+                fail_unknown("domain", name)
+            else
+              name
+            end
+          }
+    def map
+      app = input[:app]
+      space = app.space if v2?
+
+      host = input[:host]
+      domain = input[:domain, space]
+
+      if v2?
+        route = find_or_create_route(domain, host, space)
+        bind_route(route, app) if app
+      else
+        with_progress("Updating #{c(app.name, :name)}") do
+          app.urls << domain
+          app.update!
+        end
+      end
+    end
+
+    private
+
+    def bind_route(route, app)
+      with_progress("Binding #{c(route.name, :name)} to #{c(app.name, :name)}") do
+        app.add_route(route)
+      end
+    end
+
+    def find_or_create_route(domain, host, space)
+      find_route(domain, host) || create_route(domain, host, space)
+    end
+
+    def find_route(domain, host)
+      client.routes_by_host(host, :depth => 0).find { |r| r.domain == domain }
+    end
+
+    def create_route(domain, host, space)
+      route = client.route
+      route.host = host
+      route.domain = domain
+      route.space = space
+
+      with_progress("Creating route #{c(route.name, :name)}") do
+        route.create!
+      end
+
+      route
+    end
+
+    def find_domain(space, name)
+      domain = space.domain_by_name(name, :depth => 0)
+      fail "Invalid domain '#{name}'" unless domain
+      domain
+    end
+
+    def ask_app
+      ask("Which application?", :choices => client.apps, :display => proc(&:name))
+    end
+  end
+end

data/lib/vmc/cli/route/routes.rb

@@ -0,0 +1,25 @@
+require "vmc/cli/route/base"
+
+module VMC::Route
+  class Routes < Base
+    desc "List routes in a space"
+
+    def routes
+      # TODO: scope to space once space.routes is possible
+      routes =
+          with_progress("Getting routes") do
+            client.routes
+          end
+
+      line unless quiet?
+
+      table(
+          %w{host domain},
+          routes.sort_by { |r| "#{r.domain.name} #{r.host}" }.collect { |r|
+            [c(r.host, :name),
+             r.domain.name
+            ]
+          })
+    end
+  end
+end

data/lib/vmc/cli/route/unmap.rb

@@ -0,0 +1,94 @@
+require "vmc/cli/route/base"
+
+module VMC::Route
+  class Unmap < Base
+    desc "Remove a URL mapping"
+    group :apps, :info
+    input :url, :desc => "URL to unmap", :argument => :optional,
+          :from_given => find_by_name("route") { client.routes }
+    input :app, :desc => "Application to remove the URL from",
+          :argument => :optional, :from_given => by_name(:app)
+    input :delete, :desc => "Delete route", :type => :boolean
+    input :all, :desc => "Act on all routes", :type => :boolean
+    input :really, :type => :boolean, :forget => true, :hidden => true,
+          :default => proc { force? || interact }
+    def unmap
+      return invoke :v1_unmap, input.inputs, input.given unless v2?
+
+      if input[:all]
+        if input.has?(:app)
+          app = target = input[:app]
+          return unless !input[:delete] || input[:really, "ALL URLS bound to #{target.name}", :bad]
+        else
+          target = client
+          return unless !input[:delete] || input[:really, "ALL URLS", :bad]
+        end
+
+        target.routes.each do |r|
+          begin
+            invoke :unmap, :delete => input[:delete], :url => r, :really => true, :app => app
+          rescue CFoundry::APIError => e
+            err "#{e.class}: #{e.message}"
+          end
+        end
+
+        return
+      end
+
+      app = input[:app]
+      url = input[:url, app ? app.routes : client.routes]
+
+      if input[:delete]
+        with_progress("Deleting route #{c(url.name, :name)}") do
+          url.delete!
+        end
+      elsif app
+        with_progress("Unbinding #{c(url.name, :name)} from #{c(app.name, :name)}") do
+          app.remove_route(url)
+        end
+      else
+        fail "Missing either --delete or --app."
+      end
+    end
+
+
+    desc "V1 ONLY UNMAP YOU SHOULD NOT SEE THIS"
+    input :url, :desc => "URL to unmap", :argument => :optional,
+          :interact => :v1_ask_url
+    input :app, :desc => "Application to remove the URL from",
+          :argument => :optional, :from_given => by_name(:app)
+    input :all, :desc => "Act on all routes", :type => :boolean
+    def v1_unmap
+      app = input[:app]
+      url = input[:url, app.urls] unless input[:all]
+
+      with_progress("Updating #{c(app.name, :name)}") do |s|
+        if input[:all]
+          app.urls = []
+        else
+          simple = url.sub(/^https?:\/\/(.*)\/?/i, '\1')
+
+          unless app.urls.delete(simple)
+            fail "URL #{url} is not mapped to this application."
+          end
+        end
+
+        app.update!
+      end
+    end
+
+    private
+
+    def ask_url(choices)
+      ask("Which URL?", :choices => choices.sort_by(&:name), :display => proc(&:name))
+    end
+
+    def v1_ask_url(choices)
+      ask("Which URL?", :choices => choices.sort)
+    end
+
+    def ask_really(name, color)
+      ask("Really delete #{c(name, color)}?", :default => false)
+    end
+  end
+end

data/lib/vmc/cli/service/base.rb

@@ -0,0 +1,8 @@
+require "vmc/cli/v2_check_cli"
+
+module VMC
+  module Service
+    class Base < V2CheckCLI
+    end
+  end
+end

data/lib/vmc/cli/service/bind.rb

@@ -0,0 +1,44 @@
+require "vmc/detect"
+
+require "vmc/cli/service/base"
+
+module VMC::Service
+  class Bind < Base
+    desc "Bind a service to an application"
+    group :services, :manage
+    input :service, :desc => "Service to bind", :argument => :optional,
+          :from_given => by_name(:service_instance, "service")
+    input :app, :desc => "Application to bind to", :argument => :optional,
+          :from_given => by_name(:app)
+    def bind_service
+      app = input[:app]
+      service = input[:service, app]
+
+      with_progress(
+          "Binding #{c(service.name, :name)} to #{c(app.name, :name)}") do |s|
+        if app.binds?(service)
+          s.skip do
+            err "App #{b(app.name)} already binds #{b(service.name)}."
+          end
+        else
+          app.bind(service)
+        end
+      end
+    end
+
+    private
+
+    def ask_service(app)
+      services = client.service_instances
+      fail "No services." if services.empty?
+
+      ask "Which service?", :choices => services - app.services,
+        :display => proc(&:name)
+    end
+
+    def ask_app
+      ask "Which application?", :choices => client.apps,
+        :display => proc(&:name)
+    end
+  end
+end