cf 0.1.0

data/lib/cf/cli/service.rb

@@ -0,0 +1,91 @@
+require "cf/cli/command"
+
+module CF
+  class Service < Command
+    desc "delete", "Delete a service"
+    flag(:name) { |choices|
+      ask "Delete which service?", :choices => choices
+    }
+    def delete(name = nil)
+      name ||= input(:name, client.services.collect(&:name))
+
+      with_progress("Deleting #{c(name, :blue)}") do
+        client.service(name).delete!
+      end
+    end
+
+    desc "bind", "Bind a service to an application"
+    flag(:name) { |choices|
+      ask "Which service?", :choices => choices
+    }
+    flag(:app) { |choices|
+      ask "Which application?", :choices => choices
+    }
+    def bind(name = nil, appname = nil)
+      name ||= input(:name, client.services.collect(&:name))
+      appname ||= input(:app, client.apps.collect(&:name))
+
+      with_progress("Binding #{c(name, :blue)} to #{c(appname, :blue)}") do
+        client.app(appname).bind(name)
+      end
+    end
+
+    desc "unbind", "Unbind a service from an application"
+    flag(:name) { |choices|
+      ask "Which service?", :choices => choices
+    }
+    flag(:app) { |choices|
+      ask "Which application?", :choices => choices
+    }
+    def unbind(name = nil, appname = nil)
+      appname ||= input(:app, client.apps.collect(&:name))
+
+      app = client.app(appname)
+      name ||= input(:name, app.services)
+
+      with_progress("Unbinding #{c(name, :blue)} from #{c(appname, :blue)}") do
+        app.unbind(name)
+      end
+    end
+
+    desc "create", "Create a service"
+    flag(:type) { |choices|
+      ask "What kind?", :choices => choices
+    }
+    flag(:name) { |vendor|
+      random = sprintf("%x", rand(1000000))
+      ask "Name?", :default => "#{vendor}-#{random}"
+    }
+    def create
+      choices = []
+      manifests = {}
+      client.system_services.each do |type, vendors|
+        vendors.each do |vendor, versions|
+          versions.each do |version, _|
+            choice = "#{vendor} #{version}"
+            manifests[choice] = {
+              :type => type,
+              :vendor => vendor,
+              :version => version
+            }
+
+            choices << choice
+          end
+        end
+      end
+
+      type = input(:type, choices)
+      meta = manifests[type]
+
+      service = client.service(input(:name, meta[:vendor]))
+      service.type = meta[:type]
+      service.vendor = meta[:vendor]
+      service.version = meta[:version]
+      service.tier = "free"
+
+      with_progress("Creating service") do
+        service.create!
+      end
+    end
+  end
+end

data/lib/cf/cli/user.rb

@@ -0,0 +1,71 @@
+require "cf/cli/command"
+
+module CF
+  class User < Command
+    desc "create [EMAIL]", "Create a user"
+    flag(:email) {
+      ask("Email")
+    }
+    flag(:password) {
+      ask("Password", :echo => "*", :forget => true)
+    }
+    flag(:verify) {
+      ask("Verify Password", :echo => "*", :forget => true)
+    }
+    def create(email = nil)
+      email ||= input(:email)
+      password = input(:password)
+      verify = input(:verify)
+
+      if password != verify
+        err "Passwords don't match."
+        return
+      end
+
+      with_progress("Creating user") do
+        client.register(email, password)
+      end
+    end
+
+    desc "delete [EMAIL]", "Delete a user"
+    flag(:really) { |email|
+      force? || ask("Really delete user #{c(email, :blue)}?", :default => false)
+    }
+    def delete(email)
+      return unless input(:really, email)
+
+      with_progress("Deleting #{c(email, :blue)}") do
+        client.user(email).delete!
+      end
+    ensure
+      forget(:really)
+    end
+
+    desc "passwd [EMAIL]", "Update a user's password"
+    flag(:email) {
+      ask("Email")
+    }
+    flag(:password) {
+      ask("Password", :echo => "*", :forget => true)
+    }
+    flag(:verify) {
+      ask("Verify Password", :echo => "*", :forget => true)
+    }
+    def passwd(email = nil)
+      email ||= input(:email)
+      password = input(:password)
+      verify = input(:verify)
+
+      if password != verify
+        err "Passwords don't match."
+        return
+      end
+
+      with_progress("Changing password") do
+        user = client.user(email)
+        user.password = password
+        user.update!
+      end
+    end
+  end
+end

data/lib/cf/constants.rb

@@ -0,0 +1,10 @@
+module CF
+  OLD_TARGET_FILE = "~/.vmc_target"
+  OLD_TOKENS_FILE = "~/.vmc_token"
+
+  CONFIG_DIR = "~/.cf"
+  PLUGINS_DIR = "#{CONFIG_DIR}/plugins"
+  TARGET_FILE = "#{CONFIG_DIR}/target"
+  TOKENS_FILE = "#{CONFIG_DIR}/tokens"
+  CRASH_FILE = "#{CONFIG_DIR}/crash"
+end

data/lib/cf/detect.rb

@@ -0,0 +1,60 @@
+module CF
+  class Detector
+    def initialize(client, path)
+      @client = client
+      @path = path
+    end
+
+    def all_frameworks
+      info = @client.info
+      info["frameworks"] || {}
+    end
+
+    def frameworks
+      info = @client.info
+
+      matches = {}
+      all_frameworks.each do |name, meta|
+        matched = false
+        meta["detection"].first.each do |file, match|
+          files =
+            if File.file? @path
+              if File.fnmatch(file, @path)
+                [@path]
+              else
+                []
+              end
+            else
+              Dir.glob("#@path/#{file}")
+            end
+
+          unless files.empty?
+            if match == true
+              matched = true
+            elsif match == false
+              matched = false
+              break
+            else
+              files.each do |f|
+                contents = File.open(f, &:read)
+                if contents =~ Regexp.new(match)
+                  matched = true
+                end
+              end
+            end
+          end
+        end
+
+        if matched
+          matches[name] = meta
+        end
+      end
+
+      if matches.size == 1
+        default = matches.keys.first
+      end
+
+      [matches, default]
+    end
+  end
+end

data/lib/cf/plugin.rb

@@ -0,0 +1,24 @@
+require "cf/constants"
+require "cf/cli"
+
+module CF
+  module Plugin
+    @@plugins = []
+
+    def self.load_all
+      bundled = File.expand_path("../../../plugins/*/main.rb", __FILE__)
+      Dir.glob(bundled).each do |main|
+        require main
+      end
+
+      Dir.glob(File.expand_path("#{CF::PLUGINS_DIR}/*/main.rb")).each do |main|
+        require main
+      end
+    end
+  end
+
+  def self.Plugin(target = CLI, &blk)
+    # SUPER FANCY PLUGIN SYSTEM
+    target.class_eval &blk
+  end
+end

data/lib/cf/version.rb

@@ -0,0 +1,3 @@
+module CF
+  VERSION = "0.1.0"
+end

data/plugins/manifests/main.rb

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