add disk and log rate limit

Author: sethboyles

app/actions/deployment_create.rb

@@ -50,6 +50,8 @@ def create(app:, user_audit_info:, message:)
           end
 
           process.memory = message.memory_in_mb if message.memory_in_mb
+          process.disk_quota = message.disk_in_mb if message.disk_in_mb
+          process.log_rate_limit = message.log_rate_limit_in_bytes_per_second if message.log_rate_limit_in_bytes_per_second
 
           if app.stopped?
             process.instances = message.web_instances if message.web_instances
@@ -172,6 +174,8 @@ def validate_quota!(message, app)
         current_web_process = app.newest_web_process
         current_web_process.instances = message.web_instances if message.web_instances
         current_web_process.memory = message.memory_in_mb if message.memory_in_mb
+        current_web_process.disk_quota = message.disk_in_mb if message.disk_in_mb
+        current_web_process.log_rate_limit = message.log_rate_limit_in_bytes_per_second if message.log_rate_limit_in_bytes_per_second
         # Quotas wont get checked unless the process is started
         current_web_process.state = ProcessModel::STARTED
         current_web_process.validate
@@ -181,7 +185,7 @@ def validate_quota!(message, app)
         current_web_process.reload
       end
 
-      def create_deployment(app, message, previous_deployment, previous_droplet, revision, target_state, user_audit_info)
+      def create_deployment(app, message, previous_deployment, previous_droplet, revision, target_state, _user_audit_info)
         deployment = DeploymentModel.create(
           app: app,
           state: starting_state(message),
@@ -193,8 +197,10 @@ def create_deployment(app, message, previous_deployment, previous_droplet, revis
           revision_guid: revision&.guid,
           revision_version: revision&.version,
           strategy: message.strategy,
-          memory_in_mb: message.memory_in_mb,
           max_in_flight: message.max_in_flight,
+          memory_in_mb: message.memory_in_mb,
+          disk_in_mb: message.disk_in_mb,
+          log_rate_limit_in_bytes_per_second: message.log_rate_limit_in_bytes_per_second,
           canary_steps: message.options&.dig(:canary, :steps),
           web_instances: message.web_instances || desired_instances(app.oldest_web_process, previous_deployment)
         )

app/messages/deployment_create_message.rb

@@ -16,6 +16,8 @@ class DeploymentCreateMessage < MetadataBaseMessage
       max_in_flight
       web_instances
       memory_in_mb
+      disk_in_mb
+      log_rate_limit_in_bytes_per_second
     ].freeze
 
     ALLOWED_STEP_KEYS = [
@@ -54,6 +56,14 @@ def memory_in_mb
       options&.dig(:memory_in_mb)
     end
 
+    def disk_in_mb
+      options&.dig(:disk_in_mb)
+    end
+
+    def log_rate_limit_in_bytes_per_second
+      options&.dig(:log_rate_limit_in_bytes_per_second)
+    end
+
     private
 
     def mutually_exclusive_droplet_sources
@@ -81,7 +91,9 @@ def validate_options
     def validate_scaling_options
       scaling_options = {
         instances: options[:web_instances],
-        memory_in_mb: options[:memory_in_mb]
+        memory_in_mb: options[:memory_in_mb],
+        disk_in_mb: options[:disk_in_mb],
+        log_rate_limit_in_bytes_per_second: options[:log_rate_limit_in_bytes_per_second]
       }
 
       message = ProcessScaleMessage.new(scaling_options)

app/models/runtime/constraints/max_memory_policy.rb

@@ -34,15 +34,6 @@ def field
 end
 
 class AppMaxMemoryPolicy < BaseMaxMemoryPolicy
-  def validate
-    return unless policy_target
-    return unless additional_checks
-
-    return if policy_target.has_remaining_memory(requested_memory)
-
-    resource.errors.add(field, error_name)
-  end
-
   private
 
   def additional_checks

app/presenters/v3/deployment_presenter.rb

@@ -61,6 +61,10 @@ def options(deployment)
         web_instances: deployment.desired_web_instances
       }
 
+      options[:memory_in_mb] = deployment.memory_in_mb if deployment.memory_in_mb
+      options[:disk_in_mb] = deployment.disk_in_mb if deployment.disk_in_mb
+      options[:log_rate_limit_in_bytes_per_second] = deployment.log_rate_limit_in_bytes_per_second if deployment.log_rate_limit_in_bytes_per_second
+
       if deployment.strategy == VCAP::CloudController::DeploymentModel::CANARY_STRATEGY && deployment.canary_steps
         options[:canary] = {
           steps: deployment.canary_steps

config/cloud_controller.yml

@@ -11,7 +11,7 @@ readiness_port:
 
 external_protocol: http
 external_domain: api2.vcap.me
-temporary_disable_deployments: true
+temporary_disable_deployments: false
 deployment_updater:
   update_frequency_in_seconds: 30
   lock_key: 'cf-deployment-updater'

db/migrations/20250312233355_add_scaling_columns_to_deployments.rb

@@ -2,11 +2,15 @@
   up do
     alter_table(:deployments) do
       add_column :memory_in_mb, :integer, null: true
+      add_column :disk_in_mb, :integer, null: true
+      add_column :log_rate_limit_in_bytes_per_second, :integer, null: true
     end
   end
   down do
     alter_table(:deployments) do
       drop_column :memory_in_mb
+      drop_column :disk_in_mb
+      drop_column :log_rate_limit_in_bytes_per_second
     end
   end
 end

spec/request/deployments_spec.rb

@@ -1164,7 +1164,7 @@
     context 'memory_in_mb' do
       let!(:process_model) { VCAP::CloudController::ProcessModel.make(app: app_model, instances: 10) }
       let(:user) { make_developer_for_space(space) }
-      let(:memory_in_mb) { 5 }
+      let(:memory_in_mb) { 500 }
       let(:create_request) do
         {
           options: {
@@ -1185,13 +1185,13 @@
           post '/v3/deployments', create_request.to_json, user_header
           expect(last_response.status).to eq(201), last_response.body
 
-          expect(parsed_response['options']['memory_in_mb']).to eq(5)
+          expect(parsed_response['options']['memory_in_mb']).to eq(500)
         end
       end
 
       context 'when memory_in_mb violates a quota' do
-        let(:memory_in_mb) { 100_000 }
-        let(:quota) { VCAP::CloudController::QuotaDefinition.make(memory_limit: 1_000_000) }
+        let(:memory_in_mb) { 1001 }
+        let(:quota) { VCAP::CloudController::QuotaDefinition.make(memory_limit: 10_000) }
 
         before do
           org.quota_definition = quota
@@ -1227,9 +1227,135 @@
       end
     end
 
-    context 'disk_in_mb'
+    context 'disk_in_mb' do
+      let!(:process_model) { VCAP::CloudController::ProcessModel.make(app: app_model, instances: 10) }
+      let(:user) { make_developer_for_space(space) }
+      let(:disk_in_mb) { 500 }
+      let(:create_request) do
+        {
+          options: {
+            disk_in_mb:
+          },
+          relationships: {
+            app: {
+              data: {
+                guid: app_model.guid
+              }
+            }
+          }
+        }
+      end
+
+      context 'when disk_in_mb is provided' do
+        it 'is set on the resource' do
+          post '/v3/deployments', create_request.to_json, user_header
+          expect(last_response.status).to eq(201), last_response.body
+
+          expect(parsed_response['options']['disk_in_mb']).to eq(500)
+        end
+      end
+
+      context 'when disk_in_mb violates a quota' do
+        let(:disk_in_mb) { 1001 }
+
+        before do
+          TestConfig.override(maximum_app_disk_in_mb: 1000)
+        end
+
+        it 'is set on the resource' do
+          post '/v3/deployments', create_request.to_json, user_header
+          expect(last_response.status).to eq(422), last_response.body
+          expect(parsed_response['errors'][0]['detail']).to match('disk_quota too much disk requested (requested 1024 MB - must be less than 1000 MB)')
+        end
+      end
+
+      context 'when disk_in_mb is not provided' do
+        let(:create_request) do
+          {
+            relationships: {
+              app: {
+                data: {
+                  guid: app_model.guid
+                }
+              }
+            }
+          }
+        end
+
+        it 'is not returned as part of the deployment options' do
+          post '/v3/deployments', create_request.to_json, user_header
+          expect(last_response.status).to eq(201), last_response.body
+
+          expect(parsed_response['options'].key?('disk_in_mb')).to be false
+        end
+      end
+    end
+
+    context 'log_rate_limit_in_bytes_per_second' do
+      let!(:process_model) { VCAP::CloudController::ProcessModel.make(app: app_model, instances: 10) }
+      let(:user) { make_developer_for_space(space) }
+      let(:log_rate_limit_in_bytes_per_second) { 500 }
+      let(:create_request) do
+        {
+          options: {
+            log_rate_limit_in_bytes_per_second:
+          },
+          relationships: {
+            app: {
+              data: {
+                guid: app_model.guid
+              }
+            }
+          }
+        }
+      end
 
-    context 'log_rate_limit_in_bytes_per_second'
+      context 'when log_rate_limit_in_bytes_per_second is provided' do
+        it 'is set on the resource' do
+          post '/v3/deployments', create_request.to_json, user_header
+          expect(last_response.status).to eq(201), last_response.body
+
+          expect(parsed_response['options']['log_rate_limit_in_bytes_per_second']).to eq(500)
+        end
+      end
+
+      context 'when log_rate_limit_in_bytes_per_second violates a quota' do
+        let(:log_rate_limit_in_bytes_per_second) { 1001 }
+        let(:quota) { VCAP::CloudController::QuotaDefinition.make(log_rate_limit: 1000) }
+
+        before do
+          org.quota_definition = quota
+          org.save
+        end
+
+        it 'is set on the resource' do
+          post '/v3/deployments', create_request.to_json, user_header
+          expect(last_response.status).to eq(422), last_response.body
+          expect(parsed_response['errors'][0]['detail']).to match('log_rate_limit exceeds organization log rate quota')
+        end
+      end
+
+      context 'when log_rate_limit_in_bytes_per_second is not provided' do
+        let(:create_request) do
+          {
+            relationships: {
+              app: {
+                data: {
+                  guid: app_model.guid
+                }
+              }
+            }
+          }
+        end
+
+        it 'is not returned as part of the deployment options' do
+          post '/v3/deployments', create_request.to_json, user_header
+          expect(last_response.status).to eq(201), last_response.body
+
+          expect(parsed_response['options'].key?('log_rate_limit_in_bytes_per_second')).to be false
+        end
+      end
+    end
 
     context 'web_instances' do
       let!(:process_model) { VCAP::CloudController::ProcessModel.make(app: app_model, instances: 10) }