jdc 0.2.1.pre → 0.2.1

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

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

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

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

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

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

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

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

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

@@ -1,26 +0,0 @@
-require "jdc/cli/app/base"
-
-module JDC::App
-  class Health < Base
-    desc "Get application health"
-    group :apps, :info
-    input :apps, :desc => "Show the health information for one or more applications", :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/jdc/cli/app/instances.rb

@@ -1,53 +0,0 @@
-require "jdc/cli/app/base"
-
-module JDC::App
-  class Instances < Base
-    desc "List an app's instances"
-    group :apps, :info
-    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/jdc/cli/app/logs.rb

@@ -1,76 +0,0 @@
-require "jdc/cli/app/base"
-
-module JDC::App
-  class Logs < Base
-    desc "Print out an app's logs"
-    group :apps, :info
-    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
-    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 JFoundry::NotFound
-        end
-      end
-    end
-  end
-end