v3(bindings): create binding for MSI (sync) (cloudfoundry#1859)

[#174090447](https://www.pivotaltracker.com/story/show/174090447)

Author: Derik Evangelista

app/actions/service_credential_binding_create.rb

@@ -10,13 +10,12 @@ class UnprocessableCreate < StandardError
       class Unimplemented < StandardError
       end
 
-      def initialize(user_audit_info, volume_mount_services_enabled)
+      def initialize(user_audit_info)
         @user_audit_info = user_audit_info
-        @volume_mount_services_enabled = volume_mount_services_enabled
       end
 
-      def precursor(service_instance, app: nil, name: nil)
-        validate!(service_instance, app)
+      def precursor(service_instance, app: nil, name: nil, volume_mount_services_enabled: false)
+        validate!(service_instance, app, volume_mount_services_enabled)
 
         binding_details = {
           service_instance: service_instance,
@@ -39,13 +38,16 @@ def precursor(service_instance, app: nil, name: nil)
         raise UnprocessableCreate.new(e.full_message)
       end
 
-      def bind(binding)
+      def bind(binding, parameters: {}, accepts_incomplete: false)
         client = VCAP::Services::ServiceClientProvider.provide(instance: binding.service_instance)
-        details = client.bind(binding, arbitrary_parameters: {}, accepts_incomplete: false)
+        details = client.bind(binding, arbitrary_parameters: parameters, accepts_incomplete: accepts_incomplete)
 
-        binding.save_with_new_operation({ type: 'create', state: 'succeeded' }, attributes: details[:binding])
-
-        event_repository.record_create(binding, @user_audit_info, manifest_triggered: false)
+        if details[:async]
+          save_incomplete_binding(binding, details[:operation])
+        else
+          binding.save_with_new_operation(operation_succeeded, attributes: details[:binding])
+          event_repository.record_create(binding, @user_audit_info, manifest_triggered: false)
+        end
       rescue => e
         binding.save_with_new_operation({
           type: 'create',
@@ -57,15 +59,26 @@ def bind(binding)
 
       private
 
-      def validate!(service_instance, app)
+      def operation_succeeded
+        { type: 'create', state: 'succeeded' }
+      end
+
+      def save_incomplete_binding(binding, operation)
+        binding.save_with_new_operation({
+          type: 'create',
+          state: 'in progress',
+          broker_provided_operation: operation
+        })
+      end
+
+      def validate!(service_instance, app, volume_mount_services_enabled)
         app_is_required! unless app.present?
         space_mismatch! unless all_space_guids(service_instance).include? app.space.guid
 
         if service_instance.managed_instance?
           service_not_bindable! unless service_instance.service_plan.bindable?
           service_not_available! unless service_instance.service_plan.active?
-          volume_mount_not_enabled! if service_instance.volume_service? && !@volume_mount_services_enabled
-          not_supported!
+          volume_mount_not_enabled! if service_instance.volume_service? && !volume_mount_services_enabled
         end
       end
 

app/controllers/v3/service_credential_bindings_controller.rb

@@ -9,6 +9,7 @@
 require 'messages/service_credential_binding_create_message'
 require 'decorators/include_binding_app_decorator'
 require 'decorators/include_binding_service_instance_decorator'
+require 'jobs/v3/create_service_credential_binding_job'
 
 class ServiceCredentialBindingsController < ApplicationController
   def index
@@ -48,10 +49,17 @@ def create
     resource_not_accessible!('app', message.app_guid) unless can_access_resource?(app)
     unauthorized! unless can_write_to_space?(app.space)
 
-    action = V3::ServiceCredentialBindingCreate.new(user_audit_info, volume_services_enabled?)
-    binding = action.precursor(service_instance, app: app, name: message.name)
-    action.bind(binding)
-    render status: :created, json: Presenters::V3::ServiceCredentialBindingPresenter.new(binding).to_hash
+    action = V3::ServiceCredentialBindingCreate.new(user_audit_info)
+    binding = action.precursor(service_instance, app: app, name: message.name, volume_mount_services_enabled: volume_services_enabled?)
+
+    case service_instance
+    when ManagedServiceInstance
+      pollable_job_guid = enqueue_bind_job(binding.guid, message.parameters)
+      head :accepted, 'Location' => url_builder.build_url(path: "/v3/jobs/#{pollable_job_guid}")
+    when UserProvidedServiceInstance
+      action.bind(binding)
+      render status: :created, json: Presenters::V3::ServiceCredentialBindingPresenter.new(binding).to_hash
+    end
   rescue V3::ServiceCredentialBindingCreate::UnprocessableCreate => e
     unprocessable!(e.message)
   rescue V3::ServiceCredentialBindingCreate::Unimplemented
@@ -103,6 +111,16 @@ def parameters
 
   private
 
+  def enqueue_bind_job(binding_guid, parameters)
+    bind_job = VCAP::CloudController::V3::CreateServiceCredentialBindingJob.new(
+      binding_guid,
+      user_audit_info: user_audit_info,
+      parameters: parameters
+    )
+    pollable_job = Jobs::Enqueuer.new(bind_job, queue: Jobs::Queues.generic).enqueue_pollable
+    pollable_job.guid
+  end
+
   def resource_not_accessible!(resource, guid)
     unprocessable!("The #{resource} could not be found: '#{guid}'")
   end

app/jobs/v3/create_service_credential_binding_job.rb

@@ -0,0 +1,69 @@
+require 'jobs/reoccurring_job'
+require 'actions/service_credential_binding_create'
+require 'cloud_controller/errors/api_error'
+
+module VCAP::CloudController
+  module V3
+    class CreateServiceCredentialBindingJob < Jobs::ReoccurringJob
+      def initialize(binding_guid, parameters:, user_audit_info:)
+        super()
+        @binding_guid = binding_guid
+        @user_audit_info = user_audit_info
+        @parameters = parameters
+        @first_time = true
+      end
+
+      def operation
+        :bind
+      end
+
+      def operation_type
+        'create'
+      end
+
+      def max_attempts
+        1
+      end
+
+      def display_name
+        'service_bindings.create'
+      end
+
+      def resource_guid
+        @binding_guid
+      end
+
+      def resource_type
+        'service_binding'
+      end
+
+      def perform
+        binding = ServiceBinding.first(guid: @binding_guid)
+        gone! unless binding
+
+        action = V3::ServiceCredentialBindingCreate.new(@user_audit_info)
+
+        if @first_time
+          @first_time = false
+          action.bind(binding, parameters: @parameters, accepts_incomplete: false)
+          return finish if binding.reload.terminal_state?
+        end
+
+        binding.save_with_new_operation({
+          type: 'create',
+          state: 'failed',
+          description: 'async bindings are not supported'
+        })
+        finish
+      rescue => e
+        raise CloudController::Errors::ApiError.new_from_details('UnableToPerform', 'bind', e.message)
+      end
+
+      private
+
+      def gone!
+        raise CloudController::Errors::ApiError.new_from_details('ResourceNotFound', "The binding could not be found: #{@binding_guid}")
+      end
+    end
+  end
+end

app/messages/service_credential_binding_create_message.rb

@@ -1,7 +1,8 @@
 module VCAP::CloudController
   class ServiceCredentialBindingCreateMessage < BaseMessage
-    register_allowed_keys [:type, :name, :relationships]
+    register_allowed_keys [:type, :name, :relationships, :parameters]
     validates_with NoAdditionalKeysValidator, RelationshipValidator
+    validates :parameters, hash: true, allow_nil: true
     validates :type, allow_blank: false, inclusion: {
       in: %w(app),
       message: "must be 'app'"

spec/request/service_credential_bindings_spec.rb

@@ -798,7 +798,7 @@ def check_filtered_bindings(*bindings)
 
   describe 'POST /v3/service_credential_bindings' do
     let(:api_call) { ->(user_headers) { post '/v3/service_credential_bindings', create_body.to_json, user_headers } }
-
+    let(:request_extra) { {} }
     let(:app_to_bind_to) { VCAP::CloudController::AppModel.make(space: space) }
     let(:service_instance_details) {
       {
@@ -817,7 +817,7 @@ def check_filtered_bindings(*bindings)
           service_instance: { data: { guid: service_instance_guid } },
           app: { data: { guid: app_guid } }
         }
-      }
+      }.merge(request_extra)
     }
 
     context 'user-provided service' do
@@ -879,9 +879,9 @@ def check_filtered_bindings(*bindings)
           get "/v3/service_credential_bindings/#{@binding_guid}/details", {}, admin_headers
           expect(last_response).to have_status_code(200)
           expect(parsed_response).to match_json_response({
-                                                           credentials: { password: 'foo' },
-                                                           syslog_drain_url: 'http://syslog.example.com/wow'
-                                                         })
+            credentials: { password: 'foo' },
+            syslog_drain_url: 'http://syslog.example.com/wow'
+          })
         end
       end
     end
@@ -890,9 +890,128 @@ def check_filtered_bindings(*bindings)
       let(:service_instance) { VCAP::CloudController::ManagedServiceInstance.make(space: space) }
 
       describe 'a successful creation' do
-        it 'returns unimplemented' do
+        let(:binding) { VCAP::CloudController::ServiceBinding.last }
+        let(:job) { VCAP::CloudController::PollableJobModel.last }
+
+        it 'creates a credential binding in the database' do
+          api_call.call(admin_headers)
+
+          expect(binding.service_instance).to eq(service_instance)
+          expect(binding.app).to eq(app_to_bind_to)
+          expect(binding.last_operation.state).to eq('in progress')
+          expect(binding.last_operation.type).to eq('create')
+        end
+
+        it 'responds with a job resource' do
           api_call.call(admin_headers)
-          expect(last_response).to have_status_code(501)
+
+          expect(last_response).to have_status_code(202)
+          expect(last_response.headers['Location']).to end_with("/v3/jobs/#{job.guid}")
+
+          expect(job.state).to eq(VCAP::CloudController::PollableJobModel::PROCESSING_STATE)
+          expect(job.operation).to eq('service_bindings.create')
+          expect(job.resource_guid).to eq(binding.guid)
+          expect(job.resource_type).to eq('service_binding')
+
+          get "/v3/jobs/#{job.guid}", nil, admin_headers
+          expect(last_response).to have_status_code(200)
+          expect(parsed_response['guid']).to eq(job.guid)
+        end
+
+        describe 'the pollable job' do
+          let(:credentials) { { 'password' => 'special sauce' } }
+          let(:broker_base_url) { service_instance.service_broker.broker_url }
+          let(:broker_bind_url) { "#{broker_base_url}/v2/service_instances/#{service_instance.guid}/service_bindings/#{binding.guid}" }
+          let(:broker_status_code) { 201 }
+          let(:broker_response) { { credentials: credentials } }
+          let(:client_body) do
+            {
+              context: {
+                platform: 'cloudfoundry',
+                organization_guid: org.guid,
+                organization_name: org.name,
+                space_guid: space.guid,
+                space_name: space.name,
+              },
+              app_guid: app_to_bind_to.guid,
+              service_id: service_instance.service_plan.service.unique_id,
+              plan_id: service_instance.service_plan.unique_id,
+              bind_resource: {
+                app_guid: app_to_bind_to.guid,
+                space_guid: service_instance.space.guid
+              },
+            }
+          end
+
+          before do
+            api_call.call(admin_headers)
+            expect(last_response).to have_status_code(202)
+
+            stub_request(:put, broker_bind_url).
+              to_return(status: broker_status_code, body: broker_response.to_json, headers: {})
+          end
+
+          it 'sends a bind request with the right arguments to the service broker' do
+            execute_all_jobs(expected_successes: 1, expected_failures: 0)
+
+            expect(
+              a_request(:put, broker_bind_url).
+                with(
+                  body: client_body,
+                )
+            ).to have_been_made.once
+          end
+
+          context 'parameters are specified' do
+            let(:request_extra) { { parameters: { foo: 'bar' } } }
+
+            it 'sends the parameters to the broker' do
+              execute_all_jobs(expected_successes: 1, expected_failures: 0)
+
+              expect(
+                a_request(:put, broker_bind_url).
+                  with(
+                    body: client_body.deep_merge(request_extra)
+                  )
+              ).to have_been_made.once
+            end
+          end
+
+          context 'when the bind completes synchronously' do
+            it 'updates the the binding' do
+              execute_all_jobs(expected_successes: 1, expected_failures: 0)
+
+              binding.reload
+              expect(binding.credentials).to eq(credentials)
+              expect(binding.last_operation.type).to eq('create')
+              expect(binding.last_operation.state).to eq('succeeded')
+            end
+
+            it 'completes the job' do
+              execute_all_jobs(expected_successes: 1, expected_failures: 0)
+
+              expect(job.state).to eq(VCAP::CloudController::PollableJobModel::COMPLETE_STATE)
+            end
+          end
+
+          context 'when the broker fails to bind' do
+            let(:broker_status_code) { 422 }
+            let(:broker_response) { { error: 'RequiresApp' } }
+
+            it 'updates the the binding with a failure' do
+              execute_all_jobs(expected_successes: 0, expected_failures: 1)
+
+              binding.reload
+              expect(binding.last_operation.type).to eq('create')
+              expect(binding.last_operation.state).to eq('failed')
+            end
+
+            it 'fails the job' do
+              execute_all_jobs(expected_successes: 0, expected_failures: 1)
+
+              expect(job.state).to eq(VCAP::CloudController::PollableJobModel::FAILED_STATE)
+            end
+          end
         end
       end
     end