cloulu 0.2.6 → 0.3.0

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

@@ -0,0 +1,317 @@
+require "yaml"
+require "set"
+
+require "manifests-vmc-plugin/loader"
+
+
+module VMCManifests
+  MANIFEST_FILE = "manifest.yml"
+
+  @@showed_manifest_usage = false
+
+  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)
+    fail "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 @manifest_file if @manifest_file
+
+    unless path = input[:manifest]
+      where = Dir.pwd
+      while true
+        if File.exists?(File.join(where, MANIFEST_FILE))
+          path = File.join(where, MANIFEST_FILE)
+          break
+        elsif File.basename(where) == "/"
+          path = nil
+          break
+        else
+          where = File.expand_path("../", where)
+        end
+      end
+    end
+
+    return unless path
+
+    @manifest_file = File.expand_path(path)
+  end
+
+  # load and resolve a given manifest file
+  def load_manifest(file)
+    Loader.new(file, self).manifest
+  end
+
+  # dynamic symbol resolution
+  def resolve_symbol(sym)
+    case sym
+    when "target-url"
+      client_target
+
+    when "target-base"
+      target_base
+
+    when "random-word"
+      sprintf("%04x", rand(0x0100000))
+
+    when /^ask (.+)/
+      ask($1)
+    end
+  end
+
+  # find apps by an identifier, which may be either a tag, a name, or a path
+  def find_apps(identifier)
+    return [] unless manifest
+
+    apps = apps_by(:name, identifier)
+
+    if apps.empty?
+      apps = apps_by(:path, from_manifest(identifier))
+    end
+
+    apps
+  end
+
+  # return all the apps described by the manifest
+  def all_apps
+    manifest[:applications]
+  end
+
+  def current_apps
+    manifest[:applications].select do |app|
+      next unless app[:path]
+      from_manifest(app[:path]) == Dir.pwd
+    end
+  end
+
+  # splits the user's input, resolving paths with the manifest,
+  # into internal/external apps
+  #
+  # internal apps are returned as their data in the manifest
+  #
+  # external apps are the strings that the user gave, to be
+  # passed along wholesale to the wrapped command
+  def apps_in_manifest(input = nil, use_name = true, &blk)
+    names_or_paths =
+      if input.has?(:apps)
+        # names may be given but be [], which will still cause
+        # interaction, so use #direct instead of #[] here
+        input.direct(:apps)
+      elsif input.has?(:app)
+        [input.direct(:app)]
+      elsif input.has?(:name)
+        [input.direct(:name)]
+      else
+        []
+      end
+
+    internal = []
+    external = []
+
+    names_or_paths.each do |x|
+      if x.is_a?(String)
+        if x =~ %r([/\\])
+          apps = find_apps(File.expand_path(x))
+
+          if apps.empty?
+            fail("Path #{b(x)} is not present in manifest #{b(relative_manifest_file)}.")
+          end
+        else
+          apps = find_apps(x)
+        end
+
+        if !apps.empty?
+          internal += apps
+        else
+          external << x
+        end
+      else
+        external << x
+      end
+    end
+
+    [internal, external]
+  end
+
+  def create_manifest_for(app, path)
+    meta = {
+      "name" => app.name,
+      "framework" => app.framework.name,
+      "runtime" => app.runtime.name,
+      "memory" => human_size(app.memory * 1024 * 1024, 0),
+      "instances" => app.total_instances,
+      "url" => app.url ? app.url.sub(target_base, '${target-base}') : "none",
+      "path" => path
+    }
+
+    services = app.services
+
+    unless services.empty?
+      meta["services"] = {}
+
+      services.each do |i|
+        if v2?
+          p = i.service_plan
+          s = p.service
+
+          meta["services"][i.name] = {
+            "label" => s.label,
+            "provider" => s.provider,
+            "version" => s.version,
+            "plan" => p.name
+          }
+        else
+          meta["services"][i.name] = {
+            "vendor" => i.vendor,
+            "version" => i.version,
+            "tier" => i.tier
+          }
+        end
+      end
+    end
+
+    if cmd = app.command
+      meta["command"] = cmd
+    end
+
+    if buildpack = app.buildpack
+      meta["buildpack"] = buildpack
+    end
+
+    meta
+  end
+
+  private
+
+  def relative_manifest_file
+    Pathname.new(manifest_file).relative_path_from(Pathname.pwd)
+  end
+
+  def show_manifest_usage
+    return if @@showed_manifest_usage
+
+    path = relative_manifest_file
+    line "Using manifest file #{c(path, :name)}"
+    line
+
+    @@showed_manifest_usage = true
+  end
+
+  def no_apps
+    fail "No applications or manifest to operate on."
+  end
+
+  def warn_reset_changes
+    line c("Not applying manifest changes without --reset", :warning)
+    line "See `vmc diff` for more details."
+    line
+  end
+
+  def apps_by(attr, val)
+    manifest[:applications].select do |info|
+      info[attr] == val
+    end
+  end
+
+  # expand a path relative to the manifest file's directory
+  def from_manifest(path)
+    File.expand_path(path, File.dirname(manifest_file))
+  end
+
+
+  def ask_to_save(input, app)
+    return if manifest_file
+    return unless ask("Save configuration?", :default => false)
+
+    manifest = create_manifest_for(app, input[:path])
+
+    with_progress("Saving to #{c("manifest.yml", :name)}") do
+      File.open("manifest.yml", "w") do |io|
+        YAML.dump(
+          { "applications" => [manifest] },
+          io)
+      end
+    end
+  end
+
+  def env_hash(val)
+    if val.is_a?(Hash)
+      val
+    else
+      hash = {}
+
+      val.each do |pair|
+        name, val = pair.split("=", 2)
+        hash[name] = val
+      end
+
+      hash
+    end
+  end
+
+  def setup_env(app, info)
+    return unless info[:env]
+    app.env = env_hash(info[:env])
+  end
+
+  def setup_services(app, info)
+    return if !info[:services] || info[:services].empty?
+
+    offerings = client.services
+
+    to_bind = []
+
+    info[:services].each do |name, svc|
+      name = name.to_s
+
+      if instance = client.service_instance_by_name(name)
+        to_bind << instance
+      else
+        offering = offerings.find { |o|
+          o.label == (svc[:label] || svc[:type] || svc[:vendor]) &&
+            (!svc[:version] || o.version == svc[:version]) &&
+            (o.provider == (svc[:provider] || "core"))
+        }
+
+        fail "Unknown service offering: #{svc.inspect}." unless offering
+
+        if v2?
+          plan = offering.service_plans.find { |p|
+            p.name == (svc[:plan] || "D100")
+          }
+
+          fail "Unknown service plan: #{svc[:plan]}." unless plan
+        end
+
+        invoke :create_service,
+          :name => name,
+          :offering => offering,
+          :plan => plan,
+          :app => app
+      end
+    end
+
+    to_bind.each do |s|
+      next if app.binds?(s)
+
+      # TODO: splat
+      invoke :bind_service, :app => app, :service => s
+    end
+  end
+
+  def target_base
+    client_target.sub(/^[^\.]+\./, "")
+  end
+end

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+require "manifests-vmc-plugin/errors"
+
+
+describe VMCManifests::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/lib/manifests-vmc-plugin/spec/manifests-vmc-plugin/loader/builder_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+require "manifests-vmc-plugin/loader"
+require "manifests-vmc-plugin/errors"
+
+
+describe VMCManifests::Builder do
+  subject { VMCManifests::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(VMCManifests::InvalidManifest)
+      end
+    end
+  end
+end

data/lib/manifests-vmc-plugin/spec/manifests-vmc-plugin/loader/normalizer_spec.rb

@@ -0,0 +1,176 @@
+require "spec_helper"
+
+require "manifests-vmc-plugin/loader"
+
+
+describe VMCManifests::Normalizer do
+  let(:manifest) { {} }
+  let(:loader) { VMCManifests::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