Module: Fluent::Config::SectionGenerator

Defined in:
lib/fluent/config/section.rb

Class Method Summary collapse

Class Method Details

.check_unused_section(proxy, conf, plugin_class) ⇒ Object 



165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/fluent/config/section.rb', line 165

def self.check_unused_section(proxy, conf, plugin_class)
  elems = conf.respond_to?(:elements) ? conf.elements : []
  elems.each { |e|
    next if plugin_class.nil? && Fluent::Config::V1Parser::ELEM_SYMBOLS.include?(e.name) # skip pre-defined non-plugin elements because it doens't have proxy section
    # In v0.12, buffer and output parameters are defined in same place.
    # It causes same configuration is used in different buffer / output
    # and buffer plugin's sections are always empty. It should be skipped.
    next if proxy.sections.empty?

    unless proxy.sections.any? { |name, subproxy| e.name == subproxy.name.to_s || e.name == subproxy.alias.to_s }
      parent_name = if conf.arg.empty?
                      conf.name
                    else
                      "#{conf.name} #{conf.arg}"
                    end
      e.unused_in = [parent_name, plugin_class]
    end
  }
end

.generate(proxy, conf, logger, plugin_class, stack = []) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/fluent/config/section.rb', line 79

def self.generate(proxy, conf, logger, plugin_class, stack = [])
  return nil if conf.nil?

  section_stack = ""
  unless stack.empty?
    section_stack = ", in section " + stack.join(" > ")
  end

  section_params = {}

  proxy.defaults.each_pair do |name, defval|
    varname = name.to_sym
    section_params[varname] = defval
  end

  if proxy.argument
    unless conf.arg.empty?
      key, block, opts = proxy.argument
      section_params[key] = self.instance_exec(conf.arg, opts, name, &block)
    end
    unless section_params.has_key?(proxy.argument.first)
      logger.error "config error in:\n#{conf}"
      raise ConfigError, "'<#{proxy.name} ARG>' section requires argument" + section_stack
    end
    # argument should NOT be deprecated... (argument always has a value: '')
  end

  proxy.params.each_pair do |name, defval|
    varname = name.to_sym
    block, opts = defval
    if conf.has_key?(name.to_s) || opts[:alias] && conf.has_key?(opts[:alias].to_s)
      val = if conf.has_key?(name.to_s)
              conf[name.to_s]
            else
              conf[opts[:alias].to_s]
            end
      section_params[varname] = self.instance_exec(val, opts, name, &block)

      # Source of definitions of deprecated/obsoleted:
      # https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features
      #
      # Deprecated: These deprecated features can still be used, but should be used with caution
      #             because they are expected to be removed entirely sometime in the future.
      # Obsoleted: These obsolete features have been entirely removed from JavaScript and can no longer be used.
      if opts[:deprecated]
        logger.warn "'#{name}' parameter is deprecated: #{opts[:deprecated]}"
      end
      if opts[:obsoleted]
        logger.error "config error in:\n#{conf}" if logger
        raise ObsoletedParameterError, "'#{name}' parameter is already removed: #{opts[:obsoleted]}" + section_stack
      end
    end
    unless section_params.has_key?(varname)
      logger.error "config error in:\n#{conf}"
      raise ConfigError, "'#{name}' parameter is required" + section_stack
    end
  end

  check_unused_section(proxy, conf, plugin_class)

  proxy.sections.each do |name, subproxy|
    varname = subproxy.param_name.to_sym
    elements = (conf.respond_to?(:elements) ? conf.elements : []).select{ |e| e.name == subproxy.name.to_s || e.name == subproxy.alias.to_s }
    # set subproxy for secret option
    elements.each { |element|
      element.corresponding_proxies << subproxy
    }

    if subproxy.required? && elements.size < 1
      logger.error "config error in:\n#{conf}"
      raise ConfigError, "'<#{subproxy.name}>' sections are required" + section_stack
    end
    if subproxy.multi?
      section_params[varname] = elements.map{ |e| generate(subproxy, e, logger, plugin_class, stack + [subproxy.name]) }
    else
      if elements.size > 1
        logger.error "config error in:\n#{conf}"
        raise ConfigError, "'<#{subproxy.name}>' section cannot be written twice or more" + section_stack
      end
      section_params[varname] = generate(subproxy, elements.first, logger, plugin_class, stack + [subproxy.name])
    end
  end

  Section.new(section_params)
end