cf 0.1.2 → 0.1.3

data/lib/cf/cli.rb

@@ -5,6 +5,8 @@ require "cf/cli/user"
 
 module CF
   class CLI < App # subclass App since we operate on Apps by default
+    class_option :proxy, :aliases => "-u", :desc => "Proxy user"
+
     class_option :verbose,
       :type => :boolean, :aliases => "-v", :desc => "Verbose"
 
@@ -95,17 +97,20 @@ module CF
       puts "target: #{b(client.target)}"
       puts "  version: #{info["version"]}"
       puts "  support: #{info["support"]}"
-      puts ""
-      puts "user: #{b(info["user"])}"
-      puts "  usage:"
-
-      limits = info["limits"]
-      info["usage"].each do |k, v|
-        m = limits[k]
-        if k == "memory"
-          puts "    #{k}: #{usage(v * 1024 * 1024, m * 1024 * 1024)}"
-        else
-          puts "    #{k}: #{b(v)} of #{b(m)} limit"
+
+      if info["user"]
+        puts ""
+        puts "user: #{b(info["user"])}"
+        puts "  usage:"
+
+        limits = info["limits"]
+        info["usage"].each do |k, v|
+          m = limits[k]
+          if k == "memory"
+            puts "    #{k}: #{usage(v * 1024 * 1024, m * 1024 * 1024)}"
+          else
+            puts "    #{k}: #{b(v)} of #{b(m)} limit"
+          end
         end
       end
     end

data/lib/cf/cli/app.rb

@@ -23,6 +23,25 @@ module CF
       end
     end
 
+    desc "health ...APPS", "Get application health"
+    def health(*names)
+      apps =
+        with_progress("Getting application health") do
+          names.collect do |n|
+            [n, app_status(client.app(n))]
+          end
+        end
+
+      apps.each do |name, status|
+        unless simple_output?
+          puts ""
+          print "#{c(name, :blue)}: "
+        end
+
+        puts status
+      end
+    end
+
     desc "stop [APP]", "Stop an application"
     def stop(name)
       with_progress("Stopping #{c(name, :blue)}") do |s|
@@ -274,7 +293,7 @@ module CF
       err "The 'update' command is no longer used; use 'push' instead."
     end
 
-    desc "stats", "Display application instance status"
+    desc "stats [APP]", "Display application instance status"
     def stats(name)
       stats =
         with_progress("Getting stats") do
@@ -500,6 +519,16 @@ module CF
       end
     end
 
+    def app_status(a)
+      health = a.health
+
+      if a.debug_mode == "suspend" && health == "0%"
+        c("suspended", :yellow)
+      else
+        c(health.downcase, state_color(health))
+      end
+    end
+
     def display_app(a)
       if simple_output?
         puts a.name
@@ -508,13 +537,7 @@ module CF
 
       puts ""
 
-      health = a.health
-
-      if a.debug_mode == "suspend" && health == "0%"
-        status = c("suspended", :yellow)
-      else
-        status = c(health.downcase, state_color(health))
-      end
+      status = app_status(a)
 
       print "#{c(a.name, :blue)}: #{status}"
 

data/lib/cf/cli/command.rb

@@ -1,6 +1,6 @@
 require "thor"
 require "interact"
-require "json/pure"
+require "yaml"
 
 require "cfoundry"
 
@@ -357,7 +357,7 @@ module CF
     end
 
     def tokens
-      JSON.parse(File.read(tokens_file))
+      YAML.load_file(tokens_file)
     end
 
     def client_token
@@ -367,8 +367,8 @@ module CF
     def save_tokens(ts)
       ensure_config_dir
 
-      File.open(File.expand_path(CF::TOKENS_FILE), "w") do |f|
-        f.write ts.to_json
+      File.open(File.expand_path(CF::TOKENS_FILE), "w") do |io|
+        YAML.dump(ts, io)
       end
     end
 
@@ -385,7 +385,11 @@ module CF
     end
 
     def client
-      @client ||= CFoundry::Client.new(client_target, client_token)
+      return @client if @client
+
+      @client = CFoundry::Client.new(client_target, client_token)
+      @client.proxy = options[:proxy]
+      @client
     end
 
     def usage(used, limit)

data/lib/cf/cli/dots.rb

@@ -69,9 +69,12 @@ module CF
     }
 
     # colored text
-    def c(str, color, bright = true)
+    #
+    # shouldn't use bright colors, as some color themes abuse
+    # the bright palette (I'm looking at you, Solarized)
+    def c(str, color)
       return str unless color?
-      "\e[#{bright ? 9 : 3}#{COLOR_CODES[color]}m#{str}\e[0m"
+      "\e[3#{COLOR_CODES[color]}m#{str}\e[0m"
     end
     module_function :c
 

data/lib/cf/constants.rb

@@ -3,8 +3,8 @@ module CF
   OLD_TOKENS_FILE = "~/.vmc_token"
 
   CONFIG_DIR = "~/.cf"
-  PLUGINS_DIR = "#{CONFIG_DIR}/plugins"
+  PLUGINS_FILE = "#{CONFIG_DIR}/plugins.yml"
   TARGET_FILE = "#{CONFIG_DIR}/target"
-  TOKENS_FILE = "#{CONFIG_DIR}/tokens"
+  TOKENS_FILE = "#{CONFIG_DIR}/tokens.yml"
   CRASH_FILE = "#{CONFIG_DIR}/crash"
 end

data/lib/cf/detect.rb

@@ -16,6 +16,10 @@ module CF
       matches = {}
       all_frameworks.each do |name, meta|
         matched = false
+
+        # e.g. standalone has no detection
+        next if meta["detection"].nil?
+
         meta["detection"].first.each do |file, match|
           files =
             if File.file? @path

data/lib/cf/plugin.rb

@@ -1,3 +1,6 @@
+require "set"
+require "yaml"
+
 require "cf/constants"
 require "cf/cli"
 
@@ -6,13 +9,26 @@ module CF
     @@plugins = []
 
     def self.load_all
-      bundled = File.expand_path("../../../plugins/*/main.rb", __FILE__)
-      Dir.glob(bundled).each do |main|
-        require main
+      # auto-load gems with 'vmc-plugin' in their name
+      enabled =
+        Set.new(
+          Gem::Specification.find_all { |s|
+            s.name =~ /vmc-plugin/
+          }.collect(&:name))
+
+      # allow explicit enabling/disabling of gems via config
+      plugins = File.expand_path(CF::PLUGINS_FILE)
+      if File.exists?(plugins) && yaml = YAML.load_file(plugins)
+        enabled += yaml["enabled"] if yaml["enabled"]
+        enabled -= yaml["disabled"] if yaml["disabled"]
       end
 
-      Dir.glob(File.expand_path("#{CF::PLUGINS_DIR}/*/main.rb")).each do |main|
-        require main
+      # load up each gem's 'plugin' file
+      #
+      # we require this file specifically so people can require the gem
+      # without it plugging into CF
+      enabled.each do |gemname|
+        require "#{gemname}/plugin"
       end
     end
   end

data/lib/cf/version.rb

@@ -1,3 +1,3 @@
 module CF
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,68 +1,96 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: cf
-version: !ruby/object:Gem::Version
-  version: 0.1.2
+version: !ruby/object:Gem::Version 
+  hash: 29
   prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 3
+  version: 0.1.3
 platform: ruby
-authors:
+authors: 
 - Alex Suraci
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-05 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-05-01 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: interact
-  requirement: &70204736023380 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 0
+        - 4
+        - 1
         version: 0.4.1
   type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cfoundry
   prerelease: false
-  version_requirements: *70204736023380
-- !ruby/object:Gem::Dependency
-  name: json_pure
-  requirement: &70204736022880 !ruby/object:Gem::Requirement
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: 1.6.5
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
   type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: thor
   prerelease: false
-  version_requirements: *70204736022880
-- !ruby/object:Gem::Dependency
-  name: cfoundry
-  requirement: &70204736022420 !ruby/object:Gem::Requirement
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.1.0
+      - !ruby/object:Gem::Version 
+        hash: 43
+        segments: 
+        - 0
+        - 14
+        - 6
+        version: 0.14.6
   type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: manifests-vmc-plugin
   prerelease: false
-  version_requirements: *70204736022420
-- !ruby/object:Gem::Dependency
-  name: thor
-  requirement: &70204736021940 !ruby/object:Gem::Requirement
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.14.6
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
   type: :runtime
-  prerelease: false
-  version_requirements: *70204736021940
+  version_requirements: *id004
 description: 
-email:
+email: 
 - asuraci@vmware.com
-executables:
+executables: 
 - cf
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - LICENSE
 - Rakefile
 - lib/cf/cli/app.rb
@@ -76,30 +104,39 @@ files:
 - lib/cf/plugin.rb
 - lib/cf/version.rb
 - lib/cf.rb
-- plugins/manifests/main.rb
 - bin/cf
 homepage: http://cloudfoundry.com/
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: cf
-rubygems_version: 1.8.10
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Friendly command-line interface for Cloud Foundry.
 test_files: []
+

data/plugins/manifests/main.rb

@@ -1,508 +0,0 @@
-require "yaml"
-require "set"
-require "cf/plugin"
-
-CF.Plugin do
-  class_option :manifest,
-    :aliases => "-m", :desc => "Manifest file"
-
-  class_option :path,
-    :aliases => "-p", :desc => "Application path"
-end
-
-module CF::Plugins
-  module Manifests
-    MANIFEST_FILE = "manifest.yml"
-
-    def manifest
-      return @manifest if @manifest
-
-      if manifest_file && File.exists?(manifest_file)
-        @manifest = load_manifest(manifest_file)
-      end
-    end
-
-    def save_manifest(save_to = manifest_file)
-      err "No manifest to save!" unless @manifest
-
-      File.open(save_to, "w") do |io|
-        YAML.dump(@manifest, io)
-      end
-    end
-
-    # find the manifest file to work with
-    def manifest_file
-      return options[:manifest] if options[:manifest]
-      return @manifest_file if @manifest_file
-
-      where = Dir.pwd
-      while true
-        if File.exists?(File.join(where, MANIFEST_FILE))
-          @manifest_file = File.join(where, MANIFEST_FILE)
-          break
-        elsif File.basename(where) == "/"
-          @manifest_file = nil
-          break
-        else
-          where = File.expand_path("../", where)
-        end
-      end
-
-      @manifest_file
-    end
-
-    # load and resolve a given manifest file
-    def load_manifest(file)
-      manifest = build_manifest(file)
-      resolve_manifest(manifest)
-      manifest
-    end
-
-    # parse a manifest and merge with its inherited manifests
-    def build_manifest(file)
-      manifest = YAML.load_file file
-
-      Array(manifest["inherit"]).each do |p|
-        manifest = merge_parent(manifest, p)
-      end
-
-      manifest
-    end
-
-    # merge the manifest at `path' into the `child'
-    def merge_parent(child, path)
-      file = File.expand_path("../" + path, manifest_file)
-      merge_manifest(child, build_manifest(file))
-    end
-
-    # deep hash merge
-    def merge_manifest(child, parent)
-      merge = proc do |_, old, new|
-        if new.is_a?(Hash) and old.is_a?(Hash)
-          old.merge(new, &merge)
-        else
-          new
-        end
-      end
-
-      parent.merge(child, &merge)
-    end
-
-    # resolve symbols in a manifest
-    def resolve_manifest(manifest)
-      if apps = manifest["applications"]
-        apps.each_value do |v|
-          resolve_lexically(v, [manifest])
-        end
-      end
-
-      resolve_lexically(manifest, [manifest])
-
-      nil
-    end
-
-    # resolve symbols, with hashes introducing new lexical symbols
-    def resolve_lexically(val, ctx)
-      case val
-      when Hash
-        val.each_value do |v|
-          resolve_lexically(v, [val] + ctx)
-        end
-      when Array
-        val.each do |v|
-          resolve_lexically(v, ctx)
-        end
-      when String
-        val.gsub!(/\$\{([[:alnum:]\-]+)\}/) do
-          resolve_symbol($1, ctx)
-        end
-      end
-
-      nil
-    end
-
-    # resolve a symbol to its value, and then resolve that value
-    def resolve_symbol(sym, ctx)
-      case sym
-      when "target-url"
-        target_url(ctx)
-
-      when "target-base"
-        target_url(ctx).sub(/^[^\.]+\./, "")
-
-      when "random-word"
-        "%04x" % [rand(0x0100000)]
-
-      else
-        found = find_symbol(sym, ctx)
-
-        if found
-          resolve_lexically(found, ctx)
-          found
-        else
-          err("Unknown symbol in manifest: #{sym}")
-        end
-      end
-    end
-
-    # get the target url from either the manifest or the current client
-    def target_url(ctx = [])
-      find_symbol("target", ctx) || client_target
-    end
-
-    # search for a symbol introduced in the lexical context
-    def find_symbol(sym, ctx)
-      ctx.each do |h|
-        if val = resolve_in(h, sym)
-          return val
-        end
-      end
-
-      nil
-    end
-
-    # find a value, searching in explicit properties first
-    def resolve_in(hash, *where)
-      find_in_hash(hash, ["properties"] + where) ||
-        find_in_hash(hash, where)
-    end
-
-    # helper for following a path of values in a hash
-    def find_in_hash(hash, where)
-      what = hash
-      where.each do |x|
-        return nil unless what.is_a?(Hash)
-        what = what[x]
-      end
-
-      what
-    end
-
-    MANIFEST_META = ["applications", "properties"]
-
-    def toplevel_attributes
-      if m = manifest
-        m.reject do |k, _|
-          MANIFEST_META.include? k
-        end
-      end
-    end
-
-    def app_info(find_path)
-      return unless manifest and manifest["applications"]
-      
-      manifest["applications"].each do |path, info|
-        app = File.expand_path("../" + path, manifest_file)
-        if find_path == app
-          return toplevel_attributes.merge info
-        end
-      end
-
-      nil
-    end
-
-    # call a block for each app in a manifest (in dependency order), setting
-    # inputs for each app
-    def each_app
-      given_path = passed_value(:path)
-
-      if manifest and all_apps = manifest["applications"]
-        # given a specific application
-        if given_path
-          full_path = File.expand_path(given_path)
-
-          if info = app_info(full_path)
-            with_app(full_path, info) do
-              yield info
-            end
-          else
-            raise "Path #{given_path} is not described by the manifest."
-          end
-        else
-          # all apps in the manifest
-          ordered_by_deps(all_apps).each do |path|
-            app = File.expand_path("../" + path, manifest_file)
-            info = app_info(app)
-
-            with_app(app, info) do
-              yield info
-            end
-          end
-        end
-
-        true
-      
-      # manually created or legacy single-app manifest
-      elsif single = toplevel_attributes
-        with_app(full_path || ".", single) do
-          yield single
-        end
-
-        true
-
-      else
-        false
-      end
-    end
-
-    private
-
-    def inputs
-      @inputs ||= {}
-    end
-
-    # call the block as if the app info and path were given as flags
-    def with_app(path, info)
-      before_path = inputs[:path]
-      before_info = {}
-
-      inputs[:path] = path
-
-      info.each do |k, v|
-        before_info[k.to_sym] = inputs[k.to_sym]
-        inputs[k.to_sym] = v
-      end
-
-      yield
-    ensure
-      if before_path.nil?
-        inputs.delete :path
-      else
-        inputs[:path] = before_path
-      end
-
-      before_info.each do |k, v|
-        if v.nil?
-          inputs.delete k
-        else
-          inputs[k] = v
-        end
-      end
-    end
-
-    # sort applications in dependency order
-    # e.g. if A depends on B, B will be listed before A
-    def ordered_by_deps(apps, abspaths = nil, processed = Set[])
-      unless abspaths
-        abspaths = {}
-        apps.each do |p, i|
-          ep = File.expand_path("../" + p, manifest_file)
-          abspaths[ep] = i
-        end
-      end
-
-      ordered = []
-      apps.each do |path, info|
-        epath = File.expand_path("../" + path, manifest_file)
-
-        if deps = info["depends-on"]
-          dep_apps = {}
-          deps.each do |dep|
-            edep = File.expand_path("../" + dep, manifest_file)
-
-            err "Circular dependency detected." if processed.include? edep
-
-            dep_apps[dep] = abspaths[edep]
-          end
-
-          processed.add(epath)
-
-          ordered += ordered_by_deps(dep_apps, abspaths, processed)
-          ordered << path
-        elsif not processed.include? epath
-          ordered << path
-          processed.add(epath)
-        end
-      end
-
-      ordered
-    end
-
-    # detect changes in app info, and update the app if necessary.
-    #
-    # redeploys the app if necessary (after prompting the user), e.g. for
-    # runtime/framework change
-    def sync_changes(info)
-      app = client.app(info["name"])
-      return unless app.exists?
-
-      diff = {}
-      need_restage = []
-      info.each do |k, v|
-        case k
-        when /ur[li]s?/
-          old = app.urls
-          if old != Array(v)
-            diff[k] = [old, v]
-            app.urls = Array(v)
-          end
-        when "env"
-          old = app.env
-          if old != v
-            diff[k] = [old, v]
-            app.env = v
-          end
-        when "framework", "runtime"
-          old = app.send(k)
-          if old != v
-            diff[k] = [old, v]
-            app.send(:"#{k}=", v)
-            need_restage << k
-          end
-        when "instances"
-          old = app.total_instances
-          if old != v
-            diff[k] = [old, v]
-            app.total_instances = v
-          end
-        when "mem", "memory"
-          old = app.memory
-          new = megabytes(v)
-          if old != new
-            diff[k] = [old, new]
-            app.memory = new
-          end
-        end
-      end
-
-      return if diff.empty?
-
-      unless simple_output?
-        puts "Detected the following changes to #{c(app.name, :blue)}:"
-        diff.each do |k, d|
-          old, new = d
-          label = c(k, need_restage.include?(k) ? :red : :green)
-          puts "  #{label}: #{old.inspect} #{c("->", :black)} #{new.inspect}"
-        end
-
-        puts ""
-      end
-
-      if need_restage.empty?
-        with_progress("Updating #{c(app.name, :blue)}") do
-          app.update!
-        end
-      else
-        unless simple_output?
-          puts "The following changes require the app to be recreated:"
-          need_restage.each do |n|
-            puts "  #{c(n, :magenta)}"
-          end
-          puts ""
-        end
-
-        if force? || ask("Redeploy?", :default => false)
-          with_progress("Deleting #{c(app.name, :blue)}") do
-            app.delete!
-          end
-
-          with_progress("Recreating #{c(app.name, :blue)}") do
-            app.create!
-          end
-        end
-      end
-    end
-  end
-end
-
-CF.Plugin(CF::App) do
-  include CF::Plugins::Manifests
-
-  # basic commands that, when given no args, act on the
-  # app(s) described by the manifest, in dependency-order
-  [:start, :instances, :logs].each do |wrap|
-    around(wrap) do |cmd, args|
-      if args.empty?
-        each_app do |a|
-          cmd.call(a["name"])
-          puts "" unless simple_output?
-        end || err("No applications to act on.")
-      else
-        cmd.call(args)
-      end
-    end
-  end
-
-  # same as above but in reverse dependency-order
-  [:stop, :delete].each do |wrap|
-    around(wrap) do |cmd, args|
-      if args.empty?
-        reversed = []
-        each_app do |a|
-          reversed.unshift a["name"]
-        end || err("No applications to act on.")
-
-        reversed.each do |name|
-          cmd.call(name)
-          puts "" unless simple_output?
-        end
-      else
-        cmd.call(args)
-      end
-    end
-  end
-
-  # stop apps in reverse dependency order,
-  # and then start in dependency order
-  around(:restart) do |cmd, args|
-    if args.empty?
-      reversed = []
-      forwards = []
-      each_app do |a|
-        reversed.unshift a["name"]
-        forwards << a["name"]
-      end || err("No applications to act on.")
-
-      reversed.each do |name|
-        stop(name)
-      end
-
-      puts "" unless simple_output?
-
-      forwards.each do |name|
-        start(name)
-      end
-    else
-      cmd.call(args)
-    end
-  end
-
-  # push and sync meta changes in the manifest
-  # also sets env data on creation if present in manifest
-  around(:push) do |push, args|
-    if args.empty?
-      all_pushed =
-        each_app do |a|
-          app = client.app(a["name"])
-          updating = app.exists?
-
-          start = input(:start)
-
-          begin
-            inputs[:start] = false
-
-            sync_changes(a)
-            push.call(a["name"])
-
-            unless updating
-              app.env = a["env"]
-
-              if start
-                start(a["name"])
-              else
-                app.update!
-              end
-            end
-          ensure
-            inputs[:start] = start
-          end
-
-          puts "" unless simple_output?
-        end
-
-      push.call unless all_pushed
-    else
-      push.call(args)
-    end
-  end
-end