puppet_metadata 5.3.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd19aa83607d45feded94b42519f1d8b31e19ca4806d36b5adf6031e74f7a709
-  data.tar.gz: c88d61173b62fc78a4f40f85d84add61933071b5f7d66000b702dd2ac3b4e6c1
+  metadata.gz: 9ac5190193748a7ec1f0d61f9c7ef2bac509bb78e1e854b373362e421cf4a656
+  data.tar.gz: dcafc939d26360e09cd7525b72ca2e4268802d2e4103d4c61b14570a4700a402
 SHA512:
-  metadata.gz: 725d91a9e780c4cb4249f62e76beb055c64847bf11352e5c8be776139ec8cb266cca6fc3ec2927b81628f2ee8e758a3985e80d2487b6da5e53946478f2e56ac0
-  data.tar.gz: 50ecf56b078348a0b60356b8eebc0b645bb945ae7cab4c09601d5e42e5a544ffaba7d8b84cc0214567297c73254a77a9485f90e5dbf4b8d3c610bc8fbfc43500
+  metadata.gz: 7e18f077b5298afce2a703c1c1c66d941f447a72740dc29105b57d9cd1cb929ed4c4a537a021950ca4ed2c1cda06eaf40d3f1e8c927f7b05212b1f241e0db331
+  data.tar.gz: b16239f27e4a1c74174816fe1b59bd28f1503f4839fc52bfc952f3c6ce1fe3d70bdccacb138f136e1f75a1423ef1537d574c07b2625bc044a8a12094ade701a6

data/README.md

@@ -10,6 +10,120 @@
 
 The gem intends to provide an abstraction over Puppet's metadata.json file. Its API allow easy iteration over its illogical data structures.
 
+- [puppet\_metadata](#puppet_metadata)
+  - [New CLI interface in 6.0.0](#new-cli-interface-in-600)
+  - [Manage OS versions in metadata.json](#manage-os-versions-in-metadatajson)
+    - [List supported OS versions](#list-supported-os-versions)
+    - [Add missing supported OS versions](#add-missing-supported-os-versions)
+    - [Remove EOL OS versions](#remove-eol-os-versions)
+  - [Generating Github Actions outputs](#generating-github-actions-outputs)
+  - [Work with the API](#work-with-the-api)
+    - [List all supported operating systems](#list-all-supported-operating-systems)
+    - [List supported major puppet versions](#list-supported-major-puppet-versions)
+    - [Check if an operating systems is supported](#check-if-an-operating-systems-is-supported)
+    - [Get all versions for an Operating System that are not EoL](#get-all-versions-for-an-operating-system-that-are-not-eol)
+    - [Get all versions for an Operating System that are not EoL after a certain date](#get-all-versions-for-an-operating-system-that-are-not-eol-after-a-certain-date)
+  - [Updating OS EOL dates](#updating-os-eol-dates)
+    - [Adding new operating systems](#adding-new-operating-systems)
+  - [List supported setfiles](#list-supported-setfiles)
+  - [Transfer Notice](#transfer-notice)
+  - [License](#license)
+  - [Release information](#release-information)
+
+## New CLI interface in 6.0.0
+
+Version 6.0.0 introduces a new CLI interface, in `bin/puppet-metadata`.
+It provides a new way of handling default CLI options, like the path to the metadata.json.
+
+```
+$ bundle exec bin/puppet-metadata --help
+Usage: puppet-metadata [options] <action> [options]
+        --filename METADATA          Metadata filename
+
+ACTIONS
+  os-versions         Manage operating system versions in metadata.json
+  setfiles            Show the various setfiles supported by the metadata
+
+See 'puppet-metadata ACTION --help' for more information on a specific action.
+```
+
+`--filename ` is optional.
+If ommitted, a metadata.json in the current directory will be parsed.
+
+Each action is implemented as a file in `lib/puppet_metadata/command/*rb` and automatically loaded via `lib/puppet_metadata/command.rb`.
+
+## Manage OS versions in metadata.json
+
+The `os-versions` command provides a unified interface to view, add, and remove operating system versions in the metadata.json.
+
+### List supported OS versions
+
+By default, `os-versions` shows which OS versions in your metadata.json are still supported and which are EOL:
+
+```
+$ bundle exec puppet-metadata os-versions
+module-name supports these non-EOL operating system versions:
+  AlmaLinux: 8, 9
+  CentOS: 9
+  Debian: 11, 12
+  OracleLinux: 8, 9, 10
+  RedHat: 8, 9
+  Rocky: 8, 9
+  Ubuntu: 22.04, 24.04
+
+module-name supports these EOL operating system versions:
+  Fedora: 40
+  Ubuntu: 20.04
+```
+
+You can filter to a specific OS:
+
+```
+$ bundle exec puppet-metadata os-versions --os Ubuntu
+module-name supports these non-EOL operating system versions:
+  Ubuntu: 22.04, 24.04
+
+module-name supports these EOL operating system versions:
+  Ubuntu: 20.04
+```
+
+### Add missing supported OS versions
+
+Use `--add-missing` to automatically add all non-EOL OS versions to metadata.json:
+
+```
+$ bundle exec puppet-metadata os-versions --add-missing
+Added support:
+CentOS => 10
+Debian => 13
+```
+
+These OSes are exceptions (to align with [beaker-hostgenerator](https://github.com/voxpupuli/beaker-hostgenerator) support):
+
+- For SLES, only major versions are added.
+- For Ubuntu, only LTS versions are added.
+
+### Remove EOL OS versions
+
+Use `--remove-eol` to automatically remove all EOL OS versions from metadata.json:
+
+```
+$ bundle exec puppet-metadata os-versions --remove-eol
+Removed EOL operating systems:
+CentOS => 7, 8
+Debian => 9, 10
+Ubuntu => 20.04
+```
+
+You can preview changes without modifying metadata.json using `--noop`:
+
+```
+$ bundle exec puppet-metadata os-versions --add-missing --noop
+[NOOP] Would add support:
+CentOS => 10
+Debian => 13
+```
+
 ## Generating Github Actions outputs
 
 To get outputs [usable in Github Actions](https://docs.github.com/en/free-pro-team@latest/actions/reference/workflow-commands-for-github-actions), there is the `metadata2gha` command available. This generates based on metadata.json, such as [Beaker](https://github.com/voxpupuli/beaker) setfiles, Puppet major versions and a Puppet unit test matrix.
@@ -71,39 +185,6 @@ Beaker test matrix formatted for readability
 ]
 ```
 
-It is possible to specify the path to metadata.json and customize the setfiles. For example, to ensure the setfiles use FQDNs and apply the [systemd PIDFile workaround under docker](https://github.com/docker/for-linux/issues/835). This either means either using an older image (CentOS 7, Ubuntu 16.04) or skipping (CentOS 8).
-
-```console
-$ metadata2gha --use-fqdn --pidfile-workaround true /path/to/metadata.json
-```
-
-This results in the following JSON data
-```json
-[
-  {
-    "name": "Puppet 7 - CentOS 7",
-    "env": {
-      "BEAKER_PUPPET_COLLECTION": "puppet7",
-      "BEAKER_SETFILE": "centos7-64{hostname=centos7-64-puppet7.example.com,image=centos:7.6.1810}"
-    }
-  },
-  {
-    "name": "Puppet 7 - Debian 12",
-    "env": {
-      "BEAKER_PUPPET_COLLECTION": "puppet7",
-      "BEAKER_SETFILE": "debian12-64{hostname=debian12-64-puppet7.example.com}"
-    }
-  },
-  {
-    "name": "Puppet 7 - Ubuntu 22.04",
-    "env": {
-      "BEAKER_PUPPET_COLLECTION": "puppet7",
-      "BEAKER_SETFILE": "ubuntu2204-64{hostname=ubuntu2204-64-puppet7.example.com}"
-    }
-  }
-]
-```
-
 If you need custom hostname or multiple hosts in your integration tests this could be achived by using the --beaker-hosts option
 
 Option argument is 'HOSTNAME:ROLES;HOSTNAME:..;..' where
@@ -212,6 +293,60 @@ The metadata object has several different methods that we can call
 [7] pry(main)>
 ```
 
+### Get all versions for an Operating System that are not EoL
+
+```
+[1] pry(main)> require 'puppet_metadata'
+=> true
+[2] pry(main)> PuppetMetadata::OperatingSystem.supported_releases('RedHat')
+=> ["8", "9", "10"]
+[3] pry(main)> PuppetMetadata::OperatingSystem.supported_releases('windows')
+=> []
+[4] pry(main)>
+```
+
+**For Operating systems without any known releases, an empty array is returned.**
+
+### Get all versions for an Operating System that are not EoL after a certain date
+
+```
+[1] pry(main)> require 'puppet_metadata'
+=> true
+[2] pry(main)> PuppetMetadata::OperatingSystem.supported_releases('CentOS', Date.parse('2025-04-15'))
+=> ["9", "10"]
+[3] pry(main)>
+```
+
+CentOS 8 and older aren't listed.
+8 is EoL since 2024-05-31.
+
+## Updating OS EOL dates
+
+The EOL dates for operating systems are stored in `data/eol_dates.json` and are automatically updated weekly via GitHub Actions using data from [endoflife.date](https://endoflife.date/).
+
+- For Amazon Linux, this is security support, not standard support.
+- For Debian, this is extended life cycle, not standard support.
+- For CentOS, this is security support, not active support.
+- For OracleLinux, this is basic support, not extended support.
+- For RedHat, this is maintenance support, not extended life cycle.
+- For Rocky, this is security support, not active support.
+- For SLES, this is general support, not long term service pack support.
+
+To manually update the EOL dates:
+
+```bash
+./bin/update_eol_dates
+```
+
+### Adding new operating systems
+
+To add a new operating system to the EOL tracking:
+
+1. Add an entry to the `OS_MAPPING` hash in `bin/update_eol_dates`
+2. Map it to the corresponding [endoflife.date product identifier](https://endoflife.date/docs/api/)
+3. Run `./bin/update_eol_dates` to fetch the data
+4. If the OS requires special handling (like Amazon Linux which uses multiple API endpoints), add a custom handler function
+
 ## List supported setfiles
 
 When running beaker on the CLI, you can specify a specific setfile. `puppet_metadata` provides `bin/setfiles` to list all setfiles:

data/bin/metadata2gha

@@ -3,10 +3,7 @@ require 'optparse'
 require 'json'
 require 'puppet_metadata'
 
-PidfileWorkaround = Object.new
-
 options = {
-  beaker_pidfile_workaround: false,
   domain: nil,
   minimum_major_puppet_version: nil,
   beaker_fact: nil,
@@ -14,20 +11,8 @@ options = {
 }
 
 OptionParser.new do |opts|
-  opts.accept(PidfileWorkaround) do |value|
-    case value
-    when 'true'
-      true
-    when 'false'
-      false
-    else
-      value.split(',')
-    end
-  end
-
   opts.banner = "Usage: #{$0} [options] metadata"
 
-  opts.on('--pidfile-workaround VALUE', 'Generate the systemd PIDFile workaround to work around a docker bug', PidfileWorkaround) { |opt| options[:beaker_pidfile_workaround] = opt }
   opts.on('-d', '--domain VALUE', 'the domain for the box, only used when --use-fqdn is set to true') { |opt| options[:domain] = opt }
   opts.on('--minimum-major-puppet-version VERSION', "Don't create actions for Puppet versions less than this major version") { |opt| options[:minimum_major_puppet_version] = opt }
   opts.on('--beaker-facter FACT:LABEL:VALUES', 'Expand the matrix based on a fact. Separate values using commas') do |opt|

data/bin/puppet-metadata

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# optparse subcommands inspired by https://gist.github.com/rkumar/445735
+
+require 'optparse'
+require 'optparse/date'
+
+require 'puppet_metadata'
+
+def main
+  subcommands = PuppetMetadata::BaseCommand.commands
+
+  options = {}
+
+  parsers = subcommands.transform_values { |cls| cls.parser(options) }
+
+  global = OptionParser.new do |opts|
+    opts.banner = "Usage: #{opts.program_name} [options] <action> [options]"
+    opts.on('--filename METADATA', 'Metadata filename') do |value|
+      options[:filename] = value
+    end
+
+    opts.separator ''
+    opts.separator 'ACTIONS'
+    width = subcommands.keys.max { |command, _parser| command.length }.length
+    parsers.each do |command, parser|
+      # TODO: positional argument
+      parser.banner = "Usage: #{opts.program_name} #{command} [options]"
+      opts.separator "  #{command.ljust(width + 4)}#{parser.program_name}"
+    end
+    opts.separator ''
+    opts.separator "See '#{opts.program_name} ACTION --help' for more information on a specific action."
+  end
+
+  begin
+    global.order!
+  rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
+    warn e.cause ? "#{e}: #{e.cause}" : e
+    warn ''
+    global.help_exit
+  end
+  unless (command = ARGV.shift)
+    puts global
+    exit 1
+  end
+  if (parser = parsers[command])
+    begin
+      arguments = parser.parse!
+    rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
+      warn e.cause ? "#{e}: #{e.cause}" : e
+      warn ''
+      parser.help_exit
+    end
+
+    command = subcommands[command].new(arguments, options)
+    command.run
+  else
+    puts global
+    exit 1
+  end
+end
+
+main

data/bin/setfiles

@@ -16,13 +16,14 @@ rescue StandardError => e
 end
 
 options = {
-  beaker_pidfile_workaround: false,
   domain: 'example.com',
   minimum_major_puppet_version: nil,
   beaker_fact: nil,
   beaker_hosts: nil,
 }
 
+warn 'Command deprecated - call puppet-metadata setfiles instead'
+
 metadata.github_actions(options).outputs[:puppet_beaker_test_matrix].each do |os|
   puts "BEAKER_SETFILE=\"#{os[:env]['BEAKER_SETFILE']}\""
 end

data/bin/update_eol_dates

@@ -0,0 +1,267 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This script updates the EOL dates data file using the endoflife.date API
+# It can be run manually or via GitHub Actions automation
+
+require 'json'
+require 'net/http'
+require 'uri'
+require 'date'
+
+# Mapping between internal OS names and endoflife.date identifiers; only OSes listed here will be updated
+OS_MAPPING = {
+  'AlmaLinux' => 'almalinux',
+  'Amazon' => 'amazon-linux',
+  'CentOS' => 'centos',
+  'Debian' => 'debian',
+  'OracleLinux' => 'oracle-linux',
+  'Fedora' => 'fedora',
+  'FreeBSD' => 'freebsd',
+  'RedHat' => 'rhel',
+  'Rocky' => 'rocky-linux',
+  'Scientific' => nil, # Not in endoflife.date
+  'SLES' => 'sles',
+  'Ubuntu' => 'ubuntu',
+}.freeze
+
+def fetch_eol_data(product)
+  uri = URI("https://endoflife.date/api/#{product}.json")
+  response = Net::HTTP.get_response(uri)
+
+  unless response.is_a?(Net::HTTPSuccess)
+    warn "Failed to fetch data for #{product}: #{response.code} #{response.message}"
+    return nil
+  end
+
+  JSON.parse(response.body)
+rescue StandardError => e
+  warn "Error fetching data for #{product}: #{e.message}"
+  nil
+end
+
+def parse_eol_date(eol_value)
+  # endoflife.date returns different formats:
+  # - Date string: "2024-06-30"
+  # - Boolean false: not yet EOL
+  # - Boolean true: EOL date unknown
+  case eol_value
+  when String
+    # Validate it's a proper date
+    Date.parse(eol_value)
+    eol_value
+  when false, 'false', true, 'true'
+    # false: Not yet EOL
+    # true: EOL date unknown - keep existing data or skip
+    nil
+  end
+rescue Date::Error
+  nil
+end
+
+def update_os_data(os_name, product_id, current_data)
+  return current_data unless product_id
+
+  puts "Fetching data for #{os_name} (#{product_id})..."
+  api_data = fetch_eol_data(product_id)
+  return current_data unless api_data
+
+  updated_data = {}
+
+  api_data.each do |cycle|
+    # The API returns an array of cycles, each with:
+    # - cycle: version number
+    # - eol: end of life date or boolean
+    version = cycle['cycle'].to_s
+    eol_value = if os_name == 'Debian' && cycle.key?('extendedSupport')
+                  cycle['extendedSupport']
+                else
+                  cycle['eol']
+                end
+
+    eol = parse_eol_date(eol_value)
+
+    if eol
+      updated_data[version] = eol
+      puts "  #{version}: #{eol}"
+    elsif eol_value == false || cycle['eol'] == false
+      # Track versions that aren't EOL yet
+      updated_data[version] = nil
+      puts "  #{version}: not yet EOL"
+    end
+  end
+
+  current_data[os_name]&.each do |version, date|
+    unless updated_data.key?(version)
+      puts "  Preserving #{version}: #{date || 'nil'} (not in API)"
+      updated_data[version] = date
+    end
+  end
+
+  updated_data
+end
+
+def handle_amazon_linux(current_data)
+  puts 'Fetching data for Amazon Linux...'
+
+  updated_data = {}
+
+  al_data = fetch_eol_data('amazon-linux')
+  al_data&.each do |cycle|
+    version = cycle['cycle'].to_s
+    eol = parse_eol_date(cycle['eol'])
+
+    # Map version "2" to "2.0" for compatibility with existing metadata entries
+    version = '2.0' if version == '2'
+
+    if eol
+      updated_data[version] = eol
+      puts "  #{version}: #{eol}"
+    elsif cycle['eol'] == false
+      updated_data[version] = nil
+      puts "  #{version}: not yet EOL"
+    end
+  end
+
+  current_data['Amazon']&.each do |version, date|
+    unless updated_data.key?(version)
+      puts "  Preserving #{version}: #{date || 'nil'} (not in API)"
+      updated_data[version] = date
+    end
+  end
+
+  updated_data
+end
+
+def handle_centos(current_data)
+  puts 'Fetching data for CentOS...'
+
+  updated_data = {}
+
+  centos_data = fetch_eol_data('centos')
+  centos_data&.each do |cycle|
+    version = cycle['cycle'].to_s
+    eol = parse_eol_date(cycle['eol'])
+
+    if eol
+      updated_data[version] = eol
+      puts "  #{version}: #{eol}"
+    elsif cycle['eol'] == false
+      updated_data[version] = nil
+      puts "  #{version}: not yet EOL"
+    end
+  end
+
+  # Fetch CentOS Stream versions after CentOS. Stream takes precedence for overlapping versions.
+  stream_data = fetch_eol_data('centos-stream')
+  stream_data&.each do |cycle|
+    version = cycle['cycle'].to_s
+    eol = parse_eol_date(cycle['eol'])
+
+    if eol
+      updated_data[version] = eol
+      puts "  #{version}: #{eol}"
+    elsif cycle['eol'] == false
+      updated_data[version] = nil
+      puts "  #{version}: not yet EOL"
+    end
+  end
+
+  current_data['CentOS']&.each do |version, date|
+    unless updated_data.key?(version)
+      puts "  Preserving #{version}: #{date || 'nil'} (not in API)"
+      updated_data[version] = date
+    end
+  end
+
+  updated_data
+end
+
+def handle_ubuntu(current_data)
+  puts 'Fetching data for Ubuntu...'
+
+  updated_data = {}
+
+  ubuntu_data = fetch_eol_data('ubuntu')
+  ubuntu_data&.each do |cycle|
+    version = cycle['cycle'].to_s
+    eol = parse_eol_date(cycle['eol'])
+
+    if eol
+      updated_data[version] = eol
+      puts "  #{version}: #{eol}"
+    elsif cycle['eol'] == false
+      updated_data[version] = nil
+      puts "  #{version}: not yet EOL"
+    end
+  end
+
+  current_data['Ubuntu']&.each do |version, date|
+    next if updated_data.key?(version)
+
+    puts "  Preserving #{version}: #{date || 'nil'} (not in API)"
+    updated_data[version] = date
+  end
+
+  updated_data
+end
+
+def main
+  data_file = File.expand_path('../data/eol_dates.json', __dir__)
+
+  # Load current data
+  current_data = JSON.parse(File.read(data_file))
+
+  # Update each OS
+  updated_data = {}
+
+  OS_MAPPING.each do |os_name, product_id|
+    if os_name == 'Amazon'
+      updated_data[os_name] = handle_amazon_linux(current_data)
+    elsif os_name == 'CentOS'
+      updated_data[os_name] = handle_centos(current_data)
+    elsif os_name == 'Ubuntu'
+      updated_data[os_name] = handle_ubuntu(current_data)
+    elsif product_id
+      updated_data[os_name] = update_os_data(os_name, product_id, current_data)
+    else
+      puts "Preserving #{os_name} (not in endoflife.date API)"
+      updated_data[os_name] = current_data[os_name]
+    end
+  end
+
+  # Sort each OS's versions by EOL date (latest EOL first, then nulls)
+  sorted_data = {}
+  updated_data.each do |os_name, versions|
+    sorted_versions = versions.sort do |a, b|
+      version_a, eol_a = a
+      version_b, eol_b = b
+
+      # Handle nil values (not yet EOL) - they go first
+      return -1 if eol_a.nil? && !eol_b.nil?
+      return 1 if !eol_a.nil? && eol_b.nil?
+
+      if eol_a == eol_b
+        # Same EOL date (or both nil) - sort by version number descending
+        Gem::Version.new(version_b) <=> Gem::Version.new(version_a)
+      else
+        # Different EOL dates - sort by date descending (later date first)
+        (eol_b || '0000-00-00') <=> (eol_a || '0000-00-00')
+      end
+    end.to_h
+    sorted_data[os_name] = sorted_versions
+  end
+
+  File.write(data_file, "#{JSON.pretty_generate(sorted_data)}\n")
+  puts "\nUpdated #{data_file}"
+
+  if current_data == updated_data
+    puts 'No changes detected.'
+    exit 0
+  else
+    puts 'Changes detected!'
+    exit 1 # Exit with 1 to signal changes (useful for CI)
+  end
+end
+
+main if __FILE__ == $0