manifests-vmc-plugin 0.1.0

data/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c)2012, Alex Suraci
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Alex Suraci nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/manifests-vmc-plugin.rb

@@ -0,0 +1,410 @@
+require "yaml"
+require "set"
+
+module VMCManifests
+  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
+      info =
+        m.reject do |k, _|
+          MANIFEST_META.include? k
+        end
+
+      if info["framework"].is_a?(Hash)
+        info["framework"] = info["framework"]["name"]
+      end
+
+      info
+    end
+  end
+
+  def app_info(find_path)
+    return unless manifest and manifest["applications"]
+    
+    manifest["applications"].each do |path, info|
+      if info["framework"].is_a?(Hash)
+        info["framework"] = info["framework"]["name"]
+      end
+
+      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|
+      if k == "mem"
+        k = "memory"
+      end
+
+      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["memory"] = [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

data/lib/manifests-vmc-plugin/errors.rb

@@ -0,0 +1,21 @@
+module VMCManifests
+  class CircularDependency < RuntimeError
+    def initialize(app)
+      @app = app
+    end
+
+    def to_s
+      "Circular dependency in application '#@app'"
+    end
+  end
+
+  class UnknownSymbol < RuntimeError
+    def initialize(sym)
+      @sym = sym
+    end
+
+    def to_s
+      "Undefined symbol in manifest: '#@sym'"
+    end
+  end
+end

data/lib/manifests-vmc-plugin/manifest.rb

@@ -0,0 +1,222 @@
+require "yaml"
+require "set"
+
+module VMCManifests
+  class Manifest
+    def initialize(file)
+      @file = file
+    end
+
+    def body
+      @body ||= load
+    end
+
+    # load and resolve a given manifest file
+    def load
+      manifest = build_manifest(@file)
+      resolve_manifest(manifest)
+      manifest
+    end
+
+    def save(dest = @file)
+      File.open(save_to, "w") do |io|
+        YAML.dump(@body, io)
+      end
+    end
+
+    MANIFEST_META = ["applications", "properties"]
+
+    def toplevel_attributes
+      info =
+        body.reject do |k, _|
+          MANIFEST_META.include? k
+        end
+
+      if info["framework"].is_a?(Hash)
+        info["framework"] = info["framework"]["name"]
+      end
+
+      info
+    end
+
+    def app_info(find_path)
+      return unless body["applications"]
+
+      body["applications"].each do |path, info|
+        if info["framework"].is_a?(Hash)
+          info["framework"] = info["framework"]["name"]
+        end
+
+        app = File.expand_path("../" + path, manifest_file)
+        if find_path == app
+          return toplevel_attributes.merge info
+        end
+      end
+
+      nil
+    end
+
+    # sort applications in dependency order
+    # e.g. if A depends on B, B will be listed before A
+    def applications(
+        apps = body["applications"],
+        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)
+
+            raise CircularDependency.new(edep) if processed.include?(edep)
+
+            dep_apps[dep] = abspaths[edep]
+          end
+
+          processed.add(epath)
+
+          ordered += applications(dep_apps, abspaths, processed)
+          ordered << path
+        elsif not processed.include? epath
+          ordered << path
+          processed.add(epath)
+        end
+      end
+
+      ordered
+    end
+
+    private
+
+    # 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, @file)
+      deep_merge(child, build_manifest(file))
+    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
+          raise UnknownSymbol.new(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
+
+    # deep hash merge
+    def deep_merge(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
+  end
+end

data/lib/manifests-vmc-plugin/plugin.rb

@@ -0,0 +1,112 @@
+require "cf/plugin"
+require File.expand_path("../../manifests-vmc-plugin", __FILE__)
+
+CF.Plugin do
+  class_option :manifest,
+    :aliases => "-m", :desc => "Manifest file"
+
+  class_option :path,
+    :aliases => "-p", :desc => "Application path"
+end
+
+CF.Plugin(CF::App) do
+  include VMCManifests
+
+  # 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

data/lib/manifests-vmc-plugin/version.rb

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

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: manifests-vmc-plugin
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Alex Suraci
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-01 00:00:00 Z
+dependencies: []
+
+description: 
+email: 
+- asuraci@vmware.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- Rakefile
+- lib/manifests-vmc-plugin/errors.rb
+- lib/manifests-vmc-plugin/manifest.rb
+- lib/manifests-vmc-plugin/plugin.rb
+- lib/manifests-vmc-plugin/version.rb
+- lib/manifests-vmc-plugin.rb
+homepage: http://cloudfoundry.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: manifests-vmc-plugin
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Cloud Foundry automation via manifest documents.
+test_files: []
+