af 0.3.22 → 0.5.0.beta.1

data/lib/vmc/cli/app/push/interactions.rb

@@ -0,0 +1,100 @@
+module VMC::App
+  module PushInteractions
+    def ask_name
+      ask("Name")
+    end
+
+    def ask_host(name)
+      ask "Subdomain", :choices => [name, "none"],
+        :default => name,
+        :allow_other => true
+    end
+
+    def ask_domain(app)
+      choices = v2? ? app.space.domains : ["#{app.name}.#{target_base}"]
+# =======
+#     def ask_url(name, infra)
+#       choices = url_choices(name, infra)
+# >>>>>>> Added infra to url domain
+
+      options = {
+        :choices => choices + ["none"],
+        :display => proc { |d| d.is_a?(String) ? d : d.name },
+        :allow_other => true
+      }
+
+      options[:default] = choices.first if choices.size == 1
+
+      ask "Domain", options
+    end
+
+    def ask_memory(default)
+      ask("Memory Limit",
+          :choices => memory_choices,
+          :allow_other => true,
+          :default => default || "64M")
+    end
+
+    def ask_instances
+      ask("Instances", :default => 1)
+    end
+
+    def ask_framework(choices, default, other)
+      ask_with_other("Framework", client.frameworks, choices, default, other)
+    end
+
+    def ask_infra(choices, default, other)
+      ask_with_other("Infrastructure", client.infras, choices, default, other)
+    end
+
+    def ask_runtime(choices, default, other)
+      ask_with_other("Runtime", client.runtimes, choices, default, other)
+    end
+
+    def ask_command
+      if ask("Use custom startup command?", :default => false)
+        ask("Startup command")
+      end
+    end
+
+    def ask_create_services
+      line unless quiet?
+      ask "Create services for application?", :default => false
+    end
+
+    def ask_bind_services
+      return if all_instances.empty?
+
+      ask "Bind other services to application?", :default => false
+    end
+
+    private
+
+    def ask_with_other(message, all, choices, default, other)
+      choices = choices.sort_by(&:name)
+      choices << other if other
+
+      opts = {
+        :choices => choices,
+        :display => proc { |x|
+          if other && x == other
+            "other"
+          else
+            x.name
+          end
+        }
+      }
+
+      opts[:default] = default if default
+
+      res = ask(message, opts)
+
+      if other && res == other
+        opts[:choices] = all
+        res = ask(message, opts)
+      end
+
+      res
+    end
+  end
+end

data/lib/vmc/cli/app/push/sync.rb

@@ -0,0 +1,64 @@
+module VMC::App
+  module Sync
+    def apply_changes(app)
+      app.memory = megabytes(input[:memory]) if input.has?(:memory)
+      app.total_instances = input[:instances] if input.has?(:instances)
+      app.command = input[:command] if input.has?(:command)
+      app.production = input[:plan].upcase.start_with?("P") if input.has?(:plan)
+      app.framework = input[:framework] if input.has?(:framework)
+      app.runtime = input[:runtime] if input.has?(:runtime)
+      app.buildpack = input[:buildpack] if input.has?(:buildpack)
+    end
+
+    def display_changes(app)
+      return unless app.changed?
+
+      line "Changes:"
+
+      indented do
+        app.changes.each do |attr, (old, new)|
+          line "#{c(attr, :name)}: #{diff_str(attr, old)} -> #{diff_str(attr, new)}"
+        end
+      end
+    end
+
+    def commit_changes(app)
+      if app.changed?
+        with_progress("Updating #{c(app.name, :name)}") do
+          wrap_message_format_errors do
+            app.update!
+          end
+        end
+      end
+
+      if input[:restart] && app.started?
+        invoke :restart, :app => app
+      end
+    end
+
+    private
+
+    def diff_str(attr, val)
+      case attr
+      when :memory
+        human_mb(val)
+      when :framework, :runtime
+        val.name
+      when :command, :buildpack
+        "'#{val}'"
+      when :production
+        bool(val)
+      else
+        val
+      end
+    end
+
+    def bool(b)
+      if b
+        c("true", :yes)
+      else
+        c("false", :no)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Rename < Base
+    desc "Rename an application"
+    group :apps, :manage
+    input :app, :desc => "Application to rename", :argument => :optional,
+          :from_given => by_name(:app)
+    input :name, :desc => "New application name", :argument => :optional
+    def rename
+      app = input[:app]
+      name = input[:name]
+
+      original_name = app.guid
+      app.name = name
+      app.class.guid_name = "hack" # allows the guid to set to original name
+      app.guid = original_name
+      app.class.guid_name = "name" # restore guid name
+
+      with_progress("Renaming to #{c(name, :name)}") do
+        app.update!
+      end
+    end
+
+    private
+
+    def ask_app
+      apps = client.apps
+      fail "No applications." if apps.empty?
+
+      ask("Rename which application?", :choices => apps.sort_by(&:name),
+          :display => proc(&:name))
+    end
+
+    def ask_name
+      ask("New name")
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Restart < Base
+    desc "Stop and 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 => "Restart all applications", :default => false
+    def restart
+      invoke :stop, :all => input[:all], :apps => input[:apps]
+
+      line unless quiet?
+
+      invoke :start, :all => input[:all], :apps => input[:apps],
+        :debug_mode => input[:debug_mode]
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require "vmc/cli/app/base"
+
+module VMC::App
+  class Scale < Base
+    desc "Update the instances/memory limit for an application"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to update", :argument => true,
+          :from_given => by_name(:app)
+    input :instances, :desc => "Number of instances to run",
+          :type => :numeric
+    input :memory, :desc => "Memory limit"
+    input :disk, :desc => "Disk quota"
+    input :plan, :desc => "Application plan", :default => "D100"
+    input :restart, :desc => "Restart app after updating?", :default => true
+    def scale
+      app = input[:app]
+
+      if input.has?(:instances)
+        instances = input[:instances, app.total_instances]
+      end
+
+      if input.has?(:memory)
+        memory = input[:memory, app.memory]
+      end
+
+      if input.has?(:disk)
+        disk = input[:disk, human_mb(app.disk_quota)]
+      end
+
+      if input.has?(:plan)
+        fail "Plans not supported on target cloud." unless v2?
+
+        plan_name = input[:plan]
+        production = !!(plan_name =~ /^p/i)
+      end
+
+      unless instances || memory || disk || plan_name
+        instances = input[:instances, app.total_instances]
+        memory = input[:memory, app.memory]
+      end
+
+      app.total_instances = instances if input.has?(:instances)
+      app.memory = megabytes(memory) if input.has?(:memory)
+      app.disk_quota = megabytes(disk) if input.has?(:disk)
+      app.production = production if input.has?(:plan)
+
+      fail "No changes!" unless app.changed?
+
+      with_progress("Scaling #{c(app.name, :name)}") do
+        app.update!
+      end
+
+      needs_restart = app.changes.key?(:memory) || app.changes.key?(:disk_quota)
+
+      if needs_restart && app.started? && input[:restart]
+        invoke :restart, :app => app
+      end
+    end
+
+    private
+
+    def ask_instances(default)
+      ask("Instances", :default => default)
+    end
+
+    def ask_memory(default)
+      ask("Memory Limit", :choices => memory_choices(default),
+          :default => human_mb(default), :allow_other => true)
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+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])
+
+        with_progress("Starting #{c(app.name, :name)}") do |s|
+          if app.started?
+            s.skip do
+              err "Already started."
+            end
+          end
+
+          app.start!
+        end
+
+        check_application(app)
+
+        if app.debug_mode && !quiet?
+          line
+          invoke :instances, :app => app
+        end
+      end
+    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 == "debug_mode" # no value given
+
+      return false if app.debug_mode == mode
+
+      if mode.nil?
+        with_progress("Removing debug mode") do
+          app.debug_mode = nil
+          app.stop! if app.started?
+        end
+
+        return true
+      end
+
+      with_progress("Switching mode to #{c(mode, :name)}") do |s|
+        runtime = client.runtimes.find { |r| r.name == app.runtime.name }
+        modes = runtime.debug_modes
+
+        if modes.include?(mode)
+          app.debug_mode = mode
+          app.stop! if app.started?
+        else
+          fail "Unknown mode '#{mode}'; available: #{modes.join ", "}"
+        end
+      end
+    end
+
+    def check_application(app)
+      with_progress("Checking #{c(app.name, :name)}") do |s|
+        if app.debug_mode == "suspend"
+          s.skip do
+            line "Application is in suspended debugging mode."
+            line "It will wait for you to attach to it before starting."
+          end
+        end
+
+        seconds = 0
+        until app.healthy?
+          sleep 1
+          seconds += 1
+          if seconds == APP_CHECK_LIMIT
+            s.give_up do
+              err "Application failed to start."
+              # TODO: print logs
+            end
+          end
+        end
+      end
+    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, :hidden => true
+    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