mamiya 0.0.1.alpha24 → 0.0.1.beta1

data/spec/agent/tasks/notifyable_spec.rb

@@ -12,7 +12,7 @@ describe Mamiya::Agent::Tasks::Notifyable do
 
   describe "#execute" do
     it "notifies first, then :run" do
-      expect(agent).to receive(:trigger).with('task', action: 'start', task: job).ordered
+      expect(agent).to receive(:trigger).with('task', action: 'start', task: job, coalesce: false).ordered
       expect(task).to receive(:before).ordered
       expect(task).to receive(:run).ordered
       task.execute
@@ -21,12 +21,12 @@ describe Mamiya::Agent::Tasks::Notifyable do
     it "calls after, then notify" do
       expect(task).to receive(:run).ordered
       expect(task).to receive(:after).ordered
-      expect(agent).to receive(:trigger).with('task', action: 'finish', task: job).ordered
+      expect(agent).to receive(:trigger).with('task', action: 'finish', task: job, coalesce: false).ordered
       task.execute
     end
 
     it "handles error" do
-      expect(agent).to receive(:trigger).with('task', action: 'error', task: job, error: RuntimeError.name)
+      expect(agent).to receive(:trigger).with('task', action: 'error', task: job, error: RuntimeError.name, coalesce: false)
       err = RuntimeError.new
       allow(task).to receive(:run).and_raise(err)
       task.execute

data/spec/agent/tasks/switch_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+require 'tmpdir'
+require 'pathname'
+
+require 'mamiya/agent/tasks/switch'
+
+require 'mamiya/steps/switch'
+
+describe Mamiya::Agent::Tasks::Switch do
+  let!(:tmpdir) { Pathname.new Dir.mktmpdir("mamiya-agent-tasks-switch-spec") }
+  after { FileUtils.remove_entry_secure tmpdir }
+
+  let(:deploy_to) { tmpdir.join('deploy_to').tap(&:mkpath) }
+  let(:packages_dir) { tmpdir.join('packages').tap(&:mkpath) }
+  let(:packages_app_dir) { tmpdir.join('packages', 'myapp').tap(&:mkpath) }
+  let(:prereleases_dir) { tmpdir.join('prereleases').tap(&:mkpath) }
+  let(:prereleases_app_dir) { tmpdir.join('prereleases', 'myapp').tap(&:mkpath) }
+
+
+  let(:config) do
+    _pkg, _pre, _dto = packages_dir, prereleases_dir, deploy_to
+    Mamiya::Configuration.new.evaluate! do
+      set :packages_dir, _pkg
+      set :prereleases_dir, _pre
+      applications[:myapp] = {deploy_to: _dto}
+    end
+  end
+
+  let(:agent) { double('agent', config: config, trigger: nil, labels: [:foo, :bar]) }
+  let(:task_queue) { double('task_queue', enqueue: nil) }
+
+  let(:switch_step) { double('switch step', run!: nil) }
+
+  let(:job) { {'app' => 'myapp', 'pkg' => 'mypkg'} }
+
+  subject(:task) { described_class.new(task_queue, job, agent: agent, raise_error: true) }
+
+  it 'inherits notifyable task' do
+    expect(described_class.ancestors).to include(Mamiya::Agent::Tasks::Notifyable)
+  end
+
+  describe "#execute" do
+    context "when package not fetched and not prepared" do
+      before do
+        expect(Mamiya::Steps::Switch).not_to receive(:new)
+      end
+
+      it "enqueues fetch task and finish" do
+        expect(task_queue).to receive(:enqueue).with(
+          :fetch, job.merge('task' => 'switch', '_chain' => ['prepare', 'switch'])
+        )
+
+        task.execute
+      end
+
+      context "with _chain-ed job" do
+        let(:job) { {'app' => 'myapp', 'pkg' => 'mypkg', '_chain' => ['next']} }
+
+        it "enqueues prepare task and finish" do
+          expect(task_queue).to receive(:enqueue).with(
+            :fetch, job.merge('task' => 'switch', '_chain' => ['prepare', 'switch', 'next'])
+          )
+
+          task.execute
+        end
+      end
+    end
+
+    context "when package fetched but not prepared" do
+      before do
+        File.write packages_app_dir.join('mypkg.tar.gz'), "\n"
+        File.write packages_app_dir.join('mypkg.json'), "{}\n"
+        expect(Mamiya::Steps::Switch).not_to receive(:new)
+      end
+
+      it "enqueues prepare task and finish" do
+        expect(task_queue).to receive(:enqueue).with(
+          :prepare, job.merge('task' => 'switch', '_chain' => ['switch'])
+        )
+
+        task.execute
+      end
+
+      context "with _chain-ed job" do
+        let(:job) { {'app' => 'myapp', 'pkg' => 'mypkg', '_chain' => ['next']} }
+
+        it "enqueues prepare task and finish" do
+          expect(task_queue).to receive(:enqueue).with(
+            :prepare, job.merge('task' => 'switch', '_chain' => ['switch', 'next'])
+          )
+
+          task.execute
+        end
+      end
+    end
+
+    context "when package prepared" do
+      before do
+        File.write packages_app_dir.join('mypkg.tar.gz'), "\n"
+        File.write packages_app_dir.join('mypkg.json'), "{}\n"
+
+        prerelease = prereleases_app_dir.join('mypkg').tap(&:mkpath)
+        File.write prerelease.join('hello'), "hola\n"
+        File.write prerelease.join('.mamiya.prepared'), "#{Time.now.to_i}\n"
+
+        allow(Mamiya::Steps::Switch).to receive(:new).with(
+          target: deploy_to.join('releases', 'mypkg'),
+          labels: [:foo, :bar],
+          no_release: false,
+          config: config,
+          logger: task.logger,
+        ).and_return(switch_step)
+      end
+
+      it "copies prerelease to releases_dir" do
+        expect {
+          task.execute
+        }.to change {
+          deploy_to.join('releases', 'mypkg', 'hello').exist? &&
+          deploy_to.join('releases', 'mypkg', 'hello').read
+        }.from(false).to "hola\n"
+      end
+
+      it "calls switch step" do
+        expect(switch_step).to receive(:run!) do
+          expect(deploy_to.join('releases', 'mypkg', 'hello')).to be_exist
+        end
+        task.execute
+      end
+
+      context "when prepared release exists in releases_dir" do
+        before do
+          release = deploy_to.join('releases', 'mypkg').tap(&:mkpath)
+          File.write release.join('hehe'), ":)\n"
+          File.write release.join('.mamiya.prepared'), "#{Time.now.to_i}\n"
+        end
+
+        it "re-uses existing release" do
+          task.execute
+          expect(deploy_to.join('releases', 'mypkg', 'hehe').read).to eq ":)\n"
+        end
+      end
+
+      context "when non-prepared release exists in releases_dir" do
+        before do
+          release = deploy_to.join('releases', 'mypkg').tap(&:mkpath)
+          File.write release.join('hehe'), ":)\n"
+        end
+
+        it "re-uses existing release" do
+          task.execute
+          expect(deploy_to.join('releases', 'mypkg', 'hehe')).not_to be_exist
+          expect(deploy_to.join('releases', 'mypkg', 'hello')).to be_exist
+        end
+      end
+
+      context "with no_release" do
+        let(:job) { {'app' => 'myapp', 'pkg' => 'mypkg', 'no_release' => true} }
+
+        it "calls switch step with no_release" do
+          expect(Mamiya::Steps::Switch).to receive(:new).with(
+            target: deploy_to.join('releases', 'mypkg'),
+            labels: [:foo, :bar],
+            no_release: true,
+            config: config,
+            logger: task.logger,
+          ).and_return(switch_step)
+
+          expect(switch_step).to receive(:run!)
+
+          task.execute
+        end
+      end
+    end
+  end
+end

data/spec/agent_spec.rb

@@ -92,8 +92,13 @@ describe Mamiya::Agent do
     before do
       allow(agent).to receive(:existing_packages).and_return("app" => ["pkg"])
       allow(agent).to receive(:existing_prereleases).and_return("app" => ["pkg"])
+
+      allow(agent).to receive(:releases).and_return("app" => ["pkg"])
+      allow(agent).to receive(:currents).and_return("app" => "pkg")
+
       allow(agent).to receive(:labels).and_return([:foo,:bar])
 
+
       allow(task_queue).to receive(:status).and_return({a: {working: nil, queue: []}})
     end
 
@@ -119,6 +124,14 @@ describe Mamiya::Agent do
       expect(status[:prereleases]).to eq agent.existing_prereleases
     end
 
+    it "includes releases" do
+      expect(status[:releases]).to eq agent.releases
+    end
+
+    it "includes currents" do
+      expect(status[:currents]).to eq agent.currents
+    end
+
     it "includes status" do
       expect(status[:labels]).to eq agent.labels
     end
@@ -130,9 +143,17 @@ describe Mamiya::Agent do
         expect(status.has_key?(:packages)).to be_false
       end
 
-      it "doesn't include existing packages" do
+      it "doesn't include existing prereleases" do
         expect(status.has_key?(:prereleases)).to be_false
       end
+
+      it "doesn't include existing releases" do
+        expect(status.has_key?(:releases)).to be_false
+      end
+
+      it "doesn't include existing currents" do
+        expect(status.has_key?(:currents)).to be_false
+      end
     end
 
     describe "(task queue)" do
@@ -192,6 +213,118 @@ describe Mamiya::Agent do
     end
   end
 
+  describe "#releases" do
+    let!(:tmpdir) { Pathname.new Dir.mktmpdir('mamiya-agent-spec') }
+    after { FileUtils.remove_entry_secure(tmpdir) }
+
+    let(:deploy_to_a) { tmpdir.join('a').tap(&:mkdir) }
+    let(:deploy_to_b) { tmpdir.join('b').tap(&:mkdir) }
+
+    # To test unexist directory (should return empty element)
+    let(:deploy_to_c) { tmpdir.join('c') }
+
+    let(:config) do
+      _a, _b, _c = deploy_to_a, deploy_to_b, deploy_to_c
+      Mamiya::Configuration.new.evaluate! do
+        set :applications, {
+          a: {deploy_to: _a.to_s},
+          b: {deploy_to: _b.to_s},
+          c: {deploy_to: _c.to_s},
+        }
+      end
+    end
+
+    before do
+      deploy_to_a.join('releases').tap do |releases|
+        releases.mkdir
+
+        releases.join('1').mkdir
+        releases.join('2').mkdir
+      end
+
+      deploy_to_b.join('releases').tap do |releases|
+        releases.mkdir
+
+        releases.join('3').mkdir
+        releases.join('4').mkdir
+        releases.join('5').mkdir
+      end
+    end
+
+    subject(:releases) { agent.releases }
+
+    it "returns releases" do
+      expect(releases).to eq(
+        a: ['1','2'],
+        b: ['3','4','5'],
+        c: [],
+      )
+    end
+  end
+
+  describe "#currents" do
+    let!(:tmpdir) { Pathname.new Dir.mktmpdir('mamiya-agent-spec') }
+    after { FileUtils.remove_entry_secure(tmpdir) }
+
+    let(:deploy_to_a) { tmpdir.join('a').tap(&:mkdir) }
+    let(:deploy_to_b) { tmpdir.join('b').tap(&:mkdir) }
+
+    let(:release_a) { deploy_to_a.join('releases', '1').tap(&:mkpath) }
+    let(:release_b) { deploy_to_b.join('releases', '2').tap(&:mkpath) }
+
+    let(:current_a) { deploy_to_a.join('current') }
+    let(:current_b) { deploy_to_b.join('current') }
+
+    let(:target_a) { release_a.realpath }
+    let(:target_b) { release_b.realpath }
+
+    let(:config) do
+      _a, _b = deploy_to_a, deploy_to_b
+      Mamiya::Configuration.new.evaluate! do
+        set :applications, {
+          a: {deploy_to: _a.to_s},
+          b: {deploy_to: _b.to_s},
+        }
+      end
+    end
+
+    before do
+      deploy_to_a.join('current').make_symlink(target_a)
+      deploy_to_b.join('current').make_symlink(target_b)
+    end
+
+    subject(:currents) { agent.currents }
+
+    it "returns releases" do
+      expect(currents).to eq(
+        a: '1',
+        b: '2',
+      )
+    end
+
+    context "when relative" do
+      let(:target_a) { release_a.relative_path_from(deploy_to_a) }
+      let(:target_b) { release_b.relative_path_from(deploy_to_b) }
+
+      it "returns releases" do
+        expect(currents).to eq(
+          a: '1',
+          b: '2',
+        )
+      end
+    end
+
+    context "when noexist" do
+      before do
+        FileUtils.remove_entry_secure release_a
+        FileUtils.remove_entry_secure release_b
+      end
+
+      it "returns releases" do
+        expect(currents).to eq({})
+      end
+    end
+  end
 
   describe "#labels" do
     subject(:labels) { agent.labels }
@@ -226,6 +359,8 @@ describe Mamiya::Agent do
     it "responds to 'mamiya:packages'" do
       allow(agent).to receive(:existing_packages).and_return("app" => %w(pkg1 pkg2))
       allow(agent).to receive(:existing_prereleases).and_return("app" => %w(pkg2))
+      allow(agent).to receive(:currents).and_return("app" => 'pkg2')
+      allow(agent).to receive(:releases).and_return("app" => %w(pkg3))
 
       response = serf.trigger_query('mamiya:packages', '')
 
@@ -236,6 +371,12 @@ describe Mamiya::Agent do
         "prereleases" => {
           "app" => %w(pkg2)
         },
+        "currents" => {
+          "app" => 'pkg2'
+        },
+        "releases" => {
+          "app" => %w(pkg3)
+        },
       )
     end
   end

data/spec/configuration_spec.rb

@@ -32,4 +32,27 @@ describe Mamiya::Configuration do
       expect(storage_class).to eq klass
     end
   end
+
+  describe "#deploy_to_for(app)" do
+    before do
+      config.evaluate! do
+        applications[:myapp] = {deploy_to: '/apps/myapp'}
+      end
+    end
+
+    it "returns deploy_to" do
+      expect(config.deploy_to_for(:myapp)).to eq Pathname.new('/apps/myapp')
+    end
+
+    it "returns deploy_to" do
+      expect(config.deploy_to_for('myapp')).to eq Pathname.new('/apps/myapp')
+    end
+
+    context "for nonexistent" do
+      it "returns nil" do
+      expect(config.deploy_to_for('nonexistent')).to be_nil
+      expect(config.deploy_to_for(:nonexistent)).to be_nil
+      end
+    end
+  end
 end

data/spec/master/agent_monitor_spec.rb

@@ -32,7 +32,13 @@ describe Mamiya::Master::AgentMonitor do
     {
       "Acks" => ['a'],
       "Responses" => {
-        'a' => {"foo" => "bar", 'packages' => {"app" => ['pkg1']}, 'prereleases' => {"app" => ['pkg2']}}.to_json,
+        'a' => {
+          "foo" => "bar",
+          'packages' => {"app" => ['pkg1']},
+          'prereleases' => {"app" => ['pkg2']},
+          'releases' => {"app" => ['pkg3']},
+          'currents' => {"app" => 'pkg4'},
+        }.to_json,
       },
     }
   end
@@ -41,7 +47,12 @@ describe Mamiya::Master::AgentMonitor do
     {
       "Acks" => ['a'],
       "Responses" => {
-        'a' => {"packages" => {"app" => ['pkg1','pkg2']}, "prereleases" => {"app" => ['pkg2']}}.to_json,
+        'a' => {
+          'packages' => {"app" => ['pkg1', 'pkg2']},
+          'prereleases' => {"app" => ['pkg2']},
+          'releases' => {"app" => ['pkg4']},
+          'currents' => {"app" => 'pkg5'},
+        }.to_json,
       },
     }
   end
@@ -121,20 +132,18 @@ describe Mamiya::Master::AgentMonitor do
       }
     end
 
-    it "updates status .packages by packages query" do
+    it "updates package statuses from status" do
       expect {
         agent_monitor.refresh
       }.to change {
-        agent_monitor.statuses["a"] && agent_monitor.statuses["a"]['packages']
-      }.to("app" => %w(pkg1 pkg2))
-    end
-
-    it "updates status .prereleases by packages query" do
-      expect {
-        agent_monitor.refresh
-      }.to change {
-        agent_monitor.statuses["a"] && agent_monitor.statuses["a"]['prereleases']
-      }.to("app" => %w(pkg2))
+        agent_monitor.statuses["a"] && \
+        agent_monitor.statuses["a"].values_at('packages', 'prereleases', 'releases', 'currents')
+      }.to([
+        {"app" => %w(pkg1 pkg2)},
+        {"app" => %w(pkg2)},
+        {"app" => %w(pkg4)},
+        {"app" => 'pkg5'},
+      ])
     end
 
     context "when packages query unavailable, but available in status query" do
@@ -146,24 +155,31 @@ describe Mamiya::Master::AgentMonitor do
         }
       end
 
-      it "updates status .packages from status" do
-        expect {
-          agent_monitor.refresh
-        }.to change {
-          agent_monitor.statuses["a"] && agent_monitor.statuses["a"]['packages']
-        }.to("app" => %w(pkg1))
-      end
-
-      it "updates status .prereleases from status" do
+      it "updates package statuses from status" do
         expect {
           agent_monitor.refresh
         }.to change {
-          agent_monitor.statuses["a"] && agent_monitor.statuses["a"]['prereleases']
-        }.to("app" => %w(pkg2))
+          agent_monitor.statuses["a"] && \
+          agent_monitor.statuses["a"].values_at('packages', 'prereleases', 'releases', 'currents')
+        }.to([
+          {"app" => %w(pkg1)},
+          {"app" => %w(pkg2)},
+          {"app" => %w(pkg3)},
+          {"app" => 'pkg4'},
+        ])
       end
     end
 
     context "when failed to retrieve package list, but it was available previously in packages query" do
+      let(:status_query_response) do
+        {
+          "Acks" => ['a'],
+          "Responses" => {
+            'a' => {"foo" => "bar"}.to_json,
+          },
+        }
+      end
+
       before do
         agent_monitor.refresh
         packages_query_response['Responses'] = {}
@@ -173,7 +189,7 @@ describe Mamiya::Master::AgentMonitor do
         expect {
           agent_monitor.refresh
         }.not_to change {
-          agent_monitor.statuses["a"]['packages']
+          agent_monitor.statuses["a"].values_at('packages', 'prereleases', 'releases', 'currents')
         }
       end
     end
@@ -256,18 +272,9 @@ describe Mamiya::Master::AgentMonitor do
         }
       end
 
-      let(:packages_query_response) do
-        {
-          "Acks" => ['a'],
-          "Responses" => {
-            'a' => {"packages" => {"app" => ['pkg1','pkg2']}, "prereleases" => {"app" => ['pkg2']}}.to_json,
-          },
-        }
-      end
-
       let(:status_query_response_part) do
         {
-          "Acks" => ['a'],
+          "Acks" => ['b'],
           "Responses" => {
             'b' => {"foo" => "bar"}.to_json,
           },
@@ -276,9 +283,14 @@ describe Mamiya::Master::AgentMonitor do
 
       let(:packages_query_response_part) do
         {
-          "Acks" => ['a'],
+          "Acks" => ['b'],
           "Responses" => {
-            'b' => {"packages" => {"app" => ['pkg1']}, "prereleases" => {"app" => ['pkg2']}}.to_json,
+            'b' => {
+              "packages" => {"app" => ['pkg1']},
+              "prereleases" => {"app" => ['pkg2']},
+              "releases" => {"app" => ['pkg4','pkg5']},
+              "currents" => {"app" => ['pkg6']},
+            }.to_json,
           },
         }
       end
@@ -311,7 +323,13 @@ describe Mamiya::Master::AgentMonitor do
 
         expect(agent_monitor.failed_agents).to eq []
         expect(agent_monitor.statuses['b']).to eq(
-          {"foo" => "bar", "packages" => {"app" => ['pkg1']}, "prereleases" => {"app" => ['pkg2']}}
+          {
+            "foo" => "bar",
+            "packages" => {"app" => ['pkg1']},
+            "prereleases" => {"app" => ['pkg2']},
+            "releases" => {"app" => ['pkg4','pkg5']},
+            "currents" => {"app" => ['pkg6']},
+          }
         )
         expect(agent_monitor.agents['b']).to eq(
           {
@@ -325,6 +343,9 @@ describe Mamiya::Master::AgentMonitor do
     end
   end
 
+  describe "#package_status(application, package)", pending: 'WIP' do
+  end
+
   describe "(commiting events)" do
     let(:status_query_response) do
       {
@@ -593,6 +614,47 @@ describe Mamiya::Master::AgentMonitor do
         end
       end
 
+      describe "release" do
+        describe ":remove" do
+          let(:status) do
+            {releases: {'myapp' => ['pkg1']}}
+          end
+
+          it "removes removed release from releases" do
+            commit('mamiya:release:remove',
+                   app: 'myapp', pkg: 'pkg1')
+
+            expect(new_status["releases"]['myapp']).to eq []
+          end
+
+          context "with existing packages" do
+            let(:status) do
+              {releases: {'myapp' => ['pkg1', 'pkg2']}}
+            end
+
+            it "removes removed release from releases" do
+              commit('mamiya:release:remove',
+                     app: 'myapp', pkg: 'pkg1')
+
+              expect(new_status["releases"]['myapp']).to eq ['pkg2']
+            end
+          end
+
+          context "with inexist package" do
+            let(:status) do
+              {releases: {'myapp' => ['pkg1', 'pkg3']}}
+            end
+
+            it "removes removed release from packages" do
+              commit('mamiya:release:remove',
+                     app: 'myapp', pkg: 'pkg2')
+
+              expect(new_status["releases"]['myapp']).to eq ['pkg1', 'pkg3']
+            end
+          end
+        end
+      end
+
       describe "fetch" do
         describe "success" do
           let(:status) do
@@ -648,6 +710,34 @@ describe Mamiya::Master::AgentMonitor do
           end
         end
       end
+
+      describe "switch" do
+        describe "success" do
+          let(:status) do
+            {currents: {}}
+          end
+
+          it "updates current" do
+            commit('mamiya:task:finish',
+                   task: {task: 'switch', app: 'myapp', pkg: 'pkg'})
+
+            expect(new_status["currents"]['myapp']).to eq "pkg"
+          end
+
+          context "with existing current" do
+            let(:status) do
+              {currents: {'myapp' => 'pkg1'}}
+            end
+
+            it "updates current" do
+              commit('mamiya:task:finish',
+                     task: {task: 'switch', app: 'myapp', pkg: 'pkg2'})
+
+              expect(new_status["currents"]['myapp']).to eq 'pkg2'
+            end
+          end
+        end
+      end
     end
   end
 end