Module: Bolt::Util

Defined in:
lib/bolt/util.rb,
lib/bolt/util/puppet_log_level.rb

Defined Under Namespace

Modules: PuppetLogLevel

Class Method Summary collapse

Class Method Details

.class_name_to_file_name(cls_name) ⇒ Object 



356
357
358
359
360
 
# File 'lib/bolt/util.rb', line 356

def class_name_to_file_name(cls_name)
  # Note this turns Bolt::CLI -> 'bolt/cli' not 'bolt/c_l_i'
  # this won't handle Bolt::Inventory2Foo
  cls_name.gsub(/([a-z])([A-Z])/, '\1_\2').gsub('::', '/').downcase
end

.deep_clone(obj, cloned = {}) ⇒ Object

Performs a deep_clone, using an identical copy if the cloned structure contains multiple references to the same object and prevents endless recursion. Credit to Jan Molic via github.com/rubyworks/facets/blob/master/LICENSE.txt



288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
 
# File 'lib/bolt/util.rb', line 288

def deep_clone(obj, cloned = {})
  return cloned[obj.object_id] if cloned.include?(obj.object_id)

  # The `defined?` method will not reliably find the Java::JavaLang::CloneNotSupportedException constant
  # presumably due to some sort of optimization that short-cuts doing a bunch of Java introspection.
  # Java::JavaLang::<...> IS defining the constant (via const_missing or const_get magic perhaps) so
  # it is safe to reference it in the error_types array when a JRuby interpreter is evaluating the code
  # (detected by RUBY_PLATFORM == `java`). SO instead of conditionally adding the CloneNotSupportedException
  # constant to the error_types array based on `defined?` detecting the Java::JavaLang constant it is added
  # based on detecting a JRuby interpreter.
  # TypeError handles unclonable Ruby ojbects (TrueClass, Fixnum, ...)
  # CloneNotSupportedException handles uncloneable Java objects (JRuby only)
  error_types = [TypeError]
  error_types << Java::JavaLang::CloneNotSupportedException if RUBY_PLATFORM == 'java'

  begin
    # We can't recurse on frozen objects to populate them with cloned
    # data. Instead we store the freeze-state of the original object,
    # deep_clone, then set the cloned object to frozen if the original
    # object was frozen
    frozen = obj.frozen?
    cl = begin
      obj.clone(freeze: false)
    # Some datatypes, such as FalseClass, can't be unfrozen. These
    # aren't the types we recurse on, so we can leave them frozen
    rescue ArgumentError => e
      if e.message =~ /can't unfreeze/
        obj.clone
      else
        raise e
      end
    end
  rescue *error_types
    cloned[obj.object_id] = obj
    obj
  else
    cloned[obj.object_id] = cl
    cloned[cl.object_id] = cl

    case cl
    when Hash
      obj.each { |k, v| cl[k] = deep_clone(v, cloned) }
    when Array
      cl.collect! { |v| deep_clone(v, cloned) }
    when Struct
      obj.each_pair { |k, v| cl[k] = deep_clone(v, cloned) }
    end

    cl.instance_variables.each do |var|
      v = cl.instance_variable_get(var)
      v_cl = deep_clone(v, cloned)
      cl.instance_variable_set(var, v_cl)
    end

    cl.freeze if frozen
    cl
  end
end

.deep_merge(hash1, hash2) ⇒ Object 



224
225
226
227
228
229
230
231
232
233
 
# File 'lib/bolt/util.rb', line 224

def deep_merge(hash1, hash2)
  recursive_merge = proc do |_key, h1, h2|
    if h1.is_a?(Hash) && h2.is_a?(Hash)
      h1.merge(h2, &recursive_merge)
    else
      h2
    end
  end
  hash1.merge(hash2, &recursive_merge)
end

.exec_docker(cmd, env = {}) ⇒ String, Process::Status

Executes a Docker CLI command. This is useful for running commands as part of this class without having to go through the ‘execute` function and manage pipes.

Parameters:

  • cmd (String) —

    The docker command and arguments to run e.g. ‘cp <src> <dest>’ for ‘docker cp <src> <dest>`

Returns:

  • (String, String, Process::Status) —

    The output of the command: STDOUT, STDERR, Process Status



414
415
416
 
# File 'lib/bolt/util.rb', line 414

def exec_docker(cmd, env = {})
  Open3.capture3(env, 'docker', *cmd, { binmode: true })
end

.exec_podman(cmd, env = {}) ⇒ String, Process::Status

Executes a Podman CLI command. This is useful for running commands as part of this class without having to go through the ‘execute` function and manage pipes.

Parameters:

  • cmd (String) —

    The podman command and arguments to run e.g. ‘cp <src> <dest>’ for ‘podman cp <src> <dest>`

Returns:

  • (String, String, Process::Status) —

    The output of the command: STDOUT, STDERR, Process Status



425
426
427
 
# File 'lib/bolt/util.rb', line 425

def exec_podman(cmd, env = {})
  Open3.capture3(env, 'podman', *cmd, { binmode: true })
end

.file_stat(path) ⇒ Object

This is stubbed for testing validate_file



348
349
350
 
# File 'lib/bolt/util.rb', line 348

def file_stat(path)
  File.stat(File.expand_path(path))
end

.find_file_from_scope(file, scope, fallback = false) ⇒ Object

If Puppet is loaded, we aleady have the path to the module and should just get it. This takes the path to a file provided by the user and a Puppet Parser scope object and tries to find the file, either as an absolute path or Puppet module syntax lookup. Returns the path to the file if found, or nil.



106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/bolt/util.rb', line 106

def find_file_from_scope(file, scope, fallback = false)
  # If we got an absolute path, just return that.
  return file if Pathname.new(file).absolute?

  module_name, file_pattern = Bolt::Util.split_path(file)
  # Get the absolute path to the module root from the scope
  mod_path = scope.compiler.environment.module(module_name)&.path

  # Search the module for the file, falling back to new-style paths if enabled.
  find_file_in_module(mod_path, file_pattern, fallback) if mod_path
end

.find_file_in_module(module_path, module_file, fallback = false) ⇒ Object

This method is used by Bolt to find files when provided a module-style path without loading Puppet. It takes the absolute path to the module root and the module-style path minus the module name and searches subdirectories in the module in order of precedence.



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/bolt/util.rb', line 123

def find_file_in_module(module_path, module_file, fallback = false)
  # If the first part of the path is 'scripts' or 'files', the path may
  # be a new-style file location and should fall back to the new path.
  subdir_or_file = split_path(module_file).first
  case subdir_or_file
    # For any subdirs that may indicate the user passed a new-style path,
    # first look in 'mymod/files/<relative_path>' (old-style) then fall
    # back to 'mymod/<relative_path>' (new-style) if enabled.
  when 'scripts', 'files'
    search_module(module_path, module_file, fallback)
  else
    # If the path definitely isn't new-style, only look in the 'files/'
    # directory.
    search_module(module_path, module_file)
  end
end

.first_run? ⇒ Boolean

Returns:

  • (Boolean) 


95
96
97
98
 
# File 'lib/bolt/util.rb', line 95

def first_run?
  !first_runs_free.nil? &&
    !File.exist?(first_runs_free)
end

.first_runs_free ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/bolt/util.rb', line 80

def first_runs_free
  # If this fails, use the system path instead
  FileUtils.mkdir_p(Bolt::Config.user_path)
  Bolt::Config.user_path + '.first_runs_free'
rescue StandardError
  begin
    # If using the system path fails, then don't bother with the welcome
    # message
    FileUtils.mkdir_p(Bolt::Config.system_path)
    Bolt::Config.system_path + '.first_runs_free'
  rescue StandardError
    nil
  end
end

.format_env_vars_for_cli(env_vars) ⇒ String

Formats a map of environment variables to be passed to a command that accepts repeated ‘–env` flags

Parameters:

  • env_vars (Hash) —

    A map of environment variables keys and their values

Returns:

  • (String) 


434
435
436
437
438
439
 
# File 'lib/bolt/util.rb', line 434

def format_env_vars_for_cli(env_vars)
  @env_vars = env_vars.each_with_object([]) do |(key, value), acc|
    acc << "--env"
    acc << "#{key}=#{value}"
  end
end

.get_arg_input(value) ⇒ Object

Gets input for an argument.



7
8
9
10
11
12
13
14
15
16
 
# File 'lib/bolt/util.rb', line 7

def get_arg_input(value)
  if value.start_with?('@')
    file = value.sub(/^@/, '')
    read_arg_file(file)
  elsif value == '-'
    $stdin.read
  else
    value
  end
end

.module_name(path) ⇒ Object

Accepts a path with either ‘plans’ or ‘tasks’ in it and determines the name of the module



162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/bolt/util.rb', line 162

def module_name(path)
  # Remove extra dots and slashes
  path = Pathname.new(path).cleanpath.to_s
  fs = File::SEPARATOR
  regex = Regexp.new("#{fs}plans#{fs}|#{fs}tasks#{fs}")

  # Only accept paths with '/plans/' or '/tasks/'
  unless path.match?(regex)
    msg = "Could not determine module from #{path}. "\
      "The path must include 'plans' or 'tasks' directory"
    raise Bolt::Error.new(msg, 'bolt/modulepath-error')
  end

  # Split the path on the first instance of /plans/ or /tasks/
  parts = path.split(regex, 2)
  # Module name is the last entry before 'plans' or 'tasks'
  modulename = parts[0].split(fs)[-1]
  filename = File.basename(path).split('.')[0]
  # Remove "/init.*" if filename is init or just remove the file
  # extension
  if filename == 'init'
    parts[1].chomp!(File.basename(path))
  else
    parts[1].chomp!(File.extname(path))
  end

  # The plan or task name is the rest of the path
  [modulename, parts[1].split(fs)].flatten.join('::')
end

.postwalk_vals(data, skip_top = false, &block) ⇒ Object

Accepts a Data object and returns a copy with all hash and array values modified by the given block. Descendants are modified before their parents.



269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
 
# File 'lib/bolt/util.rb', line 269

def postwalk_vals(data, skip_top = false, &block)
  new_data = case data
             when Hash
               data.transform_values { |v| postwalk_vals(v, &block) }
             when Array
               data.map { |v| postwalk_vals(v, &block) }
             else
               data
             end
  if skip_top
    new_data
  else
    yield(new_data)
  end
end

.powershell? ⇒ Boolean

Returns true if running in PowerShell.

Returns:

  • (Boolean) 


386
387
388
 
# File 'lib/bolt/util.rb', line 386

def powershell?
  !!ENV['PSModulePath']
end

.prompt_yes_no(prompt, outputter) ⇒ Object

Prompts yes or no, returning true for yes and false for no.



453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
 
# File 'lib/bolt/util.rb', line 453

def prompt_yes_no(prompt, outputter)
  choices = {
    'y'   => true,
    'yes' => true,
    'n'   => false,
    'no'  => false
  }

  loop do
    outputter.print_prompt("#{prompt} ([y]es/[n]o) ")
    response = $stdin.gets.to_s.downcase.chomp

    if choices.key?(response)
      return choices[response]
    else
      outputter.print_prompt_error("Invalid response, must pick [y]es or [n]o")
    end
  end
end

.read_arg_file(file) ⇒ Object

Reads a file passed as an argument to a command.



19
20
21
22
23
 
# File 'lib/bolt/util.rb', line 19

def read_arg_file(file)
  File.read(File.expand_path(file))
rescue StandardError => e
  raise Bolt::FileError.new("Error attempting to read #{file}: #{e}", file)
end

.read_json_file(path, filename) ⇒ Object 



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/bolt/util.rb', line 25

def read_json_file(path, filename)
  require 'json'

  logger = Bolt::Logger.logger(self)
  path = File.expand_path(path)
  content = JSON.parse(File.read(path))
  logger.trace("Loaded #{filename} from #{path}")
  content
rescue Errno::ENOENT
  raise Bolt::FileError.new("Could not read #{filename} file at #{path}", path)
rescue JSON::ParserError => e
  msg = "Unable to parse #{filename} file at #{path} as JSON: #{e.message}"
  raise Bolt::FileError.new(msg, path)
rescue IOError, SystemCallError => e
  raise Bolt::FileError.new("Could not read #{filename} file at #{path}\n#{e.message}",
                            path)
end

.read_optional_json_file(path, file_name) ⇒ Object 



43
44
45
 
# File 'lib/bolt/util.rb', line 43

def read_optional_json_file(path, file_name)
  File.exist?(path) && !File.zero?(path) ? read_yaml_hash(path, file_name) : {}
end

.read_optional_yaml_hash(path, file_name) ⇒ Object 



76
77
78
 
# File 'lib/bolt/util.rb', line 76

def read_optional_yaml_hash(path, file_name)
  File.exist?(path) ? read_yaml_hash(path, file_name) : {}
end

.read_yaml_hash(path, file_name) ⇒ Object 



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
 
# File 'lib/bolt/util.rb', line 47

def read_yaml_hash(path, file_name)
  require 'yaml'

  logger = Bolt::Logger.logger(self)
  path = File.expand_path(path)
  content = File.open(path, "r:UTF-8") { |f| YAML.safe_load(f.read) } || {}
  unless content.is_a?(Hash)
    raise Bolt::FileError.new(
      "Invalid content for #{file_name} file at #{path}\nContent should be a Hash or empty, "\
      "not #{content.class}",
      path
    )
  end
  logger.trace("Loaded #{file_name} from #{path}")
  content
rescue Errno::ENOENT
  raise Bolt::FileError.new("Could not read #{file_name} file at #{path}", path)
rescue Psych::SyntaxError => e
  raise Bolt::FileError.new("Could not parse #{file_name} file at #{path}, line #{e.line}, "\
                            "column #{e.column}\n#{e.problem}",
                            path)
rescue Psych::Exception => e
  raise Bolt::FileError.new("Could not parse #{file_name} file at #{path}\n#{e.message}",
                            path)
rescue IOError, SystemCallError => e
  raise Bolt::FileError.new("Could not read #{file_name} file at #{path}\n#{e.message}",
                            path)
end

.references?(input) ⇒ Boolean

Recursively searches a data structure for plugin references

Returns:

  • (Boolean) 


396
397
398
399
400
401
402
403
404
405
 
# File 'lib/bolt/util.rb', line 396

def references?(input)
  case input
  when Hash
    input.key?('_plugin') || input.values.any? { |v| references?(v) }
  when Array
    input.any? { |v| references?(v) }
  else
    false
  end
end

.snake_name_to_class_name(snake_name) ⇒ Object 



352
353
354
 
# File 'lib/bolt/util.rb', line 352

def snake_name_to_class_name(snake_name)
  snake_name.split('_').map(&:capitalize).join
end

.split_path(path) ⇒ Object

Copied directly from puppet/lib/puppet/parser/files.rb



156
157
158
 
# File 'lib/bolt/util.rb', line 156

def split_path(path)
  path.split(File::SEPARATOR, 2)
end

.symbolize_top_level_keys(hsh) ⇒ Object

Accept hash and return hash with top level keys of type “String” converted to symbols.



391
392
393
 
# File 'lib/bolt/util.rb', line 391

def symbolize_top_level_keys(hsh)
  hsh.each_with_object({}) { |(k, v), h| k.is_a?(String) ? h[k.to_sym] = v : h[k] = v }
end

.to_code(string) ⇒ Object 



192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
 
# File 'lib/bolt/util.rb', line 192

def to_code(string)
  case string
  when Bolt::PAL::YamlPlan::DoubleQuotedString
    string.value.inspect
  when Bolt::PAL::YamlPlan::BareString
    if string.value.start_with?('$')
      string.value.to_s
    else
      "'#{string.value}'"
    end
  when Bolt::PAL::YamlPlan::EvaluableString, Bolt::PAL::YamlPlan::CodeLiteral
    string.value.to_s
  when String
    "'#{string}'"
  when Hash
    formatted = String.new("{")
    string.each do |k, v|
      formatted << "#{to_code(k)} => #{to_code(v)}, "
    end
    formatted.chomp!(", ")
    formatted << "}"
    formatted
  when Array
    formatted = String.new("[")
    formatted << string.map { |str| to_code(str) }.join(', ')
    formatted << "]"
    formatted
  else
    string
  end
end

.unix_basename(path) ⇒ Object

Raises:



441
442
443
444
 
# File 'lib/bolt/util.rb', line 441

def unix_basename(path)
  raise Bolt::ValidationError, "path must be a String, received #{path.class} #{path}" unless path.is_a?(String)
  path.split('/').last
end

.validate_file(type, path, allow_dir = false) ⇒ Object 



362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
 
# File 'lib/bolt/util.rb', line 362

def validate_file(type, path, allow_dir = false)
  stat = file_stat(path)

  if !stat.readable?
    raise Bolt::FileError.new("The #{type} '#{path}' is unreadable", path)
  elsif !stat.file? && (!allow_dir || !stat.directory?)
    expected = allow_dir ? 'file or directory' : 'file'
    raise Bolt::FileError.new("The #{type} '#{path}' is not a #{expected}", path)
  elsif stat.directory?
    Dir.foreach(path) do |file|
      next if %w[. ..].include?(file)
      validate_file(type, File.join(path, file), allow_dir)
    end
  end
rescue Errno::ENOENT
  raise Bolt::FileError.new("The #{type} '#{path}' does not exist", path)
end

.walk_keys(data, &block) ⇒ Object

Accepts a Data object and returns a copy with all hash keys modified by block. use &:to_s to stringify keys or &:to_sym to symbolize them



237
238
239
240
241
242
243
244
245
246
247
248
249
 
# File 'lib/bolt/util.rb', line 237

def walk_keys(data, &block)
  case data
  when Hash
    data.each_with_object({}) do |(k, v), acc|
      v = walk_keys(v, &block)
      acc[yield(k)] = v
    end
  when Array
    data.map { |v| walk_keys(v, &block) }
  else
    data
  end
end

.walk_vals(data, skip_top = false, &block) ⇒ Object

Accepts a Data object and returns a copy with all hash and array values Arrays and hashes including the initial object are modified before their descendants are.



254
255
256
257
258
259
260
261
262
263
264
 
# File 'lib/bolt/util.rb', line 254

def walk_vals(data, skip_top = false, &block)
  data = yield(data) unless skip_top
  case data
  when Hash
    data.transform_values { |v| walk_vals(v, &block) }
  when Array
    data.map { |v| walk_vals(v, &block) }
  else
    data
  end
end

.windows? ⇒ Boolean

Returns true if windows false if not.

Returns:

  • (Boolean) 


381
382
383
 
# File 'lib/bolt/util.rb', line 381

def windows?
  !!File::ALT_SEPARATOR
end

.windows_basename(path) ⇒ Object

Raises:



446
447
448
449
 
# File 'lib/bolt/util.rb', line 446

def windows_basename(path)
  raise Bolt::ValidationError, "path must be a String, received #{path.class} #{path}" unless path.is_a?(String)
  path.split(%r{[/\\]}).last
end