Merge pull request #265 from travis-ci/ar-enqueue-cancelling-jobs-builds

Enqueue messages for Hub to cancel Jobs/Builds | Modify restart endpoints

lib/travis/api/app/endpoint/builds.rb

@@ -2,6 +2,7 @@ require 'travis/api/app'
 require 'travis/api/workers/build_cancellation'
 require 'travis/api/workers/build_restart'
 require 'travis/api/enqueue/services/restart_model'
+require 'travis/api/enqueue/services/cancel_model'
 
 class Travis::Api::App
   class Endpoint
@@ -21,7 +22,12 @@ class Travis::Api::App
       post '/:id/cancel' do
         Metriks.meter("api.request.cancel_build").mark
 
-        service = self.service(:cancel_build, params.merge(source: 'api'))
+        if Travis::Features.owner_active?(:enqueue_to_hub, current_user)
+          service = Travis::Enqueue::Services::CancelModel.new(current_user, { build_id: params[:id] })
+        else
+          service = self.service(:cancel_build, params.merge(source: 'api'))
+        end
+
         if !service.authorized?
           json = { error: {
             message: "You don't have access to cancel build(#{params[:id]})"
@@ -40,7 +46,12 @@ class Travis::Api::App
           status 422
           respond_with json
         else
-          Travis::Sidekiq::BuildCancellation.perform_async(id: params[:id], user_id: current_user.id, source: 'api')
+          payload = { id: params[:id], user_id: current_user.id, source: 'api' }
+          if service.respond_to?(:push)
+            service.push("build:cancel", payload)
+          else
+            Travis::Sidekiq::BuildCancellation.perform_async(payload)
+          end
 
           Metriks.meter("api.request.cancel_build.success").mark
           status 204

lib/travis/api/app/endpoint/jobs.rb

@@ -2,6 +2,7 @@ require 'travis/api/app'
 require 'travis/api/workers/job_cancellation'
 require 'travis/api/workers/job_restart'
 require 'travis/api/enqueue/services/restart_model'
+require 'travis/api/enqueue/services/cancel_model'
 
 class Travis::Api::App
   class Endpoint
@@ -28,7 +29,12 @@ class Travis::Api::App
       post '/:id/cancel' do
         Metriks.meter("api.request.cancel_job").mark
 
-        service = self.service(:cancel_job, params.merge(source: 'api'))
+        if Travis::Features.owner_active?(:enqueue_to_hub, current_user)
+          service = Travis::Enqueue::Services::CancelModel.new(current_user, { job_id: params[:id] })
+        else
+          service = self.service(:cancel_job, params.merge(source: 'api'))
+        end
+
         if !service.authorized?
           json = { error: {
             message: "You don't have access to cancel job(#{params[:id]})"
@@ -47,7 +53,12 @@ class Travis::Api::App
           status 422
           respond_with json
         else
-          Travis::Sidekiq::JobCancellation.perform_async(id: params[:id], user_id: current_user.id, source: 'api')
+          payload = { id: params[:id], user_id: current_user.id, source: 'api' }
+          if service.respond_to?(:push)
+            service.push("job:cancel", payload)
+          else
+            Travis::Sidekiq::JobCancellation.perform_async(payload)
+          end
 
           Metriks.meter("api.request.cancel_job.success").mark
           status 204
@@ -56,6 +67,7 @@ class Travis::Api::App
 
       post '/:id/restart' do
         Metriks.meter("api.request.restart_job").mark
+
         service = if Travis::Features.owner_active?(:enqueue_to_hub, current_user)
           Travis::Enqueue::Services::RestartModel.new(current_user, { job_id: params[:id] })
         else

lib/travis/api/enqueue/services/cancel_model.rb

@@ -0,0 +1,59 @@
+module Travis
+  module Enqueue
+    module Services
+
+      class CancelModel
+
+        attr_reader :current_user, :target
+
+        def initialize(current_user, params)
+          @current_user = current_user
+          @params = params
+          target
+        end
+
+        def messages
+          messages = []
+          messages << { :notice => "The #{type} was successfully cancelled." } if can_cancel?
+          messages << { :error  => "You are not authorized to cancel this #{type}." } unless authorized?
+          messages << { :error  => "The #{type} could not be cancelled." } unless build.cancelable?
+          messages
+        end
+
+        def push(event, payload)
+          # target may have been retrieved with a :join query, so we need to reset the readonly status
+          if can_cancel?
+            ::Sidekiq::Client.push(
+                  'queue'   => 'hub',
+                  'class'   => 'Travis::Hub::Sidekiq::Worker',
+                  #'args'    => ["#{type}:cancel", @params]
+                  'args'    => [event, payload]
+                )
+          end
+        end
+
+        def type
+          @type ||= @params[:build_id] ? :build : :job
+        end
+
+        def target
+          if type == :build
+            @target = Build.find(@params[:build_id])
+          else
+            @target = Job.find(@params[:job_id])
+          end
+        end
+
+        def can_cancel?
+          authorized? && target.cancelable?
+        end
+
+        # check on web
+        def authorized?
+          current_user.permission?(:pull, :repository_id => target.repository_id)
+        end
+
+      end
+    end
+  end
+end

lib/travis/api/v3/models/permission.rb

@@ -1,6 +1,25 @@
 module Travis::API::V3
   class Models::Permission < Model
+    ROLES = %w(admin push pull)
+
     belongs_to :user
     belongs_to :repository
+
+    class << self
+      def by_roles(roles)
+        roles = Array(roles).select { |role| ROLES.include?(role.to_s) }
+        roles.empty? ? none : where(has_roles(roles))
+      end
+
+      def has_roles(roles)
+        roles.inject(has_role(roles.shift)) do |sql, role|
+          sql.or(has_role(role))
+        end
+      end
+
+      def has_role(role)
+        arel_table[role].eq(true)
+      end
+    end
   end
 end

lib/travis/api/v3/models/user.rb

@@ -22,5 +22,13 @@ module Travis::API::V3
     def starred_repository_ids
       @starred_repository_ids ||= stars.map(&:repository_id)
     end
+
+    def permission?(roles, options = {})
+      roles, options = nil, roles if roles.is_a?(Hash)
+      scope = permissions.where(options)
+      scope = scope.by_roles(roles) if roles
+      scope.any?
+    end
+
   end
 end

lib/travis/api/v3/queries/build.rb

@@ -1,3 +1,6 @@
+require 'travis/api/enqueue/services/restart_model'
+require 'travis/api/enqueue/services/cancel_model'
+
 module Travis::API::V3
   class Queries::Build < Query
     params :id
@@ -10,14 +13,25 @@ module Travis::API::V3
     def cancel(user)
       raise BuildNotCancelable if %w(passed failed canceled errored).include? find.state
       payload = { id: id, user_id: user.id, source: 'api' }
-      perform_async(:build_cancellation, payload)
+      if Travis::Features.owner_active?(:enqueue_to_hub, user)
+        service = Travis::Enqueue::Services::CancelModel.new(user, { build_id: id })
+        service.push("build:cancel", payload)
+      else
+        perform_async(:build_cancellation, payload)
+      end
       payload
     end
 
     def restart(user)
       raise BuildAlreadyRunning if %w(received queued started).include? find.state
-      payload = { id: id, user_id: user.id, source: 'api' }
-      perform_async(:build_restart, payload)
+      if Travis::Features.owner_active?(:enqueue_to_hub, user)
+        service = Travis::Enqueue::Services::RestartModel.new(user, { build_id: id })
+        payload = { id: id, user_id: user.id }
+        service.push("build:restart", payload)
+      else
+        payload = { id: id, user_id: user.id, source: 'api' }
+        perform_async(:build_restart, payload)
+      end
       payload
     end
   end

lib/travis/api/v3/queries/job.rb

@@ -1,3 +1,6 @@
+require 'travis/api/enqueue/services/restart_model'
+require 'travis/api/enqueue/services/cancel_model'
+
 module Travis::API::V3
   class Queries::Job < Query
     params :id
@@ -10,14 +13,26 @@ module Travis::API::V3
     def cancel(user)
       raise JobNotCancelable if %w(passed failed canceled errored).include? find.state
       payload = { id: id, user_id: user.id, source: 'api' }
-      perform_async(:job_cancellation, payload)
+      if Travis::Features.owner_active?(:enqueue_to_hub, user)
+        service = Travis::Enqueue::Services::CancelModel.new(user, { job_id: id })
+        service.push("job:cancel", payload)
+      else
+        perform_async(:job_cancellation, payload)
+      end
       payload
     end
 
     def restart(user)
       raise JobAlreadyRunning if %w(received queued started).include? find.state
-      payload = { id: id, user_id: user.id, source: 'api' }
-      perform_async(:job_restart, payload)
+
+      if Travis::Features.owner_active?(:enqueue_to_hub, user)
+        service = Travis::Enqueue::Services::RestartModel.new(user, { job_id: id })
+        payload = { id: id, user_id: user.id }
+        service.push("job:restart", payload)
+      else
+        payload = { id: id, user_id: user.id, source: 'api' }
+        perform_async(:job_restart, payload)
+      end
       payload
     end
   end

spec/integration/v2/builds_spec.rb

@@ -63,6 +63,16 @@ describe 'Builds' do
         response = post "/builds/#{build.id}/cancel", {}, headers
         response.status.should == 403
       end
+
+      context 'and enqueues cancel event for the Hub' do
+        before { Travis::Features.activate_owner(:enqueue_to_hub, repo.owner) }
+
+        it 'responds with 403' do
+          response = post "/builds/#{build.id}/cancel", {}, headers
+          response.status.should == 403
+        end
+
+      end
     end
 
     context 'when build is not cancelable' do
@@ -72,23 +82,55 @@ describe 'Builds' do
         response = post "/builds/#{build.id}/cancel", {}, headers
         response.status.should == 422
       end
+
+      context 'and enqueues cancel event for the Hub' do
+        before { Travis::Features.activate_owner(:enqueue_to_hub, repo.owner) }
+
+        it 'responds with 422' do
+          response = post "/builds/#{build.id}/cancel", {}, headers
+          response.status.should == 422
+        end
+      end
     end
 
     context 'when build can be canceled' do
       before do
-        Travis::Sidekiq::BuildCancellation.stubs(:perform_async)
         build.matrix.each { |j| j.update_attribute(:state, 'created') }
         build.update_attribute(:state, 'created')
       end
 
-      it 'cancels the build' do
-        Travis::Sidekiq::BuildCancellation.expects(:perform_async).with( id: build.id.to_s, user_id: user.id, source: 'api')
-        post "/builds/#{build.id}/cancel", {}, headers
+      context 'from the Core' do
+        before { Travis::Sidekiq::BuildCancellation.stubs(:perform_async) }
+
+        it 'cancels the build' do
+          Travis::Sidekiq::BuildCancellation.expects(:perform_async).with( id: build.id.to_s, user_id: user.id, source: 'api')
+          post "/builds/#{build.id}/cancel", {}, headers
+        end
+
+        it 'responds with 204' do
+          response = post "/builds/#{build.id}/cancel", {}, headers
+          response.status.should == 204
+        end
       end
 
-      it 'responds with 204' do
-        response = post "/builds/#{build.id}/cancel", {}, headers
-        response.status.should == 204
+      context 'and enqueues cancel event for the Hub' do
+        before { Travis::Features.activate_owner(:enqueue_to_hub, repo.owner) }
+
+        before do
+          build.matrix.each { |j| j.update_attribute(:state, 'created') }
+          build.update_attribute(:state, 'created')
+        end
+
+        it 'cancels the build' do
+          ::Sidekiq::Client.expects(:push)
+          post "/builds/#{build.id}/cancel", {}, headers
+        end
+
+        it 'responds with 204' do
+          ::Sidekiq::Client.expects(:push)
+          response = post "/builds/#{build.id}/cancel", {}, headers
+          response.status.should == 204
+        end
       end
     end
   end

spec/integration/v2/jobs_spec.rb

@@ -230,6 +230,15 @@ describe 'Jobs' do
         response = post "/jobs/#{job.id}/cancel", {}, headers
         response.status.should == 403
       end
+
+      context 'and tries to enqueue cancel event for the Hub' do
+        before { Travis::Features.activate_owner(:enqueue_to_hub, job.repository.owner) }
+
+        it 'responds with 403' do
+          response = post "/jobs/#{job.id}/cancel", {}, headers
+          response.status.should == 403
+        end
+      end
     end
 
     context 'when job is not cancelable' do
@@ -239,6 +248,15 @@ describe 'Jobs' do
         response = post "/jobs/#{job.id}/cancel", {}, headers
         response.status.should == 422
       end
+
+      context 'and tries to enqueue cancel event for the Hub' do
+        before { Travis::Features.activate_owner(:enqueue_to_hub, job.repository.owner) }
+
+        it 'responds with 422' do
+          response = post "/jobs/#{job.id}/cancel", {}, headers
+          response.status.should == 422
+        end
+      end
     end
 
     context 'when job can be canceled' do
@@ -255,6 +273,21 @@ describe 'Jobs' do
         response = post "/jobs/#{job.id}/cancel", {}, headers
         response.status.should == 204
       end
+
+      context 'and enqueues cancel event for the Hub' do
+        before { Travis::Features.activate_owner(:enqueue_to_hub, job.repository.owner) }
+
+        it 'cancels the job' do
+          ::Sidekiq::Client.expects(:push)
+          post "/jobs/#{job.id}/cancel", {}, headers
+        end
+
+        it 'responds with 204' do
+          ::Sidekiq::Client.expects(:push)
+          response = post "/jobs/#{job.id}/cancel", {}, headers
+          response.status.should == 204
+        end
+      end
     end
   end
 

spec/v3/services/build/cancel_spec.rb

@@ -8,6 +8,7 @@ describe Travis::API::V3::Services::Build::Cancel do
 
   before do
     Travis::Features.stubs(:owner_active?).returns(true)
+    Travis::Features.stubs(:owner_active?).with(:enqueue_to_hub, repo.owner).returns(false)
     @original_sidekiq = Sidekiq::Client
     Sidekiq.send(:remove_const, :Client) # to avoid a warning
     Sidekiq::Client = []
@@ -227,6 +228,107 @@ describe Travis::API::V3::Services::Build::Cancel do
     end
   end
 
+  describe "existing repository, push & pull access, cancelable, enqueues message for Hub" do
+    let(:params)  {{}}
+    let(:token)   { Travis::Api::App::AccessToken.create(user: repo.owner, app_id: 1)                          }
+    let(:headers) {{ 'HTTP_AUTHORIZATION' => "token #{token}"                                                 }}
+    before do
+      Travis::API::V3::Models::Permission.create(repository: repo, user: repo.owner, push: true, pull: true)
+      Travis::Features.stubs(:owner_active?).with(:enqueue_to_hub, repo.owner).returns(true)
+    end
+
+    describe "started state" do
+      before        { build.update_attribute(:state, "started")                                                  }
+      before        { post("/v3/build/#{build.id}/cancel", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "build",
+        "@href",
+        "@representation",
+        "minimal",
+        "cancel",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{build.id}",
+        "user_id"=> repo.owner_id,
+        "source" => "api"}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub' }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "queued state" do
+      before        { build.update_attribute(:state, "queued")                                                  }
+      before        { post("/v3/build/#{build.id}/cancel", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "build",
+        "@href",
+        "@representation",
+        "minimal",
+        "cancel",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{build.id}",
+        "user_id"=> repo.owner_id,
+        "source" => "api"}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "received state" do
+      before        { build.update_attribute(:state, "received")                                                  }
+      before        { post("/v3/build/#{build.id}/cancel", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "build",
+        "@href",
+        "@representation",
+        "minimal",
+        "cancel",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{build.id}",
+        "user_id"=> repo.owner_id,
+        "source" => "api"}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "setting id has no effect" do
+      let(:params) {{ id: 42 }}
+      before  { post("/v3/build/#{build.id}/cancel", params, headers)                                      }
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{build.id}",
+        "user_id"=> repo.owner_id,
+        "source" => "api"}
+      }
+    end
+  end
+
+
+
+
   #  TODO decided to discuss further with rkh as this use case doesn't really exist at the moment
   #  and 'fixing' the query requires modifying workers that v2 uses, thereby running the risk of breaking v2,
   #  and also because in 6 months or so travis-hub will be able to cancel builds without using travis-core at all.

spec/v3/services/build/restart_spec.rb

@@ -8,6 +8,7 @@ describe Travis::API::V3::Services::Build::Restart do
 
   before do
     Travis::Features.stubs(:owner_active?).returns(true)
+    Travis::Features.stubs(:owner_active?).with(:enqueue_to_hub, repo.owner).returns(false)
     @original_sidekiq = Sidekiq::Client
     Sidekiq.send(:remove_const, :Client) # to avoid a warning
     Sidekiq::Client = []
@@ -245,6 +246,133 @@ describe Travis::API::V3::Services::Build::Restart do
     end
   end
 
+  describe "existing repository, push access, build not already running, enqueues message for Hub" do
+    let(:params)  {{}}
+    let(:token)   { Travis::Api::App::AccessToken.create(user: repo.owner, app_id: 1)                          }
+    let(:headers) {{ 'HTTP_AUTHORIZATION' => "token #{token}"                                                 }}
+    before do
+      Travis::API::V3::Models::Permission.create(repository: repo, user: repo.owner, push: true)
+      Travis::Features.stubs(:owner_active?).with(:enqueue_to_hub, repo.owner).returns(true)
+    end
+
+    describe "errored state" do
+      before do
+        build.update_attribute(:state, "errored")
+        post("/v3/build/#{build.id}/restart", params, headers)
+      end
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "build",
+        "@href",
+        "@representation",
+        "minimal",
+        "restart",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{build.id}",
+        "user_id"=> repo.owner_id}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                          }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "passed state" do
+      before        { build.update_attribute(:state, "passed")                                                  }
+      before        { post("/v3/build/#{build.id}/restart", params, headers)                                    }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "build",
+        "@href",
+        "@representation",
+        "minimal",
+        "restart",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{build.id}",
+        "user_id"=> repo.owner_id}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                          }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "failed state" do
+      before        { build.update_attribute(:state, "failed")                                                  }
+      before        { post("/v3/build/#{build.id}/restart", params, headers)                                    }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "build",
+        "@href",
+        "@representation",
+        "minimal",
+        "restart",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{build.id}",
+        "user_id"=> repo.owner_id}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                          }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "canceled state" do
+      before        { build.update_attribute(:state, "canceled")                                                  }
+      before        { post("/v3/build/#{build.id}/restart", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "build",
+        "@href",
+        "@representation",
+        "minimal",
+        "restart",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{build.id}",
+        "user_id"=> repo.owner_id}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                          }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "setting id has no effect" do
+      before        { build.update_attribute(:state, "canceled")               }
+      before        { post("/v3/build/#{build.id}/restart", params, headers)   }
+      let(:params) {{ id: 42 }}
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{build.id}",
+        "user_id"=> repo.owner_id}
+      }
+    end
+  end
+
   #  TODO decided to discuss further with rkh as this use case doesn't really exist at the moment
   #  and 'fixing' the query requires modifying workers that v2 uses, thereby running the risk of breaking v2,
   #  and also because in 6 months or so travis-hub will be able to cancel builds without using travis-core at all.

spec/v3/services/job/cancel_spec.rb

@@ -9,6 +9,7 @@ describe Travis::API::V3::Services::Job::Cancel do
 
   before do
     Travis::Features.stubs(:owner_active?).returns(true)
+    Travis::Features.stubs(:owner_active?).with(:enqueue_to_hub, repo.owner).returns(false)
     @original_sidekiq = Sidekiq::Client
     Sidekiq.send(:remove_const, :Client) # to avoid a warning
     Sidekiq::Client = []
@@ -174,6 +175,107 @@ describe Travis::API::V3::Services::Job::Cancel do
       }
     end
   end
+
+  describe "existing repository, push access, job cancelable, enqueues message for Hub" do
+    let(:params)  {{}}
+    let(:token)   { Travis::Api::App::AccessToken.create(user: repo.owner, app_id: 1)                          }
+    let(:headers) {{ 'HTTP_AUTHORIZATION' => "token #{token}"                                                 }}
+    before  do
+      Travis::API::V3::Models::Permission.create(repository: repo, user: repo.owner, push: true, pull: true)
+      Travis::Features.stubs(:owner_active?).with(:enqueue_to_hub, repo.owner).returns(true)
+    end
+
+    describe "started state" do
+      before        { job.update_attribute(:state, "started")                                                }
+      before        { post("/v3/job/#{job.id}/cancel", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "job",
+        "@href",
+        "@representation",
+        "minimal",
+        "cancel",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{job.id}",
+        "user_id"=> repo.owner_id,
+        "source" => "api"}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+    describe "queued state" do
+      before        { job.update_attribute(:state, "queued")                                                }
+      before        { post("/v3/job/#{job.id}/cancel", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "job",
+        "@href",
+        "@representation",
+        "minimal",
+        "cancel",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{job.id}",
+        "user_id"=> repo.owner_id,
+        "source" => "api"}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "received state" do
+      before        { job.update_attribute(:state, "received")                                                }
+      before        { post("/v3/job/#{job.id}/cancel", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "job",
+        "@href",
+        "@representation",
+        "minimal",
+        "cancel",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{job.id}",
+        "user_id"=> repo.owner_id,
+        "source" => "api"}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "setting id has no effect" do
+      before        { post("/v3/job/#{job.id}/cancel", params, headers)                           }
+      let(:params) {{ id: 42 }}
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{job.id}",
+        "user_id"=> repo.owner_id,
+        "source" => "api"}
+      }
+    end
+  end
+
   describe "existing repository, push access, not cancelable" do
     let(:params)  {{}}
     let(:token)   { Travis::Api::App::AccessToken.create(user: repo.owner, app_id: 1)                          }

spec/v3/services/job/restart_spec.rb

@@ -9,6 +9,7 @@ describe Travis::API::V3::Services::Job::Restart do
 
   before do
     Travis::Features.stubs(:owner_active?).returns(true)
+    Travis::Features.stubs(:owner_active?).with(:enqueue_to_hub, repo.owner).returns(false)
     @original_sidekiq = Sidekiq::Client
     Sidekiq.send(:remove_const, :Client) # to avoid a warning
     Sidekiq::Client = []
@@ -200,6 +201,130 @@ describe Travis::API::V3::Services::Job::Restart do
     end
   end
 
+  describe "existing repository, push access, job not already running, enqueues message for Hub" do
+    let(:params)  {{}}
+    let(:token)   { Travis::Api::App::AccessToken.create(user: repo.owner, app_id: 1)                          }
+    let(:headers) {{ 'HTTP_AUTHORIZATION' => "token #{token}"                                                 }}
+    before do
+      Travis::API::V3::Models::Permission.create(repository: repo, user: repo.owner, push: true)
+      Travis::Features.stubs(:owner_active?).with(:enqueue_to_hub, repo.owner).returns(true)
+    end
+
+    describe "canceled state" do
+      before        { job.update_attribute(:state, "canceled")                                                }
+      before        { post("/v3/job/#{job.id}/restart", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "job",
+        "@href",
+        "@representation",
+        "minimal",
+        "restart",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{job.id}",
+        "user_id"=> repo.owner_id}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+    describe "errored state" do
+      before        { job.update_attribute(:state, "errored")                                                }
+      before        { post("/v3/job/#{job.id}/restart", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "job",
+        "@href",
+        "@representation",
+        "minimal",
+        "restart",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{job.id}",
+        "user_id"=> repo.owner_id}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+    describe "failed state" do
+      before        { job.update_attribute(:state, "failed")                                                }
+      before        { post("/v3/job/#{job.id}/restart", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "job",
+        "@href",
+        "@representation",
+        "minimal",
+        "restart",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{job.id}",
+        "user_id"=> repo.owner_id}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+    describe "passed state" do
+      before        { job.update_attribute(:state, "passed")                                                }
+      before        { post("/v3/job/#{job.id}/restart", params, headers)                                      }
+
+      example { expect(last_response.status).to be == 202 }
+      example { expect(JSON.load(body).to_s).to include(
+        "@type",
+        "pending",
+        "job",
+        "@href",
+        "@representation",
+        "minimal",
+        "restart",
+        "id",
+        "state_change")
+      }
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{job.id}",
+        "user_id"=> repo.owner_id}
+      }
+
+      example { expect(Sidekiq::Client.last['queue']).to be == 'hub'                }
+      example { expect(Sidekiq::Client.last['class']).to be == 'Travis::Hub::Sidekiq::Worker' }
+    end
+
+    describe "setting id has no effect" do
+      before do
+        job.update_attribute(:state, "passed")
+        post("/v3/job/#{job.id}/restart", params, headers)
+      end
+      let(:params) {{ id: 42 }}
+
+      example { expect(sidekiq_payload).to be == {
+        "id"     => "#{job.id}",
+        "user_id"=> repo.owner_id}
+      }
+    end
+  end
+
   describe "existing repository, push access, job already running" do
     let(:params)  {{}}
     let(:token)   { Travis::Api::App::AccessToken.create(user: repo.owner, app_id: 1)                          }