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

data/app/javascript/packs/transport_config.js

@@ -0,0 +1,62 @@
+/* global _ */
+"use strict";
+
+import "lodash/lodash";
+import ConfigField from "./config_field";
+
+const TransportConfig = {
+  template: "#vue-transport-config",
+  components: {
+    "config-field": ConfigField
+  },
+  props: [
+    "pluginType",
+    "pluginName"
+  ],
+  data: function() {
+    return {
+      transportType: "tcp",
+      options: ["tcp", "tls"],
+      tlsOptions: []
+    };
+  },
+  computed: {
+    token: function() {
+      return Rails.csrfToken();
+    }
+  },
+  filters: {
+    toUpper: function(value) {
+      return _.toUpper(value);
+    }
+  },
+  mounted: function() {
+  },
+  methods: {
+    onChange: function() {
+      console.log(this.pluginType, this.pluginName, this.transportType);
+      this.updateSection();
+    },
+
+    updateSection: function() {
+      if (this.transportType === "tcp") {
+        return;
+      }
+      $.ajax({
+        method: "GET",
+        url: "/api/config_definitions",
+        headers: {
+          "X-CSRF-Token": this.token
+        },
+        data: {
+          type: this.pluginType,
+          name: this.pluginName
+        }
+      }).then((data) => {
+        this.tlsOptions = data.tlsOptions;
+      });
+    }
+  }
+};
+
+export { TransportConfig as default };

data/app/javascript/packs/transport_section.js

@@ -0,0 +1,72 @@
+/* global _ */
+"use strict";
+import "lodash/lodash";
+
+import ConfigField from "./config_field";
+
+$(document).ready(() => {
+  new Vue({
+    el: "#transport-section",
+    components: {
+      "config-field": ConfigField
+    },
+    filters: {
+      toUpper: function(value) {
+        return _.toUpper(value);
+      }
+    },
+    props: {
+      "transportType": {
+        default: "tcp",
+        type: String
+      }
+    },
+    data: function() {
+      return {
+        pluginType: null,
+        pluginName: null,
+        options: ["tcp", "tls"],
+        commonOptions: [],
+        advancedOptions: []
+
+      };
+    },
+    computed: {
+      token: function() {
+        return Rails.csrfToken();
+      }
+    },
+    beforeMount: function() {
+      this.pluginType = this.$el.attributes.pluginType.nodeValue;
+      this.pluginName = this.$el.attributes.pluginName.nodeValue;
+    },
+    mounted: function() {
+    },
+    methods: {
+      onChange: function() {
+        console.log(this.pluginType, this.pluginName, this.transportType);
+        this.updateSection();
+      },
+
+      updateSection: function() {
+        if (this.transportType === "tcp") {
+          return;
+        }
+        $.ajax({
+          method: "GET",
+          url: "/api/config_definitions",
+          headers: {
+            "X-CSRF-Token": this.token
+          },
+          data: {
+            type: this.pluginType,
+            name: this.pluginName
+          }
+        }).then((data) => {
+          this.commonOptions = data.transport.commonOptions;
+          this.advancedOptions = data.transport.advancedOptions;
+        });
+      }
+    }
+  });
+});

data/app/javascript/packs/treeview.js

@@ -1,5 +1,6 @@
-'use strict';
-import 'lodash/lodash';
+/* global _ */
+"use strict";
+import "lodash/lodash";
 $(document).ready(() => {
   new Vue({
     el: "#treeview",
@@ -15,14 +16,6 @@ $(document).ready(() => {
       paths: []
     },
 
-    mounted: function(){
-      console.log(this.initialPath);
-      this.path = this.initialPath;
-      this.fetchTree();
-      this.$watch("path", this.fetchTree);
-      this.$watch("path", this.fetchPreview);
-    },
-
     computed: {
       selected: function(){
         var self = this;
@@ -55,6 +48,14 @@ $(document).ready(() => {
       }
     },
 
+    mounted: function(){
+      console.log(this.initialPath);
+      this.path = this.initialPath;
+      this.fetchTree();
+      this.$watch("path", this.fetchTree);
+      this.$watch("path", this.fetchPreview);
+    },
+
     methods: {
       isAncestor: function(target) {
         return this.path.indexOf(target) === 0;

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

@@ -64,11 +64,9 @@ class Fluentd
             self._built_in_params << name
             unless name == "type"
               attribute(name, type, **options.slice(:precision, :limit, :scale))
-              validates(name, presence: true) if options[:required]
             end
           else
             attribute(name, type, **options.slice(:precision, :limit, :scale))
-            validates(name, presence: true) if options[:required]
           end
           self._types[name] = type
           self._descriptions[name] = options[:desc] if options.key?(:desc)
@@ -100,7 +98,7 @@ class Fluentd
         end
 
         def config_argument(name, type = ActiveModel::Type::Value.new, **options)
-          config_param(name, **options)
+          config_param(name, type, **options)
           self._argument_name = name
         end
 

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

@@ -1,4 +1,10 @@
 require "fluent/plugin"
+require "fluent/test/log"
+require "fluent/test/driver/input"
+require "fluent/test/driver/output"
+require "fluent/test/driver/filter"
+require "fluent/test/driver/parser"
+require "fluent/test/driver/formatter"
 
 class Fluentd
   module Setting
@@ -11,7 +17,6 @@ class Fluentd
       include Fluentd::Setting::PluginConfig
       include Fluentd::Setting::SectionParser
       include Fluentd::Setting::PluginParameter
-      include Fluentd::Setting::SectionValidator
 
       included do
         cattr_accessor :plugin_type, :plugin_name, :config_definition
@@ -61,6 +66,29 @@ class Fluentd
           @plugin_class ||= plugin_instance.class
         end
 
+        def create_driver(config)
+          case plugin_type
+          when "input"
+            if plugin_class.class_variable_defined?(:@@pos_file_paths)
+              plugin_class.class_variable_set(:@@pos_file_paths, {})
+            end
+            Fluent::Test::Driver::Input.new(plugin_class).configure(config)
+          when "output"
+            if Fluent::Plugin::FileBuffer.class_variable_defined?(:@@buffer_paths)
+              Fluent::Plugin::FileBuffer.class_variable_set(:@@buffer_paths, {})
+            end
+            Fluent::Test::Driver::Output.new(plugin_class).configure(config)
+          when "filter"
+            Fluent::Test::Driver::Filter.new(plugin_class).configure(config)
+          when "parser"
+            Fluent::Test::Driver::Parser.new(plugin_class).configure(config)
+          when "formatter"
+            FLuent::Test::Driver::Formatter.new(plugin_class).configure(config)
+          else
+            nil
+          end
+        end
+
         def plugin_helpers
           @plugin_helpers ||= if plugin_instance.respond_to?(:plugin_helpers)
                                 plugin_instance.plugin_helpers

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

@@ -3,6 +3,21 @@ class Fluentd
     module PluginConfig
       extend ActiveSupport::Concern
 
+      included do
+        validate :validate_configuration
+      end
+
+      def validate_configuration
+        original_log = $log
+        $log = DummyLogger.logger
+        config = to_config.to_s.lines[1..-2].join
+        self.class.create_driver(config)
+      rescue Fluent::ConfigError => ex
+        errors.add(:base, :invalid, message: ex.message)
+      ensure
+        $log = original_log
+      end
+
       def to_config
         name = case plugin_type
                when "input"
@@ -44,16 +59,25 @@ class Fluentd
         end
         elements = []
         sections.to_h.each do |key, section_params|
-          if %w(parse format buffer storage).include?(key)
-            section_params["0"] = { "@type" => self.attributes["#{key}_type"] }.merge(section_params["0"])
-          end
           next if section_params.blank?
-          section_params.each do |index, _section_params|
-            sub_attrs, sub_elements = parse_attributes(_section_params)
-            elements << config_element(key, "", sub_attrs, sub_elements)
+          section_class = self._sections[key.to_sym]
+          if %w(parse format buffer storage).include?(key)
+            if section_params && section_params.key?("0")
+              section_params["0"] = { "type" => self.attributes["#{key}_type"] }.merge(section_params["0"])
+            else
+              section_params = {
+                "0" => { "type" => self.attributes["#{key}_type"] }
+              }
+            end
           end
+          elements = section_params.map do |index, _section_params|
+            section_class.new(_section_params).to_config
+          end.compact
+        end
+        attrs = params.to_h.reject do |key, value|
+          skip?(key.to_sym, value)
         end
-        return params.to_h.reject{|key, value| skip?(key.to_sym, value) }, elements
+        return attrs, elements
       end
 
       # copy from Fluent::Test::Helpers#config_element
@@ -64,7 +88,7 @@ class Fluentd
       def skip?(key, value)
         return true if value.blank?
         if self._defaults.key?(key)
-          reformat_value(key, self._defaults[key]) == reformat_value(key, value)
+          self.class.reformat_value(key, self._defaults[key]) == self.class.reformat_value(key, value)
         else
           false
         end

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

@@ -6,19 +6,19 @@ class Fluentd
       include Fluentd::Setting::Configurable
 
       def column_type(name)
-        self.class._types[name]
+        self.class.column_type(name)
       end
 
       def list_of(name)
-        self.class._list[name]
+        self.class.list_of(name)
       end
 
       def desc(name)
-        self.class._descriptions[name]
+        self.class.desc(name)
       end
 
       def default(name)
-        reformat_value(name, self.class._defaults[name])
+        self.class.reformat_value(name, self.class.default(name))
       end
 
       def common_options
@@ -38,19 +38,19 @@ class Fluentd
       end
 
       def have_buffer_section?
-        self.class._sections.key?(:buffer)
+        self.class.have_buffer_section?
       end
 
       def have_storage_section?
-        self.class._sections.key?(:storage)
+        self.class.have_storage_section?
       end
 
       def have_parse_section?
-        self.class._sections.key?(:parse)
+        self.class.have_parse_section?
       end
 
       def have_format_section?
-        self.class._sections.key?(:format)
+        self.class.have_format_section?
       end
 
       def create_buffer
@@ -77,19 +77,6 @@ class Fluentd
         formatter_class.new(format["0"].except("type"))
       end
 
-      def reformat_value(name, value)
-        type = column_type(name)
-        return value if type.nil? # name == :time_key
-        return value if type == :enum
-        return value if type == :regexp
-        type_name = if type.is_a?(Fluentd::Setting::Type::Time)
-                      :time
-                    else
-                      type
-                    end
-        Fluent::Config::REFORMAT_VALUE.call(type_name, value)
-      end
-
       module ClassMethods
         def column_type(name)
           self._types[name]
@@ -99,12 +86,61 @@ class Fluentd
           self._list[name]
         end
 
+        def desc(name)
+          self._descriptions[name]
+        end
+
+        def default(name)
+          reformat_value(name, self._defaults[name])
+        end
+
+        def have_buffer_section?
+          self._sections.key?(:buffer)
+        end
+
+        def have_storage_section?
+          self._sections.key?(:storage)
+        end
+
+        def have_parse_section?
+          self._sections.key?(:parse)
+        end
+
+        def have_format_section?
+          self._sections.key?(:format)
+        end
+
+        def initial_params
+          new # ensure to load attributes
+          params = {}
+          self._defaults.each do |key, value|
+            if key.to_s.start_with?("@")
+              params[key.to_s[1..-1].to_sym] = value
+            else
+              params[key] = value
+            end
+          end
+          self._sections.each do |key, section|
+            next if section.initial_params.blank?
+            params[key] = {
+              "0" => section.initial_params.stringify_keys
+            }
+          end
+          params
+        end
+
         def permit_params
           self.new # init
           keys = self._types.keys
           self._sections.each do |key, section|
             keys << _permit_section(key, section)
           end
+
+          keys << :buffer_type if have_buffer_section?
+          keys << :storage_type if have_storage_section?
+          keys << :parse_type if have_parse_section?
+          keys << :format_type if have_format_section?
+
           keys
         end
 
@@ -115,6 +151,23 @@ class Fluentd
           end
           keys
         end
+
+        def reformat_value(name, value)
+          type = column_type(name)
+          return value if type.nil? # name == :time_key
+          return value.to_sym if type == :enum
+          return value if type == :regexp
+          type_name = if type.is_a?(Fluentd::Setting::Type::Time)
+                        :time
+                      else
+                        type
+                      end
+          begin
+            Fluent::Config::REFORMAT_VALUE.call(type_name, value.dup)
+          rescue TypeError
+            Fluent::Config::REFORMAT_VALUE.call(type_name, value)
+          end
+        end
       end
     end
   end