Class: Yahns::Config

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

Overview

Copyright © 2013-2016 all contributors <[email protected]> License: GPL-3.0+ (www.gnu.org/licenses/gpl-3.0.txt) frozen_string_literal: true

Implements a DSL for configuring a yahns server. See yhbt.net/yahns/examples/yahns_multi.conf.rb for a full example configuration file.

Defined Under Namespace

Classes: CfgBlock

Constant Summary collapse

APP_CLASS =

public within yahns itself, NOT a public interface for users outside of yahns. See yahns/rack for usage example

{}

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config_file = nil) ⇒ Config

Returns a new instance of Config.



18
19
20
21
22
23
24
25
26
 
# File 'lib/yahns/config.rb', line 18

def initialize(config_file = nil)
  @config_file = config_file
  @block = nil
  config_reload!

  # FIXME: we shouldn't have this at all when we go Unicorn 5-only
  Unicorn::HttpParser.respond_to?(:keepalive_requests=) and
    Unicorn::HttpParser.keepalive_requests = 0xffffffff
end

Instance Attribute Details

#app_ctx ⇒ Object (readonly)

Returns the value of attribute app_ctx.



16
17
18
 
# File 'lib/yahns/config.rb', line 16

def app_ctx
  @app_ctx
end

#config_file ⇒ Object (readonly)

Returns the value of attribute config_file.



15
16
17
 
# File 'lib/yahns/config.rb', line 15

def config_file
  @config_file
end

#config_listeners ⇒ Object (readonly)

Returns the value of attribute config_listeners.



15
16
17
 
# File 'lib/yahns/config.rb', line 15

def config_listeners
  @config_listeners
end

#qeggs ⇒ Object (readonly)

Returns the value of attribute qeggs.



16
17
18
 
# File 'lib/yahns/config.rb', line 16

def qeggs
  @qeggs
end

#set ⇒ Object (readonly)

Returns the value of attribute set.



15
16
17
 
# File 'lib/yahns/config.rb', line 15

def set
  @set
end

Instance Method Details

#_add_hook(var, my_proc) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
 
# File 'lib/yahns/config.rb', line 114

def _add_hook(var, my_proc)
  Proc === my_proc or
    raise ArgumentError, "invalid type: #{var}=#{my_proc.inspect}"

  # this sets:
  # :atfork_prepare, :atfork_parent, :atfork_child
  key = var.to_sym
  @set[key] = [] unless @set.include?(key)
  @set[key] << my_proc
end

#_check_bool(var, val) ⇒ Object

Raises:

  • (ArgumentError) 


341
342
343
344
 
# File 'lib/yahns/config.rb', line 341

def _check_bool(var, val)
  return val if [ true, false ].include?(val)
  raise ArgumentError, "#{var} must be boolean"
end

#_check_in_block(ctx, var) ⇒ Object

Raises:

  • (ArgumentError) 


28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/yahns/config.rb', line 28

def _check_in_block(ctx, var)
  if ctx.nil?
    return var if @block.nil?
    msg = "#{var} must be called outside of #{@block.type}"
  else
    ctx = Array(ctx)
    return var if @block && ctx.include?(@block.type)
    msg = @block ? "may not be used inside a #{@block.type} block" :
                   "must be used with a #{ctx.join(' or ')} block"
  end
  raise ArgumentError, msg
end

#_check_int(var, n, min) ⇒ Object 



290
291
292
293
294
 
# File 'lib/yahns/config.rb', line 290

def _check_int(var, n, min)
  Integer === n or raise ArgumentError, "not an integer: #{var}=#{n.inspect}"
  n >= min or raise ArgumentError, "too low (< #{min}): #{var}=#{n.inspect}"
  n
end

#_check_num(var, n, min) ⇒ Object 



296
297
298
299
300
 
# File 'lib/yahns/config.rb', line 296

def _check_num(var, n, min)
  Numeric === n or raise ArgumentError, "not a number: #{var}=#{n.inspect}"
  n >= min or raise ArgumentError, "too low (< #{min}): #{var}=#{n.inspect}"
  n
end

#_check_tmpdir(var, path) ⇒ Object 



363
364
365
366
367
368
369
 
# File 'lib/yahns/config.rb', line 363

def _check_tmpdir(var, path)
  File.directory?(path) or
    raise ArgumentError, "#{var} tmpdir: #{path} is not a directory"
  File.writable?(path) or
    raise ArgumentError, "#{var} tmpdir: #{path} is not writable"
  path
end

#_set_path(var, path) ⇒ Object

:nodoc:



181
182
183
184
185
186
187
188
189
 
# File 'lib/yahns/config.rb', line 181

def _set_path(var, path) #:nodoc:
  _check_in_block(nil, var)
  case path
  when NilClass, String
    @set[var] = path
  else
    raise ArgumentError
  end
end

#app(type, *args, &block) ⇒ Object

type = :rack



317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/yahns/config.rb', line 317

def app(type, *args, &block)
  var = _check_in_block(nil, :app)
  file = "yahns/#{type.to_s}"
  begin
    require file
  rescue LoadError => e
    raise ArgumentError, "#{type.inspect} is not a supported app type",
          e.backtrace
  end
  klass = APP_CLASS[type] or
    raise TypeError,
      "#{var}: #{file} did not register #{type} in #{self.class}::APP_CLASS"

  # apps may have multiple configurator contexts
  app_cfg = @app_instances[klass.instance_key(*args)] = klass.new(*args)
  ctx = app_cfg.config_context
  if block_given?
    @block = CfgBlock.new(:app, ctx)
    instance_eval(&block)
    @block = nil
  end
  @app_ctx << ctx
end

#before_exec(&blk) ⇒ Object 



109
110
111
112
 
# File 'lib/yahns/config.rb', line 109

def before_exec(&blk)
  var = _check_in_block(nil, :before_exec)
  @set[var] = (block_given? ? blk : args[0])
end

#canonicalize_tcp(addr, port) ⇒ Object 



244
245
246
247
248
 
# File 'lib/yahns/config.rb', line 244

def canonicalize_tcp(addr, port)
  packed = Socket.pack_sockaddr_in(port, addr)
  port, addr = Socket.unpack_sockaddr_in(packed)
  addr.include?(':') ? "[#{addr}]:#{port}" : "#{addr}:#{port}"
end

#client_expire_threshold(val) ⇒ Object

global



303
304
305
306
307
308
309
310
311
312
313
314
 
# File 'lib/yahns/config.rb', line 303

def client_expire_threshold(val)
  var = _check_in_block(nil, :client_expire_threshold)
  case val
  when Float
    (val > 0 && val <= 1.0) or
      raise ArgumentError, "#{var} must be > 0 and <= 1.0 if a ratio"
  when Integer
  else
    raise ArgumentError, "#{var} must be a float or integer"
  end
  @set[var] = val
end

#client_max_body_size(val) ⇒ Object 



390
391
392
393
394
 
# File 'lib/yahns/config.rb', line 390

def client_max_body_size(val)
  var = _check_in_block(:app, :client_max_body_size)
  val = _check_int(var, val, 0) if val != nil
  @block.ctx.__send__("#{var}=", val)
end

#client_timeout(val) ⇒ Object 



385
386
387
388
 
# File 'lib/yahns/config.rb', line 385

def client_timeout(val)
  var = _check_in_block(:app, :client_timeout)
  @block.ctx.__send__("#{var}=", _check_num(var, val, 0))
end

#commit!(server) ⇒ Object 



421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
 
# File 'lib/yahns/config.rb', line 421

def commit!(server)
  # redirect IOs
  { stdout_path: $stdout, stderr_path: $stderr }.each do |key, io|
    path = @set[key]
    if path == :unset && server.daemon_pipe
      @set[key] = path = "/dev/null"
    end
    File.open(path, 'a') { |fp| io.reopen(fp) } if String === path
    io.sync = true
  end

  [ :logger, :pid, :worker_processes, :user, :shutdown_timeout, :before_exec,
    :atfork_prepare, :atfork_parent, :atfork_child
  ].each do |var|
    val = @set[var]
    server.__send__("#{var}=", val) if val != :unset
  end

  @app_ctx.each { |app| app.logger ||= server.logger }
end

#config_reload! ⇒ Object

:nodoc:



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/yahns/config.rb', line 45

def config_reload! #:nodoc:
  # app_instance:app_ctx is a 1:N relationship
  @config_listeners = {} # name/address -> options
  @app_ctx = []
  @set = Hash.new(:unset)
  @qeggs = Hash.new { |h,k| h[k] = Yahns::QueueEgg.new }
  @app_instances = {}

  # set defaults:
  client_expire_threshold(0.5) # default is half of the open file limit

  instance_eval(File.read(@config_file), @config_file) if @config_file

  # working_directory binds immediately (easier error checking that way),
  # now ensure any paths we changed are correctly set.
  [ :pid, :stderr_path, :stdout_path ].each do |var|
    String === (path = @set[var]) or next
    path = File.expand_path(path)
    File.writable?(path) || File.writable?(File.dirname(path)) or \
          raise ArgumentError, "directory for #{var}=#{path} not writable"
  end
end

#errors(val) ⇒ Object

used to configure rack.errors destination



407
408
409
410
411
412
413
414
415
416
417
418
419
 
# File 'lib/yahns/config.rb', line 407

def errors(val)
  var = _check_in_block(:app, :errors)
  if String === val
    # we've already bound working_directory by the time we get here
    val = File.open(File.expand_path(val), "ab")
    val.close_on_exec = val.sync = true
  else
    rt = [ :puts, :write, :flush ] # match Rack::Lint
    rt.all? { |m| val.respond_to?(m) } or raise ArgumentError,
                 "`#{var}' destination must respond to all of: #{rt.inspect}"
  end
  @block.ctx.__send__("#{var}=", val)
end

#expand_addr(address) ⇒ Object

expands “unix:path/to/foo” to a socket relative to the current path expands pathnames of sockets if relative to “~” or “~username” expands “*:port and ”:port“ to ”0.0.0.0:port“



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/yahns/config.rb', line 224

def expand_addr(address) #:nodoc:
  return "0.0.0.0:#{address}" if Integer === address
  return address unless String === address

  case address
  when %r{\Aunix:(.*)\z}
    File.expand_path($1)
  when %r{\A~}
    File.expand_path(address)
  when %r{\A(?:\*:)?(\d+)\z}
    "0.0.0.0:#$1"
  when %r{\A\[([a-fA-F0-9:]+)\]\z}, %r/\A((?:\d+\.){3}\d+)\z/
    canonicalize_tcp($1, 80)
  when %r{\A\[([a-fA-F0-9:]+)\]:(\d+)\z}, %r{\A(.*):(\d+)\z}
    canonicalize_tcp($1, $2.to_i)
  else
    address
  end
end

#input_buffering(val, opts = {}) ⇒ Object 



396
397
398
399
400
401
402
403
404
 
# File 'lib/yahns/config.rb', line 396

def input_buffering(val, opts = {})
  var = _check_in_block(:app, :input_buffering)
  ok = [ :lazy, true, false ]
  ok.include?(val) or
    raise ArgumentError, "`#{var}' must be one of: #{ok.inspect}"
  @block.ctx.__send__("#{var}=", val)
  tmpdir = opts[:tmpdir] and
    @block.ctx.input_buffer_tmpdir = _check_tmpdir(var, tmpdir)
end

#listen(address, options = {}) ⇒ Object 



191
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
 
# File 'lib/yahns/config.rb', line 191

def listen(address, options = {})
  options = options.dup
  var = _check_in_block(:app, :listen)
  address = expand_addr(address)
  String === address or
    raise ArgumentError, "address=#{address.inspect} must be a string"
  [ :umask, :backlog ].each do |key|
    # :backlog may be negative on some OSes
    value = options[key] or next
    Integer === value or
      raise ArgumentError, "#{var}: not an integer: #{key}=#{value.inspect}"
  end
  [ :sndbuf, :rcvbuf, :threads ].each do |key|
     value = options[key] and _check_int(key, value, 1)
  end

  [ :ipv6only, :reuseport ].each do |key|
    (value = options[key]).nil? and next
    [ true, false ].include?(value) or
      raise ArgumentError, "#{var}: not boolean: #{key}=#{value.inspect}"
  end

  require_relative('openssl_server') if options[:ssl_ctx]

  options[:yahns_app_ctx] = @block.ctx
  @config_listeners.include?(address) and
    raise ArgumentError, "listen #{address} already in use"
  @config_listeners[address] = options
end

#logger(obj) ⇒ Object 



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/yahns/config.rb', line 68

def logger(obj)
  var = :logger
  %w(debug info warn error fatal).each do |m|
    obj.respond_to?(m) and next
    raise ArgumentError, "#{var}=#{obj} does not respond to method=#{m}"
  end
  if @block
    if @block.ctx.respond_to?(:logger=)
      @block.ctx.logger = obj
    else
      raise ArgumentError, "#{var} not valid inside #{@block.type}"
    end
  else
    @set[var] = obj
  end
end

#output_buffering(bool, opts = {}) ⇒ Object 



356
357
358
359
360
361
 
# File 'lib/yahns/config.rb', line 356

def output_buffering(bool, opts = {})
  var = _check_in_block(:app, :output_buffering)
  @block.ctx.__send__("#{var}=", _check_bool(var, bool))
  tmpdir = opts[:tmpdir] and
    @block.ctx.output_buffer_tmpdir = _check_tmpdir(var, tmpdir)
end

#pid(path) ⇒ Object

sets the path for the PID file of the yahns master process



126
127
128
 
# File 'lib/yahns/config.rb', line 126

def pid(path)
  _set_path(:pid, path)
end

#postfork_cleanup ⇒ Object 



41
42
43
 
# File 'lib/yahns/config.rb', line 41

def postfork_cleanup
  @app_ctx = @set = @qeggs = @app_instances = @config_file = nil
end

#queue(*args, &block) ⇒ Object 



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'lib/yahns/config.rb', line 250

def queue(*args, &block)
  var = :queue
  prev_block = @block
  if prev_block
    _check_in_block(:app, var)
    if block_given?
      args.size == 0 or
        raise ArgumentError,
              "queues defined with a block inside app must not have names"
      name = @block
    else
      name = args[0] or
        raise ArgumentError, "queue must be given a name if no block given"
    end
  else
    name = args[0] || :default
  end
  args.size > 1 and
    raise ArgumentError, "queue only takes one name argument"
  qegg = @qeggs[name]
  if block_given?
    @block = CfgBlock.new(:queue, qegg)
    instance_eval(&block)
    @block = prev_block
  end

  # associate the queue if we're inside an app
  prev_block.ctx.qegg = qegg if prev_block
end

#register_inherited(name) ⇒ Object 



442
443
444
445
 
# File 'lib/yahns/config.rb', line 442

def register_inherited(name)
  return unless @config_listeners.empty? && @app_ctx.size == 1
  @config_listeners[name] = { :yahns_app_ctx => @app_ctx[0] }
end

#shutdown_timeout(sec) ⇒ Object 



85
86
87
88
 
# File 'lib/yahns/config.rb', line 85

def shutdown_timeout(sec)
  var = _check_in_block(nil, :shutdown_timeout)
  @set[var] = _check_num(var, sec, 0)
end

#stderr_path(path) ⇒ Object 



130
131
132
 
# File 'lib/yahns/config.rb', line 130

def stderr_path(path)
  _set_path(:stderr_path, path)
end

#stdout_path(path) ⇒ Object 



134
135
136
 
# File 'lib/yahns/config.rb', line 134

def stdout_path(path)
  _set_path(:stdout_path, path)
end

#user(user, group = nil) ⇒ Object

Runs worker processes as the specified user and group. The master process always stays running as the user who started it. This switch will occur after calling the after_fork hooks, and only if the Worker#user method is not called in the after_fork hooks group is optional and will not change if unspecified.



172
173
174
175
176
177
178
179
 
# File 'lib/yahns/config.rb', line 172

def user(user, group = nil)
  var = _check_in_block(nil, :user)
  @block and raise "#{var} is not valid inside #{@block.type}"
  # raises ArgumentError on invalid user/group
  Etc.getpwnam(user)
  Etc.getgrnam(group) if group
  @set[var] = [ user, group ]
end

#value(var) ⇒ Object 



138
139
140
141
 
# File 'lib/yahns/config.rb', line 138

def value(var)
  val = @set[var]
  val == :unset ? nil : val
end

#worker_processes(nr, &blk) ⇒ Object 



90
91
92
93
94
95
96
97
98
 
# File 'lib/yahns/config.rb', line 90

def worker_processes(nr, &blk)
  var =_check_in_block(nil, :worker_processes)
  @set[var] = _check_int(var, nr, 1)
  if block_given?
    @block = CfgBlock.new(var, nil)
    instance_eval(&blk)
    @block = nil
  end
end

#working_directory(path) ⇒ Object

sets the working directory for yahns. This ensures SIGUSR2 will start a new instance of yahns in this directory. This may be a symlink, a common scenario for Capistrano users. Unlike all other yahns configuration directives, this binds immediately for error checking and cannot be undone by unsetting it in the configuration file and reloading.



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/yahns/config.rb', line 149

def working_directory(path)
  var = _check_in_block(nil, :working_directory)
  @app_ctx.empty? or
    raise ArgumentError, "#{var} must be declared before any apps"

  # just let chdir raise errors
  path = File.expand_path(path)
  if @config_file &&
     @config_file[0] != ?/ &&
     ! File.readable?("#{path}/#@config_file")
    raise ArgumentError,
          "config_file=#@config_file would not be accessible in" \
          " #{var}=#{path}"
  end
  Dir.chdir(path)
  @set[var] = ENV["PWD"] = path
end