wip: Implement lb_algo mapping to loadbalancing-algorithm in manifest

Author: a18e

app/actions/manifest_route_update.rb

@@ -57,6 +57,7 @@ def update(app_guid, message, user_audit_info)
 
       private
 
+      ## TODO: We also need to update when the route options differ
       def find_or_create_valid_route(app, manifest_route, user_audit_info)
         manifest_route[:candidate_host_domain_pairs].each do |candidate|
           potential_domain = candidate[:domain]
@@ -81,7 +82,8 @@ def find_or_create_valid_route(app, manifest_route, user_audit_info)
             message = RouteCreateMessage.new({
                                                'host' => host,
                                                'path' => manifest_route[:path],
-                                               'port' => manifest_route[:port]
+                                               'port' => manifest_route[:port],
+                                               'options' => manifest_route[:options]
                                              })
 
             route = RouteCreate.new(user_audit_info).create(

app/messages/manifest_routes_update_message.rb

@@ -7,9 +7,20 @@ class ManifestRoutesUpdateMessage < BaseMessage
 
     class ManifestRoutesYAMLValidator < ActiveModel::Validator
       def validate(record)
-        return unless is_not_array?(record.routes) || contains_non_route_hash_values?(record.routes)
-
-        record.errors.add(:routes, message: 'must be a list of route objects')
+        if is_not_array?(record.routes) || contains_non_route_hash_values?(record.routes)
+          record.errors.add(:routes, message: 'must be a list of route objects')
+          return
+        end
+
+        if contains_invalid_route_options?(record.routes)
+          record.errors.add(:routes, message: 'contains invalid route options')
+          return
+        end
+
+        if contains_invalid_lb_algo?(record.routes)
+          record.errors.add(:routes, message: 'contains an invalid loadbalancing-algorithm option')
+          return
+        end
       end
 
       def is_not_array?(routes)
@@ -19,6 +30,22 @@ def is_not_array?(routes)
       def contains_non_route_hash_values?(routes)
         routes.any? { |r| !(r.is_a?(Hash) && r[:route].present?) }
       end
+
+      def contains_invalid_route_options?(routes)
+        routes.any? do |r|
+          next unless r[:options]
+
+          return true unless r[:options].is_a?(Hash)
+        end
+      end
+
+      def contains_invalid_lb_algo?(routes)
+        routes.any? do |r|
+          next unless r[:options] && r[:options][:'loadbalancing-algorithm']
+
+          return true if r[:options][:'loadbalancing-algorithm'] && %w[round-robin least-connections].exclude?(r[:options][:'loadbalancing-algorithm'])
+        end
+      end
     end
 
     validates_with NoAdditionalKeysValidator
@@ -33,7 +60,7 @@ def contains_non_route_hash_values?(routes)
     def manifest_route_mappings
       @manifest_route_mappings ||= routes.map do |route|
         {
-          route: ManifestRoute.parse(route[:route]),
+          route: ManifestRoute.parse(route[:route], route[:options]),
           protocol: route[:protocol]
         }
       end

app/presenters/v3/app_manifest_presenters/route_properties_presenter.rb

@@ -5,10 +5,14 @@ module AppManifestPresenters
         class RoutePropertiesPresenter
           def to_hash(route_mappings:, app:, **_)
             route_hashes = route_mappings.map do |route_mapping|
-              {
+              route_hash = {
                 route: route_mapping.route.uri,
                 protocol: route_mapping.protocol
               }
+
+              route_hash[:options] = route_mapping.route.options if route_mapping.route.options && route_mapping.route.options[:lb_algo]
+
+              route_hash
             end
 
             { routes: alphabetize(route_hashes).presence }

lib/cloud_controller/app_manifest/manifest_route.rb

@@ -6,16 +6,22 @@ class ManifestRoute
     SUPPORTED_TCP_SCHEMES = %w[tcp unspecified].freeze
     WILDCARD_HOST = '*'.freeze
 
-    def self.parse(string)
-      parsed_uri = Addressable::URI.heuristic_parse(string, scheme: 'unspecified')
+    def self.parse(route, options=nil)
+      parsed_uri = Addressable::URI.heuristic_parse(route, scheme: 'unspecified')
 
       attrs = if parsed_uri.nil?
                 {}
               else
                 parsed_uri.to_hash
               end
 
-      attrs[:full_route] = string
+      attrs[:full_route] = route
+
+      if options
+        attrs[:options] = {}
+        attrs[:options][:lb_algo] = options[:'loadbalancing-algorithm'] if options[:'loadbalancing-algorithm']
+      end
+
       ManifestRoute.new(attrs)
     end
 

spec/unit/messages/manifest_routes_update_message_spec.rb

@@ -208,6 +208,40 @@ module VCAP::CloudController
           expect(msg.errors.full_messages).to include("Route protocol must be 'http1', 'http2' or 'tcp'.")
         end
       end
+
+      context 'when a route contains empty route options' do
+        let(:body) do
+          { 'routes' =>
+              [
+                { 'route' => 'existing.example.com',
+                  'options' => {} }
+              ] }
+        end
+
+        it 'returns true' do
+          msg = ManifestRoutesUpdateMessage.new(body)
+
+          expect(msg.valid?).to be(true)
+        end
+      end
+
+      context 'when a route contains a valid loadbalancing-algorithm' do
+        let(:body) do
+          { 'routes' =>
+              [
+                { 'route' => 'existing.example.com',
+                  'options' => {
+                    'loadbalancing-algorithm' => 'round-robin'
+                  } }
+              ] }
+        end
+
+        it 'returns true' do
+          msg = ManifestRoutesUpdateMessage.new(body)
+
+          expect(msg.valid?).to be(true)
+        end
+      end
     end
   end
 end