Filter autoscaling service list to only show supported services

Improve the interactive autoscaling configuration UX by pre-filtering the service list to only show services that support horizontal scaling.
This prevents users from selecting services that will fail validation, providing a cleaner and more intuitive experience.

Author: Ricardo Kirkner

src/Command/Autoscaling/AutoscalingSettingsGetCommand.php

@@ -5,6 +5,7 @@
 use Platformsh\Cli\Command\CommandBase;
 use Platformsh\Cli\Service\Table;
 use Platformsh\Client\Exception\EnvironmentStateException;
+use Platformsh\Client\Model\Deployment\Service;
 use Symfony\Component\Console\Input\ArgvInput;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
@@ -68,6 +69,19 @@ protected function execute(InputInterface $input, OutputInterface $output)
         }
 
         if (!empty($autoscalingSettings['services'])) {
+            // Filter autoscaling settings to only show services that are allowed to be configured
+            $filteredSettings = $this->filterAutoscalingSettings($autoscalingSettings['services'], $services);
+
+            if (empty($filteredSettings)) {
+                $this->stdErr->writeln(sprintf('No autoscaling configuration found for the project %s, environment %s.', $this->api()->getProjectLabel($this->getSelectedProject()), $this->api()->getEnvironmentLabel($environment)));
+                $isOriginalCommand = $input instanceof ArgvInput;
+                if ($isOriginalCommand) {
+                    $this->stdErr->writeln('');
+                    $this->stdErr->writeln(sprintf('You can configure autoscaling by running: <info>%s autoscaling:set</info>', $this->config()->get('application.executable')));
+                }
+                return 0;
+            }
+
             /** @var Table $table */
             $table = $this->getService('table');
 
@@ -81,7 +95,7 @@ protected function execute(InputInterface $input, OutputInterface $output)
             $empty = $table->formatIsMachineReadable() ? '' : '<comment>not set</comment>';
 
             $rows = [];
-            foreach ($autoscalingSettings['services'] as $service => $settings) {
+            foreach ($filteredSettings as $service => $settings) {
                 $row = [
                     'service' => $service,
                     'metric' => $empty,
@@ -131,4 +145,53 @@ protected function execute(InputInterface $input, OutputInterface $output)
 
         return 0;
     }
+
+    /**
+     * Filters autoscaling settings to only include services that are allowed to be configured.
+     *
+     * @param array $autoscalingSettings Autoscaling settings from the API
+     * @param array $services Array of Service|WebApp|Worker objects from deployment
+     *
+     * @return array Filtered autoscaling settings
+     */
+    protected function filterAutoscalingSettings(array $autoscalingSettings, array $services)
+    {
+        $project = $this->getSelectedProject();
+        // Force refresh to ensure we have the latest capabilities
+        $capabilities = $this->api()->getProjectCapabilities($project, true);
+        $servicesCapabilityEnabled = !empty($capabilities->autoscaling['supports_horizontal_scaling_services']);
+
+        $filtered = [];
+        foreach ($autoscalingSettings as $serviceName => $settings) {
+            // Skip if service doesn't exist in deployment
+            if (!isset($services[$serviceName])) {
+                continue;
+            }
+
+            $service = $services[$serviceName];
+            $properties = $service->getProperties();
+
+            // For apps and workers: check supports_horizontal_scaling if present, otherwise allow
+            if (!($service instanceof Service)) {
+                if (isset($properties['supports_horizontal_scaling']) && !$properties['supports_horizontal_scaling']) {
+                    continue;
+                }
+                $filtered[$serviceName] = $settings;
+                continue;
+            }
+
+            // For services: check both the deployment property and the project capability
+            if (!isset($properties['supports_horizontal_scaling']) || !$properties['supports_horizontal_scaling']) {
+                continue;
+            }
+
+            if (!$servicesCapabilityEnabled) {
+                continue;
+            }
+
+            $filtered[$serviceName] = $settings;
+        }
+
+        return $filtered;
+    }
 }

src/Command/Autoscaling/AutoscalingSettingsSetCommand.php

@@ -179,7 +179,15 @@ protected function execute(InputInterface $input, OutputInterface $output)
 
         if ($showInteractiveForm) {
             // Interactive mode: let user select services and configure them
-            $serviceNames = array_keys($services);
+            // Filter to only show services that support autoscaling
+            $supportedServices = $this->filterServicesWithAutoscalingSupport($services);
+
+            if (empty($supportedServices)) {
+                $this->stdErr->writeln('No services that support autoscaling were found.');
+                return 1;
+            }
+
+            $serviceNames = array_keys($supportedServices);
 
             if ($service === null) {
                 // Ask user to select services to configure
@@ -189,9 +197,6 @@ protected function execute(InputInterface $input, OutputInterface $output)
                 $service = $serviceNames[$selectedService];
             }
 
-            // Validate that the selected service supports autoscaling
-            $this->validateServiceSupportsAutoscaling($service, $services[$service]);
-
             // Get autoscaling current values for selected service
             $currentServiceSettings = $autoscalingSettings['services'][$service];
 
@@ -658,9 +663,9 @@ protected function validateServiceSupportsAutoscaling($serviceName, $service)
     {
         $properties = $service->getProperties();
 
-        // If supports_horizontal_scaling is explicitly set, use that value
-        if (isset($properties['supports_horizontal_scaling'])) {
-            if (!$properties['supports_horizontal_scaling']) {
+        // For apps and workers: check supports_horizontal_scaling if present, otherwise allow
+        if (!($service instanceof Service)) {
+            if (isset($properties['supports_horizontal_scaling']) && !$properties['supports_horizontal_scaling']) {
                 throw new InvalidArgumentException(sprintf(
                     'The %s <error>%s</error> does not support autoscaling.',
                     $this->typeName($service),
@@ -670,13 +675,57 @@ protected function validateServiceSupportsAutoscaling($serviceName, $service)
             return;
         }
 
-        // Fall back to current behavior: only apps and workers support autoscaling
-        if ($service instanceof Service) {
+        // For services: check both the deployment property and the project capability
+        if (!isset($properties['supports_horizontal_scaling']) || !$properties['supports_horizontal_scaling']) {
             throw new InvalidArgumentException(sprintf(
                 'The service <error>%s</error> does not support autoscaling.',
                 $serviceName
             ));
         }
+
+        $project = $this->getSelectedProject();
+        // Force refresh to ensure we have the latest capabilities
+        $capabilities = $this->api()->getProjectCapabilities($project, true);
+        if (empty($capabilities->autoscaling['supports_horizontal_scaling_services'])) {
+            throw new InvalidArgumentException(sprintf(
+                'The service <error>%s</error> does not support autoscaling because the project does not have horizontal scaling enabled for services.',
+                $serviceName
+            ));
+        }
+    }
+
+    /**
+     * Filters services to only those that support autoscaling.
+     *
+     * @param array $services Array of Service|WebApp|Worker objects
+     *
+     * @return array Filtered array of services that support autoscaling
+     */
+    protected function filterServicesWithAutoscalingSupport(array $services)
+    {
+        $project = $this->getSelectedProject();
+        // Force refresh to ensure we have the latest capabilities
+        $capabilities = $this->api()->getProjectCapabilities($project, true);
+        $servicesCapabilityEnabled = !empty($capabilities->autoscaling['supports_horizontal_scaling_services']);
+
+        return array_filter($services, function ($service) use ($servicesCapabilityEnabled) {
+            $properties = $service->getProperties();
+
+            // For apps and workers: check supports_horizontal_scaling if present, otherwise allow
+            if (!($service instanceof Service)) {
+                if (isset($properties['supports_horizontal_scaling'])) {
+                    return $properties['supports_horizontal_scaling'];
+                }
+                return true;
+            }
+
+            // For services: check both the deployment property and the project capability
+            if (!isset($properties['supports_horizontal_scaling']) || !$properties['supports_horizontal_scaling']) {
+                return false;
+            }
+
+            return $servicesCapabilityEnabled;
+        });
     }
 
     /**