jdc 0.2.1 → 0.2.2.pre

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

@@ -0,0 +1,43 @@
+require "jdc/cli/app/base"
+
+module JDC::App
+  class Apps < Base
+    IS_UTF8 = !!(ENV["LC_ALL"] || ENV["LC_CTYPE"] || ENV["LANG"] || "")["UTF-8"].freeze
+
+    desc "Show app information"
+    group :apps
+    input :app, :desc => "App to show", :argument => :required,
+          :from_given => by_name(:app)
+    def app
+      app = input[:app]
+
+      if quiet?
+        line app.name
+      else
+        display_app(app)
+      end
+    end
+
+    def display_app(a)
+      status = app_status(a)
+
+      line "#{c(a.name, :name)}: #{status}"
+
+      indented do
+        start_line "usage: #{b(human_mb(a.memory))}"
+        print " #{d(IS_UTF8 ? "\xc3\x97" : "x")} #{b(a.total_instances)}"
+        print " instance#{a.total_instances == 1 ? "" : "s"}"
+
+        line
+
+        unless a.urls.empty?
+          line "urls: #{a.urls.collect { |u| b(u) }.join(", ")}"
+        end
+
+        unless a.services.empty?
+          line "services: #{a.services.collect { |s| b(s.name) }.join(", ")}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+require "jdc/cli/app/base"
+
+module JDC::App
+  class Apps < Base
+    desc "List your applications"
+    group :apps
+    input :space, :desc => "Show apps in given space",
+          :default => proc { client.current_space },
+          :from_given => by_name(:space)
+    input :name, :desc => "Filter by name regexp"
+    input :url, :desc => "Filter by url regexp"
+    input :full, :desc => "Verbose output format", :default => false
+    def apps
+      if space = input[:space]
+        begin
+          space.summarize!
+        rescue JFoundry::APIError
+        end
+
+        apps =
+          with_progress("Getting applications in #{c(space.name, :name)}") do
+            space.apps
+          end
+      else
+        apps =
+          with_progress("Getting applications") do
+            client.apps(:depth => 2)
+          end
+      end
+
+      line unless quiet?
+
+      if apps.empty? and !quiet?
+        line "No applications."
+        return
+      end
+
+      apps.reject! do |a|
+        !app_matches?(a, input)
+      end
+
+      apps = apps.sort_by(&:name)
+
+      if input[:full]
+        spaced(apps) do |a|
+          invoke :app, :app => a
+        end
+      elsif quiet?
+        apps.each do |a|
+          line a.name
+        end
+      else
+        display_apps_table(apps)
+      end
+    end
+
+    def display_apps_table(apps)
+      table(
+        ["name", "status", "usage", "url"],
+        apps.collect { |a|
+          [ c(a.name, :name),
+            app_status(a),
+            "#{a.total_instances} x #{human_mb(a.memory)}",
+            if a.urls.empty?
+              d("none")
+            elsif a.urls.size == 1
+              a.url
+            else
+              "#{a.url}, ..."
+            end
+          ]
+        })
+    end
+
+    def app_matches?(a, options)
+      if name = options[:name]
+        return false if a.name !~ /#{name}/
+      end
+
+      if url = options[:url]
+        return false if a.urls.none? { |u| u =~ /#{url}/ }
+      end
+
+      true
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require "jdc/cli"
+
+module JDC 
+  module App
+    class Base < CLI
+      include LoginRequirements
+
+      # choose the right color for app/instance state
+      def state_color(s)
+        case s
+        when "STARTING"
+          :neutral
+        when "STARTED", "RUNNING"
+          :good
+        when "DOWN"
+          :bad
+        when "FLAPPING"
+          :error
+        when "N/A"
+          :unknown
+        else
+          :warning
+        end
+      end
+
+      def app_status(a)
+        health = a.health
+
+        if a.debug_mode == "suspend" && health == "0%"
+          c("suspended", :neutral)
+        else
+          c(health.downcase, state_color(health))
+        end
+      end
+
+      def memory_choices
+        [128, 256, 512, 1024].map{|n| human_mb(n)}
+      end
+
+      def human_mb(num)
+        human_size(num * 1024 * 1024, 0)
+      end
+
+      def human_size(num, precision = 1)
+        sizes = %w(G M K)
+        sizes.each.with_index do |suf, i|
+          pow = sizes.size - i
+          unit = 1024.0 ** pow
+          if num >= unit
+            return format("%.#{precision}f%s", num / unit, suf)
+          end
+        end
+
+        format("%.#{precision}fB", num)
+      end
+
+      def megabytes(str)
+        if str =~ /T$/i
+          str.to_i * 1024 * 1024
+        elsif str =~ /G$/i
+          str.to_i * 1024
+        elsif str =~ /M$/i
+          str.to_i
+        elsif str =~ /K$/i
+          str.to_i / 1024
+        else # assume megabytes
+          str.to_i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require "set"
+
+require "jdc/cli/app/base"
+
+module JDC::App
+  class Delete < Base
+    desc "Delete an application"
+    group :apps, :manage
+    input :apps, :desc => "Applications to delete", :argument => :splat,
+          :singular => :app, :from_given => by_name(:app)
+    input :routes, :desc => "Delete associated routes", :default => false
+    input :delete_orphaned, :desc => "Delete orphaned services",
+          :aliases => "-o", :default => proc { force? ? false : interact },
+          :forget => true
+    input :all, :desc => "Delete all applications", :default => false
+    input :really, :type => :boolean, :forget => true, :hidden => true,
+          :default => proc { force? || interact }
+    def delete
+      apps = client.apps
+
+      if input[:all]
+        return unless input[:really, "ALL APPS", :bad]
+
+        to_delete = apps
+        others = []
+      else
+        to_delete = input[:apps]
+        others = apps - to_delete
+      end
+
+      all_services = apps.collect(&:services).flatten
+      deleted_app_services = []
+
+      spaced(to_delete) do |app|
+        really = input[:all] || input[:really, app.name, :name]
+        next unless really
+
+        deleted_app_services += app.services
+
+        with_progress("Deleting #{c(app.name, :name)}") do
+          app.routes.collect(&:delete!) if input[:routes]
+          app.delete!
+        end
+      end
+
+      delete_orphaned_services(
+        find_orphaned_services(deleted_app_services, all_services))
+
+      to_delete
+    end
+
+    def find_orphaned_services(deleted, all)
+      orphaned = []
+
+      leftover = all.dup
+      deleted.each do |svc|
+        leftover.slice!(leftover.index(svc))
+        orphaned << svc unless leftover.include?(svc)
+      end
+
+      # clear out the relationships as the apps are now deleted
+      orphaned.each(&:invalidate!)
+    end
+
+    def delete_orphaned_services(orphans)
+      return if orphans.empty?
+
+      line unless quiet? || force?
+
+      orphans.select { |o| input[:delete_orphaned, o] }.each do |service|
+        # TODO: splat
+        invoke :delete_service, :service => service, :really => true
+      end
+    end
+
+    private
+
+    def ask_apps
+      apps = client.apps
+      fail "No applications." if apps.empty?
+
+      [ask("Delete which application?", :choices => apps.sort_by(&:name),
+           :display => proc(&:name))]
+    end
+
+    def ask_really(name, color)
+      ask("Really delete #{c(name, color)}?", :default => false)
+    end
+
+    def ask_delete_orphaned(service)
+      ask("Delete orphaned service #{c(service.name, :name)}?",
+          :default => false)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require "jdc/cli/app/base"
+
+module JDC::App
+  class Deprecated < Base
+    desc "DEPRECATED. Use 'push' instead."
+    input :app, :argument => :optional
+    def update
+      fail "The 'update' command is no longer needed; use 'push' instead."
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require "jdc/cli/app/base"
+
+module JDC::App
+  class Env < Base
+    VALID_ENV_VAR = /^[a-zA-Za-z_][[:alnum:]_]*$/
+
+    desc "Show all environment variables set for an app"
+    group :apps, :info
+    input :app, :desc => "Application to inspect the environment of",
+          :argument => true, :from_given => by_name(:app)
+    def env
+      app = input[:app]
+
+      vars =
+        with_progress("Getting env for #{c(app.name, :name)}") do |s|
+          app.env
+        end
+
+      line unless quiet?
+
+      vars.each do |name, val|
+        line "#{c(name, :name)}: #{val}"
+      end
+    end
+
+    desc "Set an environment variable"
+    group :apps, :info
+    input :app, :desc => "Application to set the variable for",
+          :argument => true, :from_given => by_name(:app)
+    input :name, :desc => "Variable name", :argument => true
+    input :value, :desc => "Variable value", :argument => :optional
+    input :restart, :desc => "Restart app after updating?", :default => true
+    def set_env
+      app = input[:app]
+      name = input[:name]
+
+      if value = input[:value]
+        name = input[:name]
+      elsif name["="]
+        name, value = name.split("=")
+      end
+
+      unless name =~ VALID_ENV_VAR
+        fail "Invalid variable name; must match #{VALID_ENV_VAR.inspect}"
+      end
+
+      with_progress("Updating #{c(app.name, :name)}") do
+        app.env[name] = value
+        app.update!
+      end
+
+      if app.started? && input[:restart]
+        invoke :restart, :app => app
+      end
+    end
+
+
+    desc "Remove an environment variable"
+    group :apps, :info
+    input :app, :desc => "Application to set the variable for",
+          :argument => true, :from_given => by_name(:app)
+    input :name, :desc => "Variable name", :argument => true
+    input :restart, :desc => "Restart app after updating?", :default => true
+    def unset_env
+      app = input[:app]
+      name = input[:name]
+
+      with_progress("Updating #{c(app.name, :name)}") do
+        app.env.delete(name)
+        app.update!
+      end
+
+      if app.started? && input[:restart]
+        invoke :restart, :app => app
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require "jdc/cli/app/base"
+
+module JDC::App
+  class Events < Base
+    desc "Display application events"
+    group :apps, :info
+    input :app, :desc => "Application to get the events for",
+          :argument => true, :from_given => by_name(:app)
+    def events
+      app = input[:app]
+
+      events =
+        with_progress("Getting events for #{c(app.name, :name)}") do
+          format_events(app.events)
+        end
+
+      line unless quiet?
+      table(%w{time instance\ index description exit\ status}, events)
+
+    end
+
+    private
+
+    def sort_events(events)
+      events.sort_by { |event| DateTime.parse(event.timestamp) }
+    end
+
+    def format_events(events)
+      sort_events(events).map do |event|
+        [event.timestamp,
+         c(event.instance_index.to_s, :warning),
+         event.exit_description,
+         format_status(event)]
+      end
+    end
+
+    def format_status(event)
+      if event.exit_status == 0
+        c("Success (#{event.exit_status})", :good)
+      else
+        c("Failure (#{event.exit_status})", :bad)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+require "thread"
+require "jdc/cli/app/base"
+
+module JDC::App
+  class Files < Base
+    desc "Print out an app's file contents"
+    group :apps, :info
+    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 JFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue JFoundry::FileError => e
+      fail e.description
+    end
+
+    desc "Examine an app's files"
+    group :apps, :info
+    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 JFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue JFoundry::FileError => e
+      fail e.description
+    end
+
+    desc "Stream an app's file contents"
+    group :apps, :info
+    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 JFoundry::NotFound
+      fail "Invalid path #{b(path)} for app #{b(app.name)}"
+    rescue JFoundry::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