Switch to a single layer

Author: mnapoli

index.js

@@ -173,62 +173,83 @@ class ServerlessPlugin {
      * Process the `php-xx` runtimes to turn them into `provided.al2` runtimes + Bref layers.
      */
     processPhpRuntimes() {
-        const includeBrefLayers = (runtime, existingLayers, isArm) => {
-            let layerName = runtime;
+        const includeBrefLayers = (existingLayers, phpVersion, isArm) => {
+            let layerName = 'php-' + phpVersion;
             // Automatically use ARM layers if the function is deployed to an ARM architecture
             if (isArm) {
                 layerName = 'arm-' + layerName;
             }
-            if (layerName.endsWith('-console')) {
-                layerName = layerName.substring(0, layerName.length - '-console'.length);
-                existingLayers.unshift(this.getLayerArn('console', this.provider.getRegion()));
-                existingLayers.unshift(this.getLayerArn(layerName, this.provider.getRegion()));
-            } else {
-                existingLayers.unshift(this.getLayerArn(layerName, this.provider.getRegion()));
-            }
+            existingLayers.unshift(this.getLayerArn(layerName, this.provider.getRegion()));
             return existingLayers;
         }
+        /**
+         * @param {string} runtime
+         * @return {string|undefined}
+         */
+        const runtimeStringToRuntimeClass = (runtime) => {
+            if (! runtime.startsWith('php-')) {
+                return undefined;
+            }
+            if (runtime.endsWith('-console')) {
+                return 'Bref\\ConsoleRuntime\\Main';
+            }
+            if (runtime.endsWith('-fpm')) {
+                return 'Bref\\FpmRuntime\\Main';
+            }
+            return 'Bref\\FunctionRuntime\\Main';
+        };
+        const configureFunctionRuntime = (f) => {
+            // `php-\d\d(-fpm|console)?`
+            const fullRuntimeString = f.runtime || config.provider.runtime;
+            if (! fullRuntimeString || ! fullRuntimeString.startsWith('php-')) {
+                return;
+            }
+            const phpVersion = fullRuntimeString.substring('php-'.length).split('-')[0];
+            const runtimeClass = runtimeStringToRuntimeClass(fullRuntimeString);
+            if (! runtimeClass) return;
+
+            // The logic here is a bit custom:
+            // If there are layers on the function, we preserve them
+            let existingLayers = f.layers || []; // make sure it's an array
+            // Else, we merge with the layers defined at the root.
+            // Indeed, SF overrides the layers defined at the root with the ones defined on the function.
+            if (existingLayers.length === 0) {
+                // for some reason it's not always an array
+                existingLayers = Array.from(config.provider.layers || []);
+            }
+
+            f.layers = includeBrefLayers(
+                existingLayers,
+                phpVersion,
+                f.architecture === 'arm64' || (isArmGlobally && !f.architecture),
+            );
+            f.runtime = 'provided.al2';
+            // Add the `BREF_RUNTIME` environment variable
+            // to let the function know which runtime it is using
+            // (this is used by the Bref runtime)
+            if (!f.environment) {
+                f.environment = {};
+            }
+            if (!f.environment.BREF_RUNTIME) {
+                f.environment.BREF_RUNTIME = runtimeClass;
+            }
+        }
 
         const config = this.serverless.service;
         const isArmGlobally = config.provider.architecture === 'arm64';
         const isBrefRuntimeGlobally = this.runtimes.includes(config.provider.runtime || '');
 
         // Check functions config
         for (const f of Object.values(config.functions || {})) {
-            if (
-              (f.runtime && this.runtimes.includes(f.runtime)) ||
-              (!f.runtime && isBrefRuntimeGlobally)
-            ) {
-                // The logic here is a bit custom:
-                // If there are layers on the function, we preserve them
-                let existingLayers = f.layers || []; // make sure it's an array
-                // Else, we merge with the layers defined at the root.
-                // Indeed, SF overrides the layers defined at the root with the ones defined on the function.
-                if (existingLayers.length === 0) {
-                    // for some reason it's not always an array
-                    existingLayers = Array.from(config.provider.layers || []);
-                }
-
-                f.layers = includeBrefLayers(
-                    f.runtime || config.provider.runtime,
-                    existingLayers,
-                    f.architecture === 'arm64' || (isArmGlobally && !f.architecture),
-                );
-                f.runtime = 'provided.al2';
-            }
+            configureFunctionRuntime(f);
         }
 
         // Check Lift constructs config
         for (const construct of Object.values(this.serverless.configurationInput.constructs || {})) {
             if (construct.type !== 'queue' && construct.type !== 'webhook') continue;
             const f = construct.type === 'queue' ? construct.worker : construct.authorizer;
-            if (f && (f.runtime && this.runtimes.includes(f.runtime) || !f.runtime && isBrefRuntimeGlobally) ) {
-                f.layers = includeBrefLayers(
-                    f.runtime || config.provider.runtime,
-                    f.layers || [], // make sure it's an array
-                    f.architecture === 'arm64' || (isArmGlobally && !f.architecture),
-                );
-                f.runtime = 'provided.al2';
+            if (f) {
+                configureFunctionRuntime(f);
             }
         }
     }

src/FpmRuntime/FpmHandler.php

@@ -76,6 +76,7 @@ public function start(): void
         /**
          * --nodaemonize: we want to keep control of the process
          * --force-stderr: force logs to be sent to stderr, which will allow us to send them to CloudWatch
+         * TODO set `max_execution_time` to the timeout of the Lambda function?
          */
         $resource = @proc_open(['php-fpm', '--nodaemonize', '--force-stderr', '--fpm-config', $this->configFile], [], $pipes);
 

src/FpmRuntime/Main.php

@@ -16,10 +16,6 @@ class Main
 {
     public static function run(): void
     {
-        // In the FPM runtime process (our process) we want to log all errors and warnings
-        ini_set('display_errors', '1');
-        error_reporting(E_ALL);
-
         ColdStartTracker::init();
 
         LazySecretsLoader::loadSecretEnvironmentVariables();

utils/layers.json/update.php

@@ -14,26 +14,15 @@
 
 const LAYER_NAMES = [
     'php-84',
-    'php-84-fpm',
     'php-83',
-    'php-83-fpm',
     'php-82',
-    'php-82-fpm',
     'php-81',
-    'php-81-fpm',
     'php-80',
-    'php-80-fpm',
     'arm-php-84',
-    'arm-php-84-fpm',
     'arm-php-83',
-    'arm-php-83-fpm',
     'arm-php-82',
-    'arm-php-82-fpm',
     'arm-php-81',
-    'arm-php-81-fpm',
     'arm-php-80',
-    'arm-php-80-fpm',
-    'console',
 ];
 
 $regions = json_decode(file_get_contents(__DIR__ . '/regions.json'), true);