jdc 0.2.1.pre → 0.2.1

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

@@ -1,108 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,161 +0,0 @@
-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