Class: Bolt::Config

Inherits:
Object
  • Object
show all
Defined in:
lib/bolt/config.rb

Constant Summary collapse

TRANSPORT_OPTIONS = 
%i[password run-as sudo-password extensions
private-key tty tmpdir user connect-timeout
cacert token-file service-url].freeze
TRANSPORT_DEFAULTS = 
{
  'connect-timeout' => 10,
  'tty' => false
}.freeze
TRANSPORT_SPECIFIC_DEFAULTS = 
{
  ssh: {
    'host-key-check' => true
  },
  winrm: {
    'ssl' => true,
    'ssl-verify' => true
  },
  pcp: {
    'task-environment' => 'production',
    'local-validation' => false
  },
  local: {}
}.freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(boltdir, config_data, overrides = {}) ⇒ Config

Returns a new instance of Config.



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/bolt/config.rb', line 74

def initialize(boltdir, config_data, overrides = {})
  @logger = Logging.logger[self]

  @boltdir = boltdir
  @concurrency = 100
  @compile_concurrency = Concurrent.processor_count
  @transport = 'ssh'
  @format = 'human'
  @puppetdb = {}
  @color = true

  # add an entry for the default console logger
  @log = { 'console' => {} }

  @transports = {}
  TRANSPORTS.each_key do |transport|
    @transports[transport] = TRANSPORT_DEFAULTS.merge(TRANSPORT_SPECIFIC_DEFAULTS[transport])
  end

  update_from_file(config_data)
  apply_overrides(overrides)

  validate
end

Instance Attribute Details

#color ⇒ Object

Returns the value of attribute color.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def color
  @color
end

#compile_concurrency ⇒ Object

Returns the value of attribute compile_concurrency.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def compile_concurrency
  @compile_concurrency
end

#concurrency ⇒ Object

Returns the value of attribute concurrency.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def concurrency
  @concurrency
end

#format ⇒ Object

Returns the value of attribute format.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def format
  @format
end

#inventoryfile ⇒ Object

Returns the value of attribute inventoryfile.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def inventoryfile
  @inventoryfile
end

#log ⇒ Object

Returns the value of attribute log.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def log
  @log
end

#modulepath ⇒ Object 



227
228
229
 
# File 'lib/bolt/config.rb', line 227

def modulepath
  @modulepath || @boltdir.modulepath
end

#puppetdb ⇒ Object

Returns the value of attribute puppetdb.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def puppetdb
  @puppetdb
end

#trace ⇒ Object

Returns the value of attribute trace.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def trace
  @trace
end

#transport ⇒ Object

Returns the value of attribute transport.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def transport
  @transport
end

#transports ⇒ Object

Returns the value of attribute transports.



30
31
32
 
# File 'lib/bolt/config.rb', line 30

def transports
  @transports
end

Class Method Details

.default ⇒ Object 



58
59
60
 
# File 'lib/bolt/config.rb', line 58

def self.default
  new(Bolt::Boltdir.new('.'), {})
end

.from_boltdir(boltdir, overrides = {}) ⇒ Object 



62
63
64
65
 
# File 'lib/bolt/config.rb', line 62

def self.from_boltdir(boltdir, overrides = {})
  data = Bolt::Util.read_config_file(nil, [boltdir.config_file], 'config') || {}
  new(boltdir, data, overrides)
end

.from_file(configfile, overrides = {}) ⇒ Object 



67
68
69
70
71
72
 
# File 'lib/bolt/config.rb', line 67

def self.from_file(configfile, overrides = {})
  boltdir = Bolt::Boltdir.new(Pathname.new(configfile).expand_path.dirname)
  data = Bolt::Util.read_config_file(configfile, [], 'config') || {}

  new(boltdir, data, overrides)
end

Instance Method Details

#apply_overrides(options) ⇒ Object 



167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/bolt/config.rb', line 167

def apply_overrides(options)
  %i[concurrency transport format trace modulepath inventoryfile color].each do |key|
    send("#{key}=", options[key]) if options.key?(key)
  end

  if options[:debug]
    @log['console'][:level] = :debug
  elsif options[:verbose]
    @log['console'][:level] = :info
  end

  @compile_concurrency = options[:'compile-concurrency'] if options[:'compile-concurrency']

  TRANSPORTS.each_key do |transport|
    transport = @transports[transport]
    TRANSPORT_OPTIONS.each do |key|
      if options[key]
        transport[key.to_s] = Bolt::Util.walk_keys(options[key], &:to_s)
      end
    end
  end

  if options.key?(:ssl) # this defaults to true so we need to check the presence of the key
    @transports[:winrm]['ssl'] = options[:ssl]
  end

  if options.key?(:'ssl-verify') # this defaults to true so we need to check the presence of the key
    @transports[:winrm]['ssl-verify'] = options[:'ssl-verify']
  end

  if options.key?(:'host-key-check') # this defaults to true so we need to check the presence of the key
    @transports[:ssh]['host-key-check'] = options[:'host-key-check']
  end
end

#deep_clone ⇒ Object 



108
109
110
 
# File 'lib/bolt/config.rb', line 108

def deep_clone
  Bolt::Util.deep_clone(self)
end

#default_inventoryfile ⇒ Object 



215
216
217
 
# File 'lib/bolt/config.rb', line 215

def default_inventoryfile
  [@boltdir.inventory_file]
end

#hiera_config ⇒ Object 



219
220
221
 
# File 'lib/bolt/config.rb', line 219

def hiera_config
  @hiera_config || @boltdir.hiera_config
end

#normalize_log(target) ⇒ Object 



112
113
114
115
116
 
# File 'lib/bolt/config.rb', line 112

def normalize_log(target)
  return target if target == 'console'
  target = target[5..-1] if target.start_with?('file:')
  'file:' + File.expand_path(target)
end

#overwrite_transport_data(transport, transports) ⇒ Object 



99
100
101
102
 
# File 'lib/bolt/config.rb', line 99

def overwrite_transport_data(transport, transports)
  @transport = transport
  @transports = transports
end

#puppetfile ⇒ Object 



223
224
225
 
# File 'lib/bolt/config.rb', line 223

def puppetfile
  @boltdir.puppetfile
end

#transport_conf ⇒ Object 



210
211
212
213
 
# File 'lib/bolt/config.rb', line 210

def transport_conf
  { transport: @transport,
    transports: @transports }
end

#transport_data_get ⇒ Object 



104
105
106
 
# File 'lib/bolt/config.rb', line 104

def transport_data_get
  { transport: @transport, transports: @transports }
end

#update_from_inventory(data) ⇒ Object 



202
203
204
205
206
207
208
 
# File 'lib/bolt/config.rb', line 202

def update_from_inventory(data)
  update_from_file(data)

  if data['transport']
    @transport = data['transport']
  end
end

#update_logs(logs) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/bolt/config.rb', line 118

def update_logs(logs)
  logs.each_pair do |k, v|
    log_name = normalize_log(k)
    @log[log_name] ||= {}
    log = @log[log_name]

    next unless v.is_a?(Hash)

    if v.key?('level')
      log[:level] = v['level'].to_s
    end

    if v.key?('append')
      log[:append] = v['append']
    end
  end
end

#validate ⇒ Object 



231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'lib/bolt/config.rb', line 231

def validate
  @log.each_pair do |name, params|
    if params.key?(:level) && !Bolt::Logger.valid_level?(params[:level])
      raise Bolt::ValidationError,
            "level of log #{name} must be one of: #{Bolt::Logger.levels.join(', ')}; received #{params[:level]}"
    end
    if params.key?(:append) && params[:append] != true && params[:append] != false
      raise Bolt::ValidationError, "append flag of log #{name} must be a Boolean, received #{params[:append]}"
    end
  end

  unless @concurrency.is_a?(Integer) && @concurrency > 0
    raise Bolt::ValidationError, 'Concurrency must be a positive integer'
  end

  unless @compile_concurrency.is_a?(Integer) && @compile_concurrency > 0
    raise Bolt::ValidationError, 'Compile concurrency must be a positive integer'
  end

  compile_limit = 2 * Concurrent.processor_count
  unless @compile_concurrency < compile_limit
    raise Bolt::ValidationError, "Compilation is CPU-intensive, set concurrency less than #{compile_limit}"
  end

  unless %w[human json].include? @format
    raise Bolt::ValidationError, "Unsupported format: '#{@format}'"
  end

  if @hiera_config && !(File.file?(@hiera_config) && File.readable?(@hiera_config))
    raise Bolt::FileError, "Could not read hiera-config file #{@hiera_config}", @hiera_config
  end

  unless @transport.nil? || Bolt::TRANSPORTS.include?(@transport.to_sym)
    raise UnknownTransportError, @transport
  end

  TRANSPORTS.each do |transport, impl|
    impl.validate(@transports[transport])
  end
end