wip: support for route options in cf push/manifest operations

(Route update note yet functional)

Author: a18e

app/actions/manifest_route_update.rb

@@ -92,6 +92,14 @@ def find_or_create_valid_route(app, manifest_route, user_audit_info)
               domain: existing_domain,
               manifest_triggered: true
             )
+          elsif route[:options] != manifest_route[:options]
+            message = RouteUpdateMessage.new({
+                                               'host' => host,
+                                               'path' => manifest_route[:path],
+                                               'port' => manifest_route[:port],
+                                               'options' => manifest_route[:options]
+                                             })
+            route = RouteUpdate.update(route, message)
           elsif route.space.guid != app.space_guid
             raise InvalidRoute.new('Routes cannot be mapped to destinations in different spaces')
           end

app/messages/manifest_routes_update_message.rb

@@ -61,7 +61,8 @@ def manifest_route_mappings
       @manifest_route_mappings ||= routes.map do |route|
         {
           route: ManifestRoute.parse(route[:route], route[:options]),
-          protocol: route[:protocol]
+          protocol: route[:protocol],
+          options: route[:options]
         }
       end
     end

app/presenters/v3/app_manifest_presenters/route_properties_presenter.rb

@@ -10,7 +10,7 @@ def to_hash(route_mappings:, app:, **_)
                 protocol: route_mapping.protocol
               }
 
-              route_hash[:options] = route_mapping.route.options if route_mapping.route.options && route_mapping.route.options['lb_algo']
+              route_hash[:options]['loadbalancing-algorithm'] = route_mapping.route.options['lb_algo'] if route_mapping.route.options && route_mapping.route.options['lb_algo']
 
               route_hash
             end

lib/cloud_controller/app_manifest/manifest_route.rb

@@ -49,7 +49,8 @@ def to_hash
       {
         candidate_host_domain_pairs: pairs,
         port: @attrs[:port],
-        path: @attrs[:path]
+        path: @attrs[:path],
+        options: @attrs[:options]
       }
     end
 

spec/request/space_manifests_spec.rb

@@ -624,6 +624,140 @@
       end
     end
 
+    describe 'route options' do
+      context 'when an empty route options hash is provided' do
+        let(:yml_manifest) do
+          {
+            'applications' => [
+              {
+                'name' => app1_model.name,
+                'routes' => [
+                  { 'route' => "https://#{route.host}.#{route.domain.name}",
+                    'options' => {} }
+                ]
+              }
+            ]
+          }.to_yaml
+        end
+
+        it 'applies the manifest' do
+          post "/v3/spaces/#{space.guid}/actions/apply_manifest", yml_manifest, yml_headers(user_header)
+
+          expect(last_response.status).to eq(202)
+        end
+      end
+
+      context 'when an invalid route option is provided' do
+        let(:yml_manifest) do
+          {
+            'applications' => [
+              {
+                'name' => app1_model.name,
+                'routes' => [
+                  { 'route' => "https://#{route.host}.#{route.domain.name}",
+                    'options' => {
+                      'doesnt-exist' => 'doesnt-exist'
+                    } }
+                ]
+              }
+            ]
+          }.to_yaml
+        end
+
+        it 'returns a 422' do
+          post "/v3/spaces/#{space.guid}/actions/apply_manifest", yml_manifest, yml_headers(user_header)
+
+          expect(last_response).to have_status_code(422)
+          expect(last_response).to have_error_message('Routes contains an invalid loadbalancing-algorithm option')
+        end
+      end
+
+      context 'loadbalancing-algorithm' do
+        context 'when the loadbalancing-algorithm is not supported' do
+          let(:yml_manifest) do
+            {
+              'applications' => [
+                {
+                  'name' => app1_model.name,
+                  'routes' => [
+                    { 'route' => "https://#{route.host}.#{route.domain.name}",
+                      'options' => {
+                        'loadbalancing-algorithm' => 'unsupported-lb-algorithm'
+                      } }
+                  ]
+                }
+              ]
+            }.to_yaml
+          end
+
+          it 'returns a 422' do
+            post "/v3/spaces/#{space.guid}/actions/apply_manifest", yml_manifest, yml_headers(user_header)
+
+            expect(last_response).to have_status_code(422)
+            expect(last_response).to have_error_message('Routes contains an invalid loadbalancing-algorithm option')
+          end
+        end
+
+        context 'when the loadbalancing-algorithm is supported' do
+          context 'when a new route is added' do
+            let(:yml_manifest) do
+              {
+                'applications' => [
+                  { 'name' => app1_model.name,
+                    'routes' => [
+                      { 'route' => "https://round-robin-app.#{shared_domain.name}",
+                        'options' => {
+                          'loadbalancing-algorithm' => 'round-robin'
+                        } }
+                    ] }
+                ]
+              }.to_yaml
+            end
+
+            it 'adds and removes the loadbalancing-algorithm to the route' do
+              post "/v3/spaces/#{space.guid}/actions/apply_manifest", yml_manifest, yml_headers(user_header)
+
+              expect(last_response.status).to eq(202)
+              job_guid = VCAP::CloudController::PollableJobModel.last.guid
+
+              Delayed::Worker.new.work_off
+              expect(VCAP::CloudController::PollableJobModel.find(guid: job_guid)).to be_complete, VCAP::CloudController::PollableJobModel.find(guid: job_guid).cf_api_error
+
+              app1_model.reload
+              expect(app1_model.routes.first.options).to eq({ 'lb_algo' => 'round-robin' })
+              # expect(route.route_mappings_dataset.first(app: app1_model).protocol).to eq('http1')
+              # expect(second_route.route_mappings_dataset.first(app: app1_model).protocol).to eq('http2')
+
+              ### remove the loadbalancing-algorithm from the route
+
+              yml_manifest = {
+                'applications' => [
+                  { 'name' => app1_model.name,
+                    'routes' => [
+                      { 'route' => "https://round-robin-app.#{shared_domain.name}" }
+                    ] }
+                ]
+              }.to_yaml
+
+              post "/v3/spaces/#{space.guid}/actions/apply_manifest", yml_manifest, yml_headers(user_header)
+
+              expect(last_response.status).to eq(202)
+              job_guid = VCAP::CloudController::PollableJobModel.last.guid
+
+              Delayed::Worker.new.work_off
+              expect(VCAP::CloudController::PollableJobModel.find(guid: job_guid)).to be_complete, VCAP::CloudController::PollableJobModel.find(guid: job_guid).cf_api_error
+
+              app1_model.reload
+              expect(app1_model.routes.first.options).to eq({})
+
+            end
+
+          end
+        end
+      end
+
+    end
+
     describe 'audit events' do
       let!(:process1) { nil }