Gestire le impostazioni di alimentazione in macOS con uno script Bash personalizzato 

Una gestione efficiente dell’energia è fondamentale per i professionisti IT e i Managed Service Provider (MSP) responsabili della manutenzione dei sistemi macOS. Questo script Bash personalizzato semplifica il processo di gestione delle impostazioni di alimentazione in macOS, consentendo agli utenti di regolare parametri come i timer di sospensione, la durata del timeout dello schermo e le funzioni di risparmio energetico. In questo articolo approfondiremo le funzionalità, i casi d’uso e le implicazioni dell’utilizzo di questo script.

Comprendere la gestione delle impostazioni di alimentazione in macOS

Gestire le impostazioni di alimentazione in macOS garantisce ai sistemi un equilibrio tra prestazioni ed efficienza energetica, prolungando la durata della batteria e riducendo al minimo l’utilizzo di risorse non necessarie. Sebbene macOS fornisca strumenti nativi come il comando pmset, la configurazione manuale di queste impostazioni può richiedere molto tempo ed essere soggetta a errori, soprattutto in ambienti con più dispositivi. Questo script offre un approccio semplificato alla gestione delle impostazioni di alimentazione in macOS, fornendo un controllo granulare su vari parametri.

Lo script per gestire le impostazioni di alimentazione in macOS:

#!/usr/bin/env bash
#
# Description: Set Power and Sleep settings. It can adjust either the plugged-in or battery settings if requested. Please note, not all devices support all options.
#   By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
#   Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
#   Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
#   Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
#   Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
#   Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
#   Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
#   EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#
# Preset Parameter: --powerSourceSetting "Both"
#   Should these changes apply when the device is plugged in, on battery, or both?
#
# Preset Parameter: --screenTimeout "10"
#		Time in minutes to wait before turning off the screen. (0 to disable)
#
# Preset Parameter: --sleepTimeout "10"
#		Time in minutes to wait before the computer sleeps. (0 to disable)
#
# Preset Parameter: --diskTimeout "10"
#		Time in minutes for the disk to spin down when idle. (0 to disable)
#
# Preset Parameter: --powernap "Disable"
#		When the Mac goes to sleep, Power Nap activates periodically to update information such as Mail, Calendar, and other iCloud events.
#
# Preset Parameter: --terminalKeepAlive "Enable"
#		Prevents the system from going to sleep when a terminal session (like a remote login) is active, only allowing sleep if the session has been idle for too long.
#
# Preset Parameter: --dimOnBattery "Enable"
#		Slightly turn down the display brightness when switching to battery power.
#
# Preset Parameter: --lowPowerMode "Enable"
#		Reduces energy consumption by lowering the system performance and brightness, stopping background processes, and adjusting system settings to extend battery life.
#
# Preset Parameter: --tcpKeepAlive "Enable"
#		Ensures that a network connection remains active by periodically sending keepalive packets to prevent the connection from being dropped due to inactivity.
#
# Preset Parameter: --wakeOnNetwork "Only on Power Adapter"
#		Wake when an Ethernet magic packet is received.
#
# Preset Parameter: --help
#		Displays some help text.
#
# Release Notes: Initial Release

# Define initial argument variables with default values
_arg_powerSourceSetting="Both"
_arg_screenTimeout=
_arg_sleepTimeout=
_arg_diskTimeout=
_arg_powernap=
_arg_terminalKeepAlive=
_arg_dimOnBattery=
_arg_wakeOneNetwork=
_arg_lowPowerMode=
_arg_tcpKeepAlive=

# Function to display help menu
print_help() {
  printf '\n\n%s\n\n' 'Usage: [--powerSourceSetting|-p <arg>] [--someSwitch|-s] [--help|-h]'
  printf '%s\n' 'Preset Parameter: --powerSourceSetting "Both"'
  printf '\t%s\n' "Should these changes apply when the device is plugged in, on battery, or both?"
  printf '%s\n' 'Preset Parameter: --screenTimeout "10"'
  printf '\t%s\n' "Time in minutes to wait before turning off the screen. (0 to disable)"
  printf '%s\n' 'Preset Parameter: --sleepTimeout "10"'
  printf '\t%s\n' "Time in minutes to wait before the computer sleeps. (0 to disable)"
  printf '%s\n' 'Preset Parameter: --diskTimeout "10"'
  printf '\t%s\n' "Time in minutes for the disk to spin down when idle. (0 to disable)"
  printf '%s\n' 'Preset Parameter: --powernap "Disable"'
  printf '\t%s\n' "When the Mac goes to sleep, Power Nap activates periodically to update information such as Mail, Calendar and other iCloud events."
  printf '%s\n' 'Preset Parameter: --terminalKeepAlive "Enable"'
  printf '\t%s\n' "Prevents the system from going to sleep when a terminal session (like a remote login) is active, only allowing sleep if the session has been idle for too long."
  printf '%s\n' 'Preset Parameter: --dimOnBattery "Enable"'
  printf '\t%s\n' "Slightly turn down the display brightness when switching to battery power."
  printf '%s\n' 'Preset Parameter: --lowPowerMode "Enable"'
  printf '\t%s\n' "Reduces energy consumption by lowering the system performance and brightness, stopping background processes, and adjusting system settings to extend battery life."
  printf '%s\n' 'Preset Parameter: --tcpKeepAlive "Enable"'
  printf '\t%s\n' "Ensures that a network connection remains active by periodically sending keepalive packets to prevent the connection from being dropped due to inactivity."
  printf '%s\n' 'Preset Parameter: --wakeOnNetwork "Only on Power Adapter"'
  printf '\t%s\n' "Wake when an Ethernet magic packet is received."
  printf '\n%s\n' 'Preset Parameter: --help'
  printf '\t%s\n' "Displays this help menu."
}

# Function to display error message and exit the script
die() {
  local _ret="${2:-1}"
  echo "$1" >&2
  test "${_PRINT_HELP:-no}" = yes && print_help >&2
  exit "${_ret}"
}

# Function to parse command-line arguments
parse_commandline() {
  while test $# -gt 0; do
    _key="$1"
    case "$_key" in
    --powerSourceSetting | --powersourcesetting | --powersource)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_powerSourceSetting=$2
      shift
      ;;
    --powerSourceSetting=*)
      _arg_powerSourceSetting="${_key##--powerSourceSetting=}"
      ;;
    --screenTimeout | --screentimeout | --screen)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_screenTimeout=$2
      shift
      ;;
    --screenTimeout=*)
      _arg_screenTimeout="${_key##--screenTimeout=}"
      ;;
    --sleepTimeout | --sleeptimeout | --sleep)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_sleepTimeout=$2
      shift
      ;;
    --sleepTimeout=*)
      _arg_sleepTimeout="${_key##--sleepTimeout=}"
      ;;
    --diskTimeout | --disktimeout | --disk)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_diskTimeout=$2
      shift
      ;;
    --diskTimeout=*)
      _arg_diskTimeout="${_key##--diskTimeout=}"
      ;;
    --powernap | --powerNap)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_powernap=$2
      shift
      ;;
    --powernap=*)
      _arg_powernap="${_key##--powernap=}"
      ;;
    --terminalKeepAlive | --terminalkeepawake | --terminalkeepalive)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_terminalKeepAlive=$2
      shift
      ;;
    --terminalKeepAlive=*)
      _arg_terminalKeepAlive="${_key##--terminalKeepAlive=}"
      ;;
    --dimOnBattery | --dimonbattery | --dim)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_dimOnBattery=$2
      shift
      ;;
    --dimOnBattery=*)
      _arg_dimOnBattery="${_key##--dimOnBattery=}"
      ;;
    --lowPowerMode | --lowpowermode | --lpm)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_lowPowerMode=$2
      shift
      ;;
    --lowPowerMode=*)
      _arg_lowPowerMode="${_key##--lowPowerMode=}"
      ;;
    --tcpKeepAlive | --tcpkeepalive | --tcp)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_tcpKeepAlive=$2
      shift
      ;;
    --tcpKeepAlive=*)
      _arg_tcpKeepAlive="${_key##--tcpKeepAlive=}"
      ;;
    --wakeOnNetwork | --wakeonnetwork | --won)
      test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
      _arg_wakeOneNetwork=$2
      shift
      ;;
    --wakeOnNetwork=*)
      _arg_wakeOneNetwork="${_key##--wakeOnNetwork=}"
      ;;
    --help | -h)
      _PRINT_HELP=yes die 0
      ;;
    *)
      _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1'"1
      ;;
    esac
    shift
  done
}

# Function to set power settings
set_powersetting() {
  while test $# -gt 0; do
    local _key="$1"
    case "$_key" in
    --setting)
      test $# -lt 2 && die "Missing value for the argument '$_key'."1
      local _setting=$2
      shift
      ;;
    --value)
      test $# -lt 2 && die "Missing value for the argument '$_key'."1
      local _value=$2
      shift
      ;;
    --errorMessage)
      test $# -lt 2 && die "Missing value for the argument '$_key'."1
      local _errorMessage=$2
      shift
      ;;
    --successMessage)
      test $# -lt 2 && die "Missing value for the argument '$_key'."1
      local _successMessage=$2
      shift
      ;;
    --singleSetting)
      local _singleSetting="on"
      ;;
    *)
      _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1'"1
      ;;
    esac
    shift
  done

  # Check if required parameters are provided
  if [[ -z $_setting || -z $_value || -z $_errorMessage || -z $_successMessage ]]; then
    echo "[Error] One of the required parameters was not provided." >&2
    exit 1
  fi

  # Apply setting for "Plugged In" if applicable
  if [[ ($_arg_powerSourceSetting == "Both" || $_arg_powerSourceSetting == "Plugged In") && $_singleSetting != "on" ]]; then
    pmset -c "$_setting" "$_value"
  fi

  # Apply setting for "On Battery" if applicable
  if [[ ($_arg_powerSourceSetting == "Both" || $_arg_powerSourceSetting == "On Battery") && $_singleSetting != "on" && -n $batteryOptions ]]; then
    pmset -b "$_setting" "$_value"
  fi

  # Apply setting for all power sources if single setting is enabled
  if [[ $_singleSetting == "on" ]]; then
    pmset -a "$_setting" "$_value"
  fi

  # Retrieve and verify the new value of the setting
  newvalue=$(pmset -g custom | grep -w "$_setting")
  if [[ -z $batteryOptions && $_singleSetting != "on" ]]; then
    newvalueAC=$(echo "$newvalue" | xargs | cut -f2 -d' ')
  elif [[ $_singleSetting != "on" ]]; then
    newvalueDC=$(echo "$newvalue" | xargs | cut -f2 -d' ')
    newvalueAC=$(echo "$newvalue" | xargs | cut -f4 -d' ')
  else
    newvalue=$(echo "$newvalue" | xargs | cut -f2 -d' ')
  fi

  # Warn if unable to verify the setting change
  if [[ -z $newvalue ]]; then
    echo "Warning: Unable to verify setting change for '$_setting'."
  fi

  # Check and report the new value for "Plugged In" setting
  if [[ ($_arg_powerSourceSetting == "Both" || $_arg_powerSourceSetting == "Plugged In") && $_singleSetting != "on" && -n $newvalue ]]; then
    if [[ $newvalueAC != "$_value" ]]; then
      echo "[Error] $_errorMessage on the 'Plugged In' Policy." >&2
      EXITCODE=1
    else
      echo "$_successMessage on the 'Plugged In' Policy."
    fi
  fi

  # Check and report the new value for "On Battery" setting
  if [[ ($_arg_powerSourceSetting == "Both" || $_arg_powerSourceSetting == "On Battery") && $_singleSetting != "on" && -n $newvalue && -n $batteryOptions ]]; then
    if [[ $newvalueDC != "$_value" ]]; then
      echo "[Error] $_errorMessage on the 'Battery' Policy." >&2
      EXITCODE=1
    else
      echo "$_successMessage on the 'Battery' Policy."
    fi
  fi

  # Check and report the new value for single setting
  if [[ $_singleSetting == "on" && -n $newvalue ]]; then
    if [[ $newvalue != "$_value" ]]; then
      echo "[Error] $_errorMessage" >&2
      EXITCODE=1
    else
      echo "$_successMessage"
    fi
  fi

  echo ""
}

# Call the function to parse command-line arguments
parse_commandline "$@"

# If script form values are set, replace the command-line parameters with these values
if [[ -n $powerSourceSetting ]]; then
  _arg_powerSourceSetting="$powerSourceSetting"
fi
if [[ -n $screenTimeoutInMinutes ]]; then
  _arg_screenTimeout="$screenTimeoutInMinutes"
fi
if [[ -n $sleepTimeoutInMinutes ]]; then
  _arg_sleepTimeout="$sleepTimeoutInMinutes"
fi
if [[ -n $diskTimeoutInMinutes ]]; then
  _arg_diskTimeout="$diskTimeoutInMinutes"
fi
if [[ -n $powerNap ]]; then
  _arg_powernap="$powerNap"
fi
if [[ -n $terminalKeepAlive ]]; then
  _arg_terminalKeepAlive="$terminalKeepAlive"
fi
if [[ -n $dimTheDisplayOnBattery ]]; then
  _arg_dimOnBattery="$dimTheDisplayOnBattery"
fi
if [[ -n $lowPowerMode ]]; then
  _arg_lowPowerMode="$lowPowerMode"
fi
if [[ -n $tcpKeepAlive ]]; then
  _arg_tcpKeepAlive="$tcpKeepAlive"
fi
if [[ -n $wakeOnNetwork ]]; then
  _arg_wakeOneNetwork="$wakeOnNetwork"
fi

# Check if the device has battery options available
batteryOptions=$(pmset -g custom | grep "Battery Power")

# Validate the power source setting
if [[ -z $_arg_powerSourceSetting || ($_arg_powerSourceSetting != "Both" && $_arg_powerSourceSetting != "Plugged In" && $_arg_powerSourceSetting != "On Battery") ]]; then
  echo "[Error] An invalid power source was given '$_arg_powerSourceSetting'. The only valid options are 'Both', 'Plugged In', and 'On Battery'." >&2
  exit 1
fi

if [[ -z $_arg_screenTimeout && -z $_arg_sleepTimeout && -z $_arg_diskTimeout && -z $_arg_powernap && -z $_arg_terminalKeepAlive && -z $_arg_dimOnBattery && -z $_arg_wakeOneNetwork && -z $_arg_lowPowerMode && -z $_arg_tcpKeepAlive ]]; then
  PRINT_HELP=yes die "[Error] No action given to take. Please specify a power setting to set." 1
fi

# Check if setting battery power source on a device without a battery
if [[ $_arg_powerSourceSetting == "On Battery" && -z $batteryOptions ]]; then
  echo "[Error] Cannot set battery power source setting on a device that does not have a battery." >&2
  exit 1
fi

# Warn if trying to set battery power source on a device without a battery
if [[ $_arg_powerSourceSetting == "Both" && -z $batteryOptions ]]; then
  echo "[Warning] Cannot set battery power source setting on a device that does not have a battery. Ignoring battery power source settings."
fi

# Validate screen timeout argument
if [[ -n $_arg_screenTimeout && (! $_arg_screenTimeout =~ [0-9]+ || $_arg_screenTimeout -lt 0) ]]; then
  echo "[Error] An invalid screen timeout argument was given '$_arg_screenTimeout'. Please specify a positive number representing the desired timeout in minutes." >&2
  exit 1
fi

# Validate sleep timeout argument
if [[ -n $_arg_sleepTimeout && (! $_arg_sleepTimeout =~ [0-9]+ || $_arg_sleepTimeout -lt 0) ]]; then
  echo "[Error] An invalid sleep timeout argument was given '$_arg_sleepTimeout'. Please specify a positive number representing the desired timeout in minutes." >&2
  exit 1
fi

# Validate disk timeout argument
if [[ -n $_arg_diskTimeout && (! $_arg_diskTimeout =~ [0-9]+ || $_arg_diskTimeout -lt 0) ]]; then
  echo "[Error] An invalid disk timeout argument was given '$_arg_diskTimeout'. Please specify a positive number representing the desired timeout in minutes." >&2
  exit 1
fi

# Validate powernap setting
if [[ -n $_arg_powernap && $_arg_powernap != "Disable" && $_arg_powernap != "Enable" ]]; then
  echo "[Error] An invalid power nap setting was given '$_arg_powernap'. The only valid options are 'Disable' or 'Enable'." >&2
  exit 1
fi

# Validate terminal keep alive setting
if [[ -n $_arg_terminalKeepAlive && $_arg_terminalKeepAlive != "Disable" && $_arg_terminalKeepAlive != "Enable" ]]; then
  echo "[Error] An invalid terminal keep alive setting was given '$_arg_terminalKeepAlive'. The only valid options are 'Disable' or 'Enable'." >&2
  exit 1
fi

# Validate dim on battery setting
if [[ -n $_arg_dimOnBattery && $_arg_dimOnBattery != "Disable" && $_arg_dimOnBattery != "Enable" ]]; then
  echo "[Error] An invalid dim on battery setting was given '$_arg_dimOnBattery'. The only valid options are 'Disable' or 'Enable'." >&2
  exit 1
fi

# Validate low power mode setting
if [[ -n $_arg_lowPowerMode && $_arg_lowPowerMode != "Disable" && $_arg_lowPowerMode != "Enable" ]]; then
  echo "[Error] An invalid low power mode setting was given '$_arg_lowPowerMode'. The only valid options are 'Disable' or 'Enable'." >&2
  exit 1
fi

# Validate TCP keep alive setting
if [[ -n $_arg_tcpKeepAlive && $_arg_tcpKeepAlive != "Disable" && $_arg_tcpKeepAlive != "Enable" ]]; then
  echo "[Error] An invalid tcp keep alive setting was given '$_arg_tcpKeepAlive'. The only valid options are 'Disable' or 'Enable'." >&2
  exit 1
fi

# Validate wake on network setting
if [[ -n $_arg_wakeOneNetwork && $_arg_wakeOneNetwork != "Never" && $_arg_wakeOneNetwork != "Always" && $_arg_wakeOneNetwork != "Only on Power Adapter" ]]; then
  echo "[Error] An invalid wake one network setting was given '$_arg_wakeOneNetwork'. The only valid options are 'Never', 'Always' and 'Only on Power Adapter'." >&2
  exit 1
fi

# Set screen timeout if provided
if [[ -n $_arg_screenTimeout ]]; then
  timeoutError="Failed to set screen timeout of '$_arg_screenTimeout' minutes"
  timeoutSuccess="Successfully set screen timeout of '$_arg_screenTimeout' minutes"

  # Call the function to set the power setting for screen timeout
  set_powersetting --setting "displaysleep" --value "$_arg_screenTimeout" --errorMessage "$timeoutError" --successMessage "$timeoutSuccess"
fi

# Set sleep timeout if provided
if [[ -n $_arg_sleepTimeout ]]; then
  sleepError="Failed to set sleep timeout of '$_arg_sleepTimeout' minutes"
  sleepSuccess="Successfully set sleep timeout of '$_arg_sleepTimeout' minutes"

  # Call the function to set the power setting for sleep timeout
  set_powersetting --setting "sleep" --value "$_arg_sleepTimeout" --errorMessage "$sleepError" --successMessage "$sleepSuccess"
fi

# Set disk timeout if provided
if [[ -n $_arg_diskTimeout ]]; then
  diskError="Failed to set disk timeout of '$_arg_diskTimeout' minutes"
  diskSuccess="Successfully set disk timeout of '$_arg_diskTimeout' minutes"

  # Call the function to set the power setting for disk timeout
  set_powersetting --setting "disksleep" --value "$_arg_diskTimeout" --errorMessage "$diskError" --successMessage "$diskSuccess"
fi

# Set power nap setting if provided
if [[ -n $_arg_powernap ]]; then
  if [[ $_arg_powernap == "Enable" ]]; then
    _powernap_setting=1
    napError="Failed to enable powernap"
    napSuccess="Successfully enabled powernap"
  else
    _powernap_setting=0
    napError="Failed to disable powernap"
    napSuccess="Successfully disabled powernap"
  fi

  # Call the function to set the power setting for power nap
  set_powersetting --setting "powernap" --value "$_powernap_setting" --errorMessage "$napError" --successMessage "$napSuccess"
fi

# Set terminal keep alive setting if provided
if [[ -n $_arg_terminalKeepAlive ]]; then
  if [[ $_arg_terminalKeepAlive == "Enable" ]]; then
    _terminal_setting=1
    terminalError="Failed to enable terminal keep alive"
    terminalSuccess="Successfully terminal keep alive"
  else
    _terminal_setting=0
    terminalError="Failed to disable terminal keep alive"
    terminalSuccess="Successfully disabled terminal keep alive"
  fi

  # Call the function to set the power setting for terminal keep alive
  set_powersetting --setting "ttyskeepawake" --value "$_terminal_setting" --errorMessage "$terminalError" --successMessage "$terminalSuccess"
fi

# Set the "dim on battery" setting if the argument is provided
if [[ -n $_arg_dimOnBattery ]]; then
  if [[ $_arg_dimOnBattery == "Enable" ]]; then
    _dim_setting=1
    dimError="Failed to enable the setting 'dim on battery'."
    dimSuccess="Successfully enabled the setting 'dim on battery'."
  else
    _dim_setting=0
    dimError="Failed to disable the setting 'dim on battery'."
    dimSuccess="Successfully disabled the setting 'dim on battery'."
  fi

  # Call the function to set the power setting for dim on battery
  set_powersetting --setting "lessbright" --value "$_dim_setting" --errorMessage "$dimError" --successMessage "$dimSuccess" --singleSetting
fi

# Set the low power mode setting if the argument is provided
if [[ -n $_arg_lowPowerMode ]]; then
  if [[ $_arg_lowPowerMode == "Enable" ]]; then
    _lpm_setting=1
    lpmError="Failed to enable low power mode"
    lpmSuccess="Successfully enabled low power mode"
  else
    _lpm_setting=0
    lpmError="Failed to disable low power mode"
    lpmSuccess="Successfully disabled low power mode"
  fi

  # Call the function to set the power setting for low power mode
  set_powersetting --setting "lowpowermode" --value "$_lpm_setting" --errorMessage "$lpmError" --successMessage "$lpmSuccess"
fi

# Set the TCP keep alive setting if the argument is provided
if [[ -n $_arg_tcpKeepAlive ]]; then
  if [[ $_arg_tcpKeepAlive == "Enable" ]]; then
    _tcp_setting=1
    tcpError="Failed to enable tcp keep alive"
    tcpSuccess="Successfully enabled tcp keep alive"
  else
    _tcp_setting=0
    tcpError="Failed to disable tcp keep alive"
    tcpSuccess="Successfully disabled tcp keep alive"
  fi

  # Call the function to set the power setting for TCP keep alive
  set_powersetting --setting "tcpkeepalive" --value "$_tcp_setting" --errorMessage "$tcpError" --successMessage "$tcpSuccess"
fi

# Set the wake on network setting if the argument is provided
if [[ -n $_arg_wakeOneNetwork ]]; then
  case $_arg_wakeOneNetwork in
  "Never")
    pmset -a womp 0
    ;;
  "Always")
    pmset -a womp 1
    ;;
  "Only on Power Adapter")
    if [[ -n $batteryOptions ]]; then
      pmset -b womp 0
    fi
    pmset -c womp 1
    ;;
  esac

  # Retrieve and verify the new value of the wake on network setting
  newvalue=$(pmset -g custom | grep -w "womp")
  if [[ -z $batteryOptions ]]; then
    # Get the new value for the "Plugged In" policy if no battery options
    newvalueAC=$(echo "$newvalue" | xargs | cut -f2 -d' ')
  else
    # Get the new values for both "Battery" and "Plugged In" policies
    newvalueDC=$(echo "$newvalue" | xargs | cut -f2 -d' ')
    newvalueAC=$(echo "$newvalue" | xargs | cut -f4 -d' ')
  fi

  # Check and report the new value for "Always" and "Only on Power Adapter" settings
  if [[ $_arg_wakeOneNetwork == "Always" || $_arg_wakeOneNetwork == "Only on Power Adapter" ]]; then
    if [[ $newvalueAC != 1 ]]; then
      echo "[Error] Unable to enable wake on network on the 'Plugged In' Policy." >&2
      EXITCODE=1
    else
      echo "Successfully enabled wake on network on the 'Plugged In' Policy."
    fi
  fi

  # Check and report the new value for "Never" setting
  if [[ $_arg_wakeOneNetwork == "Never" ]]; then
    if [[ $newvalueAC != 0 ]]; then
      echo "[Error] Unable to disable wake on network on the 'Plugged In' Policy." >&2
      EXITCODE=1
    else
      echo "Successfully disabled wake on network on the 'Plugged In' Policy."
    fi
  fi

  # Check and report the new value for "Always" setting on battery
  if [[ -n $batteryOptions && $_arg_wakeOneNetwork == "Always" ]]; then
    if [[ $newvalueDC != 1 ]]; then
      echo "[Error] Unable to enable wake on network on the 'Battery' Policy." >&2
      EXITCODE=1
    else
      echo "Successfully enabled wake on network on the 'Battery' Policy."
    fi
  fi

  # Check and report the new value for "Never" and "Only on Power Adapter" settings on battery
  if [[ -n $batteryOptions && ($_arg_wakeOneNetwork == "Never" || $_arg_wakeOneNetwork == "Only on Power Adapter") ]]; then
    if [[ $newvalueDC != 0 ]]; then
      echo "[Error] Unable to disable wake on network on the 'Battery' Policy." >&2
      EXITCODE=1
    else
      echo "Successfully disabled wake on network on the 'Battery' Policy."
    fi
  fi
fi

# Exit the script with the set exit code if it is defined
if [[ -n $EXITCODE ]]; then
  exit "$EXITCODE"
fi

 

Cosa fa questo script per gestire le impostazioni di alimentazione in macOS

Questo script è uno strumento completo per gestire le impostazioni di alimentazione in macOS. Supporta opzioni sia per la modalità a batteria che per quella con dispositivo collegato alla corrente, gestendo parametri quali:

• Timeout dello schermo: Tempo prima che il display si spenga.
• Timeout per la sospensione: Tempo prima che il sistema entri in modalità sospensione.
• Spin-down del disco: Tempo prima che il disco si spenga durante l’inattività.
• Power Nap: Aggiorna i dati del sistema durante la sospensione.
• Modalità a basso consumo: Riduce il consumo di energia per prolungare la durata della batteria.
• TCP Keepalive: Mantiene attive le connessioni di rete.
• Wake on Network: Risveglia il dispositivo dalla sospensione alla ricezione di un pacchetto di rete.

Lo script utilizza il comando pmset per configurare queste impostazioni, con una gestione degli errori e una verifica migliorate per garantire il successo dell’applicazione.

Come funziona lo script per gestire le impostazioni di alimentazione in macOS

Parsing degli argomenti

Lo script per gestire le impostazioni di alimentazione in macOS accetta una serie di argomenti da riga di comando, come –screenTimeout, –sleepTimeout e –lowPowerMode. Ogni parametro può essere personalizzato per applicare le impostazioni per l’alimentazione a batteria, per la modalità plug-in o per entrambe. Se vengono forniti argomenti errati o non validi, lo script mostra messaggi di errore dettagliati.

Convalida delle impostazioni in corso

Prima di applicare le modifiche, lo script per gestire le impostazioni di alimentazione in macOS convalida i valori di input per garantire la compatibilità con macOS. Per esempio:

• I valori di timeout dello schermo devono essere numeri interi non negativi.
• Le impostazioni di Power Nap possono essere solo “Abilita” o “Disabilita”.
• Il comportamento di Wake-on-network deve essere in linea con le funzionalità di macOS.

Caso d’uso ipotetico

Immagina un amministratore IT che gestisce un parco computer portatili macOS in un ambiente di livello enterprise. Vuole assicurarsi che:

• Gli schermi si spengano dopo 5 minuti di inattività per risparmiare energia.
• I dispositivi entrino in modalità sleep dopo 10 minuti di funzionamento a batteria.
• Power Nap sia disattivato per risparmiare risorse durante le ore non lavorative.

Usando questo script per gestire le impostazioni di alimentazione in macOS, può farlo, garantendo la coerenza e riducendo i tempi di configurazione manuale.

Confronto tra lo script per gestire le impostazioni di alimentazione in macOS e altri metodi

Il comando pmset di macOS è potente, ma richiede di essere inserito manualmente e non prevede meccanismi di convalida delle impostazioni. Gli strumenti basati su GUI, come Preferenze di sistema, offrono un’automazione limitata e non supportano la configurazione in blocco. Questo script per gestire le impostazioni di alimentazione in macOS rappresenta una soluzione ottimale combinando la flessibilità di pmset con la facilità dell’automazione.

Domande comuni sulla script per gestire le impostazioni di alimentazione in macOS

Questo script per gestire le impostazioni di alimentazione in macOS può funzionare su dispositivi senza batteria?

Sì, ma le impostazioni specifiche della batteria saranno ignorate. Lo script per gestire le impostazioni di alimentazione in macOS rileva la disponibilità della batteria e genera avvisi se vengono utilizzate opzioni relative alla batteria su dispositivi che ne sono sprovvisti.

Cosa succede se fornisco argomenti non validi?

Lo script per gestire le impostazioni di alimentazione in macOS convalida tutti gli input e fornisce messaggi di errore dettagliati se un argomento non è corretto.

È sicuro usare Power Nap?

Power Nap può consumare risorse aggiuntive durante la sospensione. Si consiglia di disattivarla negli ambienti che richiedono la massima efficienza energetica.

Implicazioni più ampie per la sicurezza e l’efficienza IT

La gestione automatizzata dell’alimentazione contribuisce all’efficienza energetica e riduce le emissioni di carbonio, allineandosi agli obiettivi di sostenibilità aziendale. Inoltre, funzioni come la disabilitazione di Power Nap possono migliorare la sicurezza riducendo al minimo i processi in background e i potenziali vettori di attacco.

Best practice per l’utilizzo dello script

1. Testa le configurazioni: Esegui lo script per gestire le impostazioni di alimentazione in macOS su un dispositivo di prova prima di distribuirlo per assicurarti che le impostazioni si comportino come previsto.
2. Documenta le modifiche: Conserva un registro delle impostazioni applicate per la risoluzione dei problemi e la conformità.
3. Monitora le prestazioni: Verifica regolarmente che i dispositivi rispettino le impostazioni di alimentazione configurate.

Considerazioni finali

La gestione dell’alimentazione è un aspetto critico dell’amministrazione dei sistemi macOS. Questo script semplifica il processo, consentendo ai professionisti IT di configurare e applicare in modo efficiente le impostazioni di alimentazione in macOS. Per gli MSP e le aziende che desiderano semplificare la gestione dei dispositivi macOS, soluzioni come NinjaOne offrono strumenti avanzati di monitoraggio e automazione, garantendo che i dispositivi rimangano ottimizzati e sicuri.