Module: Pkg::Platforms

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

Overview

Data plus utilities surrounding platforms that the automation in this repo explicitly supports

Constant Summary collapse

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

Each element in this hash

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

  'cisco-wrlinux' => {
    '5' => {
      architectures: ['x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
    '7' => {
      architectures: ['x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    }
  },

  'cumulus' => {
    '2.2' => {
      codename: 'cumulus',
      architectures: ['amd64'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    }
  },

  'debian' => {
    '7' => {
      codename: 'wheezy',
      architectures: ['i386', 'amd64'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    },
    '8' => {
      codename: 'jessie',
      architectures: ['i386', 'amd64', 'powerpc'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    },
    '9' => {
      codename: 'stretch',
      architectures: ['i386', 'amd64'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    }
  },

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

  'eos' => {
    '4' => {
      architectures: ['i386'],
      package_format: 'swix',
      repo: false,
    }
  },

  'fedora' => {
    'f25' => {
      architectures: ['i386', 'x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
    'f26' => {
      architectures: ['x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
    '25' => {
      architectures: ['i386', 'x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
    '26' => {
      architectures: ['x86_64'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v4',
      repo: true,
    },
  },

  'osx' => {
    '10.10' => {
      architectures: ['x86_64'],
      package_format: 'dmg',
      repo: false,
    },
    '10.11' => {
      architectures: ['x86_64'],
      package_format: 'dmg',
      repo: false,
    },
    '10.12' => {
      architectures: ['x86_64'],
      package_format: 'dmg',
      repo: false,
    },
    '10.13' => {
      architectures: ['x86_64'],
      package_format: 'dmg',
      repo: false,
    }
  },

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

  'sles' => {
    '11' => {
      architectures: ['i386', 'x86_64', 's390x'],
      source_architecture: 'SRPMS',
      package_format: 'rpm',
      source_package_formats: ['src.rpm'],
      signature_format: 'v3',
      repo: true,
    },
    '12' => {
      architectures: ['x86_64', 's390x', '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' => {
    '14.04' => {
      codename: 'trusty',
      architectures: ['i386', 'amd64'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    },
    '16.04' => {
      codename: 'xenial',
      architectures: ['i386', 'amd64', 'ppc64el'],
      source_architecture: 'source',
      package_format: 'deb',
      source_package_formats: DEBIAN_SOURCE_FORMATS,
      repo: true,
    },
  },

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

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



353
354
355
356
357
358
359
360
361
362
 
# File 'lib/packaging/platforms.rb', line 353

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



392
393
394
395
 
# File 'lib/packaging/platforms.rb', line 392

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



409
410
411
412
413
414
415
416
417
418
419
420
421
422
 
# File 'lib/packaging/platforms.rb', line 409

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
    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



477
478
479
 
# File 'lib/packaging/platforms.rb', line 477

def by_deb
  by_package_format('deb')
end

.by_package_format(format) ⇒ Array

Returns An Array of Strings, containing all platforms that use 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 for their packages



333
334
335
336
337
338
 
# File 'lib/packaging/platforms.rb', line 333

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



486
487
488
 
# File 'lib/packaging/platforms.rb', line 486

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



387
388
389
 
# File 'lib/packaging/platforms.rb', line 387

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



376
377
378
379
380
381
382
383
 
# File 'lib/packaging/platforms.rb', line 376

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



398
399
400
401
402
403
404
405
 
# File 'lib/packaging/platforms.rb', line 398

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



368
369
370
371
372
373
 
# File 'lib/packaging/platforms.rb', line 368

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



342
343
344
345
346
347
348
349
 
# File 'lib/packaging/platforms.rb', line 342

def formats
  fmts = PLATFORM_INFO.flat_map do |_, p|
    p.collect do |_, r|
      r[:package_format]
    end
  end
  fmts.to_set.sort
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



317
318
319
320
321
 
# File 'lib/packaging/platforms.rb', line 317

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 



323
324
325
326
327
 
# File 'lib/packaging/platforms.rb', line 323

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 



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

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



271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
 
# File 'lib/packaging/platforms.rb', line 271

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?
  return [platform, version, architecture]
rescue
  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



307
308
309
310
 
# File 'lib/packaging/platforms.rb', line 307

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



425
426
427
428
429
430
431
432
433
434
435
 
# File 'lib/packaging/platforms.rb', line 425

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



458
459
460
461
462
463
464
465
466
467
468
469
470
 
# File 'lib/packaging/platforms.rb', line 458

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 



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

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 



441
442
443
 
# File 'lib/packaging/platforms.rb', line 441

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

.source_architecture_for_platform_tag(platform_tag) ⇒ Object 



449
450
451
 
# File 'lib/packaging/platforms.rb', line 449

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

.source_package_formats_for_platform_tag(platform_tag) ⇒ Object 



453
454
455
 
# File 'lib/packaging/platforms.rb', line 453

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



252
253
254
 
# File 'lib/packaging/platforms.rb', line 252

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



258
259
260
261
262
 
# File 'lib/packaging/platforms.rb', line 258

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