v3(services): create route binding for user-provided service instance (cloudfoundry#1799)

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

Author: blgm

app/actions/service_route_binding_create.rb

@@ -0,0 +1,62 @@
+module VCAP::CloudController
+  module V3
+    class ServiceRouteBindingCreate
+      def initialize(service_event_repository)
+        @service_event_repository = service_event_repository
+      end
+
+      def preflight(service_instance, route)
+        not_supported! unless service_instance.route_service?
+        route_is_internal! if route.try(:internal?)
+        space_mismatch! unless route.space == service_instance.space
+        already_exists! if route.service_instance == service_instance
+        already_bound! if route.service_instance
+      end
+
+      def create(service_instance, route)
+        binding = RouteBinding.new
+        binding.service_instance = service_instance
+        binding.route = route
+
+        client = VCAP::Services::ServiceClientProvider.provide(instance: service_instance)
+        details = client.bind(binding)
+
+        binding.route_service_url = details[:binding][:route_service_url]
+        binding.save
+
+        binding.notify_diego
+
+        service_event_repository.record_service_instance_event(:bind_route, service_instance, { route_guid: route.guid })
+
+        binding
+      end
+
+      class UnprocessableCreate < StandardError; end
+      class RouteBindingAlreadyExists < StandardError; end
+
+      private
+
+      attr_reader :service_event_repository
+
+      def route_is_internal!
+        raise UnprocessableCreate.new('Route services cannot be bound to internal routes')
+      end
+
+      def space_mismatch!
+        raise UnprocessableCreate.new('The service instance and the route are in different spaces')
+      end
+
+      def already_bound!
+        raise UnprocessableCreate.new('A route may only be bound to a single service instance')
+      end
+
+      def not_supported!
+        raise UnprocessableCreate.new('This service instance does not support route binding')
+      end
+
+      def already_exists!
+        raise RouteBindingAlreadyExists.new('The route and service instance are already bound')
+      end
+    end
+  end
+end

app/controllers/v3/service_route_bindings_controller.rb

@@ -1,19 +1,33 @@
 require 'messages/service_route_binding_create_message'
+require 'actions/service_route_binding_create'
 
 class ServiceRouteBindingsController < ApplicationController
   def create
-    message = parse_request
+    route_services_disabled! unless route_services_enabled?
+    message = parse_create_request
 
     service_instance = fetch_service_instance(message.service_instance_guid)
     route = fetch_route(message.route_guid)
-    check_space(service_instance, route)
 
-    head :not_implemented
+    action = V3::ServiceRouteBindingCreate.new(service_event_repository)
+    action.preflight(service_instance, route)
+
+    case service_instance
+    when ManagedServiceInstance
+      head :not_implemented
+    when UserProvidedServiceInstance
+      binding = action.create(service_instance, route)
+      render status: :created, json: { guid: binding.guid }.to_json
+    end
+  rescue V3::ServiceRouteBindingCreate::UnprocessableCreate => e
+    unprocessable!(e.message)
+  rescue V3::ServiceRouteBindingCreate::RouteBindingAlreadyExists
+    already_exists!
   end
 
   private
 
-  def parse_request
+  def parse_create_request
     message = ServiceRouteBindingCreateMessage.new(hashed_params[:body])
     unprocessable!(message.errors.full_messages) unless message.valid?
     message
@@ -22,23 +36,25 @@ def parse_request
   def fetch_service_instance(guid)
     service_instance = VCAP::CloudController::ServiceInstance.first(guid: guid)
     unless service_instance && can_read_space?(service_instance.space)
-      unprocessable_service_instance!(guid)
+      service_instance_not_found!(guid)
     end
+
+    unauthorized! unless can_write_space?(service_instance.space)
+
     service_instance
   end
 
   def fetch_route(guid)
     route = VCAP::CloudController::Route.first(guid: guid)
     unless route && can_read_space?(route.space)
-      unprocessable_route!(guid)
+      route_not_found!(guid)
     end
+
     route
   end
 
-  def check_space(service_instance, route)
-    space = service_instance.space
-    space_mismatch! unless space == route.space
-    unauthorized! unless can_write_space?(space)
+  def service_event_repository
+    VCAP::CloudController::Repositories::ServiceEventRepository::WithUserActor.new(user_audit_info)
   end
 
   def can_read_space?(space)
@@ -49,15 +65,23 @@ def can_write_space?(space)
     permission_queryer.can_write_to_space?(space.guid)
   end
 
-  def unprocessable_service_instance!(guid)
+  def route_services_enabled?
+    VCAP::CloudController::Config.config.get(:route_services_enabled)
+  end
+
+  def service_instance_not_found!(guid)
     unprocessable!("The service instance could not be found: #{guid}")
   end
 
-  def unprocessable_route!(guid)
+  def route_not_found!(guid)
     unprocessable!("The route could not be found: #{guid}")
   end
 
-  def space_mismatch!
-    unprocessable!('The service instance and the route are in different spaces.')
+  def route_services_disabled!
+    unprocessable!('Support for route services is disabled')
+  end
+
+  def already_exists!
+    raise CloudController::Errors::ApiError.new_from_details('ServiceInstanceAlreadyBoundToSameRoute')
   end
 end