wip scale memory with deployments

Author: sethboyles

app/actions/deployment_create.rb

@@ -56,6 +56,7 @@ def create(app:, user_audit_info:, message:)
             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,
             canary_steps: message.options&.dig(:canary, :steps),
             web_instances: message.web_instances || desired_instances
@@ -67,7 +68,7 @@ def create(app:, user_audit_info:, message:)
 
           process_instances = starting_process_instances(deployment, desired_instances)
 
-          process = create_deployment_process(app, deployment.guid, revision, process_instances)
+          process = create_deployment_process(app, message, deployment.guid, revision, process_instances)
           # Need to transition from STOPPED to STARTED to engage the ProcessObserver to desire the LRP.
           # It'd be better to do this via Diego::Runner.new(process, config).start,
           # but it is nontrivial to get that working in test.
@@ -85,8 +86,8 @@ def create(app:, user_audit_info:, message:)
         raise error
       end
 
-      def create_deployment_process(app, deployment_guid, revision, process_instances)
-        process = clone_existing_web_process(app, revision, process_instances)
+      def create_deployment_process(app, message, deployment_guid, revision, process_instances)
+        process = clone_existing_web_process(app, message, revision, process_instances)
 
         DeploymentProcessModel.create(
           deployment_guid: deployment_guid,
@@ -97,21 +98,20 @@ def create_deployment_process(app, deployment_guid, revision, process_instances)
         process
       end
 
-      def clone_existing_web_process(app, revision, process_instances)
+      def clone_existing_web_process(app, message, revision, process_instances)
         web_process = app.newest_web_process
         command = if revision
                     revision.commands_by_process_type[ProcessTypes::WEB]
                   else
                     web_process.command
                   end
-
         ProcessModel.create(
           app: app,
           type: ProcessTypes::WEB,
           state: ProcessModel::STOPPED,
           instances: process_instances,
           command: command,
-          memory: web_process.memory,
+          memory: message.memory_in_mb || web_process.memory,
           file_descriptors: web_process.file_descriptors,
           disk_quota: web_process.disk_quota,
           log_rate_limit: web_process.log_rate_limit,
@@ -167,11 +167,13 @@ def record_audit_event(deployment, droplet, user_audit_info, message)
       private
 
       def validate_quota!(message, app)
-        return if message.web_instances.blank?
+        return if message.web_instances.blank? && message.memory_in_mb.blank?
 
         current_web_process = app.newest_web_process
-        current_web_process.instances = message.web_instances
-
+        current_web_process.instances = message.web_instances if message.web_instances
+        current_web_process.memory = message.memory_in_mb if message.memory_in_mb
+        # Quotas wont get checked unless the process is started
+        current_web_process.state = ProcessModel::STARTED
         current_web_process.validate
 
         raise Sequel::ValidationFailed.new(current_web_process) unless current_web_process.valid?
@@ -181,6 +183,7 @@ def validate_quota!(message, app)
 
       def deployment_for_stopped_app(app, message, previous_deployment, previous_droplet, revision, target_state, user_audit_info)
         app.newest_web_process.update(instances: message.web_instances) if message.web_instances
+        app.newest_web_process.update(memory: message.memory_in_mb) if message.memory_in_mb
         # Do not create a revision here because AppStart will not handle the rollback case
         AppStart.start(app: app, user_audit_info: user_audit_info, create_revision: false)
 
@@ -197,6 +200,7 @@ def deployment_for_stopped_app(app, message, previous_deployment, previous_dropl
           strategy: message.strategy,
           max_in_flight: message.max_in_flight,
           canary_steps: message.options&.dig(:canary, :steps),
+          memory_in_mb: message.memory_in_mb,
           web_instances: message.web_instances || desired_instances(app.oldest_web_process, previous_deployment)
         )
 

app/messages/deployment_create_message.rb

@@ -1,4 +1,5 @@
 require 'messages/metadata_base_message'
+require 'messages/process_scale_message'
 
 module VCAP::CloudController
   class DeploymentCreateMessage < MetadataBaseMessage
@@ -14,6 +15,7 @@ class DeploymentCreateMessage < MetadataBaseMessage
       canary
       max_in_flight
       web_instances
+      memory_in_mb
     ].freeze
 
     ALLOWED_STEP_KEYS = [
@@ -48,6 +50,10 @@ def web_instances
       options&.dig(:web_instances)
     end
 
+    def memory_in_mb
+      options&.dig(:memory_in_mb)
+    end
+
     private
 
     def mutually_exclusive_droplet_sources
@@ -66,12 +72,30 @@ def validate_options
 
       disallowed_keys = options.keys - ALLOWED_OPTION_KEYS
       errors.add(:options, "has unsupported key(s): #{disallowed_keys.join(', ')}") if disallowed_keys.present?
-
-      validate_web_instances if options[:web_instances]
+      validate_scaling_options
+      # validate_web_instances if options[:web_instances]
       validate_max_in_flight if options[:max_in_flight]
       validate_canary if options[:canary]
     end
 
+    def validate_scaling_options
+      scaling_options = {
+        instances: options[:web_instances],
+        memory_in_mb: options[:memory_in_mb]
+      }
+
+      message = ProcessScaleMessage.new(scaling_options)
+      message.valid?
+      if message.errors[:instances].present?
+        message.errors.select { |e| e.attribute == :instances }.each do |error|
+          errors.import(error, { attribute: :web_instances })
+        end
+        message.errors.delete(:instances)
+      end
+
+      errors.merge!(message.errors)
+    end
+
     def validate_max_in_flight
       max_in_flight = options[:max_in_flight]
 

app/models/runtime/constraints/max_memory_policy.rb

@@ -34,6 +34,15 @@ 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

db/migrations/20250312233355_add_scaling_columns_to_deployments.rb

@@ -0,0 +1,12 @@
+Sequel.migration do
+  up do
+    alter_table(:deployments) do
+      add_column :memory_in_mb, :integer, null: true
+    end
+  end
+  down do
+    alter_table(:deployments) do
+      drop_column :memory_in_mb
+    end
+  end
+end

spec/request/deployments_spec.rb

@@ -1161,6 +1161,76 @@
       end
     end
 
+    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(:create_request) do
+        {
+          options: {
+            memory_in_mb:
+          },
+          relationships: {
+            app: {
+              data: {
+                guid: app_model.guid
+              }
+            }
+          }
+        }
+      end
+
+      context 'when memory_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']['memory_in_mb']).to eq(5)
+        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) }
+
+        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('memory quota_exceeded')
+        end
+      end
+
+      context 'when memory_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?('memory_in_mb')).to be false
+        end
+      end
+    end
+
+    context 'disk_in_mb'
+
+    context 'log_rate_limit_in_bytes_per_second'
+
     context 'web_instances' do
       let!(:process_model) { VCAP::CloudController::ProcessModel.make(app: app_model, instances: 10) }
       let(:user) { make_developer_for_space(space) }