Class: PuppetMetadata::Metadata

Inherits:
Object
  • Object
show all
Defined in:
lib/puppet_metadata/metadata.rb

Overview

An abstraction over Puppet metadata

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(metadata, validate = true) ⇒ Metadata

Returns a new instance of Metadata.

Parameters:

  • The metadata as a data structure

  • (defaults to: true)

    Whether to validate the metadata using metadata-json-lint

Raises:

  • When the provided metadata is invalid according to metadata.json-lint

See Also:



34
35
36
37
38
39
40
41
42
 
# File 'lib/puppet_metadata/metadata.rb', line 34

def initialize(metadata, validate = true)
  if validate
    require 'metadata_json_lint'
    schema_errors = MetadataJsonLint::Schema.new.validate(metadata)
    raise InvalidMetadataException.new(schema_errors) if schema_errors.any?
  end

  @metadata = metadata
end

Instance Attribute Details

#metadata ⇒ Object (readonly)

Returns the value of attribute metadata.



23
24
25
 
# File 'lib/puppet_metadata/metadata.rb', line 23

def metadata
  @metadata
end

Instance Method Details

#beaker_setfiles(use_fqdn: false, pidfile_workaround: false) {|setfile| ... } ⇒ Object

Parameters:

  • (defaults to: false)

    Whether to set the hostname to a fully qualified domain name

  • (defaults to: false)

    Whether to apply the Docker pidfile workaround

Yield Parameters:

  • setfile (String) —

    The supported setfile configurations

See Also:

  • Beaker#os_release_to_setfile


193
194
195
196
197
198
199
200
201
 
# File 'lib/puppet_metadata/metadata.rb', line 193

def beaker_setfiles(use_fqdn: false, pidfile_workaround: false)
  operatingsystems.each do |os, releases|
    next unless PuppetMetadata::Beaker.os_supported?(os)
    releases&.each do |release|
      setfile = PuppetMetadata::Beaker.os_release_to_setfile(os, release, use_fqdn: use_fqdn, pidfile_workaround: pidfile_workaround)
      yield setfile if setfile
    end
  end
end

#dependencies ⇒ Hash[String, SemanticPuppet::VersionRange]

A hash representation of the dependencies

Every element in the original array is converted. The name is used as a key while version_requirement is used as a value. No value indicates any version is accepted.

Examples:

metadata = Metadata.new(data)
metadata.dependencies.each do |os, releases|
  if releases
    releases.each do |release|
      puts "#{metadata.name} supports #{os} #{release}"
    end
  else
    puts "#{metadata.name} supports all #{os} releases"
  end
end

Returns:

  • The dependencies of the module

See Also:



170
171
172
 
# File 'lib/puppet_metadata/metadata.rb', line 170

def dependencies
  @dependencies ||= build_version_requirement_hash(metadata['dependencies'])
end

#eol_operatingsystems(at = nil) ⇒ Hash[String, Array[String]]

Parameters:

  • (defaults to: nil)

    The date to check the EOL time. Today is used when nil.

Returns:



96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/puppet_metadata/metadata.rb', line 96

def eol_operatingsystems(at = nil)
  at ||= Date.today

  unsupported = operatingsystems.map do |os, rels|
    next unless rels
    eol = rels.select { |rel| OperatingSystem.eol?(os, rel, at) }
    [os, eol] if eol.any?
  end

  Hash[unsupported.compact]
end

#github_actions ⇒ PuppetMetadata::GithubActions

Returns A GithubActions instance.

Returns:

  • A GithubActions instance



182
183
184
 
# File 'lib/puppet_metadata/metadata.rb', line 182

def github_actions
  PuppetMetadata::GithubActions.new(self)
end

#license ⇒ String

The license

Returns:

  • The license



58
59
60
 
# File 'lib/puppet_metadata/metadata.rb', line 58

def license
  metadata['license']
end

#name ⇒ String

The name

Returns:

  • The name



46
47
48
 
# File 'lib/puppet_metadata/metadata.rb', line 46

def name
  metadata['name']
end

#operatingsystems ⇒ Hash[String, Array[String]]

Returns The supported operating system and its major releases.

Returns:

  • The supported operating system and its major releases



64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/puppet_metadata/metadata.rb', line 64

def operatingsystems
  @operatingsystems ||= begin
    return {} if metadata['operatingsystem_support'].nil?

    supported = metadata['operatingsystem_support'].map do |os|
      next unless os['operatingsystem']
      [os['operatingsystem'], os['operatingsystemrelease']]
    end

    Hash[supported.compact]
  end
end

#os_release_supported?(operatingsystem, release) ⇒ Boolean

Returns whether an operating system’s release is supported

Parameters:

  • The operating system

  • The major release of the OS

Returns:

  • Whether an operating system’s release is supported



82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/puppet_metadata/metadata.rb', line 82

def os_release_supported?(operatingsystem, release)
  # If no OS is present, everything is supported. An example of this is
  # modules with only functions.
  return true if operatingsystems.empty?

  # if the key present, nil indicates all releases are supported
  return false unless operatingsystems.key?(operatingsystem)

  releases = operatingsystems[operatingsystem]
  releases.nil? || releases.include?(release)
end

#puppet_major_versions ⇒ Array[Integer]

Returns Supported major Puppet versions.

Returns:

  • Supported major Puppet versions

Raises:

See Also:



140
141
142
143
144
145
146
147
 
# File 'lib/puppet_metadata/metadata.rb', line 140

def puppet_major_versions
  requirement = requirements['puppet']
  raise Exception, 'No Puppet requirement found' unless requirement

  (requirement.begin.major..requirement.end.major).select do |major|
    requirement.include?(SemanticPuppet::Version.new(major, 0, 0)) || requirement.include?(SemanticPuppet::Version.new(major, 99, 99))
  end
end

#requirements ⇒ Hash[String, SemanticPuppet::VersionRange]

A hash representation of the requirements

Every element in the original array is converted. The name is used as a key while version_requirement is used as a value. No value indicates any version is accepted.

Examples:

metadata = Metadata.new(data)
metadata.requirements.each do |requirement, version_requirement|
  if version_requirement
    puts "#{metadata.name} requires #{requirement} #{version_requirement}"
  else
    puts "#{metadata.name} requires any #{requirement}"
  end
end

Returns:

  • The requirements of the module

See Also:



127
128
129
 
# File 'lib/puppet_metadata/metadata.rb', line 127

def requirements
  @requirements ||= build_version_requirement_hash(metadata['requirements'])
end

#satisfies_dependency?(name, version) ⇒ Boolean

Parameters:

  • The name of the dependency

  • The version of the dependency

Returns:

See Also:



177
178
179
 
# File 'lib/puppet_metadata/metadata.rb', line 177

def satisfies_dependency?(name, version)
  matches?(dependencies[name], version)
end

#satisfies_requirement?(name, version) ⇒ Boolean

Parameters:

  • The name of the requirement

  • The version of the requirement

Returns:

See Also:



134
135
136
 
# File 'lib/puppet_metadata/metadata.rb', line 134

def satisfies_requirement?(name, version)
  matches?(requirements[name], version)
end

#version ⇒ String

The version

Returns:



52
53
54
 
# File 'lib/puppet_metadata/metadata.rb', line 52

def version
  metadata['version']
end