Module: PuppetX::AugeasprovidersGrub::Util

Defined in:
lib/puppetx/augeasproviders_grub/menuentry.rb

Class Method Summary collapse

Class Method Details

.grub2_cfg ⇒ String

Return the contents of the GRUB2 configuration on the system. Raise an error if not found.

Returns:

  • (String) —

    The contents of the GRUB2 configuration on the system.



165
166
167
 
# File 'lib/puppetx/augeasproviders_grub/menuentry.rb', line 165

def self.grub2_cfg
  return File.read(grub2_cfg_path)
end

.grub2_cfg_path ⇒ String

Return the location of the GRUB2 configuration on the system. Raise an error if not found.

Returns:

  • (String) —

    The full path to the GRUB2 configuration file.

Raises:

  • (Puppet::Error) 


129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/puppetx/augeasproviders_grub/menuentry.rb', line 129

def self.grub2_cfg_path
  paths = [
    '/etc/grub2.cfg',
    '/boot/grub/grub.cfg',
    '/boot/grub2/grub.cfg'
  ]

  if File.exist?('/sys/firmware/efi')
    os_info = Facter.value(:os)
    if os_info
      os_name = Facter.value(:os)['name']
    else
      # Support for old versions of Facter
      unless os_name
        os_name = Facter.value(:operatingsystem)
      end
    end

    paths = [
      '/etc/grub2-efi.cfg',
      # Handle the standard EFI naming convention
      "/boot/efi/EFI/#{os_name.downcase}/grub.cfg"
    ] + paths
  end

  paths.each do |path|
    return path if (File.readable?(path) && !File.directory?(path))
  end

  raise Puppet::Error, 'Could not find a GRUB2 configuration on the system'
end

.munge_grubby_value(value, flavor, grubby_info) ⇒ Object

Take care of copying ‘:default:’ values and ensure that the leading ‘boot’ entries are stripped off of passed entries.



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/puppetx/augeasproviders_grub/menuentry.rb', line 104

def self.munge_grubby_value(value, flavor, grubby_info)
  if value == ':default:'
    if grubby_info.empty? || !grubby_info[flavor]
      raise Puppet::Error, "No default GRUB information found for `#{flavor}`"
    end

    value = grubby_info[flavor]

    # In some cases, /boot gets shoved on by GRUB and we can't compare againt
    # that.
    value = value.split('/')
    if value[1] == 'boot'
      value.delete_at(1)
    end

    value = value.join('/')
  end

  return value
end

.munge_options(system_opts, new_opts, default_opts = []) ⇒ Array

Return a merge of the system options and the new options.

The following format is supported for the new options ‘:defaults:’ => Copy defaults from the default GRUB entry ‘:preserve:’ => Preserve all existing options (if present)

‘:defaults:’ and ‘:preserve:’ are mutually exclusive!

All of the options below supersede any items affected by the above

‘entry(=.*)?’ => Ensure that ‘entry` exists *as entered*; replaces all

other options with the same name

‘!entry(=.*)? => Add this option to the end of the arguments,

preserving any other options of the same name

‘-:entry’ => Ensure that all instances of ‘entry` do not exist ’-:entry=foo’ => Ensure that only instances of ‘entry` with value `foo` do not exist

Parameters:

  • system_opts (Array) —

    the current system options for this entry

  • new_opts (Array) —

    the new options for this entry

  • default_opts (Array) (defaults to: []) —

    the default entry options (if applicable)

Returns:

  • (Array) —

    a merged/manipulated array of options



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/puppetx/augeasproviders_grub/menuentry.rb', line 25

def self.munge_options(system_opts, new_opts, default_opts=[])
  sys_opts = Array(system_opts).flatten.map(&:strip)
  opts     = Array(new_opts).flatten.map(&:strip)
  def_opts = Array(default_opts).flatten.map(&:strip)

  result_opts = []
  result_opts = def_opts.dup if opts.delete(':defaults:')

  if opts.delete(':preserve:')
    # Need to remove any result opts that are being preserved
    sys_opts_keys = sys_opts.map{|x| x = x.split('=').first.strip}

    result_opts.delete_if do |x|
      key = x.split('=').first.strip

      sys_opts_keys.include?(key)
    end

    result_opts += sys_opts
  end

  # Get rid of everything with a '-:'
  discards = Array(opts.select{|x| x =~ /^-:/}.map{|x| x = x[2..-1]})
  opts.delete_if{|x| x =~ /^-:/}

  result_opts.delete_if{|x|
    discards.index{|d|
      ( d == x ) || ( d == x.split('=').first )
    }
  }

  # Prepare to append everything with a '!:'
  appends = Array(opts.select{|x| x =~ /^!:/}.map{|x| x = x[2..-1]})
  opts.delete_if{|x| x =~ /^!:/}

  # We only want to append items that aren't in the list already
  appends.delete_if{|x| result_opts.include?(x)}

  # Replace these items in place if possible
  tmp_results = []
  new_results = []

  opts.each do |opt|
    key = opt.split('=').first

    old_entry = result_opts.index{|x| x.split('=').first == key}

    if old_entry
      # Replace the first instance of a given item with the matching option.
      tmp_results[old_entry] = opt
      result_opts.map!{|x| x = (x.split('=').first == key) ? nil : x}
    else
      # Keep track of everything that we aren't replacing
      new_results << opt
    end
  end

  # Copy in all of the remaining options in place
  result_opts.each_index do |i|
    if result_opts[i]
      tmp_results[i] = result_opts[i]
    end
  end

  # Ensure that we're not duplicating arguments
  return (tmp_results.compact + new_results + appends).
    flatten.
    join(' ').
    scan(/\S+=(?:(?:".+?")|(?:\S+))|\S+/).
    uniq
end

.munged_options(old_opts, new_opts, default_kernel, default_kernel_opts, prepend_kernel_path = false) ⇒ Array[String]

Return a list of options that have the kernel path prepended and are formatted with all processing arguments handled.

Parameters:

  • old_opts (Array[String]) —

    An array of all old options

  • new_opts (Array[String]) —

    An array of all new options

  • default_kernel (String) —

    The default kernel

  • default_kernel_opts (Array[String]) —

    The default kernel options

  • prepend_kernel_path (Boolean) (defaults to: false) —

    If true, add the kernel itself to the default kernel options

Returns:

  • (Array[String]) —

    An Array of processed options



178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/puppetx/augeasproviders_grub/menuentry.rb', line 178

def self.munged_options(old_opts, new_opts, default_kernel, default_kernel_opts, prepend_kernel_path=false)
  # You need to prepend the kernel path for the defaults if you're trying to
  # format for `module` lines.

  default_kernel_opts = Array(default_kernel_opts)

  if default_kernel && prepend_kernel_path
    default_kernel_opts = Array(default_kernel) + default_kernel_opts
  end

  return munge_options(old_opts, new_opts, default_kernel_opts)
end