bosh-workspace 0.8.5 → 0.9.0.rc1

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

@@ -0,0 +1,25 @@
+module Bosh::Workspace
+  module Schemas
+    class Stemcells < Membrane::Schemas::Base
+      def validate(object)
+        Membrane::SchemaParser.parse do
+          [{
+            "name"    => String,
+            "version" => StemcellVersion.new
+          }]
+        end.validate object
+      end
+    end
+
+    class StemcellVersion < Membrane::Schemas::Base
+      def validate(object)
+        return if object.is_a? Integer
+        return if object.is_a? Float
+        return if object == "latest"
+        return if object.to_s =~ /^\d+\.\d+$/
+        raise Membrane::SchemaValidationError.new(
+          "Should match: latest, version.patch or version. Given: #{object}")
+      end
+    end
+  end
+end

data/lib/bosh/workspace/shell.rb

@@ -0,0 +1,67 @@
+module Bosh
+  module Workspace
+    class Shell
+      def initialize(stdout = $stdout)
+        @stdout = stdout
+      end
+
+      def run(command, options = {})
+        output_lines = run_command(command, options)
+        output_lines = tail(output_lines, options)
+
+        command_output = output_lines.join("\n")
+        report(command, command_output, options)
+        command_output
+      end
+
+      private
+
+      attr_reader :stdout
+
+      def run_command(command, options)
+        stdout.puts command if options[:output_command]
+        lines = []
+
+        if options[:env]
+          # Wrap in a shell because existing api to Shell#run takes a string
+          # which makes it really hard to pass it to popen with custom environment.
+          popen_args = [options[:env], ENV['SHELL'] || 'bash', '-c', command]
+        else
+          popen_args = command
+        end
+
+        IO.popen(popen_args) do |io|
+          io.each do |line|
+            stdout.puts line.chomp
+            stdout.flush
+            lines << line.chomp
+          end
+        end
+
+        lines
+      end
+
+      def tail(lines, options)
+        line_number = options[:last_number]
+        line_number ? lines.last(line_number) : lines
+      end
+
+      def report(cmd, command_output, options)
+        return if command_exited_successfully?
+
+        err_msg = "Failed: '#{cmd}' from #{pwd}, with exit status #{$?.to_i}\n\n #{command_output}"
+        options[:ignore_failures] ? stdout.puts("#{err_msg}, continuing anyway") : raise(err_msg)
+      end
+
+      def command_exited_successfully?
+        $?.success?
+      end
+
+      def pwd
+        Dir.pwd
+      rescue Errno::ENOENT
+        'a deleted directory'
+      end
+    end
+  end
+end

data/lib/bosh/workspace/tasks/bosh_command_runner.rb

@@ -0,0 +1,29 @@
+module Bosh::Workspace::Tasks
+  class BoshCommandRunner
+    attr_reader :target, :username, :password
+    attr_accessor :deployment_file
+
+    def initialize(target, username, password)
+      @target = target
+      @username = username
+      @password = password
+      @shell = Bosh::Workspace::Shell.new
+    end      
+
+    def run(command, options = {})
+      options.merge! default_options
+      args = ['-n', '-t', target]
+      args.concat ['-d', deployment_file] if deployment_file
+      @shell.run "bundle exec bosh #{args.join(' ')} #{command}", options
+    end
+
+    private
+
+    def default_options
+      {
+        output_command: true,
+        env: { "BOSH_USER" => username, "BOSH_PASSWORD" => password }
+      }
+    end
+  end
+end

data/lib/bosh/workspace/tasks/deployment.rb

@@ -0,0 +1,63 @@
+module Bosh::Workspace::Tasks
+  class Deployment
+    def initialize(deployment)
+      schema.validate deployment
+      @raw = OpenStruct.new(deployment)
+    end
+
+    def name
+      file = File.join 'deployments', file_name
+      YAML.load_file(file)["name"]
+    end
+
+    def target
+      return @raw.target unless @raw.target =~ /@/
+      @raw.target.split('@')[1]
+    end
+
+    def username
+      return "admin" unless @raw.target =~ /@/
+      @raw.target.match(/^([^@:]+)/)[1] || "admin"
+    end
+
+    def password
+      return "admin" unless @raw.target =~ /@/
+      match = @raw.target.match(/^[^:@]+:([^@]+)/)
+      match && match[1] || "admin"
+    end
+
+    def merged_file
+      File.join ".deployments", file_name
+    end
+
+    def file_name
+      @raw.name + ".yml"
+    end
+
+    def errands
+      @raw.errands
+    end
+
+    def apply_patch
+      @raw.apply_patch
+    end
+
+    def create_patch
+      @raw.create_patch
+    end
+
+    private
+
+    def schema
+      Membrane::SchemaParser.parse do
+        {
+          "name"                   => /^((?!\.yml).)*$/, # Should not contain .yml
+          "target"                 => String,
+          optional("apply_patch")  => String,
+          optional("create_patch") => String,
+          optional("errands")      => [String]
+        }
+      end
+    end
+  end
+end

data/lib/bosh/workspace/tasks/workspace.rake

@@ -0,0 +1,69 @@
+namespace :workspace do
+  include Bosh::Workspace::Tasks
+
+  desc "Apply or create patches as defined in deployments.yml"
+  task :patch do
+    with_deployments do |deployment|
+      if apply_patch_path = deployment.apply_patch
+        bosh "apply deployment patch #{apply_patch_path}"
+      end
+
+      if create_patch_path = deployment.create_patch
+        bosh "create deployment patch #{create_patch_path}"
+      end
+    end
+  end
+
+  desc "Deploy deployments as defined in deployments.yml"
+  task :deploy do
+    with_deployments do
+      bosh "prepare deployment"
+      bosh_deploy
+    end
+  end
+
+  desc "Verifies deployments by running errands specified in deployments.yml"
+  task :run_errands do
+    with_deployments do |deployment|
+      deployment.errands.each do |errand|
+        bosh "run errand #{errand}"
+      end if deployment.errands
+    end    
+  end
+
+  desc "Cleans up by deleting all deployments specified in deployments.yml"
+  task :clean do
+    unless ENV["DESTROY_DEPLOYMENTS"]
+      raise "Set DESTROY_DEPLOYMENTS to confirm deployment destruction"
+    end
+
+    with_deployments(set_deployment: false) do |deployment|
+      bosh "delete deployment #{deployment.name} --force", ignore_failures: true
+    end
+  end
+
+  def with_deployments(options = {})
+    deployments.each do |d|
+      @cli = BoshCommandRunner.new(d.target, d.username, d.password)
+      unless options[:set_deployment] == false
+        @cli.deployment_file = d.merged_file
+      end
+      yield d
+    end
+  end
+
+  def deployments
+    @deployments ||= begin
+      YAML.load_file("deployments.yml").map { |d| Deployment.new(d) }
+    end
+  end
+
+  def bosh_deploy
+    out = bosh("deploy", last_number: 1)
+    exit 1 if out =~ /error/
+  end
+
+  def bosh(command, options = {})
+    @cli.run command, options
+  end
+end

data/lib/bosh/workspace/tasks.rb

@@ -0,0 +1,15 @@
+require "yaml"
+require "membrane"
+
+module Bosh
+  module Workspace
+    module Tasks; end
+  end
+end
+
+require "bosh/workspace/shell"
+require "bosh/workspace/tasks/bosh_command_runner.rb"
+require "bosh/workspace/tasks/deployment.rb"
+
+rake_paths = File.expand_path('tasks/**/*.rake', File.dirname(__FILE__))
+Dir.glob(rake_paths).each { |r| import r  } if defined? import

data/lib/bosh/workspace/version.rb

@@ -1,5 +1,5 @@
 module Bosh
   module Manifests
-    VERSION = "0.8.5"
+    VERSION = "0.9.0.rc1"
   end
 end

data/lib/bosh/workspace.rb

@@ -1,17 +1,31 @@
 module Bosh; module Workspace; end; end
 
+require "membrane"
+require "shellwords"
+require "rugged"
+require "hashdiff"
 require "cli/core_ext"
 require "cli/validation"
 
 require "bosh/workspace/helpers/spiff_helper"
 require "bosh/workspace/helpers/project_deployment_helper"
+require "bosh/workspace/helpers/git_credentials_helper"
 require "bosh/workspace/helpers/release_helper"
 require "bosh/workspace/helpers/stemcell_helper"
 require "bosh/workspace/helpers/dns_helper"
 
+require "bosh/workspace/schemas/project_deployment"
+require "bosh/workspace/schemas/deployment_patch"
+require "bosh/workspace/schemas/releases"
+require "bosh/workspace/schemas/stemcells"
+require "bosh/workspace/schemas/credentials"
+
+require "bosh/workspace/shell"
 require "bosh/workspace/manifest_builder"
 require "bosh/workspace/release"
 require "bosh/workspace/stemcell"
 require "bosh/workspace/project_deployment"
 require "bosh/workspace/stub_file"
+require "bosh/workspace/deployment_patch"
+require "bosh/workspace/credentials"
 require "bosh/workspace/version"

data/spec/commands/deployment_patch_spec.rb

@@ -0,0 +1,152 @@
+require "bosh/cli/commands/deployment_patch"
+
+module Bosh::Cli::Command
+  include Bosh::Workspace
+
+  describe DeploymentPatch do
+    let(:command) { DeploymentPatch.new }
+    let(:patch) do
+      instance_double 'Bosh::Workspace::DeploymentPatch', templates_ref: ref
+    end
+    let(:current_patch) { instance_double 'Bosh::Workspace::DeploymentPatch' }
+    let(:deployment_file) { 'deployments/foo.yml' }
+    let(:patch_file) { 'patch.yml' }
+    let(:project_dir) { File.realpath Dir.mktmpdir }
+    let(:changes?) { nil }
+    let(:valid?) { true }
+    let(:ref) { "baz" }
+    let(:changes) do
+      { stemcells: "foo", releases: "bar", templates_ref: ref }
+    end
+
+    before do
+      Dir.chdir project_dir
+      allow(Bosh::Workspace::DeploymentPatch).to receive(:create)
+        .with(deployment_file, /templates/).and_return(current_patch)
+      allow(Bosh::Workspace::DeploymentPatch).to receive(:from_file)
+        .with(patch_file).and_return(patch)
+      allow(current_patch).to receive(:changes?).with(patch)
+        .and_return(changes?)
+      expect(command).to receive(:require_project_deployment)
+      allow(command).to receive_message_chain("project_deployment.file")
+        .and_return(deployment_file)
+    end
+
+    describe '.create' do
+      it 'writes to file' do
+        expect(current_patch).to receive(:to_file).with(patch_file)
+        expect(command).to receive(:say).with /wrote patch/i
+        command.create(patch_file)
+      end
+    end
+
+    describe '.apply' do
+      let(:patch_valid?) { true }
+
+      before do
+        expect(patch).to receive(:valid?).and_return(patch_valid?)
+      end
+
+      context 'with non valid patch' do
+        let(:patch_valid?) { false }
+
+        it "raises an error" do
+          expect(patch).to receive(:errors).and_return(['foo', 'bar'])
+          expect(command).to receive(:say).with(/validation errors/i)
+          expect(command).to receive(:say).with(/foo/)
+          expect(command).to receive(:say).with(/bar/)
+          expect { command.apply(patch_file) }.to raise_error(/is not valid/)
+        end
+      end
+
+      context 'with changes' do
+        let(:changes?) { true }
+        let(:index) do
+          instance_double('Rugged::Index',
+            read_tree: true, write_tree: true, add_all: true)
+        end
+        let(:repo) { instance_double 'Rugged::Repository', index: index }
+
+        def expect_patch_changes_table
+          expect(command).to receive(:say) do |s|
+            subject = s.to_s.delete ' '
+            expect(subject).to include "stemcells|foo"
+            expect(subject).to include "releases|bar"
+          end
+        end
+
+        before do
+          allow(repo).to receive_message_chain('head.target.tree')
+          expect(current_patch).to receive(:changes).with(patch)
+            .and_return(changes)
+        end
+
+        context 'no dry-run' do
+          before do
+            allow(command).to receive(:fetch_repo).with(/templates/)
+            expect(patch).to receive(:apply).with(deployment_file, /templates/)
+            expect(command).to receive(:say).with /successfully applied/i
+            expect_patch_changes_table
+          end
+
+          context 'without no-commit' do
+            before do
+              expect(Rugged::Repository).to receive(:new)
+                .with(project_dir).and_return(repo)
+            end
+
+            def expect_commit(message)
+              expect(Rugged::Commit).to receive(:create) do |repo, options|
+                expect(options[:message]).to match message
+              end
+            end
+
+            it 'applies changes, shows changes and commits' do
+              expect_commit "Applied stemcells foo," \
+                            " releases bar, templates_ref baz"
+              command.apply(patch_file)
+            end
+
+            context 'without templates_ref' do
+              let(:ref) { nil }
+              let(:changes) do
+                { stemcells: "foo", releases: "bar" }
+              end
+
+              it 'applies changes, shows changes and commits' do
+                expect_commit("Applied stemcells foo, releases bar")
+                expect(command).to_not receive(:fetch_repo)
+                command.apply(patch_file)
+              end
+            end
+          end
+
+          context 'no-commit' do
+            it 'applies changes and shows changes' do
+              command.add_option(:no_commit, true)
+              command.apply(patch_file)
+            end
+          end
+        end
+
+        context 'dry-run' do
+          it 'only shows changes' do
+            expect(command).to receive(:say).with /deployment patch/i
+            expect_patch_changes_table
+            command.add_option(:dry_run, true)
+            command.apply(patch_file)
+          end
+        end
+      end
+
+      context 'without changes' do
+        let(:changes?) { false }
+
+        it 'says no changes' do
+          expect(command).to receive(:say).with /no changes/i
+          command.apply(patch_file)
+        end
+      end
+    end
+  end
+end

data/spec/commands/prepare_spec.rb

@@ -5,7 +5,7 @@ describe Bosh::Cli::Command::Prepare do
     let(:command) { Bosh::Cli::Command::Prepare.new }
     let(:release) do
       instance_double("Bosh::Workspace::Release",
-        name: "foo", version: "1", repo_dir: ".releases/foo",
+        name: "foo", version: "1", repo_dir: ".releases/foo", git_url: "/.git",
         name_version: "foo/1", manifest_file: "releases/foo-1.yml")
     end
     let(:stemcell) do
@@ -24,7 +24,7 @@ describe Bosh::Cli::Command::Prepare do
     end
 
     describe "prepare_release(s/_repos)" do
-      let(:releases) { [ release ] }
+      let(:releases) { [release] }
       let(:stemcells) { [] }
       let(:ref) { nil }
 
@@ -33,6 +33,8 @@ describe Bosh::Cli::Command::Prepare do
         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)
       end
 
       context "release uploaded" do
@@ -80,7 +82,7 @@ describe Bosh::Cli::Command::Prepare do
       context "stemcell not uploaded" do
         let(:stemcell_uploaded) { false }
 
-        before do 
+        before do
           allow(stemcell).to receive(:downloaded?)
             .and_return(stemcell_downloaded)
         end

data/spec/credentials_spec.rb

@@ -0,0 +1,46 @@
+module Bosh::Workspace
+  describe Credentials do
+    let(:credentials) do
+      [{ "url" => "foo", "private_key" => "foobarkey" }]
+    end
+
+    before do
+      expect(YAML).to receive(:load_file).with(:file).and_return(credentials)
+    end
+
+    subject do
+      Credentials.new(:file)
+    end
+
+    describe '#find_by_url' do
+      it "returns credentials when found multiple times" do
+        expect(subject.find_by_url("foo")).to eq({ private_key: "foobarkey" })
+        expect(subject.find_by_url("foo")).to eq({ private_key: "foobarkey" })
+      end
+
+      it "returns nil when not found" do
+        expect(subject.find_by_url("bar")).to be nil
+      end
+    end
+
+    describe '#perform_validation' do
+      context "valid" do
+        it "validates" do
+          allow_any_instance_of(Schemas::Credentials)
+            .to receive(:validate).with(credentials)
+          expect(subject).to be_valid
+        end
+      end
+
+      context "invalid" do
+        it "has errors" do
+          allow_any_instance_of(Schemas::Credentials)
+            .to receive(:validate).with(credentials)
+            .and_raise(Membrane::SchemaValidationError.new("foo"))
+          expect(subject).to_not be_valid
+          expect(subject.errors).to include "foo"
+        end
+      end
+    end
+  end
+end