@florianpat/lando-core 3.23.7-compose → 3.23.22-test2

package/plugins/networking/app.js

@@ -22,7 +22,8 @@ module.exports = (app, lando) => {
       return landonet.disconnect({Container: container.id, Force: true})
       // Only throw non not connected errors
       .catch(error => {
-        if (!_.includes(error.message, 'is not connected to network')) throw error;
+        if (!_.includes(error.message, 'is not connected to network') &&
+          !_.includes(error.message, 'is not connected to the network')) throw error;
       })
       // Connect
       .then(() => {
@@ -67,7 +68,8 @@ module.exports = (app, lando) => {
         return bridgeNet.disconnect({Container: proxyContainer, Force: true})
           // Only throw non not connected errors
           .catch(error => {
-            if (!_.includes(error.message, 'is not connected to network')) throw error;
+            if (!_.includes(error.message, 'is not connected to network') &&
+              !_.includes(error.message, 'is not connected to the network')) throw error;
           })
           // Connect
           .then(() => {

package/plugins/networking/index.js

@@ -2,13 +2,15 @@
 
 // Modules
 const _ = require('lodash');
+const fs = require('fs');
+const getDockerDesktopBin = require('../../utils/get-docker-desktop-x');
 
 /*
  * Helper to clean out any old networks when we hit the limit
  */
 const cleanNetworks = lando => lando.engine.getNetworks()
   .then(networks => {
-    if (_.size(networks) >= 32) {
+    if (_.size(networks) >= lando.config.networkLimit) {
       // Warn user about this action
       lando.log.warn('Lando has detected you are at Docker\'s network limit!');
       lando.log.warn('Give us a moment as we try to make space by cleaning up old networks...');
@@ -53,26 +55,37 @@ module.exports = lando => {
     // skip the installation of the network if set
     if (options.skipNetworking) return;
 
+    // we need access to dat socket for this to work
+    const dependsOn = ['linux', 'wsl']
+      .includes(lando.config.os.landoPlatform) ? ['setup-build-engine-group', 'setup-build-engine'] : ['setup-build-engine'];
+
     options.tasks.push({
       title: `Creating Landonet`,
       id: 'create-landonet',
-      dependsOn: ['setup-build-engine'],
+      dependsOn,
       description: '@lando/landonet',
       comments: {
-        'NOT INSTALLED': 'Will create Landonet',
+        'NOT INSTALLED': 'Will create LandoNet',
+      },
+      skip: () => {
+        if (!['linux', 'wsl'].includes(lando.config.os.landoPlatform)) return false;
+        return !require('../../utils/is-group-member')('docker');
       },
       hasRun: async () => {
         // if docker isnt even installed then this is easy
         if (lando.engine.dockerInstalled === false) return false;
 
+        // we also want to do an additional check on docker-destkop
+        if (lando.config.os.landoPlatform !== 'linux' && !fs.existsSync(getDockerDesktopBin())) return false;
+
         // otherwise attempt to sus things out
         try {
+          await lando.engine.daemon.up({max: 10, backoff: 1000});
           const landonet = lando.engine.getNetwork(lando.config.networkBridge);
-          await lando.engine.daemon.up();
           await landonet.inspect();
           return lando.versions.networking > 1;
         } catch (error) {
-          debug('looks like there isnt a landonet yet %o %o', error.message, error.stack);
+          debug('looks like there isnt a landonet yet %o %o', error?.message, error?.stack);
           return false;
         }
       },
@@ -82,7 +95,7 @@ module.exports = lando => {
         const daemon = new LandoDaemon(lando.cache, lando.events, undefined, lando.log);
 
         // we need docker up for this
-        await daemon.up();
+        await daemon.up({max: 5, backoff: 1000});
 
         // if we are v1 then disconnect and remove for upgrade
         if (lando.versions.networking === 1) {

package/plugins/proxy/builders/_proxy.js

@@ -17,7 +17,7 @@ const getProxy = ({
   return {
     services: {
       proxy: {
-        image: 'traefik:2.10.7',
+        image: 'traefik:2.11.16',
         command: proxyCommand.join(' '),
         environment: {
           LANDO_APP_PROJECT: '_lando_',
@@ -25,7 +25,6 @@ const getProxy = ({
           LANDO_PROXY_CONFIG_FILE: '/proxy_config/proxy.yaml',
           LANDO_PROXY_PASSTHRU: _.toString(proxyPassThru),
           LANDO_VERSION: version,
-          LANDO_DOMAIN: proxyDomain,
         },
         networks: ['edge'],
         volumes: [

package/release-aliases/3-EDGE

@@ -1 +1 @@
-v3.23.7
+v3.24.0-beta.8

package/release-aliases/3-STABLE

@@ -1 +1 @@
-v3.23.7
+v3.23.22

package/renderers/dc2.js

@@ -36,8 +36,9 @@ class DC2Renderer extends LandoRenderer {
     options.states = {
       COMPLETED: {message: 'Done', color: 'green'},
       FAILED: {message: 'ERROR', color: 'red'},
+      SKIPPED: {message: 'Deferred', color: 'gray'},
       STARTED: {message: 'Waiting', color: 'green'},
-      WAITING: {message: 'Waiting', color: 'yellow'},
+      WAITING: {message: 'Waiting', color: 'gray'},
       ...options.states,
     };
 

package/scripts/add-to-group.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+set -eo pipefail
+
+DEBUG=0
+GROUP=""
+USER=""
+
+chomp() {
+  printf "%s" "${1%$'\n'}"
+}
+
+abort() {
+  printf "ERROR: %s\n" "$(chomp "$1")" >&2
+  exit 1
+}
+
+debug() {
+  if [ "${DEBUG}" == 1 ]; then printf '%s\n' "$1" >&2; fi
+}
+
+# PARSE THE ARGZZ
+while (( "$#" )); do
+  case "$1" in
+    --debug)
+      DEBUG=1
+      shift
+    ;;
+    --group)
+      GROUP="$2"
+      shift 2
+    ;;
+    --group=*)
+      GROUP="${1#*=}"
+      shift
+    ;;
+    --user)
+      USER="$2"
+      shift 2
+    ;;
+    --user=*)
+      USER="${1#*=}"
+      shift
+    ;;
+    --)
+      shift
+      break
+    ;;
+    -*|--*=)
+      shift
+    ;;
+    *)
+      shift
+    ;;
+  esac
+done
+
+# Check that both --group and --user were provided
+if [ -z "$GROUP" ] || [ -z "$USER" ]; then
+  abort "Usage: $0 --group GROUPNAME --user USERNAME"
+fi
+
+# Check if the group exists, create if not
+if ! getent group "$GROUP" > /dev/null 2>&1; then
+  debug "Group '$GROUP' does not exist. Creating..."
+  groupadd "$GROUP" || { abort "Failed to create group."; }
+fi
+
+# Add the user to the group
+debug "Adding user '$USER' to group '$GROUP'..."
+usermod -aG "$GROUP" "$USER" || { abort "Failed to add user to group."; }
+
+echo "User '$USER' successfully added to group '$GROUP'."

package/scripts/docker-engine-start.sh

@@ -1,4 +1,18 @@
 #!/bin/sh
 set -e
 
-systemctl start docker.service || service docker start
+# Function to check if a Polkit agent is running
+is_polkit_agent_running() {
+  ps aux | grep -q "[p]olkit" && return 0 || return 1
+}
+
+# Check if the DISPLAY or XDG_SESSION_TYPE indicates a desktop environment
+if [ -n "$DISPLAY" ] || [ "$XDG_SESSION_TYPE" = "x11" ] || [ "$XDG_SESSION_TYPE" = "wayland" ]; then
+  if is_polkit_agent_running; then
+    systemctl start docker.service || service docker start
+  else
+    sudo systemctl start docker.service || sudo service docker start
+  fi
+else
+  sudo systemctl start docker.service || sudo service docker start
+fi

package/scripts/install-docker-desktop.ps1

@@ -1,11 +1,10 @@
 #!/
 
 # handle params
-# @NOTE: we omit DEBUG as a param because its "built in"
 [CmdletBinding(PositionalBinding=$false)]
 Param(
-  [string]$installer,
-  [switch]$acceptlicense = $false
+  [string]$Installer,
+  [switch]$AcceptLicense = $false
 )
 
 # error handling
@@ -19,28 +18,28 @@ trap {
 
 # enable debugging if debug is true
 $DebugPreference = If ($DebugPreference -eq "Inquire") {"Continue"} Else {"SilentlyContinue"}
-$debug = If ($DebugPreference -eq "Continue") {$true} Else {$false}
+$Debug = If ($DebugPreference -eq "Continue") {$true} Else {$false}
 Write-Debug "running script with:"
-Write-Debug "INSTALLER: $installer"
-Write-Debug "ACCEPT LICENSE: $acceptlicense"
-Write-Debug "DEBUG: $debug"
+Write-Debug "INSTALLER: $Installer"
+Write-Debug "ACCEPT LICENSE: $AcceptLicense"
+Write-Debug "DEBUG: $Debug"
 
 # validation
 # @TODO: check if installer exists on fs?
-if ([string]::IsNullOrEmpty($installer)) {
+if ([string]::IsNullOrEmpty($Installer)) {
   throw "You must pass in an -Installer!"
 }
 
 # Start arg stuff
 $options = "--backend=wsl-2"
 # if debug mode is off then make the installer quiet
-if ($debug -eq $false) {$options = "$options --quiet"}
+if ($Debug -eq $false) {$options = "$options --quiet"}
 # if accept license is true then add that as well
-if ($acceptlicense -eq $true) {$options = "$options --accept-license"}
+if ($AcceptLicense -eq $true) {$options = "$options --accept-license"}
 
 # Install
-Write-Debug "Running $installer with 'install $options'"
-$p = Start-Process -FilePath "$installer" -ArgumentList "install $options" -Wait -PassThru
+Write-Debug "Running $Installer with 'install $options'"
+$p = Start-Process -FilePath "$Installer" -ArgumentList "install $options" -Wait -PassThru
 Write-Debug "Process finished with return code: $($p.ExitCode)"
 
 # If there is an error then throw here

package/scripts/install-system-ca-win32.ps1

@@ -1,14 +1,14 @@
 #!/
 
 # handle params
-# @NOTE: we omit DEBUG as a param because its "built in"
 [CmdletBinding(PositionalBinding=$false)]
 Param(
-  [string]$ca,
-  [switch]$noninteractive = $false
+  [string]$Ca,
+  [switch]$NonInteractive = $env:LANDO_NONINTERACTIVE -or $env:NONINTERACTIVE -or $false
 )
 
-# error handling
+# Stop execution of this script if any cmdlet fails.
+# We'll still need to check exit codes on any exe we run.
 $ErrorActionPreference = "Stop"
 
 # handle uncaught errorz
@@ -18,30 +18,30 @@ trap {
 }
 
 # validation
-# @TODO: check if installer exists on fs?
-if ([string]::IsNullOrEmpty($ca)) {
+if ([string]::IsNullOrEmpty($Ca)) {
   throw "You must pass in a -CA!"
 }
 
+# enable debugging if debug is true
 # enable debugging if debug is true
 $DebugPreference = If ($DebugPreference -eq "Inquire") {"Continue"} Else {"SilentlyContinue"}
-$debug = If ($DebugPreference -eq "Continue") {$true} Else {$false}
+$Debug = If ($DebugPreference -eq "Continue") {$true} Else {$false}
 Write-Debug "running script with:"
-Write-Debug "CA: $ca"
+Write-Debug "CA: $Ca"
 Write-Debug "CI: $env:CI"
-Write-Debug "DEBUG: $debug"
-Write-Debug "NONINTERACTIVE: $noninteractive"
+Write-Debug "DEBUG: $Debug"
+Write-Debug "NONINTERACTIVE: $NonInteractive"
 
 # if we are in CI then reset non-interactive to true
 if ($env:CI) {
-  $noninteractive = $true
+  $NonInteractive = $true
   Write-Debug "Running in non-interactive mode because CI=$env:CI is set."
 }
 
 # if non-interactive eg we are probably on CI lets just powershell it out as admin
-if ($noninteractive -eq $true) {
+if ($NonInteractive -eq $true) {
   # start the process with elevated permissions
-  $p = Start-Process -FilePath certutil.exe -ArgumentList "-addstore Root `"$ca`"" -Verb RunAs -Wait -PassThru
+  $p = Start-Process -FilePath certutil.exe -ArgumentList "-addstore Root `"$Ca`"" -Verb RunAs -Wait -PassThru
   Write-Debug "Process finished with return code: $($p.ExitCode)"
 
   # if there is an error then throw here
@@ -51,7 +51,7 @@ if ($noninteractive -eq $true) {
 } else {
   # read the certificate
   $cert = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2
-  $cert.Import($ca)
+  $cert.Import($Ca)
   # add it to the store
   $store = New-Object System.Security.Cryptography.X509Certificates.X509Store "Root", "CurrentUser"
   $store.Open("ReadWrite")

package/scripts/run-elevated.ps1

@@ -16,8 +16,8 @@ $debug = If ($DebugPreference -eq "Continue") {$true} Else {$false}
 
 # figure out the command and setup fake fds
 $command = $cmd.split(',')
-$stdoutfile = Join-Path $Env:Temp $(New-Guid)
-$stderrfile = Join-Path $Env:Temp $(New-Guid)
+$stdoutfile = Join-Path $Env:Temp $([guid]::NewGuid().ToString())
+$stderrfile = Join-Path $Env:Temp $([guid]::NewGuid().ToString())
 
 # DEBUG
 Write-Debug "running elevated command:"

package/scripts/semcompare.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+
+# semcompare.sh
+# Usage: ./semcompare.sh version1 version2
+
+version1="$1"
+version2="$2"
+
+parse_version() {
+  local version="$1"
+  local major minor patch pre_release
+
+  # Updated regex to allow optional leading 'v'
+  if [[ "$version" =~ ^v?([0-9]+)\.([0-9]+)\.([0-9]+)(-([0-9A-Za-z.-]+))?$ ]]; then
+    major="${BASH_REMATCH[1]}"
+    minor="${BASH_REMATCH[2]}"
+    patch="${BASH_REMATCH[3]}"
+    pre_release="${BASH_REMATCH[5]}"
+  else
+    echo "Invalid version: $version" >&2
+    exit 1
+  fi
+
+  echo "$major" "$minor" "$patch" "$pre_release"
+}
+
+compare_pre_release() {
+    local pre1="$1"
+    local pre2="$2"
+
+    # If both are empty, they're equal
+    if [[ -z "$pre1" && -z "$pre2" ]]; then
+      echo 0
+      return
+    fi
+
+    # A version without pre-release is higher
+    if [[ -z "$pre1" ]]; then
+      echo 1
+      return
+    fi
+    if [[ -z "$pre2" ]]; then
+      echo -1
+      return
+    fi
+
+    IFS='.' read -ra arr1 <<< "$pre1"
+    IFS='.' read -ra arr2 <<< "$pre2"
+
+    local len1="${#arr1[@]}"
+    local len2="${#arr2[@]}"
+    local len=$(( len1 > len2 ? len1 : len2 ))
+
+    for ((i=0; i<len; i++)); do
+      id1="${arr1[i]}"
+      id2="${arr2[i]}"
+
+      # Treat missing identifiers as empty strings
+      [[ -z "$id1" ]] && id1=""
+      [[ -z "$id2" ]] && id2=""
+
+      # Numeric identifiers compare numerically
+      if [[ "$id1" =~ ^[0-9]+$ ]] && [[ "$id2" =~ ^[0-9]+$ ]]; then
+        if ((10#$id1 > 10#$id2)); then
+          echo 1
+          return
+        elif ((10#$id1 < 10#$id2)); then
+          echo -1
+          return
+        fi
+      else
+        # Alphanumeric identifiers compare lexically
+        if [[ "$id1" > "$id2" ]]; then
+          echo 1
+          return
+        elif [[ "$id1" < "$id2" ]]; then
+          echo -1
+          return
+        fi
+      fi
+    done
+
+    echo 0
+}
+
+compare_versions() {
+  local v1=($1)
+  local v2=($2)
+
+  local major1="${v1[0]}"
+  local minor1="${v1[1]}"
+  local patch1="${v1[2]}"
+  local pre1="${v1[3]}"
+
+  local major2="${v2[0]}"
+  local minor2="${v2[1]}"
+  local patch2="${v2[2]}"
+  local pre2="${v2[3]}"
+
+  # Compare major
+  if ((major1 > major2)); then
+    echo 1
+    return
+  elif ((major1 < major2)); then
+    echo -1
+    return
+  fi
+
+  # Compare minor
+  if ((minor1 > minor2)); then
+    echo 1
+    return
+  elif ((minor1 < minor2)); then
+    echo -1
+    return
+  fi
+
+  # Compare patch
+  if ((patch1 > patch2)); then
+    echo 1
+    return
+  elif ((patch1 < patch2)); then
+    echo -1
+    return
+  fi
+
+  # Compare pre-release
+  pre_release_cmp=$(compare_pre_release "$pre1" "$pre2")
+  echo "$pre_release_cmp"
+}
+
+v1_components=$(parse_version "$version1")
+v2_components=$(parse_version "$version2")
+
+result=$(compare_versions "$v1_components" "$v2_components")
+
+# Return 1 if the first version is higher, else 0
+if [[ "$result" -gt 0 ]]; then
+  exit 0
+else
+  exit 1
+fi

package/scripts/wait-for-user.sh

@@ -5,7 +5,6 @@ set -e
 # user info
 user="${1:-$LANDO_WEBROOT_USER}"
 id="${2:-$LANDO_HOST_UID}"
-gid="${3:-$LANDO_HOST_GID}"
 
 # retry settings
 attempt=0
@@ -14,7 +13,7 @@ retry=25
 
 until [ "$attempt" -ge "$retry" ]
 do
-  id -u "$user" | grep "$id" &>/dev/null && id -g "$user" | grep "$gid" &>/dev/null && break
+  id "$user"| grep uid | grep "$id" &>/dev/null && break
   attempt=$((attempt+1))
   sleep "$delay"
 done

package/tasks/destroy.js

@@ -22,6 +22,9 @@ module.exports = lando => {
       // Destroy the app
       if (app) {
         console.log(lando.cli.makeArt('appDestroy', {name: app.name, phase: 'pre'}));
+        // run setup if we need to
+        await require('../hooks/lando-run-setup')(lando);
+        // destroy
         await app.destroy();
         console.log(lando.cli.makeArt('appDestroy', {name: app.name, phase: 'post'}));
       }

package/tasks/info.js

@@ -34,11 +34,12 @@ module.exports = lando => ({
     const getData = async () => {
       // go deep
       if (options.deep) {
+        const separator = _.get(app, '_config.orchestratorSeparator', '_');
         return await lando.engine.list({project: app.project})
           .map(async container => await lando.engine.scan(container))
           .filter(container => {
             if (!options.service) return true;
-            return options.service.map(service => `/${app.project}-${service}-1`).includes(container.Name);
+            return options.service.map(service => `/${app.project}${separator}${service}${separator}1`).includes(container.Name);
           });
 
       // normal info

package/tasks/init.js

@@ -44,7 +44,7 @@ const runBuild = (lando, options = {}, steps = []) => lando.Promise.each(steps,
         step,
       )),
     );
-  };
+  }
 });
 
 module.exports = lando => {
@@ -80,7 +80,7 @@ module.exports = lando => {
     [--yes]
     [--other-plugin-provided-options...]`,
     options: _.merge(getInitBaseOpts(recipes, sources), configOpts, getInitOveridesOpts(inits, recipes, sources)),
-    run: options => {
+    run: async options => {
       // Parse options abd and configs
       options = parseInitOptions(options);
       // Get our recipe and source configs
@@ -90,44 +90,49 @@ module.exports = lando => {
       const buildSteps = (_.has(sourceConfig, 'build')) ? sourceConfig.build(options, lando) : [];
       const configStep = (_.has(recipeConfig, 'build')) ? recipeConfig.build : () => {};
 
+      // run setup if we need to
+      await require('../hooks/lando-run-setup')(lando);
+
       // Pre init event and run build steps
       // @NOTE: source build steps are designed to grab code from somewhere
-      return lando.events.emit('pre-init', options, buildSteps).then(() => runBuild(lando, options, buildSteps))
+      await lando.events.emit('pre-init', options, buildSteps);
+
+      // run build
+      await runBuild(lando, options, buildSteps);
+
       // Run any config steps
       // @NOTE: config steps are designed to augmnet the landofile with additional metadata
-      .then(() => configStep(options, lando))
+      const config = await configStep(options, lando);
 
       // Compile and dump the yaml
-      .then((config = {}) => {
-        // if config is false then it means we want to skip landofile mutation
-        if (config !== false) {
-          // Where are we going?
-          const dest = path.join(options.destination, '.lando.yml');
-          const landoFile = getYaml(dest, options, lando);
-
-          // Get a lower level config if needed, merge in current recipe config
-          if (options.full) {
-            const Recipe = lando.factory.get(options.recipe);
-            const recipeConfig = _.merge({}, landoFile, {app: landoFile.name, _app: {_config: lando.config}});
-            _.merge(landoFile, new Recipe(landoFile.name, recipeConfig).config);
-          }
-
-          // Merge in any additional configuration options specified
-          _.forEach(options.option, option => {
-            const key = _.first(option.split('='));
-            _.set(landoFile, `config.${key}`, _.last(option.split('=')));
-          });
-
-          // Merge and dump the config file
-          lando.yaml.dump(dest, _.merge(landoFile, config));
+      // if config is false then it means we want to skip landofile mutation
+      if (config !== false) {
+        // Where are we going?
+        const dest = path.join(options.destination, '.lando.yml');
+        const landoFile = getYaml(dest, options, lando);
+
+        // Get a lower level config if needed, merge in current recipe config
+        if (options.full) {
+          const Recipe = lando.factory.get(options.recipe);
+          const recipeConfig = _.merge({}, landoFile, {app: landoFile.name, _app: {_config: lando.config}});
+          _.merge(landoFile, new Recipe(landoFile.name, recipeConfig).config);
         }
 
-        // Show it
-        showInit(lando, options);
-      })
+        // Merge in any additional configuration options specified
+        _.forEach(options.option, option => {
+          const key = _.first(option.split('='));
+          _.set(landoFile, `config.${key}`, _.last(option.split('=')));
+        });
+
+        // Merge and dump the config file
+        lando.yaml.dump(dest, _.merge(landoFile, config));
+      }
+
+      // Show it
+      showInit(lando, options);
 
       // Post init event
-      .then(() => lando.events.emit('post-init', options));
+      await lando.events.emit('post-init', options);
     },
   };
 };

package/tasks/rebuild.js

@@ -33,16 +33,10 @@ module.exports = lando => {
       if (app) {
         console.log(lando.cli.makeArt('appRebuild', {name: app.name, phase: 'pre'}));
 
-        // run any setup if we need to but without common plugins or build engine
-        const sopts = lando?.config?.setup;
-        sopts.buildEngine = false;
-        sopts.skipCommonPlugins = true;
-        sopts.yes = true;
-        const setupTasks = await lando.getSetupStatus(sopts);
+        // run setup if we need to
+        await require('../hooks/lando-run-setup')(lando);
 
         try {
-          // run a limited setup if needed
-          if (setupTasks.length > 0) await lando.setup(sopts);
           // If user has given us options then set those
           if (!_.isEmpty(options.service)) app.opts = _.merge({}, app.opts, {services: options.service});
           // rebuild hero

package/tasks/restart.js

@@ -16,17 +16,11 @@ module.exports = lando => {
       if (app) {
         console.log(lando.cli.makeArt('appRestart', {name: app.name, phase: 'pre'}));
 
-        // run any setup if we need to but without common plugins or build engine
-        const sopts = lando?.config?.setup;
-        sopts.buildEngine = false;
-        sopts.skipCommonPlugins = true;
-        sopts.yes = true;
-        const setupTasks = await lando.getSetupStatus(sopts);
+        // run setup if we need to
+        await require('../hooks/lando-run-setup')(lando);
 
         // Normal bootup
         try {
-          // run a limited setup if needed
-          if (setupTasks.length > 0) await lando.setup(sopts);
           // then restart
           await app.restart();
           // determine legacy settings