Class: PuppetMetadata::Metadata

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

Overview

An abstraction over Puppet metadata

Constant Summary collapse

SUPPORTED_REQUIREMENTS = 
['openvox', 'puppet'].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(metadata, validate = true) ⇒ Metadata

Returns a new instance of Metadata.

Parameters:

  • metadata (Hash[String, Any]) —

    The metadata as a data structure

  • validate (Boolean) (defaults to: true) —

    Whether to validate the metadata using metadata-json-lint

Raises:

See Also:



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

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

  @metadata = metadata
end

Instance Attribute Details

#metadata ⇒ Object (readonly)

Returns the value of attribute metadata.



25
26
27
 
# File 'lib/puppet_metadata/metadata.rb', line 25

def metadata
  @metadata
end

Instance Method Details

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

Returns All added releases for each operating system.

Parameters:

  • at (Date) (defaults to: nil) —

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

  • desired_os (String) (defaults to: nil) —

    the name of the operating system from metadata.json we want to update

Returns:

  • (Hash[String, Array[String]]) —

    All added releases for each operating system



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/puppet_metadata/metadata.rb', line 116

def add_supported_operatingsystems(at = nil, desired_os = nil)
  added = {}

  metadata['operatingsystem_support'] = operatingsystems.map do |os, releases|
    result = {
      'operatingsystem' => os,
    }

    # desired_os is a filter
    # if set, we only care about this OS, otherwise we want all OSes from metadata.json
    if desired_os && desired_os != os
      # Preserve the original entry unchanged
      result['operatingsystemrelease'] = releases unless releases.nil?
      next result
    end

    unless releases.nil?
      supported = OperatingSystem.supported_releases(os, at)
      releases_added = supported - releases
      added[os] = releases_added if releases_added.any?
      result['operatingsystemrelease'] = releases | supported
    end
    result
  end

  # Clear the memoized operatingsystems so it gets recalculated
  @operatingsystems = nil

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

  • (Hash[String, SemanticPuppet::VersionRange]) —

    The dependencies of the module

See Also:



259
260
261
 
# File 'lib/puppet_metadata/metadata.rb', line 259

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

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

Parameters:

  • at (Date) (defaults to: nil) —

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

Returns:

  • (Hash[String, Array[String]]) 


99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/puppet_metadata/metadata.rb', line 99

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

  unsupported.compact.to_h
end

#github_actions(options) ⇒ PuppetMetadata::GithubActions

Returns A GithubActions instance.

Parameters:

  • options (Hash) —

    A hash containing the command line options

Returns:



272
273
274
 
# File 'lib/puppet_metadata/metadata.rb', line 272

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

#license ⇒ String

The license

Returns:

  • (String) —

    The license



60
61
62
 
# File 'lib/puppet_metadata/metadata.rb', line 60

def license
  metadata['license']
end

#major_versions(requirement_name) ⇒ Array[Integer]

Returns Supported major Puppet versions.

Returns:

  • (Array[Integer]) —

    Supported major Puppet versions

See Also:



224
225
226
227
228
229
 
# File 'lib/puppet_metadata/metadata.rb', line 224

def major_versions(requirement_name)
  requirement = requirements[requirement_name]
  return [] unless requirement

  major_version_for_requirement(requirement)
end

#major_versions!(requirement_name) ⇒ Object

Raises:

  • (Exception) 


231
232
233
234
235
236
 
# File 'lib/puppet_metadata/metadata.rb', line 231

def major_versions!(requirement_name)
  requirement = requirements[requirement_name]
  raise Exception, "No '#{requirement_name}' requirement found'" unless requirement

  major_version_for_requirement(requirement)
end

#name ⇒ String

The name

Returns:

  • (String) —

    The name



48
49
50
 
# File 'lib/puppet_metadata/metadata.rb', line 48

def name
  metadata['name']
end

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

Returns The supported operating system and its major releases.

Returns:

  • (Hash[String, Array[String]]) —

    The supported operating system and its major releases



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

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

    supported.compact.to_h
  end
end

#os_release_supported?(operatingsystem, release) ⇒ Boolean

Returns whether an operating system’s release is supported

Parameters:

  • operatingsystem (String) —

    The operating system

  • release (String) —

    The major release of the OS

Returns:

  • (Boolean) —

    Whether an operating system’s release is supported



85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/puppet_metadata/metadata.rb', line 85

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

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

Returns All removed EOL releases for each operating system.

Parameters:

  • at (Date, nil) (defaults to: nil) —

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

  • desired_os (String, nil) (defaults to: nil) —

    the name of the operating system from metadata.json we want to update. All OSes are processed when nil.

Returns:

  • (Hash[String, Array[String]]) —

    All removed EOL releases for each operating system



151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/puppet_metadata/metadata.rb', line 151

def remove_eol_operatingsystems(at = nil, desired_os = nil)
  removed = {}

  metadata['operatingsystem_support'] = operatingsystems.map do |os, releases|
    result = {
      'operatingsystem' => os,
    }

    # desired_os is a filter
    # if set, we only care about this OS, otherwise we want all OSes from metadata.json
    if desired_os && desired_os != os
      # Preserve the original entry unchanged
      result['operatingsystemrelease'] = releases unless releases.nil?
      next result
    end

    unless releases.nil?
      eol = releases.select { |rel| OperatingSystem.eol?(os, rel, at) }
      if eol.any?
        removed[os] = eol
        result['operatingsystemrelease'] = releases - eol
      else
        result['operatingsystemrelease'] = releases
      end
    end
    result
  end

  # Clear the memoized operatingsystems so it gets recalculated
  @operatingsystems = nil

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

  • (Hash[String, SemanticPuppet::VersionRange]) —

    The requirements of the module

See Also:



204
205
206
 
# File 'lib/puppet_metadata/metadata.rb', line 204

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

#requirements_with_major_versions ⇒ Object 



215
216
217
218
219
220
 
# File 'lib/puppet_metadata/metadata.rb', line 215

def requirements_with_major_versions
  SUPPORTED_REQUIREMENTS.filter_map do |requirement|
    majors = major_versions(requirement)
    [requirement, majors] unless majors.empty?
  end.to_h
end

#satisfies_dependency?(name, version) ⇒ Boolean

Parameters:

  • name (String) —

    The name of the dependency

  • version (String) —

    The version of the dependency

Returns:

  • (Boolean)

See Also:



266
267
268
 
# File 'lib/puppet_metadata/metadata.rb', line 266

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

#satisfies_requirement?(name, version) ⇒ Boolean

Parameters:

  • name (String) —

    The name of the requirement

  • version (String) —

    The version of the requirement

Returns:

  • (Boolean)

See Also:



211
212
213
 
# File 'lib/puppet_metadata/metadata.rb', line 211

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

#version ⇒ String

The version

Returns:

  • (String) 


54
55
56
 
# File 'lib/puppet_metadata/metadata.rb', line 54

def version
  metadata['version']
end