fluentd-ui 0.1.0

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

@@ -0,0 +1,36 @@
+class Fluentd::Settings::OutMongoController < ApplicationController
+  before_action :login_required
+  before_action :find_fluentd
+
+  def show
+    @setting = Fluentd::Setting::OutMongo.new({
+      host: "127.0.0.1",
+      port: 27017,
+      capped: true,
+      capped_size: "100m",
+    })
+  end
+
+  def finish
+    @setting = Fluentd::Setting::OutMongo.new(setting_params)
+    unless @setting.valid?
+      return render "show"
+    end
+
+    @fluentd.agent.config_append @setting.to_config
+    if @fluentd.agent.running?
+      unless @fluentd.agent.restart
+        @setting.errors.add(:base, @fluentd.agent.log_tail(1).first)
+        return render "show"
+      end
+    end
+    redirect_to daemon_setting_path(@fluentd)
+  end
+
+  private
+
+  def setting_params
+    params.require(:fluentd_setting_out_mongo).permit(*Fluentd::Setting::OutMongo::KEYS)
+  end
+
+end

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

@@ -0,0 +1,36 @@
+class Fluentd::Settings::OutS3Controller < ApplicationController
+  before_action :login_required
+  before_action :find_fluentd
+
+  def show
+    @setting = Fluentd::Setting::OutS3.new({
+      s3_endpoint: "s3-us-west-1.amazonaws.com",
+      output_tag: true,
+      output_time: true,
+      use_ssl: true,
+    })
+  end
+
+  def finish
+    @setting = Fluentd::Setting::OutS3.new(setting_params)
+    unless @setting.valid?
+      return render "show"
+    end
+
+    @fluentd.agent.config_append @setting.to_config
+    if @fluentd.agent.running?
+      unless @fluentd.agent.restart
+        @setting.errors.add(:base, @fluentd.agent.log_tail(1).first)
+        return render "show"
+      end
+    end
+    redirect_to daemon_setting_path(@fluentd)
+  end
+
+  private
+
+  def setting_params
+    params.require(:fluentd_setting_out_s3).permit(*Fluentd::Setting::OutS3::KEYS)
+  end
+
+end

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

@@ -0,0 +1,36 @@
+class Fluentd::Settings::OutTdController < ApplicationController
+  before_action :login_required
+  before_action :find_fluentd
+
+  def show
+    @setting = Fluentd::Setting::OutTd.new({
+      buffer_type: "file",
+      buffer_path: "/var/log/td-agent/buffer/td",
+      auto_create_table: true,
+      match: "td.*.*",
+    })
+  end
+
+  def finish
+    @setting = Fluentd::Setting::OutTd.new(setting_params)
+    unless @setting.valid?
+      return render "show"
+    end
+
+    @fluentd.agent.config_append @setting.to_config
+    if @fluentd.agent.running?
+      unless @fluentd.agent.restart
+        @setting.errors.add(:base, @fluentd.agent.log_tail(1).first)
+        return render "show"
+      end
+    end
+    redirect_to daemon_setting_path(@fluentd)
+  end
+
+  private
+
+  def setting_params
+    params.require(:fluentd_setting_out_td).permit(*Fluentd::Setting::OutTd::KEYS)
+  end
+
+end

data/app/controllers/fluentd/settings_controller.rb

@@ -0,0 +1,18 @@
+class Fluentd::SettingsController < ApplicationController
+  before_action :login_required
+  before_action :find_fluentd
+
+  def show
+    @config = @fluentd.agent.config
+  end
+
+  def edit
+    @config = @fluentd.agent.config
+  end
+
+  def  update
+    @fluentd.agent.config_write params[:config]
+    @fluentd.agent.restart if @fluentd.agent.running?
+    redirect_to daemon_setting_path(@fluentd)
+  end
+end

data/app/controllers/fluentd_controller.rb

@@ -0,0 +1,62 @@
+class FluentdController < ApplicationController
+  before_action :find_fluentd, only: [:show, :edit, :update, :destroy, :log, :raw_log, :errors]
+  before_action :check_fluentd_exists, only: [:edit, :log, :raw_log, :errors]
+
+  def show
+  end
+
+  def new
+    @fluentd = Fluentd.new(variant: params[:variant] || "fluentd")
+    @fluentd.load_settings_from_agent_default
+  end
+
+  def create
+    @fluentd = Fluentd.new(fluentd_params)
+    unless @fluentd.save
+      return render :new
+    end
+    redirect_to daemon_path
+  end
+
+  def edit
+  end
+
+  def update
+    # TODO: should restart if changed file path? or just do "dirty" flagged?
+    @fluentd.update_attributes(fluentd_params)
+    unless @fluentd.save
+      return render :edit
+    end
+    redirect_to daemon_path
+  end
+  
+  def destroy
+    @fluentd.agent.stop if @fluentd.agent.running?
+    @fluentd.destroy
+    redirect_to root_path, flash: {success: t('messages.destroy_succeed_fluentd_setting', brand: fluentd_ui_brand)}
+  end
+
+  def log
+  end
+
+  def errors
+    @error_duration_days = 5
+    @errors = @fluentd.agent.errors_since(@error_duration_days.days.ago)
+  end
+
+  def raw_log
+    send_data @fluentd.agent.log, type: "application/octet-stream", filename: File.basename(@fluentd.log_file)
+  end
+
+  private
+
+  def fluentd_params
+    params.require(:fluentd).permit(:log_file, :pid_file, :config_file, :variant, :api_endpoint)
+  end
+
+  def check_fluentd_exists
+    unless fluentd_exists?
+      redirect_to root_path
+    end
+  end
+end

data/app/controllers/misc_controller.rb

@@ -0,0 +1,69 @@
+require "fluent/version"
+require "zip"
+
+class MiscController < ApplicationController
+  after_action :update!, only: [:update_fluentd_ui]
+
+  def show
+    redirect_to misc_information_path
+  end
+
+  def information
+    @env = ENV
+    @plugins = Plugin.installed
+  end
+
+  def update_fluentd_ui
+    @current_pid = $$
+    render "update_fluentd_ui", layout: "sign_in"
+  end
+
+  def upgrading_status
+    if FluentdUiRestart::LOCK.present?
+      return render text: "updating"
+    end
+
+    if $$.to_s == params[:old_pid]
+      # restarting fluentd-ui is finished, but PID doesn't changed.
+      # maybe error occured at FluentdUiRestart#perform
+      render text: "failed"
+    else
+      render text: "finished"
+    end
+  end
+
+  def download_info
+    fluentd = Fluentd.instance
+    path = Rails.root.join("tmp/system_info.zip")
+    File.unlink(path) if File.exists?(path)
+
+    Zip::File.open(path, Zip::File::CREATE) do |zip|
+      zip.get_output_stream('fluentd.log') {|f| f.puts fluentd.agent.log }
+      if ENV["FLUENTD_UI_LOG_PATH"].present?
+        zip.add("fluentd-ui.log", ENV["FLUENTD_UI_LOG_PATH"])
+      else
+        zip.add("fluentd-ui.log", Rails.root.join("log/#{Rails.env}.log"))
+      end
+      zip.get_output_stream('env.txt') do |f|
+        ENV.to_a.each do |(key, value)|
+          f.puts "#{key}=#{value}"
+        end
+      end
+      zip.get_output_stream('versions.txt') do |f|
+        f.puts "ruby: #{RUBY_DESCRIPTION}"
+        f.puts "fluentd: #{FluentdUI.fluentd_version}"
+        f.puts "fluentd-ui: #{FluentdUI::VERSION}"
+        f.puts
+        f.puts "# OS Information"
+        f.puts "uname -a: #{`uname -a`.strip}"
+      end
+    end
+    send_file path
+  end
+
+  private
+
+  def update!
+    FluentdUiRestart.new.async.perform
+  end
+end

data/app/controllers/plugins_controller.rb

@@ -0,0 +1,44 @@
+class PluginsController < ApplicationController
+  def index
+    redirect_to installed_plugins_path
+  end
+
+  def installed
+    @plugins = Plugin.installed
+  end
+
+  def recommended
+    @plugins = Plugin.recommended
+  end
+
+  def updated
+    @plugins = Plugin.installed.reject{|plugin| plugin.latest_version? }
+  end
+
+  def install
+    params[:plugins].each do |gem_name|
+      GemInstaller.new.async.perform(gem_name)
+    end
+    redirect_to plugins_path
+  end
+
+  def uninstall
+    params[:plugins].each do |gem_name|
+      GemUninstaller.new.async.perform(gem_name)
+    end
+    redirect_to plugins_path
+  end
+
+  def upgrade
+    GemInstaller.new.async.perform(params[:plugins][:name], params[:plugins][:version])
+    redirect_to plugins_path
+  end
+
+  def bulk_upgrade
+    params[:plugins].each do |gem_name|
+      pl = Plugin.new(gem_name: gem_name)
+      GemInstaller.new.async.perform(gem_name, pl.latest_version)
+    end
+    redirect_to plugins_path
+  end
+end

data/app/controllers/polling_controller.rb

@@ -0,0 +1,20 @@
+class PollingController < ApplicationController
+  def alerts
+    alerts = []
+    installing_gems.each do |plugin|
+      target = plugin.gem_name.dup
+      target << "(#{plugin.version})" if plugin.version
+      alerts << {
+        text: I18n.t('terms.installing', target: target)
+      }
+    end
+    uninstalling_gems.each do |plugin|
+      target = plugin.gem_name.dup
+      target << "(#{plugin.version})" if plugin.version
+      alerts << {
+        text: I18n.t('terms.uninstalling', target: target)
+      }
+    end
+    render json: alerts
+  end
+end

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,45 @@
+class SessionsController < ApplicationController
+  layout "sign_in"
+  skip_before_action :login_required, only: [:new, :create]
+  before_action :set_user
+
+  def create
+    if session_params[:name] != "admin" # NOTE: Application user is "admin" only, other user name is invalid for now.
+      flash.now[:notice] = I18n.t("messages.login_failed")
+      return render :new
+    end
+
+    unless @user.authenticate(session_params[:password])
+      flash.now[:notice] = I18n.t("messages.login_failed")
+      return render :new
+    end
+    sign_in @user
+    if session_params[:password] == Settings.default_password
+      flash[:warning] = t('terms.changeme_password')
+    end
+    redirect_to root_path
+  end
+
+  def destroy
+    session.delete :succeed_password
+    redirect_to new_sessions_path
+  end
+
+  private
+
+  def set_user
+    @user = User.new(name: "admin")
+  end
+
+  def session_params
+    params.require(:session).permit(:name, :password)
+  end
+
+  def sign_in(user)
+    # NOTE: Cookie will encrypt by Rails, but store raw password into session is a bad practice.
+    #       If we use some DB in the future, change this to store token with expire limitation (not password).
+    #
+    #       Currently, only store to session if default password is used.
+    session[:succeed_password] = session_params[:password] if session_params[:password] == Settings.default_password
+  end
+end

data/app/controllers/tutorials_controller.rb

@@ -0,0 +1,40 @@
+class TutorialsController < ApplicationController
+  before_action :find_fluentd
+  before_action :check_ready, only: [:chapter1, :chapter2]
+  before_action :set_in_http, only: [:chapter1, :chapter2, :request_fluentd]
+  helper_method :tutorial_ready?
+
+  def index
+    @log = @fluentd.agent.log_tail.reverse if @fluentd
+  end
+
+  def chapter1
+  end
+
+  def chapter2
+    @default_conf = Fluentd::DEFAULT_CONF
+  end
+
+  def request_fluentd
+    HTTPClient.post("http://localhost:#{@in_http["port"]}#{params[:path]}", json: params[:data].to_json)
+    render nothing: true, status: 204
+  end
+
+  private
+
+  def set_in_http
+    @in_http = @fluentd.agent.configuration.sources.find{|directive| directive["type"] == "http"}
+  end
+
+  def find_fluentd
+    @fluentd = Fluentd.instance
+  end
+
+  def check_ready
+    redirect_to tutorials_url unless tutorial_ready?
+  end
+
+  def tutorial_ready?
+    @fluentd && @fluentd.agent.running?
+  end
+end

data/app/controllers/users_controller.rb

@@ -0,0 +1,28 @@
+class UsersController < ApplicationController
+  before_action :find_user
+
+  def show
+  end
+
+  def update
+    unless @user.authenticate(user_params[:current_password])
+      @user.errors.add(:current_password, :wrong_password)
+      return render :show
+    end
+    unless @user.update_attributes(user_params)
+      return render :show
+    end
+    session[:succeed_password] = user_params[:password]
+    redirect_to user_path
+  end
+
+  private
+
+  def find_user
+    @user = User.new(name: "admin") # user is only "admin"
+  end
+
+  def user_params
+    params.require(:user).permit(:current_password, :password, :password_confirmation)
+  end
+end