manifests-cf-plugin 0.7.0.rc1

data/lib/manifests-cf-plugin/loader/resolver.rb

@@ -0,0 +1,79 @@
+module CFManifests
+  module Resolver
+    def resolve(manifest, resolver)
+      new = {}
+
+      new[:applications] = manifest[:applications].collect do |app|
+        resolve_lexically(resolver, app, [manifest])
+      end
+
+      resolve_lexically(resolver, new, [new])
+    end
+
+    private
+
+    # resolve symbols, with hashes introducing new lexical symbols
+    def resolve_lexically(resolver, val, ctx)
+      case val
+      when Hash
+        new = {}
+
+        val.each do |k, v|
+          new[k] = resolve_lexically(resolver, v, [val] + ctx)
+        end
+
+        new
+      when Array
+        val.collect do |v|
+          resolve_lexically(resolver, v, ctx)
+        end
+      when String
+        val.gsub(/\$\{([^\}]+)\}/) do
+          resolve_symbol(resolver, $1, ctx)
+        end
+      else
+        val
+      end
+    end
+
+    # resolve a symbol to its value, and then resolve that value
+    def resolve_symbol(resolver, sym, ctx)
+      if found = find_symbol(sym.to_sym, ctx)
+        resolve_lexically(resolver, found, ctx)
+        found
+      elsif dynamic = resolver.resolve_symbol(sym)
+        dynamic
+      else
+        fail("Unknown symbol in manifest: #{sym}")
+      end
+    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
+  end
+end

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

@@ -0,0 +1,145 @@
+require "pathname"
+
+require "cf/plugin"
+require "manifests-cf-plugin"
+
+
+class ManifestsPlugin < CF::App::Base
+  include CFManifests
+
+  option :manifest, :aliases => "-m", :value => :file,
+    :desc => "Path to manifest file to use"
+
+
+  [ :start, :restart, :instances, :logs, :env, :health, :stats,
+    :scale, :app, :stop, :delete
+  ].each do |wrap|
+    name_made_optional = change_argument(wrap, :app, :optional)
+
+    around(wrap) do |cmd, input|
+      wrap_with_optional_name(name_made_optional, cmd, input)
+    end
+  end
+
+
+  add_input :push, :reset, :desc => "Reset to values in the manifest",
+            :default => false
+
+  around(:push) do |push, input|
+    wrap_push(push, input)
+  end
+
+  private
+
+  def wrap_with_optional_name(name_made_optional, cmd, input)
+    return cmd.call if input[:all]
+
+    unless manifest
+      # if the command knows how to handle this
+      if input.has?(:app) || !name_made_optional
+        return cmd.call
+      else
+        return no_apps
+      end
+    end
+
+    internal, external = apps_in_manifest(input)
+
+    return cmd.call if internal.empty? && !external.empty?
+
+    show_manifest_usage
+
+    if internal.empty? && external.empty?
+      internal = current_apps if internal.empty?
+      internal = all_apps if internal.empty?
+    end
+
+    internal = internal.collect { |app| app[:name] }
+
+    apps = internal + external
+    return no_apps if apps.empty?
+
+    apps.each.with_index do |app, num|
+      line unless quiet? || num == 0
+      cmd.call(input.without(:apps).merge_given(:app => app))
+    end
+  end
+
+  def apply_changes(app, input)
+    app.memory = megabytes(input[:memory]) if input.has?(:memory)
+    app.total_instances = input[:instances] if input.has?(:instances)
+    app.command = input[:command] if input.has?(:command)
+    app.production = input[:plan].upcase.start_with?("P") if input.has?(:plan)
+    app.framework = input[:framework] if input.has?(:framework)
+    app.runtime = input[:runtime] if input.has?(:runtime)
+    app.buildpack = input[:buildpack] if input.has?(:buildpack)
+  end
+
+  def wrap_push(push, input)
+    unless manifest
+      create_and_save_manifest(push, input)
+      return
+    end
+
+    particular, external = apps_in_manifest(input)
+
+    unless external.empty?
+      fail "Could not find #{b(external.join(", "))}' in the manifest."
+    end
+
+    apps = particular.empty? ? all_apps : particular
+
+    show_manifest_usage
+
+    spaced(apps) do |app_manifest|
+      push_with_manifest(app_manifest, push, input)
+    end
+  end
+
+  def push_with_manifest(app_manifest, push, input)
+    with_filters(
+      :push => {
+        :create_app => proc { |a|
+          setup_env(a, app_manifest)
+          a
+        },
+        :push_app => proc { |a|
+          setup_services(a, app_manifest)
+          a
+        }
+      }) do
+      app_input = push_input_for(app_manifest, input)
+
+      push.call(app_input)
+    end
+  end
+
+  def push_input_for(app_manifest, input)
+    existing_app = client.app_by_name(app_manifest[:name])
+    rebased_input = input.rebase_given(app_manifest)
+
+    if !existing_app || input[:reset]
+      input = rebased_input
+    else
+      warn_reset_changes if manifest_differs?(existing_app, rebased_input)
+    end
+
+    input.merge(
+      :path => from_manifest(app_manifest[:path]),
+      :name => app_manifest[:name],
+      :bind_services => false,
+      :create_services => false)
+  end
+
+  def manifest_differs?(app, input)
+    apply_changes(app, input)
+    app.changed?
+  end
+
+  def create_and_save_manifest(push, input)
+    with_filters(
+        :push => { :push_app => proc { |a| ask_to_save(input, a); a } }) do
+      push.call
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+module CFManifests
+  VERSION = "0.7.0.rc1".freeze
+end

data/spec/manifests-cf-plugin/errors_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+require "manifests-cf-plugin/errors"
+
+
+describe CFManifests::InvalidManifest do
+  let(:file) { "/path/to/file" }
+
+  subject { described_class.new(file) }
+
+  describe "#initialize" do
+    it "is initialized with a file" do
+      described_class.new(file)
+    end
+  end
+
+  describe "#to_s" do
+    it "says the file is malformed" do
+      expect(subject.to_s).to eq(
+        "Manifest file '#{file}' is malformed.")
+    end
+  end
+
+  describe "#file" do
+    it "returns the file it was initialized with" do
+      expect(subject.file).to eq(file)
+    end
+  end
+end

data/spec/manifests-cf-plugin/loader/builder_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+require "manifests-cf-plugin/loader"
+require "manifests-cf-plugin/errors"
+
+
+describe CFManifests::Builder do
+  subject { CFManifests::Loader.new(nil, nil) }
+
+  describe "#build" do
+    let(:file) { "manifest.yml" }
+
+    before do
+      FakeFS.activate!
+
+      File.open(file, "w") do |io|
+        io.write manifest
+      end
+    end
+
+    after do
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear
+    end
+
+    context "with a simple manifest" do
+      let(:manifest) do
+        <<EOF
+---
+foo: bar
+EOF
+      end
+
+      it "loads the manifest YAML" do
+        expect(subject.build(file)).to eq("foo" => "bar")
+      end
+    end
+
+    context "with a manifest that inherits another" do
+      let(:manifest) do
+        <<EOF
+---
+inherit: other-manifest.yml
+foo:
+  baz: c
+EOF
+      end
+
+      before do
+        FakeFS.activate!
+
+        File.open("other-manifest.yml", "w") do |io|
+          io.write <<OTHER
+---
+foo:
+  bar: a
+  baz: b
+OTHER
+        end
+      end
+
+      it "merges itself into the parent, by depth" do
+        manifest = subject.build(file)
+        expect(manifest).to include(
+          "foo" => { "bar" => "a", "baz" => "c" })
+      end
+
+      it "does not include the 'inherit' attribute" do
+        manifest = subject.build(file)
+        expect(manifest).to_not include("inherit")
+      end
+    end
+
+    context "with an invalid manifest" do
+      let(:manifest) { "" }
+
+      it "raises an error" do
+        expect {
+          subject.build(file)
+        }.to raise_error(CFManifests::InvalidManifest)
+      end
+    end
+  end
+end

data/spec/manifests-cf-plugin/loader/normalizer_spec.rb

@@ -0,0 +1,176 @@
+require "spec_helper"
+
+require "manifests-cf-plugin/loader"
+
+
+describe CFManifests::Normalizer do
+  let(:manifest) { {} }
+  let(:loader) { CFManifests::Loader.new(nil, nil) }
+
+  describe '#normalize!' do
+    subject do
+      loader.normalize!(manifest)
+      manifest
+    end
+
+    context 'with a manifest where the applications have no path set' do
+      let(:manifest) { { "applications" => { "." => { "name" => "foo" } } } }
+
+      it "sets the path to their tag, assuming it's a path" do
+        expect(subject).to eq(
+          :applications => [{ :name => "foo", :path => "." }])
+      end
+    end
+
+    context 'with a manifest where the url is nil' do
+      let(:manifest) { { "applications" => { "." => { "url" => nil } } } }
+
+      it "sets it to none" do
+        expect(subject).to eq(
+          :applications => [{ :path => ".", :url => "none" }]
+        )
+      end
+    end
+
+    context 'with a manifest with a subdomain attribute' do
+      let(:manifest) { { "applications" => { "." => { "subdomain" => "use-this-for-host" } } } }
+
+      it "sets the subdomain key to be host" do
+        expect(subject).to eq(
+          :applications => [{ :path => ".", :host => "use-this-for-host" }]
+        )
+      end
+
+      context "when the host attribute is also set" do
+        let(:manifest) { { "applications" => { "." => { "subdomain" => "dont-use-this-for-host", "host" => "canonical-attribute" } } } }
+
+        it 'does not overwrite an explicit host attribute' do
+          expect(subject).to eq(
+            :applications => [{ :path => ".", :host => "canonical-attribute" }]
+          )
+        end
+      end
+    end
+
+    context 'with a manifest with toplevel attributes' do
+      context 'and properties' do
+        let(:manifest) {
+          { "name" => "foo", "properties" => { "fizz" => "buzz" } }
+        }
+
+        it 'keeps the properties at the toplevel' do
+          expect(subject).to eq(
+            :applications => [{ :name => "foo", :path => "." }],
+            :properties => { :fizz => "buzz" })
+        end
+      end
+
+      context 'and no applications' do
+        context 'and no path' do
+          let(:manifest) { { "name" => "foo" } }
+
+          it 'adds it as an application with path .' do
+            expect(subject).to eq(
+              :applications => [{ :name => "foo", :path => "." }])
+          end
+        end
+
+        context 'and a path' do
+          let(:manifest) { { "name" => "foo", "path" => "./foo" } }
+
+          it 'adds it as an application with the proper tag and path' do
+            expect(subject).to eq(
+              :applications => [{ :name => "foo", :path => "./foo" }])
+          end
+        end
+      end
+
+      context 'and applications' do
+        let(:manifest) {
+          { "runtime" => "ruby19",
+            "applications" => {
+              "./foo" => { "name" => "foo" },
+              "./bar" => { "name" => "bar" },
+              "./baz" => { "name" => "baz", "runtime" => "ruby18" }
+            }
+          }
+        }
+
+        it "merges the toplevel attributes into the applications" do
+          expect(subject[:applications]).to match_array [
+            { :name => "foo", :path => "./foo", :runtime => "ruby19" },
+            { :name => "bar", :path => "./bar", :runtime => "ruby19" },
+            { :name => "baz", :path => "./baz", :runtime => "ruby18" }
+          ]
+        end
+      end
+    end
+
+    context 'with a manifest where applications is a hash' do
+      let(:manifest) { { "applications" => { "foo" => { "name" => "foo" } } } }
+
+      it 'converts the array to a hash, with the path as the key' do
+        expect(subject).to eq(
+          :applications => [{ :name => "foo", :path => "foo" }])
+      end
+
+      context "and the applications had dependencies" do
+        let(:manifest) do
+          { "applications" => {
+              "bar" => { "name" => "bar", "depends-on" => "foo" },
+              "foo" => { "name" => "foo" }
+            }
+          }
+        end
+
+        it "converts using dependency order" do
+          expect(subject).to eq(
+            :applications => [{ :name => "foo", :path => "foo" }, { :name => "bar", :path => "bar" }])
+        end
+
+        context "and there's a circular dependency" do
+          let(:manifest) do
+            { "applications" => {
+               "bar" => { "name" => "bar", "depends-on" => "foo" },
+               "foo" => { "name" => "foo", "depends-on" => "bar" }
+              }
+            }
+          end
+
+          it "doesn't blow up" do
+            expect(subject).to be_true
+          end
+        end
+      end
+    end
+  end
+
+  describe '#normalize_app!' do
+    subject do
+      loader.send(:normalize_app!, manifest)
+      manifest
+    end
+
+    context 'with framework as a hash' do
+      let(:manifest) {
+        { "name" => "foo",
+          "framework" => { "name" => "ruby19", "mem" => "64M" }
+        }
+      }
+
+      it 'sets the framework to just the name' do
+        expect(subject).to eq(
+          "name" => "foo",
+          "framework" => "ruby19")
+      end
+    end
+
+    context 'with mem instead of memory' do
+      let(:manifest) { { "name" => "foo", "mem" => "128M" } }
+
+      it 'renames mem to memory' do
+        expect(subject).to eq("name" => "foo", "memory" => "128M")
+      end
+    end
+  end
+end