bosh-workspace 0.9.2 → 0.9.3

data/lib/bosh/workspace/project_deployment.rb

@@ -6,18 +6,17 @@ module Bosh::Workspace
 
     def initialize(file)
       @file = file
-      err("Deployment file does not exist: #{file}") unless File.exist? @file
-      @manifest = Psych.load(ERB.new(File.read(@file)).result)
+      err("Deployment file does not exist: #{file}") unless File.exist?(@file)
     end
 
     def perform_validation(options = {})
-      Schemas::ProjectDeployment.new.validate @manifest
+      Schemas::ProjectDeployment.new.validate manifest
     rescue Membrane::SchemaValidationError => e
       errors << e.message
     end
 
     def director_uuid
-      @director_uuid || @manifest["director_uuid"]
+      @director_uuid || manifest["director_uuid"]
     end
 
     def merged_file
@@ -28,9 +27,25 @@ module Bosh::Workspace
       end
     end
 
+    def merge_tool
+      Bosh::Workspace::MergeTool.new(manifest['merge_tool'])
+    end
+
+    def manifest
+      return @manifest unless @manifest.nil?
+      renderer = Bosh::Template::Renderer.new(context: stub.to_json)
+      @manifest = Psych.load(renderer.render(file))
+    end
+
+    def stub
+      return @stub unless @stub.nil?
+      stub_file = File.expand_path(File.join(file_dirname, "../stubs", file_basename))
+      @stub = File.exist?(stub_file) ? Psych.load(File.read(stub_file)) : {}
+    end
+
     %w[name templates releases stemcells meta domain_name].each do |var|
       define_method var do
-        @manifest[var]
+        manifest[var]
       end
     end
 

data/lib/bosh/workspace/release.rb

@@ -1,35 +1,25 @@
 module Bosh::Workspace
   class Release
+    REFSPEC = ['HEAD:refs/remotes/origin/HEAD']
     attr_reader :name, :git_url, :repo_dir
 
-    def initialize(release, releases_dir)
-      @name         = release["name"]
-      @ref          = release["ref"]
-      @path         = release["path"]
-      @spec_version = release["version"].to_s
-      @git_url      = release["git"]
-      @repo_dir     = File.join(releases_dir, @name)
-      @url          = release["url"]
+    def initialize(release, releases_dir, credentials_callback, options = {})
+      @name                 = release["name"]
+      @ref                  = release["ref"]
+      @path                 = release["path"]
+      @spec_version         = release["version"].to_s
+      @git_url              = release["git"]
+      @repo_dir             = File.join(releases_dir, @name)
+      @url                  = release["url"]
+      @credentials_callback = credentials_callback
+      @offline              = options[:offline]
     end
 
-    def update_repo
+    def update_repo(options = {})
+      fetch_repo
       hash = ref || release[:commit]
       update_repo_with_ref(repo, hash)
-    end
-
-    def update_submodule(submodule)
-      update_repo_with_ref(submodule.repository, submodule.head_oid)
-    end
-
-    def required_submodules
-      required = []
-      symlink_templates.each do |template|
-        submodule = submodule_for(template)
-        if submodule
-          required.push(submodule)
-        end
-      end
-      required
+      update_submodules
     end
 
     def manifest_file
@@ -62,8 +52,55 @@ module Bosh::Workspace
 
     private
 
+    def update_submodules
+      required_submodules.each do |submodule|
+        fetch_repo(submodule_repo(submodule.path, submodule.url))
+        update_repo_with_ref(submodule.repository, submodule.head_oid)
+      end
+    end
+
+    def required_submodules
+      symlink_templates.map { |t| submodule_for(t) }.compact
+    end
+
+    def repo_path(path)
+      File.join(@repo_dir, path)
+    end
+
+    def submodule_repo(path, url)
+      dir = repo_path(path)
+      repo_exists?(dir) ? open_repo(dir) : init_repo(dir, url)
+    end
+
     def repo
-      @repo ||= Rugged::Repository.new(repo_dir)
+      repo_exists? ? open_repo : init_repo
+    end
+
+    def fetch_repo(repo = repo)
+      return if offline?
+      repo.fetch('origin', REFSPEC, credentials: @credentials_callback)
+      commit = repo.references['refs/remotes/origin/HEAD'].resolve.target_id
+      update_repo_with_ref(repo, commit)
+    end
+
+    def repo_exists?(dir = @repo_dir)
+      File.exist?(File.join(dir, '.git'))
+    end
+
+    def open_repo(dir = @repo_dir)
+      Rugged::Repository.new(dir)
+    end
+
+    def init_repo(dir = @repo_dir, url = @git_url)
+      offline_err(url) if offline?
+      FileUtils.mkdir_p File.dirname(dir)
+      Rugged::Repository.init_at(dir).tap do |repo|
+        repo.remotes.create('origin', url)
+      end
+    end
+
+    def offline_err(url)
+      err "Cloning repo: '#{url}' not allowed in offline mode"
     end
 
     def update_repo_with_ref(repository, ref)
@@ -93,68 +130,67 @@ module Bosh::Workspace
         final_releases = []
         releases_tree.walk_blobs(:preorder) do |_, entry|
           next if entry[:filemode] == 40960 # Skip symlinks
-          path = File.join(releases_dir, entry[:name])
-          blame = Rugged::Blame.new(repo, path).reduce { |memo, hunk|
-            if memo.nil? || hunk[:final_signature][:time] > memo[:final_signature][:time]
-              hunk
-            else
-              memo
-            end
+          next unless version = entry[:name][/#{@name}-(.+)\.yml/, 1]
+          blame = repo_blame(File.join(releases_dir, entry[:name]))
+          final_releases << {
+            version: version,
+            manifest: blame[:orig_path],
+            commit: blame[:final_commit_id]
           }
-          commit_id = blame[:final_commit_id]
-          manifest = blame[:orig_path]
-          version = entry[:name][/#{@name}-(.+)\.yml/, 1]
-          if ! version.nil?
-            final_releases.push({
-              version: version, manifest: manifest, commit: commit_id
-            })
-          end
         end
-
         final_releases.sort! { |a, b| a[:version].to_i <=> b[:version].to_i }
       end
     end
 
+    def repo_blame(path)
+      Rugged::Blame.new(repo, path).reduce do |m, h|
+        return h unless m
+        return h if h[:final_signature][:time] > m[:final_signature][:time]
+        return m
+      end
+    end
+
     def release
-      return final_releases.last if @spec_version == "latest"
-      release = final_releases.find { |v| v[:version] == @spec_version }
-      unless release
-        err("Could not find version: #{@spec_version} for release: #{@name}")
+      latest_offline_warning if latest? && offline?
+      return final_releases.last if latest?
+      final_releases.find { |v| v[:version] == @spec_version }.tap do |release|
+        missing_release_err(@spec_version, @name) unless release
       end
-      release
+    end
+
+    def missing_release_err(version, name)
+      err "Could not find version: #{version} for release: #{name}"
+    end
+
+    def latest_offline_warning
+      warning "Using 'latest' local version since in offline mode"
     end
 
     def templates_dir
-      File.join(repo.workdir, "templates")
+      repo_path 'templates'
     end
 
     def symlink_target(file)
-      if File.readlink(file).start_with?("/")
-        return File.readlink(file)
-      else
-        return File.expand_path(File.join(File.dirname(file), File.readlink(file)))
-      end
+      return File.readlink(file) if File.readlink(file).start_with?("/")
+      File.expand_path(File.join(File.dirname(file), File.readlink(file)))
     end
 
     def submodule_for(file)
-      repo.submodules.each do |submodule|
-        if file.start_with?(File.join(repo.workdir, submodule.path))
-          return submodule
-        end
-      end
-      false
+      repo.submodules.find { |s| file.start_with? repo_path(s.path) }
     end
 
     def symlink_templates
-      templates = []
-      if FileTest.exists?(templates_dir)
-        Find.find(templates_dir) do |file|
-          if FileTest.symlink?(file)
-            templates.push(symlink_target(file))
-          end
-        end
-      end
-      templates
+      return [] unless File.exist?(templates_dir)
+      Find.find(templates_dir)
+        .select { |f| File.symlink?(f) }.map { |f| symlink_target(f) }
+    end
+
+    def offline?
+      @offline
+    end
+
+    def latest?
+      @spec_version == "latest"
     end
   end
 end

data/lib/bosh/workspace/schemas/credentials.rb

@@ -1,10 +1,32 @@
 module Bosh::Workspace
   module Schemas
     class Credentials < Membrane::Schemas::Base
+      include Bosh::Workspace::GitProtocolHelper
+
       def validate(object)
         Membrane::SchemaParser.parse do
           [enum(UsernamePassword.new, SshKey.new)]
         end.validate object
+        validate_protocol_credentials_combination(object)
+      end
+
+      def validate_protocol_credentials_combination(object)
+        object.each do |creds|
+          case git_protocol_from_url(creds['url'])
+          when :https, :http
+            next if creds.keys.include? 'username'
+            validation_err "Provide username/password for: #{creds['url']}"
+          when :ssh
+            next if creds.keys.include? 'private_key'
+            validation_err "Provide private_key for: #{creds['url']}"
+          else
+            validation_err "Credentials not supported for: #{creds['url']}"
+          end
+        end
+      end
+
+      def validation_err(message)
+        raise Membrane::SchemaValidationError.new(message)
       end
 
       class UsernamePassword < Membrane::Schemas::Base

data/lib/bosh/workspace/schemas/project_deployment.rb

@@ -12,10 +12,23 @@ module Bosh::Workspace
             "releases"              => Releases.new,
             "stemcells"             => Stemcells.new,
             "templates"             => [String],
-            "meta"                  => Hash
+            "meta"                  => Hash,
+            optional("merge_tool")  => MergeTool.new
           }
         end.validate object
       end
+
+      class MergeTool < Membrane::Schemas::Base
+        def validate(object)
+          return if object.is_a? String
+          return if object.is_a? Hash &&
+                    (%w(name version) & object.keys).size == 2 &&
+                    object['version'] =~ /^\d+(\.\d+){1,2}|current$/
+          raise Membrane::SchemaValidationError.new(
+            "Should match: String, object.name and object.version. Given: #{object}")
+        end
+      end
+
     end
   end
 end

data/lib/bosh/workspace/version.rb

@@ -1,5 +1,5 @@
 module Bosh
   module Manifests
-    VERSION = "0.9.2"
+    VERSION = "0.9.3"
   end
 end

data/spec/assets/manifests-repo/deployments/foo.yml

@@ -3,3 +3,4 @@ name: foo
 templates:
   - foo/bar.yml
 meta: {}
+stub_value: <%= p('stub.value') %>

data/spec/assets/manifests-repo/stubs/foo.yml

@@ -0,0 +1,4 @@
+---
+properties:
+  stub:
+    value: value

data/spec/commands/prepare_spec.rb

@@ -3,10 +3,11 @@ require "bosh/cli/commands/prepare"
 describe Bosh::Cli::Command::Prepare do
   describe "#prepare" do
     let(:command) { Bosh::Cli::Command::Prepare.new }
+    let(:url) { nil }
     let(:release) do
       instance_double("Bosh::Workspace::Release",
         name: "foo", version: "1", repo_dir: ".releases/foo", git_url: "/.git",
-        release_dir: '.releases/foo/sub', name_version: "foo/1", url: nil,
+        release_dir: '.releases/foo/sub', name_version: "foo/1", url: url,
         manifest_file: "releases/foo-1.yml")
     end
     let(:stemcell) do
@@ -30,18 +31,24 @@ describe Bosh::Cli::Command::Prepare do
       let(:stemcells) { [] }
       let(:ref) { nil }
 
+      context "when only performing local operations" do
+        before { command.add_option(:local, true) }
+        let(:releases) { [] }
+
+        it "enables offline mode" do
+          expect(command).to receive(:offline!)
+          command.prepare
+        end
+      end
+
       context "release with git " do
         before do
-          allow(release).to receive(:required_submodules).and_return(subrepos)
-
           expect(release).to receive(:update_repo)
-          expect(release).to_not receive(:update_submodule)
           expect(release).to receive(:ref).and_return(ref)
           expect(command).to receive(:release_uploaded?)
-          .with(release.name, release.version).and_return(release_uploaded)
-          expect(command).to receive(:fetch_or_clone_repo)
-          .with(release.repo_dir, release.git_url)
+            .with(release.name, release.version).and_return(release_uploaded)
         end
+
         context "release uploaded" do
           let(:release_uploaded) { true }
 
@@ -64,14 +71,25 @@ describe Bosh::Cli::Command::Prepare do
             end
           end
         end
+
+        context "release not uploaded with url" do
+          let(:release_uploaded) { false }
+          let(:url) { "bosh.io/foo/bar.tgz" }
+
+          it "does uploads a remote release" do
+            expect(command).to receive(:release_upload_from_url)
+              .with(release.url)
+            command.prepare
+          end
+        end
       end
 
       context "if the release git_url is not given" do
         let(:release_uploaded) { false }
         let(:release) do
           instance_double("Bosh::Workspace::Release",
-                          name: "foo", version: "1", repo_dir: ".releases/foo", git_url: nil,
-                          name_version: "foo/1", manifest_file: "releases/foo-1.yml")
+            name: "foo", version: "1", repo_dir: ".releases/foo", git_url: nil,
+            name_version: "foo/1", manifest_file: "releases/foo-1.yml")
         end
 
         it "notifies the user that the git property must be specified" do
@@ -110,21 +128,30 @@ describe Bosh::Cli::Command::Prepare do
         context "stemcell downloaded" do
           let(:stemcell_downloaded) { true }
 
-          it "does not upload the stemcell" do
+          it "uploads the already downloaded stemcell" do
             expect(command).to_not receive(:stemcell_download)
             expect(command).to receive(:stemcell_upload).with(stemcell.file)
             command.prepare
           end
         end
 
-        context "stemcell downloaded" do
+        context "when stemcell not downloaded" do
           let(:stemcell_downloaded) { false }
 
-          it "does not upload the stemcell" do
+          it "downloads and uploads the stemcell" do
             expect(command).to receive(:stemcell_download).with(stemcell.file_name)
             expect(command).to receive(:stemcell_upload).with(stemcell.file)
             command.prepare
           end
+
+          context "while being offline" do
+            before { command.offline! }
+
+            it "raises an error" do
+              expect(command).to_not receive(:stemcell_download)
+              expect{command.prepare}.to raise_error /not available offline/
+            end
+          end
         end
       end
     end