fluentd-ui 1.0.0.alpha.2 → 1.0.0.alpha.3

data/app/controllers/fluentd/settings/out_td_controller.rb

@@ -1,18 +0,0 @@
-class Fluentd::Settings::OutTdController < ApplicationController
-  include SettingConcern
-
-  private
-
-  def target_class
-    Fluentd::Setting::OutTd
-  end
-
-  def initial_params
-    {
-      buffer_type: "file",
-      buffer_path: "/var/log/td-agent/buffer/td",
-      auto_create_table: true,
-      match: "td.*.*",
-    }
-  end
-end

data/app/helpers/fluentd/settings_helper.rb

@@ -1,2 +0,0 @@
-module Fluentd::SettingsHelper
-end

data/app/javascript/packs/in_tail_format.js

@@ -1,174 +0,0 @@
-'use strict'
-import 'lodash/lodash'
-
-window.addEventListener('load', () => {
-  const maxFormatCount = 20;
-
-  new Vue({
-    el: "#in_tail_format",
-    props: ["formatOptionsJson", "initialSelected", "targetFile", "paramsJson"],
-    data: {
-      previewProcessing: false,
-      format: "",
-      highlightedLines: null,
-    },
-
-    computed: {
-      options: {
-        get: function(){
-          return this.formatOptions[this.format];
-        },
-      },
-      selectableFormats: {
-        get: function() {
-          return Object.keys(this.formatOptions);
-        }
-      },
-      useTextArea: function() {
-        return this.format === "multiline";
-      }
-    },
-
-    beforeMount: function() {
-      this.formatOptions = JSON.parse(this.$el.attributes.formatOptionsJson.nodeValue);
-      this.format = this.$el.attributes.initialSelected.nodeValue;
-
-      // initialize params
-      // NOTE: if `params.setting.foo` is undefined, Vue can't binding with v-model="params.setting.foo"
-      var params = JSON.parse(this.$el.attributes.paramsJson.nodeValue);
-      if(!params.setting) {
-        params.setting = {};
-      }
-
-      var formats = _.chain(_.range(1, maxFormatCount + 1)).map(function(i) {return params.setting["format" + String(i)];}).compact().value();
-      params.setting.formats = formats.join("\n");
-
-      _.each(this.formatOptions, function(options){
-        _.each(options, function(key){
-          if(!params.setting.hasOwnProperty(key)){
-            params.setting[key] = "";
-          }
-        });
-      });
-      this.params = params;
-
-      this.targetFile = this.$el.attributes.targetFile.nodeValue;
-    },
-    mounted: function(){
-      this.$emit("data-loaded");
-    },
-
-    watch: {
-      'params.setting.formats': function(formats) {
-        _.range(1, maxFormatCount + 1).forEach(()=> {params.setting["format" + String(i)] = "";});
-
-        _.compact(formats.split("\n")).forEach((formatLine, index)=> {
-          params.setting["format" + String(index + 1)] = formatLine;
-        })
-      },
-      'params.setting.regexp': function() {
-        this.preview();
-      },
-      'format': function() {
-        this.preview();
-      },
-    },
-
-    methods: {
-      onKeyup: function(ev){
-        var el = ev.target;
-        if(el.name.match(/\[format/)){
-          this.preview();
-        }
-      },
-      updateHighlightedLines: function() {
-        if(!this.regexpMatches) {
-          this.highlightedLines = null;
-          return;
-        }
-
-        var $container = jQuery('<div>');
-        _.each(this.regexpMatches, function(match){
-          var colors = [
-            "#ff9", "#cff", "#fcf", "#dfd"
-          ];
-          var whole = match.whole;
-          var html = "";
-          var matches = [];
-
-          var lastPos = 0;
-          _.each(match.matches, function(match) {
-            var matched = match.matched;
-            if(!matched) return;
-            if(matched.length === 0) return; // Ignore empty matched with "foobar".match(/foo(.*?)bar/)[1] #=> ""
-
-            // rotated highlight color
-            var currentColor = colors.shift();
-            colors.push(currentColor);
-
-            // create highlighted range HTML
-            var $highlighted = jQuery('<span>').text(matched);
-            $highlighted.attr({
-              "class": "regexp-preview",
-              "data-toggle": "tooltip",
-              "data-placement": "top",
-              "title": match.key,
-              'style': 'background-color:' + currentColor
-            });
-            var highlightedHtml = $highlighted.wrap('<div>').parent().html();
-
-            var pos = {
-              "start": match.pos[0],
-              "end": match.pos[1]
-            };
-            if(pos.start > 0) {
-              html += _.escape(whole.substring(lastPos, pos.start));
-            }
-            html += highlightedHtml;
-            lastPos = pos.end;
-          });
-          html += whole.substring(lastPos);
-
-          $container.append(html);
-          $container.append("<br />");
-        });
-
-        this.highlightedLines = $container.html();
-      },
-
-      preview: function(){
-        if(this.previewAjax) {
-          this.previewAjax.abort();
-        }
-
-        const token = document.getElementsByName("csrf-token")[0].getAttribute('content')
-
-        var self = this;
-        new Promise(function(resolve, reject) {
-          self.previewAjax = $.ajax({
-            method: "POST",
-            url: "/api/regexp_preview",
-            headers: {
-              'X-CSRF-Token': token
-            },
-            data: {
-              regexp: self.params.setting.regexp,
-              time_format: self.params.setting.time_format,
-              format: _.isEmpty(self.format) ? "regexp" : self.format,
-              params: self.params.setting,
-              file: self.targetFile
-            }
-          }).done(resolve).fail(reject);
-        }).then(function(result){
-          self.params = _.merge(self.params, result.params);
-          self.regexpMatches = result.matches;
-          self.updateHighlightedLines();
-        })["catch"](function(error){
-          if(error.stack) {
-            console.error(error.stack);
-          }
-        });
-      },
-    }
-  });
-});

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

@@ -1,185 +0,0 @@
-class Fluentd
-  module Setting
-    module Common
-      extend ActiveSupport::Concern
-      include ActiveModel::Model
-
-      module ClassMethods
-        attr_accessor :values, :types, :children, :hidden_values
-
-        def choice(key, values)
-          @values ||= {}
-          @values[key] = values
-          set_type(:choice, [key])
-        end
-
-        def hidden(key)
-          set_type(:hidden, [key])
-        end
-
-        def nested(key, klass, options = {})
-          # e.g.:
-          #  <match>
-          #    type forward
-          #    <server>
-          #      ..
-          #    </server>
-          #  </match>
-          @children ||= {}
-          @children[key] = {
-            class: klass,
-            options: options,
-          }
-          set_type(:nested, [key])
-        end
-
-        def booleans(*keys)
-          # e.g.:
-          #   use_ssl true
-          #   include_time_key false
-          set_type(:boolean, keys)
-        end
-
-        def flags(*keys)
-          # e.g.:
-          #   tag_mapped
-          #   utc
-          set_type(:flag, keys)
-        end
-
-        private
-
-        def set_type(type, keys)
-          @types ||= {}
-          keys.each do |key|
-            @types[key] = type
-          end
-        end
-      end
-
-      def children_of(key)
-        meta = self.class.children[key]
-        return unless meta
-        klass = meta[:class]
-        data = send(key) || {"0" => {}}
-        children = []
-        data.each_pair do |index, attrs|
-          children << klass.new(attrs)
-        end
-        children
-      end
-
-      def child_class(key)
-        self.class.children[key][:class]
-      end
-
-      def values_of(key)
-        self.class.values.try(:[], key) || []
-      end
-
-      def column_type(key)
-        self.class.types.try(:[], key) || "string"
-      end
-
-      def conf(key)
-        case column_type(key)
-        when :boolean
-          boolenan(key)
-        when :flag
-          flag(key)
-        when :nested
-          return "" unless send(key)
-          klass = child_class(key)
-          send(key).map do |(_, child)|
-            # send("servers")
-            #
-            # "servers" => {
-            #   "0" => {
-            #     "name" => "foo",
-            #     "host" => "bar",
-            #     ..
-            #   },
-            #   "1" => {
-            #     ..
-            #   }
-            # }
-            child_instance = klass.new(child)
-            unless child_instance.empty_value?
-              "\n" + child_instance.to_config(key).gsub(/^/m, "  ")
-            end
-          end.join
-        else # including :hidden
-          print_if_present(key)
-        end
-      end
-
-      def plugin_type_name
-        # Fluentd::Setting::OutS3 -> s3
-        # Override this method if not above style
-        try(:plugin_name) || self.class.to_s.split("::").last.sub(/(In|Out)/, "").downcase
-      end
-
-      def print_if_present(key)
-        # e.g.:
-        #   path /var/log/td/aaa
-        #   user nobody
-        #   retry_limit 3
-        send(key).present? ? "#{key} #{send(key)}" : ""
-      end
-
-      def boolenan(key)
-        send(key).presence == "true" ? "#{key} true" : "#{key} false"
-      end
-
-      def flag(key)
-        send(key).presence == "true" ? key.to_s : ""
-      end
-
-      def empty_value?
-        config = ""
-        self.class.const_get(:KEYS).each do |key|
-          config << conf(key)
-        end
-        config.empty?
-      end
-
-      def input_plugin?
-        self.class.to_s.match(/::In|^In/)
-      end
-
-      def output_plugin?
-        not input_plugin?
-      end
-
-      def to_config(elm_name = nil)
-        indent = "  "
-        if elm_name
-          config = "<#{elm_name}>\n"
-        else
-          if input_plugin?
-            config = "<source>\n"
-          else
-            config = "<match #{match}>\n"
-          end
-          config << "#{indent}type #{plugin_type_name}\n"
-        end
-        self.class.const_get(:KEYS).each do |key|
-          next if key == :match
-          config << indent
-          config << conf(key)
-          config << "\n"
-        end
-        if elm_name
-          config << "</#{elm_name}>\n"
-        else
-          if input_plugin?
-            config << "</source>\n"
-          else
-            config << "</match>\n"
-          end
-        end
-        config.gsub(/^[ ]*\n/m, "")
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-class Fluentd
-  module Setting
-    class OutTd
-      include ActiveModel::Model
-      include Common
-
-      KEYS = [
-        :match,
-        :apikey, :auto_create_table, :database, :table,
-        :flush_interval, :buffer_type, :buffer_path,
-      ].freeze
-
-      attr_accessor(*KEYS)
-
-      flags :auto_create_table
-
-      validates :match, presence: true
-      validates :apikey, presence: true
-      validates :auto_create_table, presence: true
-      validates :buffer_path, presence: true, if: ->{ buffer_type == "file" }
-
-      def plugin_name
-        "tdlog"
-      end
-
-      def self.initial_params
-        {
-          buffer_type: "file",
-          buffer_path: "/var/log/td-agent/buffer/td",
-          auto_create_table: true,
-          match: "td.*.*",
-        }
-      end
-
-      def common_options
-        [
-          :match, :apikey, :auto_create_table, :database, :table,
-        ]
-      end
-
-      def advanced_options
-        [
-          :flush_interval, :buffer_type, :buffer_path,
-        ]
-      end
-    end
-  end
-end

data/app/views/shared/vue/_in_tail_format.html.erb

@@ -1,43 +0,0 @@
-<%- add_javascript_pack_tag("in_tail_format") %>
-
-<div id="in_tail_format"
-  formatOptionsJson="<%= formats.to_json %>"
-  initialSelected="<%= initialSelected %>"
-  targetFile="<%= file %>"
-  paramsJson="<%= params.to_json %>"
-  >
-
-  <div class="form-inline form-group">
-    <label for="in_tail_setting_format">format</label>
-    <select id="in_tail_setting_format" name="setting[format]" v-model="format" class="form-control">
-      <option v-for="selectableFormat in selectableFormats" v-bind:value="selectableFormat" v-bind:selected="format==selectableFormat" v-if="selectableFormats">{{ selectableFormat }}</option>
-    </select>
-  </div>
-  <div class="form-inline form-group" v-for="option in options">
-    <label v-bind:for="'in_tail_setting_' + option" v-if="!useTextArea">{{ option }} </label>
-    <input v-bind:id="'in_tail_setting_' + option" v-bind:type="useTextArea ? 'hidden' : 'text'" v-bind:name="'setting[' + option + ']'" v-model="params.setting[option]" v-on:keyup="onKeyup" size="100%" class="form-control" />
-  </div>
-
-  <div v-if="useTextArea">
-    <div class="form-inline form-group">
-      <label for="in_tail_setting_format_firstline">format_firstline</label>
-      <input id="in_tail_setting_format_firstline" type="text" name="setting[format_firstline]" v-model="params.setting['format_firstline']" v-on:keyup="onKeyup" size="100%" class="form-control" />
-    </div>
-
-    <div class="form-group">
-      <p class="alert alert-warning"><%= t("fluentd.settings.in_tail.notice_for_multiline_limit") %></p>
-      <label for="in_tail_setting_formats">formats</label>
-      <textarea id="in_tail_setting_formats" type="text" name="setting[formats]" v-model="params.setting['formats']" v-on:keyup="onKeyup" rows='20' size='100%' class="form-control"></textarea>
-    </div>
-  </div>
-
-  <div class="card mb-3">
-    <pre class="card-body" v-html="highlightedLines"></pre>
-  </div>
-
-  <div class="card mb-3">
-    <p class="card-body pb-0">
-      <%= raw t('fluentd.settings.in_tail_option_guide') %>
-    </p>
-  </div>
-</div>