fluentd-ui 1.0.0.alpha.3 → 1.0.0.beta.1

data/app/models/concerns/fluentd/setting/registry_loader.rb

@@ -0,0 +1,38 @@
+class Fluentd
+  module Setting
+    module RegistryLoader
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def define_all_attributes(section_name)
+          registry = case section_name
+                     when :buffer
+                       Fluent::Plugin::BUFFER_REGISTRY
+                     when :storage
+                       Fluent::Plugin::STORAGE_REGISTRY
+                     when :parse
+                       Fluent::Plugin::PARSER_REGISTRY
+                     when :format
+                       Fluent::Plugin::FORMATTER_REGISTRY
+                     end
+          registry.map.each do |key, plugin_class|
+            plugin_class.ancestors.reverse_each do |klass|
+              next unless klass.respond_to?(:dump_config_definition)
+              begin
+                dumped_config_definition = klass.dump_config_definition
+                self._dumped_config[klass.name] = dumped_config_definition unless dumped_config_definition.empty?
+              rescue NoMethodError
+              end
+            end
+          end
+          attribute(:type, :string)
+          self._types[:type] = :string
+          self._dumped_config.values.map(&:keys).flatten.uniq.each do |name|
+            attribute(name, :object)
+            self._types[name] = :object
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/fluentd/setting/section_config.rb

@@ -0,0 +1,52 @@
+class Fluentd
+  module Setting
+    module SectionConfig
+      extend ActiveSupport::Concern
+
+      def to_config
+        _attributes = attributes.dup
+        if %i(parse format buffer storage).include?(section_name)
+          _attributes["@type"] = _attributes.delete("type")
+          _attributes["@log_level"] = _attributes.delete("log_level")
+        end
+        argument = _attributes.delete(self._argument_name.to_s) || ""
+        attrs, elements = parse_attributes(_attributes)
+        if attrs.present? || elements.present?
+          config_element(section_name, argument, attrs.sort.to_h, elements)
+        end
+      end
+
+      def parse_attributes(attributes)
+        sections, params = attributes.partition do |key, _|
+          self._sections.key?(key.to_sym)
+        end
+        elements = sections.map do |key, section_params|
+          if section_params.present?
+            self._sections[key.to_sym].new(section_params).to_config
+          end
+        end.compact
+        attrs = params.to_h.reject do |key, value|
+          skip?(key.to_sym, value)
+        end
+        unless attrs.blank?
+          attrs["@type"] = params.to_h["@type"] if params.to_h.key?("@type")
+        end
+        return attrs, elements
+      end
+
+      # copy from Fluent::Test::Helpers#config_element
+      def config_element(name = 'test', argument = '', params = {}, elements = [])
+        Fluent::Config::Element.new(name, argument, params, elements)
+      end
+
+      def skip?(key, value)
+        return true if value.blank?
+        if self._defaults.key?(key)
+          self.class.reformat_value(key, self._defaults[key]) == self.class.reformat_value(key, value)
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/fluentd/setting/section_parser.rb

@@ -6,25 +6,32 @@ class Fluentd
       module ClassMethods
         def parse_section(name, definition)
           config_section(name, **definition.slice(:required, :multi, :alias)) do
-            definition.except(:section, :argument, :required, :multi, :alias).each do |_param_name, _definition|
-              if _definition[:section]
-                parse_section(_param_name, _definition)
-              else
-                if self._types.key?(_param_name)
-                  if _definition.key?(:default)
-                    self._defaults[_param_name] = _definition[:default]
-                    self._required[_param_name] = false
-                    self.clear_validators! # We register PresenceValidator only
-                  end
-                  self._secrets[_param_name] = _definition[:secret] if _definition.key?(:secret)
-                  self._aliases[name] = _definition[:alias] if _definition.key?(:alias)
-                  self._deprecated_params[name] = _definition[:deprecated] if _definition.key?(:deprecated)
-                  self._obsoleted_params[name] = _definition[:obsoleted] if _definition.key?(:obsoleted)
-                  self._list[name] = _definition[:list] if _definition.key?(:list)
-                  self._value_types[name] = _definition[:value_types] if _definition.key?(:value_types)
-                  self._symbolize_keys = _definition[:symbolize_keys] if _definition.key?(:symbolize_keys)
+            if %i(buffer storage parse format).include?(name)
+              define_all_attributes(name)
+            else
+              definition.except(:section, :argument, :required, :multi, :alias).each do |_param_name, _definition|
+                if _definition[:section]
+                  parse_section(_param_name, _definition)
                 else
-                  config_param(_param_name, _definition[:type], **_definition.except(:type))
+                  if self._types.key?(_param_name)
+                    if _definition.key?(:default) && self._required[_param_name] && _definition[:default].present?
+                      self._defaults[_param_name] = _definition[:default]
+                      self._required[_param_name] = false
+                    end
+                    self._secrets[_param_name] = _definition[:secret] if _definition.key?(:secret)
+                    self._aliases[name] = _definition[:alias] if _definition.key?(:alias)
+                    self._deprecated_params[name] = _definition[:deprecated] if _definition.key?(:deprecated)
+                    self._obsoleted_params[name] = _definition[:obsoleted] if _definition.key?(:obsoleted)
+                    self._list[name] = _definition[:list] if _definition.key?(:list)
+                    self._value_types[name] = _definition[:value_types] if _definition.key?(:value_types)
+                    self._symbolize_keys = _definition[:symbolize_keys] if _definition.key?(:symbolize_keys)
+                  else
+                    if _definition[:argument]
+                      config_argument(_param_name, _definition[:type], **_definition.except(:type))
+                    else
+                      config_param(_param_name, _definition[:type], **_definition.except(:type))
+                    end
+                  end
                 end
               end
             end

data/app/models/fluentd/setting/in_forward.rb

@@ -5,16 +5,6 @@ class Fluentd
 
       register_plugin("input", "forward")
 
-      def self.initial_params
-        {
-          bind: "0.0.0.0",
-          port: 24224,
-          linger_timeout: 0,
-          chunk_size_limit: nil,
-          chunk_size_warn_limit: nil,
-        }
-      end
-
       def common_options
         [
           :bind, :port
@@ -29,6 +19,35 @@ class Fluentd
           :blocking_timeout,
         ]
       end
+
+      def transport_common_options
+        [
+          :ca_path,
+          :cert_path,
+          :private_key_path,
+          :private_key_passphrase
+        ]
+      end
+
+      def transport_advanced_options
+        [
+          :version,
+          :ciphers,
+          :insecure,
+          :client_cert_auth,
+          :ca_cert_path,
+          :ca_private_key_path,
+          :ca_private_key_passphrase,
+          :generate_private_key_length,
+          :generate_cert_country,
+          :generate_cert_state,
+          :generate_cert_locality,
+          :generate_cert_common_name,
+          :generate_cert_common_name,
+          :generate_cert_expiration,
+          :generate_cert_digest
+        ]
+      end
     end
   end
 end

data/app/models/fluentd/setting/in_syslog.rb

@@ -6,17 +6,15 @@ class Fluentd
       register_plugin("input", "syslog")
 
       def self.initial_params
-        {
-          bind: "0.0.0.0",
-          port: 5140,
+        params = {
           parse_type: "syslog",
           parse: {
             "0" => {
               "type" => "syslog"
             }
-          },
-          protocol_type: :udp,
+          }
         }
+        super.compact.deep_merge(params)
       end
 
       def common_options
@@ -27,7 +25,9 @@ class Fluentd
 
       def hidden_options
         [
-          :parse
+          :parse,
+          :transport,
+          :blocking_timeout
         ]
       end
     end

data/app/models/fluentd/setting/out_forward.rb

@@ -10,7 +10,7 @@ class Fluentd
       end
 
       def self.initial_params
-        {
+        params = {
           buffer_type: "memory",
           buffer: {
             "0" => {
@@ -23,6 +23,7 @@ class Fluentd
             }
           }
         }
+        super.except(:transport).compact.deep_merge(params)
       end
 
       # TODO overwrite this method to support transport parameter and transport section
@@ -39,9 +40,20 @@ class Fluentd
       def hidden_options
         [
           :inject, :buffer,
+          # Deprecated options
           :host, :port,
-          # We don't support TLS configuration via fluentd-ui for now.
-          :transport, :tls_version, :tls_ciphers, :tls_insecure_mode, :tls_verify_hostname, :tls_cert_path
+          :transport
+        ].concat(tls_options) # Hide TLS related options to customize view
+      end
+
+      def tls_options
+        [
+          :tls_version,
+          :tls_ciphers,
+          :tls_insecure_mode,
+          :tls_allow_self_signed_cert,
+          :tls_verify_hostname,
+          :tls_cert_path
         ]
       end
     end

data/app/models/fluentd/setting/out_mongo.rb

@@ -7,17 +7,6 @@ class Fluentd
       config_param(:capped, :bool, default: false)
       config_param(:capped_size, :size, default: nil)
 
-      # NOTE: fluent-plugin-mongo defines database parameter as required parameter
-      #       But Fluentd tells us that the database parameter is not required.
-      validates :database, presence: true
-      validate :validate_collection
-
-      def validate_collection
-        if tag_mapped.blank? && collection.blank?
-          errors.add(:collection, :blank)
-        end
-      end
-
       def self.initial_params
         {
           host: "127.0.0.1",

data/app/models/fluentd/setting/out_s3.rb

@@ -26,14 +26,28 @@ class Fluentd
 
       def common_options
         [
-          :pattern, :aws_key_id, :aws_sec_key,
+          :pattern,
           :s3_region, :s3_bucket, :use_ssl, :path,
         ]
       end
 
-      def hidden
+      def hidden_options
         [
-          :secondary, :inject, :buffer
+          :secondary, :inject, :buffer, :format,
+        ] + aws_credential_options + aws_credential_sections
+      end
+
+      def aws_credential_options
+        [
+          :aws_key_id, :aws_sec_key,
+        ]
+      end
+
+      def aws_credential_sections
+        [
+          :assume_role_credentials,
+          :instance_profile_credentials,
+          :shared_credentials
         ]
       end
     end

data/app/models/fluentd/setting/out_tdlog.rb

@@ -6,17 +6,18 @@ class Fluentd
       register_plugin("output", "tdlog")
 
       def self.initial_params
-        {
+        params = {
           pattern: "td.*.*",
           buffer_type: "file",
           buffer: {
             "0" => {
-              "@type" => "file",
+              "type" => "file",
               "path" => "/var/log/td-agent/buffer/td",
             }
           },
           auto_create_table: true,
         }
+        super.compact.deep_merge(params)
       end
 
       def common_options

data/app/models/fluentd/setting/section.rb

@@ -9,11 +9,15 @@ class Fluentd
             include Fluentd::Setting::Configurable
             include Fluentd::Setting::SectionParser
             include Fluentd::Setting::PluginParameter
+            include Fluentd::Setting::SectionConfig
+            include Fluentd::Setting::RegistryLoader
 
             class_attribute :_klass, :_block, :_blocks
             class_attribute :section_name, :required, :multi, :alias
+            class_attribute :_dumped_config
             self._klass = klass
             self._blocks = []
+            self._dumped_config = {}
           end
         end
 

data/app/models/fluentd/setting/type/object.rb

@@ -0,0 +1,17 @@
+class Fluentd
+  module Setting
+    module Type
+      class Object < ActiveModel::Type::Value
+        def type
+          :object
+        end
+
+        private
+
+        def cast_value(value)
+          value
+        end
+      end
+    end
+  end
+end

data/app/views/fluentd/settings/in_forward/_form.html.haml

@@ -1,16 +1,18 @@
 = render "shared/setting_errors"
 
 - # NOTE: plugin_setting_form_action_url is defined at SettingConcern
-= form_with(model: @setting, scope: "setting", url: plugin_setting_form_action_url(@fluentd), local: true, class: "ignore-rails-error-div", builder: FluentdFormBuilder) do |f|
-  - @setting.common_options.each do |key|
+= form_with(model: setting, scope: "setting", url: plugin_setting_form_action_url(fluentd), local: true, class: "ignore-rails-error-div", builder: FluentdFormBuilder) do |f|
+  - setting.common_options.each do |key|
     = f.field(key)
 
+  = render "shared/vue/transport_section", setting: setting, form: f
+
   .card.card-body.bg-light
     %h4{"data-toggle" => "collapse", "href" => "#advanced-setting"}
       = icon('fa-caret-down')
       = t('terms.advanced_setting')
     #advanced-setting.collapse
-      - @setting.advanced_options.each do |key|
+      - setting.advanced_options.each do |key|
         = f.field(key)
 
   = f.submit t('fluentd.common.finish'), class: "btn btn-lg btn-primary pull-right"

data/app/views/fluentd/settings/out_forward/_form.html.haml

@@ -0,0 +1,18 @@
+= render "shared/setting_errors"
+
+- # NOTE: plugin_setting_form_action_url is defined at SettingConcern
+= form_with(model: setting, scope: "setting", url: plugin_setting_form_action_url(fluentd), local: true, class: "ignore-rails-error-div", builder: FluentdFormBuilder) do |f|
+  - setting.common_options.each do |key|
+    = f.field(key)
+
+  = render "shared/vue/out_forward_setting", setting: setting
+
+  .card.card-body.bg-light
+    %h4{"data-toggle" => "collapse", "href" => "#advanced-setting"}
+      = icon('fa-caret-down')
+      = t('terms.advanced_setting')
+    #advanced-setting.collapse
+      - setting.advanced_options.each do |key|
+        = f.field(key)
+
+  = f.submit t('fluentd.common.finish'), class: "btn btn-lg btn-primary pull-right"

data/app/views/fluentd/settings/out_s3/_form.html.haml

@@ -0,0 +1,18 @@
+= render "shared/setting_errors"
+
+- # NOTE: plugin_setting_form_action_url is defined at SettingConcern
+= form_with(model: setting, scope: "setting", url: plugin_setting_form_action_url(fluentd), local: true, class: "ignore-rails-error-div", builder: FluentdFormBuilder) do |f|
+  - setting.common_options.each do |key|
+    = f.field(key)
+
+  = render "shared/vue/out_s3_setting", setting: setting
+
+  .card.card-body.bg-light
+    %h4{"data-toggle" => "collapse", "href" => "#advanced-setting"}
+      = icon('fa-caret-down')
+      = t('terms.advanced_setting')
+    #advanced-setting.collapse
+      - setting.advanced_options.each do |key|
+        = f.field(key)
+
+  = f.submit t('fluentd.common.finish'), class: "btn btn-lg btn-primary pull-right"

data/app/views/shared/settings/_form.html.haml

@@ -5,45 +5,49 @@
 
 #plugin-setting
   - # NOTE: plugin_setting_form_action_url is defined at SettingConcern
-  = form_with(model: @setting, scope: :setting, url: plugin_setting_form_action_url(@fluentd), class: "ignore-rails-error-div", builder: FluentdFormBuilder) do |form|
+  = form_with(model: setting, scope: :setting, url: plugin_setting_form_action_url(fluentd), local: true, class: "ignore-rails-error-div", builder: FluentdFormBuilder) do |form|
     - @setting.common_options.each do |key|
       = form.field(key)
 
     - if @setting.have_buffer_section?
       %owned-plugin-form{"v-bind:id" => "'buffer-section'",
                          "v-bind:options-json" => "'#{Fluent::Plugin::BUFFER_REGISTRY.map.keys.to_json}'",
-                         "v-bind:initial-plugin-name" => "'#{@setting.buffer_type}'",
+                         "v-bind:initial-plugin-name" => "'#{setting.buffer_type}'",
+                         "v-bind:initial-params-json" => "'#{setting.class.initial_params[:buffer]["0"].to_json}'",
                          "v-bind:plugin-type" => "'buffer'",
                          "v-bind:plugin-label" => "'Buffer'"}
 
-    - if @setting.have_storage_section?
+    - if setting.have_storage_section?
       %owned-plugin-form{"v-bind:id" => "'storage-section'",
                          "v-bind:options-json" => "'#{Fluent::Plugin::STORAGE_REGISTRY.map.keys.to_json}'",
-                         "v-bind:initial-plugin-name" => "'#{@setting.storage_type}'",
+                         "v-bind:initial-plugin-name" => "'#{setting.storage_type}'",
+                         "v-bind:initial-params-json" => "'#{setting.class.initial_params[:storage]["0"].to_json}'",
                          "v-bind:plugin-type" => "'storage'",
                          "v-bind:plugin-label" => "'Storage'"}
 
-    - if @setting.have_parse_section?
+    - if setting.have_parse_section?
       %owned-plugin-form{"v-bind:id" => "'parse-section'",
                          "v-bind:options-json" => "'#{Fluent::Plugin::PARSER_REGISTRY.map.keys.to_json}'",
-                         "v-bind:initial-plugin-name" => "'#{@setting.parse_type}'",
+                         "v-bind:initial-plugin-name" => "'#{setting.parse_type}'",
+                         "v-bind:initial-params-json" => "'#{setting.class.initial_params[:parse]["0"].to_json}'",
                          "v-bind:plugin-type" => "'parse'",
                          "v-bind:plugin-label" => "'Parse'"}
 
-    - if @setting.have_format_section?
+    - if setting.have_format_section?
       %owned-plugin-form{"v-bind:id" => "'format-section'",
                          "v-bind:options-json" => "'#{Fluent::Plugin::FORMATTER_REGISTRY.map.keys.to_json}'",
-                         "v-bind:initial-plugin-name" => "'#{@setting.format_type}'",
+                         "v-bind:initial-plugin-name" => "'#{setting.format_type}'",
+                         "v-bind:initial-params-json" => "'#{setting.class.initial_params[:format]["0"].to_json}'",
                          "v-bind:plugin-type" => "'format'",
                          "v-bind:plugin-label" => "'Format'"}
 
-    - if @setting.advanced_options.present?
+    - if setting.advanced_options.present?
       .card.card-body.bg-light
         %h4{"data-toggle" => "collapse", "href" => "#advanced-setting"}
           = icon('fa-caret-down')
           = t('terms.advanced_setting')
         #advanced-setting.collapse
-          - @setting.advanced_options.each do |key|
+          - setting.advanced_options.each do |key|
             = form.field(key)
 
     = form.submit t('fluentd.common.finish'), class: "btn btn-lg btn-primary float-right mt-3"