jdc 0.1.2 → 0.2.0

data/lib/jdc/cli/app/push/create.rb

@@ -0,0 +1,108 @@
+module JDC::App
+  module Create
+    attr_accessor :input
+    attr_writer :path
+
+    def get_inputs
+      inputs = {}
+      inputs[:name] = input[:name]
+      inputs[:total_instances] = input[:instances]
+      inputs[:space] = client.current_space if client.current_space
+
+      inputs[:buildpack] = input[:buildpack]
+      inputs[:command] = input[:command] if input.has?(:command) || !has_procfile?
+
+      inputs[:memory] = megabytes(input[:memory, human_mb(256)])
+      inputs[:stack] = input[:stack]
+
+      inputs
+    end
+
+    def create_app(inputs)
+      app = client.app
+
+      inputs.each { |key, value| app.send(:"#{key}=", value) }
+      finalize
+
+      app = filter(:create_app, app)
+
+      with_progress("Creating #{c(app.name, :name)}") do
+        wrap_message_format_errors do
+          begin
+            app.create!
+          rescue JFoundry::NotAuthorized
+            fail "You need the Project Developer role in #{b(client.current_space.name)} to push."
+          end
+        end
+      end
+
+      app
+    end
+
+    def map_route(app)
+      line unless quiet?
+
+      host = input[:host, app.name]
+      finalize
+      domain = input[:domain, app]
+      finalize
+
+      mapped_url = false
+      until domain == "none" || !domain || mapped_url
+        begin
+          host = "" if host == "none"
+          invoke :map, :app => app, :host => host, :domain => domain
+          mapped_url = true
+        rescue JFoundry::RouteHostTaken, JFoundry::UriAlreadyTaken => e
+          raise if force?
+
+          line c(e.description, :bad)
+          line
+
+          input.forget(:host)
+          input.forget(:domain)
+
+          host = input[:host, app.name]
+          domain = input[:domain, app]
+        end
+      end
+    end
+
+    def create_services(app)
+      return unless input[:create_services]
+      finalize
+      while true
+        invoke :create_service, { :app => app }, :plan => :interact
+        break unless ask("Create another service?", :default => false)
+      end
+    end
+
+    def bind_services(app)
+      return unless input[:bind_services]
+
+      while true
+        invoke :bind_service, :app => app
+        break if (all_instances - app.services).empty?
+        break unless ask("Bind another service?", :default => false)
+      end
+    end
+
+    def start_app(app)
+      invoke :start, :app => app if input[:start]
+    end
+
+    private
+
+    def has_procfile?
+      File.exists?("#@path/Procfile")
+    end
+
+    def all_instances
+      @all_instances ||= client.service_instances
+    end
+
+    def target_base
+      client.target.sub(/^https?:\/\/([^\.]+\.)?(.+)\/?/, '\2')
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module JDC::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 = app.space.domains
+
+      options = {
+        :choices => choices + ["none"],
+        :display => proc { |choice| choice.is_a?(String) ? choice : choice.name },
+        :allow_other => true
+      }
+
+      options[:default] = choices.first
+
+      ask "Domain", options
+    end
+
+    def ask_memory(default)
+      ask("Memory Limit",
+          :choices => memory_choices,
+          :allow_other => true,
+          :default => default || "128M")
+    end
+
+    def ask_instances
+      ask("Instances", :default => 1)
+    end
+
+    def ask_command
+      command = ask("Custom startup command", :default => "none")
+
+      if command != "none"
+        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/jdc/cli/app/push/sync.rb

@@ -0,0 +1,57 @@
+module JDC::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.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 :command, :buildpack
+        "'#{val}'"
+      else
+        val
+      end
+    end
+
+    def bool(b)
+      if b
+        c("true", :yes)
+      else
+        c("false", :no)
+      end
+    end
+  end
+end

data/lib/jdc/cli/app/push.rb

@@ -0,0 +1,103 @@
+require "jdc/cli/app/base"
+require "jdc/cli/app/push/sync"
+require "jdc/cli/app/push/create"
+require "jdc/cli/app/push/interactions"
+
+module JDC::App
+  class Push < Base
+    include Sync
+    include Create
+
+    desc "Push an application, syncing changes if it exists"
+    group :apps, :manage
+    input :name,      :desc => "Application name", :argument => :optional
+    input :path,      :desc => "Path containing the bits", :default => "."
+    input :host,      :desc => "Subdomain for the app's URL"
+    input :domain,    :desc => "Domain for the app",
+                      :from_given => proc { |given, app|
+                        if given == "none"
+                          given
+                        else
+                          app.space.domain_by_name(given) ||
+                            fail_unknown("domain", given)
+                        end
+                      }
+    input :memory,    :desc => "Memory limit"
+    input :instances, :desc => "Number of instances to run", :type => :integer
+    input :command,   :desc => "Startup command", :default => nil
+    input :plan,      :desc => "Application plan"
+    input :start,     :desc => "Start app after pushing?", :default => true
+    input :restart,   :desc => "Restart app after updating?", :default => true
+    input :buildpack, :desc => "Custom buildpack URL", :default => nil
+    input :stack,     :desc => "Stack to use", :default => nil,
+                      :from_given => by_name(:stack)
+    input :create_services, :desc => "Interactively create services?",
+          :type => :boolean, :default => proc { force? ? false : interact }
+    input :bind_services, :desc => "Interactively bind services?",
+          :type => :boolean, :default => proc { force? ? false : interact }
+    interactions PushInteractions
+
+    def push
+      name = input[:name]
+      path = File.expand_path(input[:path])
+      app = client.app_by_name(name)
+
+      if app
+        sync_app(app, path)
+      else
+        setup_new_app(path)
+      end
+    end
+
+    def sync_app(app, path)
+      upload_app(app, path)
+      apply_changes(app)
+      display_changes(app)
+      commit_changes(app)
+
+      warn "\n#{c(app.name, :name)} is currently stopped, start it with 'jdc start'" unless app.started?
+    end
+
+    def setup_new_app(path)
+      self.path = path
+      app = create_app(get_inputs)
+      map_route(app)
+      create_services(app)
+      bind_services(app)
+      upload_app(app, path)
+      start_app(app)
+    end
+
+    private
+
+    def url_choices(name)
+      client.current_space.domains.sort_by(&:name).collect do |d|
+        # TODO: check availability
+        "#{name}.#{d.name}"
+      end
+    end
+
+    def upload_app(app, path)
+      app = filter(:push_app, app)
+
+      with_progress("Uploading #{c(app.name, :name)}") do
+        app.upload(path)
+      end
+    rescue
+      err "Upload failed. Try again with 'jdc push'."
+      raise
+    end
+
+    def wrap_message_format_errors
+      yield
+    rescue JFoundry::MessageParseError => e
+      md = e.description.match /Field: ([^,]+)/
+      field = md[1]
+
+      case field
+      when "buildpack"
+        fail "Buildpack must be a public git repository URI."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "jdc/cli/app/base"
+
+module JDC::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]
+
+      app.name = 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/jdc/cli/app/restart.rb

@@ -0,0 +1,31 @@
+require "jdc/cli/app/base"
+
+module JDC::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
+
+    ############# Uncomment to complete 50543607
+    #input :command, :desc => "Command to restart application", :default => nil
+
+    def restart
+      invoke :stop, :all => input[:all], :apps => input[:apps]
+
+      line unless quiet?
+
+      input[:apps].each do |app|
+        unless input[:command].nil?
+          app.command = input[:command]
+        end
+        app.update!
+      end
+
+      invoke :start, :all => input[:all], :apps => input[:apps],
+        :debug_mode => input[:debug_mode]
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require "jdc/cli/app/base"
+
+module JDC::App
+  class Scale < Base
+    desc "Update the instances/memory limit for an application"
+    group :apps, :info
+    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 :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
+
+      unless instances || memory || disk
+        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)
+
+      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 => human_mb(default), :allow_other => true)
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+require "jdc/cli/app/base"
+
+module JDC::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.nil? && app.debug_mode != "none" && !quiet?
+          line
+          invoke :instances, :app => app
+        end
+      end
+    end
+
+    private
+
+    def start_app(app)
+      log = nil
+      with_progress("Preparing to start #{c(app.name, :name)}") do
+        app.start! 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 JFoundry::APIError
+    end
+
+    # set app debug mode, ensuring it's valid, and shutting it down
+    def switch_mode(app, mode)
+      mode = "run" if mode == "" # no value given
+
+      return false if app.debug == mode
+
+      if mode == "none"
+        with_progress("Removing debug mode") do
+          app.debug = mode
+          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
+
+      print("Checking status of app '#{c(app.name, :name)}'...")
+
+      seconds = 0
+      @first_time_after_staging_succeeded = true
+
+      begin
+        instances = []
+        while true
+          if any_instance_flapping?(instances) || seconds == APP_CHECK_LIMIT
+            err "Push unsuccessful."
+            return
+          end
+
+          begin
+            return unless instances = app.instances
+
+            indented { print_instances_summary(instances) }
+
+            if all_instances_running?(instances)
+              line "#{c("Push successful! App '#{app.name}' available at http://#{app.host}.#{app.domain}", :good)}"
+              return
+            end
+          rescue JFoundry::NotStaged
+            print (".")
+          end
+
+          sleep 1
+          seconds += 1
+        end
+      rescue JFoundry::StagingError
+        err "Application failed to stage"
+      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)
+
+      if @first_time_after_staging_succeeded
+        line
+        @first_time_after_staging_succeeded = false
+      end
+
+      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(" of ")}#{total} instances running"
+      line "#{ratio} (#{states.join(", ")})"
+    end
+  end
+end