V2 API stack validation and tests

Signed-off-by: Rashed Kamal <[email protected]>

Author: rashedkvm

app/actions/v2/app_stage.rb

@@ -1,8 +1,11 @@
 module VCAP::CloudController
   module V2
     class AppStage
+      attr_reader :warnings
+
       def initialize(stagers:)
         @stagers = stagers
+        @warnings = []
       end
 
       def stage(process)
@@ -25,6 +28,9 @@ def stage(process)
           lifecycle: lifecycle,
           start_after_staging: true
         )
+
+        @warnings = build.instance_variable_get(:@stack_warnings) || []
+
         TelemetryLogger.v2_emit(
           'create-build',
           {

app/actions/v2/app_update.rb

@@ -4,9 +4,11 @@
 module VCAP::CloudController
   module V2
     class AppUpdate
+      attr_reader :warnings
       def initialize(access_validator:, stagers:)
         @access_validator = access_validator
         @stagers          = stagers
+        @warnings         = []
       end
 
       def update(app, process, request_attrs)
@@ -116,7 +118,9 @@ def prepare_to_stage(app)
       end
 
       def stage(process)
-        V2::AppStage.new(stagers: @stagers).stage(process)
+        app_stage = V2::AppStage.new(stagers: @stagers)
+        app_stage.stage(process)
+        @warnings = app_stage.warnings
       end
 
       def start_or_stop(app, request_attrs)

app/controllers/runtime/apps_controller.rb

@@ -294,6 +294,7 @@ def update(guid)
 
       updater = V2::AppUpdate.new(access_validator: self, stagers: @stagers)
       updater.update(app, process, request_attrs)
+      updater.warnings.each { |warning| add_warning(warning) }
 
       after_update(process)
 

app/controllers/runtime/restages_controller.rb

@@ -35,7 +35,10 @@ def restage(guid)
         process.app.update(droplet_guid: nil)
         AppStart.start_without_event(process.app, create_revision: false)
       end
-      V2::AppStage.new(stagers: @stagers).stage(process)
+      # V2::AppStage.new(stagers: @stagers).stage(process)
+      app_stage = V2::AppStage.new(stagers: @stagers)
+      app_stage.stage(process)
+      app_stage.warnings.each { |warning| add_warning(warning) }
 
       @app_event_repository.record_app_restage(process, UserAuditInfo.from_context(SecurityContext))
 

spec/request/v2/apps_spec.rb

@@ -926,6 +926,58 @@
       end
     end
 
+    context 'stack state validation on app update with staging' do
+      let(:stager) { instance_double(VCAP::CloudController::Diego::Stager, stage: nil) }
+
+      before do
+        allow_any_instance_of(VCAP::CloudController::Stagers).to receive(:validate_process)
+        allow_any_instance_of(VCAP::CloudController::Stagers).to receive(:stager_for_build).and_return(stager)
+        VCAP::CloudController::Buildpack.make
+        VCAP::CloudController::PackageModel.make(app: process.app, state: VCAP::CloudController::PackageModel::READY_STATE)
+      end
+
+      context 'when stack is DISABLED' do
+        let(:disabled_stack) { VCAP::CloudController::Stack.make(name: 'cflinuxfs2', state: 'DISABLED', description: 'Migrate to cflinuxfs4') }
+        let(:update_params) { Oj.dump({ state: 'STARTED' }) }
+
+        before do
+          process.app.buildpack_lifecycle_data.update(stack: disabled_stack.name)
+          process.update(state: 'STOPPED')
+        end
+
+        it 'returns 422 with stack validation error when starting app' do
+          put "/v2/apps/#{process.guid}", update_params, headers_for(user)
+
+          expect(last_response.status).to eq(422)
+          parsed_response = Oj.load(last_response.body)
+          expect(parsed_response['error_code']).to eq('CF-StackValidationFailed')
+          expect(parsed_response['description']).to include('disabled')
+          expect(parsed_response['description']).to include('cflinuxfs2')
+        end
+      end
+
+      context 'when stack is DEPRECATED' do
+        let(:deprecated_stack) { VCAP::CloudController::Stack.make(name: 'cflinuxfs3', state: 'DEPRECATED', description: 'EOL Dec 2025') }
+        let(:update_params) { Oj.dump({ state: 'STARTED' }) }
+
+        before do
+          process.app.buildpack_lifecycle_data.update(stack: deprecated_stack.name)
+          process.app.update(droplet_guid: nil)
+          process.update(state: 'STOPPED')
+        end
+
+        it 'allows starting app with deprecation warning' do
+          put "/v2/apps/#{process.guid}", update_params, headers_for(user)
+
+          expect(last_response.status).to eq(201)
+          expect(last_response.headers['X-Cf-Warnings']).to be_present
+          decoded_warning = CGI.unescape(last_response.headers['X-Cf-Warnings'])
+          expect(decoded_warning).to include('deprecated')
+          expect(decoded_warning).to include('EOL Dec 2025')
+        end
+      end
+    end
+
     context 'when process memory is being decreased and the new memory allocation is lower than memory of associated sidecars' do
       let!(:process) do
         VCAP::CloudController::ProcessModelFactory.make(
@@ -1563,6 +1615,139 @@ def make_actual_lrp(instance_guid:, index:, state:, error:, since:)
         end
       end
     end
+
+
+    context 'stack state validation' do
+      let(:process) { VCAP::CloudController::ProcessModelFactory.make(name: 'maria', space: space, diego: true) }
+      let(:stager) { instance_double(VCAP::CloudController::Diego::Stager, stage: nil) }
+
+      before do
+        allow_any_instance_of(VCAP::CloudController::Stagers).to receive(:validate_process)
+        allow_any_instance_of(VCAP::CloudController::Stagers).to receive(:stager_for_build).and_return(stager)
+        VCAP::CloudController::Buildpack.make
+      end
+
+      context 'when stack is DISABLED' do
+        let(:disabled_stack) { VCAP::CloudController::Stack.make(name: 'cflinuxfs2', state: 'DISABLED', description: 'Migrate to cflinuxfs4') }
+
+        before do
+          process.app.buildpack_lifecycle_data.update(stack: disabled_stack.name)
+        end
+
+        it 'returns 422 with stack validation error' do
+          post "/v2/apps/#{process.guid}/restage", nil, headers_for(user)
+
+          expect(last_response.status).to eq(422)
+          parsed_response = Oj.load(last_response.body)
+          expect(parsed_response['error_code']).to eq('CF-StackValidationFailed')
+          expect(parsed_response['description']).to include('disabled')
+          expect(parsed_response['description']).to include('cannot be used for staging')
+          expect(parsed_response['description']).to include('cflinuxfs2')
+          expect(parsed_response['description']).to include('Migrate to cflinuxfs4')
+        end
+
+        it 'does not expose stack state field in error response' do
+          post "/v2/apps/#{process.guid}/restage", nil, headers_for(user)
+
+          parsed_response = Oj.load(last_response.body)
+          expect(parsed_response['entity']).to be_nil
+          expect(parsed_response['error_code']).to eq('CF-StackValidationFailed')
+        end
+      end
+
+      context 'when stack is RESTRICTED' do
+        let(:restricted_stack) { VCAP::CloudController::Stack.make(name: 'cflinuxfs3', state: 'RESTRICTED', description: 'No new apps') }
+
+        before do
+          process.app.buildpack_lifecycle_data.update(stack: restricted_stack.name)
+        end
+
+        context 'for first build' do
+          before do
+            process.app.builds_dataset.destroy
+          end
+
+          it 'returns 422 with stack validation error' do
+            expect(process.app.builds_dataset.count).to eq(0)
+
+            post "/v2/apps/#{process.guid}/restage", nil, headers_for(user)
+
+            expect(last_response.status).to eq(422)
+            parsed_response = Oj.load(last_response.body)
+            expect(parsed_response['error_code']).to eq('CF-StackValidationFailed')
+            expect(parsed_response['description']).to include('cannot be used for staging new applications')
+            expect(parsed_response['description']).to include('cflinuxfs3')
+          end
+        end
+
+        context 'for restaging existing app' do
+          before do
+            VCAP::CloudController::BuildModel.make(app: process.app, state: 'STAGED')
+          end
+
+          it 'allows restaging without errors' do
+            post "/v2/apps/#{process.guid}/restage", nil, headers_for(user)
+
+            expect(last_response.status).to eq(201)
+          end
+
+          it 'does not include warnings header' do
+            post "/v2/apps/#{process.guid}/restage", nil, headers_for(user)
+
+            expect(last_response.headers['X-Cf-Warnings']).to be_nil
+          end
+        end
+      end
+
+      context 'when stack is DEPRECATED' do
+        let(:deprecated_stack) { VCAP::CloudController::Stack.make(name: 'cflinuxfs3', state: 'DEPRECATED', description: 'EOL Dec 2025') }
+
+        before do
+          process.app.buildpack_lifecycle_data.update(stack: deprecated_stack.name)
+        end
+
+        it 'allows restaging with success' do
+          post "/v2/apps/#{process.guid}/restage", nil, headers_for(user)
+
+          expect(last_response.status).to eq(201)
+        end
+
+        it 'includes deprecation warning in X-Cf-Warnings header' do
+          post "/v2/apps/#{process.guid}/restage", nil, headers_for(user)
+
+          expect(last_response.headers['X-Cf-Warnings']).to be_present
+          decoded_warning = CGI.unescape(last_response.headers['X-Cf-Warnings'])
+          expect(decoded_warning).to include('deprecated')
+          expect(decoded_warning).to include('cflinuxfs3')
+          expect(decoded_warning).to include('EOL Dec 2025')
+        end
+
+        it 'does not expose stack state field in response body' do
+          post "/v2/apps/#{process.guid}/restage", nil, headers_for(user)
+
+          parsed_response = Oj.load(last_response.body)
+          # The response includes process 'state' (STARTED/STOPPED) which is different from stack 'state'
+          # We verify stack state is not exposed by checking it's not in the stack-related fields
+          expect(parsed_response['entity']['stack_guid']).to be_present
+          expect(parsed_response.to_s).not_to match(/DEPRECATED/)
+        end
+      end
+
+      context 'when stack is ACTIVE' do
+        let(:active_stack) { VCAP::CloudController::Stack.make(name: 'cflinuxfs5', state: 'ACTIVE') }
+
+        before do
+          process.app.buildpack_lifecycle_data.update(stack: active_stack.name)
+        end
+
+        it 'allows restaging without warnings' do
+          post "/v2/apps/#{process.guid}/restage", nil, headers_for(user)
+
+          expect(last_response.status).to eq(201)
+          expect(last_response.headers['X-Cf-Warnings']).to be_nil
+        end
+      end
+    end
   end
 
   describe 'PUT /v2/apps/:guid/bits' do

spec/unit/actions/v2/app_stage_spec.rb

@@ -215,6 +215,100 @@ module V2
             end
           end
         end
+
+        context 'stack state warnings' do
+          let(:process) { ProcessModelFactory.make }
+          let(:user_audit_info) do
+            UserAuditInfo.new(user_email: '[email protected]', user_name: 'test-user', user_guid: 'test-guid')
+          end
+
+          before do
+            allow(UserAuditInfo).to receive(:from_context).and_return(user_audit_info)
+            allow(BuildCreate).to receive(:new).and_call_original
+            allow_any_instance_of(Diego::Stager).to receive(:stage).and_return 'staging-complete'
+          end
+
+          context 'when stack is DEPRECATED' do
+            let(:deprecated_stack) { Stack.make(name: 'cflinuxfs3', state: 'DEPRECATED', description: 'EOL Dec 2025') }
+
+            before do
+              process.app.buildpack_lifecycle_data.update(stack: deprecated_stack.name)
+            end
+
+            it 'captures warnings from BuildCreate' do
+              action.stage(process)
+
+              expect(action.warnings).not_to be_empty
+              expect(action.warnings.first).to include('deprecated')
+              expect(action.warnings.first).to include('cflinuxfs3')
+              expect(action.warnings.first).to include('EOL Dec 2025')
+            end
+          end
+
+          context 'when stack is ACTIVE' do
+            let(:active_stack) { Stack.make(name: 'cflinuxfs5', state: 'ACTIVE') }
+
+            before do
+              process.app.buildpack_lifecycle_data.update(stack: active_stack.name)
+            end
+
+            it 'has no warnings' do
+              action.stage(process)
+
+              expect(action.warnings).to be_empty
+            end
+          end
+
+          context 'when stack is DISABLED' do
+            let(:disabled_stack) { Stack.make(name: 'cflinuxfs2', state: 'DISABLED', description: 'Migrate to cflinuxfs4') }
+
+            before do
+              process.app.buildpack_lifecycle_data.update(stack: disabled_stack.name)
+            end
+
+            it 'raises StackValidationFailed error' do
+              expect { action.stage(process) }.to raise_error(CloudController::Errors::ApiError) do |error|
+                expect(error.name).to eq('StackValidationFailed')
+                expect(error.message).to include('disabled')
+                expect(error.message).to include('cannot be used for staging')
+              end
+            end
+          end
+
+          context 'when stack is RESTRICTED' do
+            let(:restricted_stack) { Stack.make(name: 'cflinuxfs3-restricted', state: 'RESTRICTED', description: 'No new apps') }
+
+            before do
+              process.app.buildpack_lifecycle_data.update(stack: restricted_stack.name)
+            end
+
+            context 'for first build' do
+              before do
+                process.app.builds_dataset.destroy
+              end
+
+              it 'raises StackValidationFailed error' do
+                expect(process.app.builds_dataset.count).to eq(0)
+
+                expect { action.stage(process) }.to raise_error(CloudController::Errors::ApiError) do |error|
+                  expect(error.name).to eq('StackValidationFailed')
+                  expect(error.message).to include('cannot be used for staging new applications')
+                end
+              end
+            end
+
+            context 'for restaging existing app' do
+              before do
+                BuildModel.make(app: process.app, state: 'STAGED')
+              end
+
+              it 'allows staging without warnings' do
+                expect { action.stage(process) }.not_to raise_error
+                expect(action.warnings).to be_empty
+              end
+            end
+          end
+        end
       end
     end
   end

spec/unit/actions/v2/app_update_spec.rb

@@ -432,7 +432,7 @@ module VCAP::CloudController
       describe 'updating docker_image' do
         let(:process) { ProcessModelFactory.make(app: AppModel.make(:docker), docker_image: 'repo/original-image') }
         let!(:original_package) { process.latest_package }
-        let(:app_stage) { instance_double(V2::AppStage, stage: nil) }
+        let(:app_stage) { instance_double(V2::AppStage, stage: nil, warnings: []) }
 
         before do
           FeatureFlag.create(name: 'diego_docker', enabled: true)
@@ -507,7 +507,7 @@ module VCAP::CloudController
       describe 'updating docker_credentials' do
         let(:process) { ProcessModelFactory.make(app: AppModel.make(:docker), docker_image: 'repo/original-image') }
         let!(:original_package) { process.latest_package }
-        let(:app_stage) { instance_double(V2::AppStage, stage: nil) }
+        let(:app_stage) { instance_double(V2::AppStage, stage: nil, warnings: []) }
 
         before do
           FeatureFlag.create(name: 'diego_docker', enabled: true)
@@ -545,7 +545,7 @@ module VCAP::CloudController
       end
 
       describe 'staging' do
-        let(:app_stage) { instance_double(V2::AppStage, stage: nil) }
+        let(:app_stage) { instance_double(V2::AppStage, stage: nil, warnings: []) }
         let(:process) { ProcessModelFactory.make(state: 'STARTED') }
         let(:app) { process.app }