cf 0.1.5 → 0.6.0.rc1

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

@@ -0,0 +1,137 @@
+require "thread"
+require "cf/cli/app/base"
+
+module CF::App
+  class Files < Base
+    desc "Print out an app's file contents"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to inspect the files of",
+          :argument => true, :from_given => by_name(:app)
+    input :path, :desc => "Path of file to read", :argument => :optional,
+          :default => "/"
+    def file
+      app = input[:app]
+      path = input[:path]
+
+      file =
+        with_progress("Getting file contents") do
+          app.file(*path.split("/"))
+        end
+
+      if quiet?
+        print file
+      else
+        line
+
+        file.split("\n").each do |l|
+          line l
+        end
+      end
+    rescue CFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue CFoundry::FileError => e
+      fail e.description
+    end
+
+    desc "Examine an app's files"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to inspect the files of",
+          :argument => true, :from_given => by_name(:app)
+    input :path, :desc => "Path of directory to list", :argument => :optional,
+          :default => "/"
+    def files
+      app = input[:app]
+      path = input[:path]
+
+      if quiet?
+        files =
+          with_progress("Getting file listing") do
+            app.files(*path.split("/"))
+          end
+
+        files.each do |file|
+          line file.join("/")
+        end
+      else
+        invoke :file, :app => app, :path => path
+      end
+    rescue CFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue CFoundry::FileError => e
+      fail e.description
+    end
+
+    desc "Stream an app's file contents"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to inspect the files of",
+          :argument => true, :from_given => by_name(:app)
+    input :path, :desc => "Path of file to stream", :argument => :optional
+    def tail
+      app = input[:app]
+
+      lines = Queue.new
+      max_len = 0
+
+      if path = input[:path]
+        max_len = path.size
+        app.instances.each do |i|
+          Thread.new do
+            stream_path(lines, i, path.split("/"))
+          end
+        end
+      else
+        app.instances.each do |i|
+          i.files("logs").each do |path|
+            len = path.join("/").size
+            max_len = len if len > max_len
+
+            Thread.new do
+              stream_path(lines, i, path)
+            end
+          end
+        end
+      end
+
+      while line = lines.pop
+        instance, path, log = line
+
+        unless log.end_with?("\n")
+          log += i("%") if color?
+          log += "\n"
+        end
+
+        print "\##{c(instance.id, :instance)}  "
+        print "#{c(path.join("/").ljust(max_len), :name)}  "
+        print log
+      end
+    rescue CFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue CFoundry::FileError => e
+      fail e.description
+    end
+
+    def stream_path(lines, instance, path)
+      if verbose?
+        lines << [instance, path, c("streaming...", :good) + "\n"]
+      end
+
+      instance.stream_file(*path) do |contents|
+        contents.each_line do |line|
+          lines << [instance, path, line]
+        end
+      end
+
+      lines << [instance, path, c("end of file", :bad) + "\n"]
+    rescue Timeout::Error
+      if verbose?
+        lines << [
+          instance,
+          path,
+          c("timed out; reconnecting...", :bad) + "\n"
+        ]
+      end
+
+      retry
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require "cf/cli/app/base"
+
+module CF::App
+  class Health < Base
+    desc "Get application health"
+    group :apps, :info, :hidden => true
+    input :apps, :desc => "Applications to start", :argument => :splat,
+          :singular => :app, :from_given => by_name(:app)
+    def health
+      apps = input[:apps]
+      fail "No applications given." if apps.empty?
+
+      health =
+        with_progress("Getting health status") do
+          apps.collect { |a| [a, app_status(a)] }
+        end
+
+      line unless quiet?
+
+      spaced(health) do |app, status|
+        start_line "#{c(app.name, :name)}: " unless quiet?
+        puts status
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require "cf/cli/app/base"
+
+module CF::App
+  class Instances < Base
+    desc "List an app's instances"
+    group :apps, :info, :hidden => true
+    input :apps, :desc => "Applications whose instances to list",
+          :argument => :splat, :singular => :app,
+          :from_given => by_name(:app)
+    def instances
+      apps = input[:apps]
+      fail "No applications given." if apps.empty?
+
+      spaced(apps) do |app|
+        instances =
+          with_progress("Getting instances for #{c(app.name, :name)}") do
+            app.instances
+          end
+
+        line unless quiet?
+
+        spaced(instances.sort { |a, b| a.id.to_i <=> b.id.to_i }) do |i|
+          if quiet?
+            line i.id
+          else
+            display_instance(i)
+          end
+        end
+      end
+    end
+
+    private
+
+    def display_instance(i)
+      start_line "instance #{c("\##{i.id}", :instance)}: "
+      puts "#{b(c(i.state.downcase, state_color(i.state)))}"
+
+      indented do
+        if s = i.since
+          line "started: #{c(s.strftime("%F %r"), :neutral)}"
+        end
+
+        if d = i.debugger
+          line "debugger: port #{b(d[:port])} at #{b(d[:ip])}"
+        end
+
+        if c = i.console
+          line "console: port #{b(c[:port])} at #{b(c[:ip])}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require "cf/cli/app/base"
+
+module CF::App
+  class Logs < Base
+    desc "Print out an app's logs"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to get the logs of", :argument => true,
+          :from_given => by_name(:app)
+    input :instance, :desc => "Instance of application to get the logs of",
+          :default => "0"
+    input :all, :desc => "Get logs for every instance", :default => false
+    def logs
+      app = input[:app]
+
+      instances =
+        if input[:all] || input[:instance] == "all"
+          app.instances
+        else
+          app.instances.select { |i| i.id == input[:instance] }
+        end
+
+      if instances.empty?
+        if input[:all]
+          fail "No instances found."
+        else
+          fail "Instance #{app.name} \##{input[:instance]} not found."
+        end
+      end
+
+      spaced(instances) do |i|
+        show_instance_logs(app, i)
+      end
+    end
+
+    desc "Print out the logs for an app's crashed instances"
+    group :apps, :info, :hidden => true
+    input :app, :desc => "Application to get the logs of", :argument => true,
+          :from_given => by_name(:app)
+    def crashlogs
+      app = input[:app]
+
+      crashes = app.crashes
+
+      fail "No crashed instances found." if crashes.empty?
+
+      most_recent = crashes.sort_by(&:since).last
+      show_instance_logs(app, most_recent)
+    end
+
+    def show_instance_logs(app, i)
+      return unless i.id
+
+      logs =
+        with_progress(
+            "Getting logs for #{c(app.name, :name)} " +
+              c("\##{i.id}", :instance)) do
+          i.files("logs")
+        end
+
+      line unless quiet?
+
+      spaced(logs) do |log|
+        begin
+          body =
+            with_progress("Reading " + b(log.join("/"))) do |s|
+              i.file(*log)
+            end
+
+          lines body
+          line unless body.empty?
+        rescue CFoundry::NotFound
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,105 @@
+require "cf/cli/app/base"
+require "cf/cli/app/push/sync"
+require "cf/cli/app/push/create"
+require "cf/cli/app/push/interactions"
+
+module CF::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 :framework, :desc => "Framework to use",
+                      :from_given => by_name(:framework)
+    input :runtime,   :desc => "Runtime to use",
+                      :from_given => by_name(:runtime)
+    input :command,   :desc => "Startup command"
+    input :plan,      :desc => "Application plan", :default => "D100"
+    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)
+    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 'cf push'."
+      raise
+    end
+
+    def wrap_message_format_errors
+      yield
+    rescue CFoundry::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/cf/cli/app/push/create.rb

@@ -0,0 +1,149 @@
+require "cf/detect"
+
+module CF::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[:production] = !!(input[:plan] =~ /^p/i)
+
+      inputs[:buildpack] = input[:buildpack]
+      inputs[:command] = input[:command] if input.has?(:command) || !has_procfile?
+
+      detected = detector.detected
+      human_mb = human_mb((detected && detected.memory_suggestion) || 64)
+      inputs[:memory] = megabytes(input[:memory, human_mb])
+
+      inputs[:stack] = input[:stack]
+
+      inputs
+    end
+
+    def determine_framework
+      return input[:framework] if input.has?(:framework)
+
+      if (detected_framework = detector.detect_framework)
+        input[:framework, [detected_framework], detected_framework, :other]
+      else
+        input[:framework, detector.all_frameworks, nil, nil]
+      end
+    end
+
+    def determine_runtime(framework)
+      return input[:runtime] if input.has?(:runtime)
+
+      detected_runtimes =
+        if framework.name == "standalone"
+          detector.detect_runtimes
+        else
+          detector.runtimes(framework)
+        end
+
+      default_runtime = detected_runtimes.size == 1 ? detected_runtimes.first : nil
+
+      if detected_runtimes.empty?
+        input[:runtime, detector.all_runtimes, nil, nil]
+      else
+        input[:runtime, detected_runtimes, default_runtime, :other]
+      end
+    end
+
+    def create_app(inputs)
+      app = client.app
+
+      inputs.each { |key, value| app.send(:"#{key}=", value) }
+
+      app = filter(:create_app, app)
+
+      with_progress("Creating #{c(app.name, :name)}") do
+        wrap_message_format_errors do
+          begin
+            app.create!
+          rescue CFoundry::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]
+      domain = input[:domain, app]
+
+      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 CFoundry::RouteHostTaken, CFoundry::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]
+
+      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 can_have_custom_start_command?(framework)
+      framework.name == "standalone"
+    end
+
+    def all_instances
+      @all_instances ||= client.service_instances
+    end
+
+    def detector
+      @detector ||= CF::Detector.new(client, @path)
+    end
+
+    def target_base
+      client.target.sub(/^https?:\/\/([^\.]+\.)?(.+)\/?/, '\2')
+    end
+  end
+end