Module: Pkg::Platforms

Included in:
Paths
Defined in:
lib/packaging/platforms.rb

Constant Summary collapse

DEBIAN_SOURCE_FORMATS = 
['debian.tar.gz', 'orig.tar.gz', 'dsc', 'changes']
PLATFORM_INFO =

Each element in this hash

{
  'aix' => {
    '7.1' => {
      architectures: ['power'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      repo: false,
    },
  },

  'debian' => {
    '10' => {
      codename: 'buster',
      architectures: ['amd64', 'i386'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    },
    '11' => {
      codename: 'bullseye',
      architectures: ['amd64'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    },
  },

  'el' => {
    '6' => {
      architectures: ['x86_64', 'i386'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
    '7' => {
      architectures: ['x86_64', 'ppc64le', 'aarch64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
    '8' => {
      architectures: ['x86_64', 'ppc64le', 'aarch64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
    '9' => {
      architectures: ['x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    }
  },

  'fedora' => {
    '36' => {
      architectures: ['x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
  },

  'osx' => {
    '10.15' => {
      architectures: ['x86_64'],
      package_format: 'dmg',
      repo: false,
    },
    '11' => {
      architectures: ['x86_64', 'arm64'],
      package_format: 'dmg',
      repo: false,
    },
    '12' => {
      architectures: ['x86_64', 'arm64'],
      package_format: 'dmg',
      repo: false,
    },
  },

  'redhatfips' => {
    '7' => {
      architectures: ['x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v3',
      repo: true,
    },
    '8' => {
      architectures: ['x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v3',
      repo: true,
    }
  },

  'sles' => {
    '11' => {
      architectures: ['x86_64', 'i386'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v3',
      repo: true,
    },
    '12' => {
      architectures: ['x86_64', 'ppc64le'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
    '15' => {
      architectures: ['x86_64', 'ppc64le'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
  },

  'solaris' => {
    '10' => {
      architectures: ['i386', 'sparc'],
      package_format: 'svr4',
      repo: false,
    },
    '11' => {
      architectures: ['i386', 'sparc'],
      package_format: 'ips',
      repo: false,
    },
  },

  'ubuntu' => {
    '18.04' => {
      codename: 'bionic',
      architectures: ['amd64', 'ppc64el', 'aarch64'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    },
    '20.04' => {
      codename: 'focal',
      architectures: ['amd64', 'aarch64'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    },
    '22.04' => {
      codename: 'jammy',
      architectures: ['amd64', 'aarch64'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    },
  },

  'windows' => {
    '2012' => {
      architectures: ['x86', 'x64'],
      package_format: 'msi',
      repo: false,
    }
  },
  'windowsfips' => {
    '2012' => {
      architectures: ['x64'],
      package_format: 'msi',
      repo: false,
    }
  },
}

Class Method Summary collapse

Class Method Details

.all_supported_package_formats ⇒ Array

Returns An Array of Strings, containing all the package formats and source package formats defined in Pkg::Platforms.

Returns:

  • (Array) —

    An Array of Strings, containing all the package formats and source package formats defined in Pkg::Platforms



314
315
316
317
318
319
320
321
322
323
 
# File 'lib/packaging/platforms.rb', line 314

def all_supported_package_formats
  fmts = formats
  source_fmts = PLATFORM_INFO.flat_map do |_, p|
    p.collect do |_, r|
      r[:source_package_formats]
    end
  end

  (fmts + source_fmts).flatten.compact.uniq.to_set.sort
end

.arches_for_codename(codename, include_source = false) ⇒ Object

Given a debian codename, return the arches that we build for that codename



353
354
355
356
 
# File 'lib/packaging/platforms.rb', line 353

def arches_for_codename(codename, include_source = false)
  platform, version = codename_to_platform_version(codename)
  arches_for_platform_version(platform, version, include_source)
end

.arches_for_platform_version(platform, version, include_source = false) ⇒ Object

Given a platform and version, return the arches that we build for that platform



370
371
372
373
374
375
376
377
378
379
380
381
382
383
 
# File 'lib/packaging/platforms.rb', line 370

def arches_for_platform_version(platform, version, include_source = false)
  platform_architectures = get_attribute_for_platform_version(platform, version, :architectures)
  # get_attribute_for_platform_version will raise an exception if the attribute
  # isn't found. We don't want this to be a fatal error, we just want to append
  # the source architecture if it's found
  source_architecture = []
  if include_source
    begin
      source_architecture = Array(get_attribute_for_platform_version(platform, version, :source_architecture))
    rescue StandardError # rubocop:disable Lint/SuppressedException
    end
  end
  return (platform_architectures + source_architecture).flatten
end

.by_deb ⇒ Array

Helper meta-method to return all platforms that use .deb packages

Returns:

  • (Array) —

    An Array of Strings, containing all platforms that use .deb packages



446
447
448
 
# File 'lib/packaging/platforms.rb', line 446

def by_deb
  by_package_format('deb')
end

.by_package_format(format) ⇒ Array

Returns An Array of Strings, containing all platforms that use <format> for their packages.

Parameters:

  • format (String) —

    The name of the packaging format to filter on

Returns:

  • (Array) —

    An Array of Strings, containing all platforms that use <format> for their packages



294
295
296
297
298
299
 
# File 'lib/packaging/platforms.rb', line 294

def by_package_format(format)
  PLATFORM_INFO.keys.select do |key|
    formats = PLATFORM_INFO[key].values.collect { |v| v[:package_format] }
    formats.include? format
  end
end

.by_rpm ⇒ Array

Helper meta-method to return all platforms that use .rpm packages

Returns:

  • (Array) —

    An Array of Strings, containing all platforms that use .rpm packages



455
456
457
 
# File 'lib/packaging/platforms.rb', line 455

def by_rpm
  by_package_format('rpm')
end

.codename_for_platform_version(platform, version) ⇒ Object

Given a debian platform and version, return the codename that corresponds to the set



348
349
350
 
# File 'lib/packaging/platforms.rb', line 348

def codename_for_platform_version(platform, version)
  get_attribute_for_platform_version(platform, version, :codename)
end

.codename_to_platform_version(codename) ⇒ Object

Given a debian codename, return the platform and version it corresponds to



337
338
339
340
341
342
343
344
 
# File 'lib/packaging/platforms.rb', line 337

def codename_to_platform_version(codename)
  PLATFORM_INFO.each do |platform, platform_versions|
    platform_versions.each do |version, info|
      return [platform, version] if info[:codename] && codename == info[:codename]
    end
  end
  raise "Unable to find a platform and version for '#{codename}'"
end

.codename_to_tags(codename) ⇒ Object

Given a codename, return an array of associated tags



359
360
361
362
363
364
365
366
 
# File 'lib/packaging/platforms.rb', line 359

def codename_to_tags(codename)
  platform_tags = []
  platform, version = codename_to_platform_version(codename)
  arches_for_codename(codename).each do |arch|
    platform_tags << "#{platform}-#{version}-#{arch}"
  end
  platform_tags
end

.codenames(platform = 'deb') ⇒ Array

Returns An Array of Strings, containing all of the codenames defined for a given Platform.

Parameters:

  • platform (String) (defaults to: 'deb') —

    Optional, the platform to list all codenames for. Defaults to ‘deb’

Returns:

  • (Array) —

    An Array of Strings, containing all of the codenames defined for a given Platform



329
330
331
332
333
334
 
# File 'lib/packaging/platforms.rb', line 329

def codenames(platform = 'deb')
  releases = by_package_format(platform).flat_map do |p|
    PLATFORM_INFO[p].values.collect { |r| r[:codename] }
  end
  releases.sort
end

.formats ⇒ Array

Returns An Array of Strings, containing all of the package formats defined in Pkg::Platforms.

Returns:

  • (Array) —

    An Array of Strings, containing all of the package formats defined in Pkg::Platforms



303
304
305
306
307
308
309
310
 
# File 'lib/packaging/platforms.rb', line 303

def formats
  fmts = PLATFORM_INFO.flat_map do |_, p|
    p.collect do |_, r|
      r[:package_format]
    end
  end
  fmts.to_set.sort
end

.generic_platform_tag(platform) ⇒ Object

Return a supported platform tag for the given platform, not caring about version or architecture



435
436
437
438
439
 
# File 'lib/packaging/platforms.rb', line 435

def generic_platform_tag(platform)
  version = versions_for_platform(platform).first
  arch = arches_for_platform_version(platform, version).first
  return "#{platform}-#{version}-#{arch}"
end

.get_attribute(platform_tag, attribute_name) ⇒ String, Array

Returns the contents of the requested attribute.

Parameters:

  • platform_tag (String) —

    May be either the two or three unit string that corresponds to a platform in the form of platform-version or platform-version-arch

  • attribute_name (String, Symbol) —

    The name of the requested attribute

Returns:

  • (String, Array) —

    the contents of the requested attribute



278
279
280
281
282
 
# File 'lib/packaging/platforms.rb', line 278

def get_attribute(platform_tag, attribute_name)
  info = platform_lookup(platform_tag)
  raise "#{platform_tag} doesn't have information about #{attribute_name} available" unless info.key?(attribute_name)
  info[attribute_name]
end

.get_attribute_for_platform_version(platform, version, attribute_name) ⇒ Object 



284
285
286
287
288
 
# File 'lib/packaging/platforms.rb', line 284

def get_attribute_for_platform_version(platform, version, attribute_name)
  info = PLATFORM_INFO[platform][version]
  raise "#{platform_tag} doesn't have information about #{attribute_name} available" unless info.key?(attribute_name)
  info[attribute_name]
end

.package_format_for_tag(platform_tag) ⇒ Object 



398
399
400
 
# File 'lib/packaging/platforms.rb', line 398

def package_format_for_tag(platform_tag)
  get_attribute(platform_tag, :package_format)
end

.parse_platform_tag(platform_tag) ⇒ Array

Returns An array of three elements: the platform name, the platform version, and the architecture. If the architecture was not included in the original platform tag, then nil is returned in place of the architecture.

Parameters:

  • platform_tag (String) —

    May be either the two or three unit string that corresponds to a platform in the form of platform-version or platform-version-arch.

Returns:

  • (Array) —

    An array of three elements: the platform name, the platform version, and the architecture. If the architecture was not included in the original platform tag, then nil is returned in place of the architecture



229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
 
# File 'lib/packaging/platforms.rb', line 229

def parse_platform_tag(platform_tag)
  platform_elements = platform_tag.split('-')

  # Look for platform. This is probably the only place where we have to look
  # for a combination of elements rather than a single element
  platform = (platform_elements & supported_platforms).first
  codename = (platform_elements & codenames).first

  # This is probably a bad assumption, but I'm assuming if we find a codename,
  # that's more reliable as it's less likely to give us a false match
  if codename
    platform, version = codename_to_platform_version(codename)
  end

  # There's a possibility that the platform name has a dash in it, in which
  # case, our assumption that it's an element of the above array is false,
  # since it would be a combination of elements in that array
  platform ||= supported_platforms.find { |p| platform_tag =~ /#{p}-/ }

  version ||= (platform_elements & versions_for_platform(platform)).first


  # For platform names with a dash in them, because everything is special
  supported_arches = arches_for_platform_version(platform, version, true)
  architecture = platform_tag.sub(/^(#{platform}-#{version}|#{codename})-?/, '')

  fail unless supported_arches.include?(architecture) || architecture.empty?

  # AIX uses 'ppc' as its architecture in paths and file names
  architecture = 'ppc' if platform == 'aix'
  return [platform, version, architecture]
rescue StandardError
  raise "Could not verify that '#{platform_tag}' is a valid tag"
end

.platform_lookup(platform_tag) ⇒ Hash

Returns The hash of data associated with the given platform version.

Parameters:

  • platform_tag (String) —

    May be either the two or three unit string that corresponds to a platform in the form of platform-version or platform-version-arch

Returns:

  • (Hash) —

    The hash of data associated with the given platform version



268
269
270
271
 
# File 'lib/packaging/platforms.rb', line 268

def platform_lookup(platform_tag)
  platform, version, = parse_platform_tag(platform_tag)
  PLATFORM_INFO[platform][version]
end

.platform_tags ⇒ Object

Returns an array of all currently valid platform tags



386
387
388
389
390
391
392
393
394
395
396
 
# File 'lib/packaging/platforms.rb', line 386

def platform_tags
  tags = []
  PLATFORM_INFO.each do |platform, platform_versions|
    platform_versions.each do |version, info|
      info[:architectures].each do |arch|
        tags << "#{platform}-#{version}-#{arch}"
      end
    end
  end
  tags
end

.platform_tags_for_package_format(format) ⇒ Object

Return an array of platform tags associated with a given package format



419
420
421
422
423
424
425
426
427
428
429
430
431
 
# File 'lib/packaging/platforms.rb', line 419

def platform_tags_for_package_format(format)
  platform_tags = []
  PLATFORM_INFO.each do |platform, platform_versions|
    platform_versions.each do |version, info|
      info[:architectures].each do |architecture|
        if info[:package_format] == format
          platform_tags << "#{platform}-#{version}-#{architecture}"
        end
      end
    end
  end
  platform_tags
end

.signature_format_for_platform_version(platform, version) ⇒ Object 



406
407
408
 
# File 'lib/packaging/platforms.rb', line 406

def signature_format_for_platform_version(platform, version)
  get_attribute_for_platform_version(platform, version, :signature_format)
end

.signature_format_for_tag(platform_tag) ⇒ Object 



402
403
404
 
# File 'lib/packaging/platforms.rb', line 402

def signature_format_for_tag(platform_tag)
  get_attribute(platform_tag, :signature_format)
end

.source_architecture_for_platform_tag(platform_tag) ⇒ Object 



410
411
412
 
# File 'lib/packaging/platforms.rb', line 410

def source_architecture_for_platform_tag(platform_tag)
  get_attribute(platform_tag, :source_architecture)
end

.source_package_formats_for_platform_tag(platform_tag) ⇒ Object 



414
415
416
 
# File 'lib/packaging/platforms.rb', line 414

def source_package_formats_for_platform_tag(platform_tag)
  get_attribute(platform_tag, :source_package_formats)
end

.supported_platforms ⇒ Array

Returns An array of Strings, containing all of the supported platforms as defined in PLATFORM_INFO.

Returns:

  • (Array) —

    An array of Strings, containing all of the supported platforms as defined in PLATFORM_INFO



210
211
212
 
# File 'lib/packaging/platforms.rb', line 210

def supported_platforms
  PLATFORM_INFO.keys
end

.versions_for_platform(platform) ⇒ Array

Returns An Array of Strings, containing all the supported versions for the given platform.

Returns:

  • (Array) —

    An Array of Strings, containing all the supported versions for the given platform



216
217
218
219
220
 
# File 'lib/packaging/platforms.rb', line 216

def versions_for_platform(platform)
  PLATFORM_INFO[platform].keys
rescue StandardError
  raise "No information found for '#{platform}'"
end