barkest_core 1.5.3.0

data/app/controllers/sessions_controller.rb

@@ -0,0 +1,64 @@
+##
+# A simple controller providing the login and logout methods for the application.
+class SessionsController < ApplicationController
+
+  before_action :require_anon, only: [ :new, :create ]
+
+  ##
+  # Shows the login form.
+  #
+  def new
+  end
+
+  ##
+  # Attempts to login a user.  To successfully log in, a user must be activated and enabled.
+  #
+  # A disabled user is treated the same as a non-existent user or an invalid password,
+  # a generic message stating invalid email or password is shown.
+  # An non-activated user is given a message indicating their account is not yet active.
+  #
+  # Upon successfuly login, the user is redirected back to where they came from or to the
+  # root url.
+  #
+  def create
+    if (@user = BarkestCore::UserManager.authenticate(params[:session][:email], params[:session][:password], request.remote_ip))
+      if @user.activated?
+        # log the user in.
+        log_in @user
+        params[:session][:remember_me] == '1' ? remember(@user) : forget(@user)
+
+        # show alerts on login.
+        session[:show_alerts] = true
+
+        redirect_back_or @user
+      else
+        flash[:safe_warning] = 'Your account has not yet been activated.<br/>Check your email for the activation link.'
+        redirect_to root_url
+      end
+    else
+      # deny login.
+      flash.now[:danger] = 'Invalid email or password.'
+      render 'new'
+    end
+  end
+
+  ##
+  # Logs out any currently logged in user session.
+  #
+  # This will not raise errors if a user is not logged in and will redirect to the
+  # root url when finished.
+  #
+  def destroy
+    log_out if logged_in?
+    redirect_to root_url
+  end
+
+  private
+
+  def require_anon
+    if logged_in?
+      flash[:danger] = 'You are already logged in.'
+      redirect_to root_url
+    end
+  end
+end

data/app/controllers/status_controller.rb

@@ -0,0 +1,150 @@
+
+##
+# A fairly simple system status controller.
+#
+# The status system revolves around the GlobalStatus class and the WorkPath#system_status_file contents.
+# When a long running process acquires a lock with the GlobalStatus, then it can update the status freely
+# until it releases the lock.  This controller simply checks the GlobalStatus lock and reads the
+# WorkPath#system_status_file contents to construct the object that gets returned to the client.
+#
+# See the methods below for more information on how this works.
+#
+class StatusController < ApplicationController
+
+  before_action :check_for_user
+
+  ##
+  # Gets the current system status from the beginning of the system status log.
+  #
+  # Status is returned as a JSON object to be consumed by Javascript.
+  #
+  # error::
+  #         The +error+ field alerts the consumer to any application error that may have occurred.
+  #
+  # locked::
+  #         The +locked+ field lets the consumer know whether the system is currently busy with a
+  #         long running task.
+  #
+  # status::
+  #         The +status+ field gives the main status for the system at the time of the request.
+  #
+  # percentage::
+  #         The +percentage+ field gives the progress for the current system status.
+  #         If blank, there is no reported progress and the consumer should hide the progress bar.
+  #         If set to '-', and +locked+ is false, then the consumer should decide whether
+  #         to show the percentage (100%) or keep the progress bar hidden.
+  #         If set to an integer between 0 and 100, then the consumer should show the progress bar
+  #         with the specified percentage.
+  #
+  # contents::
+  #         The +contents+ field contains the status log file up to this point.
+  #         Requests to #first will contain the entire log file, whereas subsequent requests to
+  #         #more will contain any data added to the log file since #first or #more was last
+  #         requested.  The consumer should append the +contents+ field to its existing log to
+  #         reconstruct the log data in entirety.
+  #         If +error+ is true, then this will contain the error message and should be treated
+  #         differently from the successful requests.
+  def first
+    self.start_position = 0
+    build_status
+    render json: @status.to_json
+  end
+
+  ##
+  # Gets any status changes since the last call to +first+ or +more+.
+  #
+  # Status is returned as a JSON object to be consumed by Javascript.
+  #
+  # See #first for a description of the JSON object returned.
+  def more
+    build_status
+    render json: @status.to_json
+  end
+
+  ##
+  # Shows the dedicated status reporting page.
+  #
+  # This action should not be invoked directly, instead use the StatusHelper#show_system_status helper
+  # method with the long running code as a block.
+  def current
+    @inital_status = BarkestCore::GlobalStatus.current[:message]
+  end
+
+  ##
+  # Shows the status testing page.
+  #
+  # This page provides five examples of how to implement status display.
+  def test
+    flag = (params[:flag] || 'menu').underscore.to_sym
+
+    if flag != :menu
+      show_system_status(
+          url_on_completion: status_test_url,
+          completion_button: 'Test Again',
+          main_status: 'Running test process'
+      ) do |status|
+        sleep 0.5
+
+        File.open(BarkestCore::WorkPath.system_status_file, 'wt') do |f|
+          2.times do |i|
+            f.write("Before loop status message ##{i+1}.\n")
+            f.flush
+            sleep 0.1
+          end
+          sleep 0.5
+
+          status.set_percentage(0) if flag == :with_progress
+          15.times do |t|
+            c = (t % 2 == 1) ? 3 : 5
+            c.times do |i|
+              f.write("Pass ##{t+1} status message ##{i+1}.\n")
+              f.flush
+              sleep 0.1
+            end
+            status.set_percentage((t * 100) / 15) if flag == :with_progress
+            sleep 0.5
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def check_for_user
+    authorize! true
+  end
+
+  def start_position
+    session[:system_status_position] || 0
+  end
+
+  def start_position=(value)
+    session[:system_status_position] = value
+  end
+
+  def build_status
+    start = start_position
+
+    cur = BarkestCore::GlobalStatus.current
+    @status = { error: false, locked: cur[:locked], status: cur[:message], percentage: cur[:percent] }
+
+    begin
+      raise StandardError.new('No system status.') unless File.exist?(BarkestCore::WorkPath.system_status_file)
+
+      File.open(BarkestCore::WorkPath.system_status_file, 'r') do |f|
+        @status[:contents] = f.read
+      end
+      if start > 0 && @status[:contents].length >= start
+        @status[:contents] = @status[:contents][start..-1]
+      end
+      start += @status[:contents].length
+    rescue Exception => err
+      @status[:contents] = err.message
+      @status[:error] = true
+    end
+
+    self.start_position = start
+  end
+
+end

data/app/controllers/system_config_controller.rb

@@ -0,0 +1,238 @@
+
+##
+# This controller makes it easy to edit the system configuration for email, authentication,
+# and additional database connections.
+#
+# Extend this class and add additional configuration items if needed.
+# New configuration items should be added as paired methods.
+#
+#   # GET: /system_config/my_config_item
+#   def show_my_config_item
+#     ...
+#   end
+#
+#   # POST: /system_config/my_config_item
+#   def update_my_config_item
+#     ...
+#   end
+#
+# If the config item requires an ID parameter, use the requires_id helper.
+#   requires_id :my_config_item
+#
+class SystemConfigController < ApplicationController
+
+  private
+
+  def self.id_config_types
+    @id_config_types ||= {}
+  end
+
+  protected
+
+  ##
+  # Sets a config type to require an id parameter.
+  def self.requires_id(config_type, id_provider)
+    config_type = config_type.to_s.to_sym
+    raise 'provider cannot be nil' unless id_provider
+    id_config_types[config_type] = id_provider
+  end
+
+  public
+
+  before_action :require_admin
+  before_action :validate_db_id, only: [ :show_database, :update_database ]
+
+  ##
+  # GET /system_config
+  def index
+
+  end
+
+  ##
+  # POST /system_config/restart
+  def restart
+    BarkestCore.request_restart
+    redirect_to system_config_url
+  end
+
+  ##
+  # GET /system_config/auth
+  def show_auth
+    @auth_params = BarkestCore::AuthConfig.new(BarkestCore.auth_config)
+  end
+
+  ##
+  # POST /system_config/auth
+  def update_auth
+    @auth_params = get_auth_params
+
+    if @auth_params.valid?
+      if @auth_params.save
+        flash[:safe_success] = 'The configuration has been saved.<br>The app will need to be restarted to use the new configuration.'
+        redirect_to system_config_url
+      else
+        flash.now[:danger] = 'Failed to save the configuration.'
+        render 'show_auth'
+      end
+    else
+      render 'show_auth'
+    end
+  end
+
+  ##
+  # GET /system_config/email
+  def show_email
+    @email_config = BarkestCore::EmailConfig.new(BarkestCore.email_config)
+  end
+
+  ##
+  # POST /system_config/email
+  def update_email
+    @email_config = get_email_params
+
+    if @email_config.valid?
+      if @email_config.save
+        flash[:safe_success] = 'The configuration has been saved.<br>The app will need to be restarted to use the new configuration.'
+        redirect_to system_config_url
+      else
+        flash.now[:danger] = 'Failed to save the configuration.'
+        render 'show_email'
+      end
+    else
+      render 'show_email'
+    end
+  end
+
+  requires_id :database, '::BarkestCore::DatabaseConfig.registered'
+
+  ##
+  # GET /system_config/database/db_name
+  def show_database
+    @db_config = BarkestCore::DatabaseConfig.new(@db_id, BarkestCore.db_config(@db_id, nil, false))
+  end
+
+  ##
+  # POST /system_config/database/db_name
+  def update_database
+    @db_config = get_db_params
+
+    if @db_config.valid?
+      if @db_config.save
+        flash[:safe_success] = 'The configuration has been saved.<br>The app will need to be restarted to use the new configuration.'
+        redirect_to system_config_url
+      else
+        flash.now[:danger] = 'Failed to save the configuration.'
+        render 'show_database'
+      end
+    else
+      render 'show_database'
+    end
+  end
+
+  ##
+  # GET /system_config/self_update
+  def show_self_update
+    @config = BarkestCore::SelfUpdateConfig.load
+  end
+
+  ##
+  # POST /system_config/self_update
+  def update_self_update
+    @config = get_self_update_params
+
+    if @config.valid?
+      if @config.save
+        flash[:success] = 'The configuration has been saved.'
+        redirect_to system_config_url
+      else
+        flash[:danger] = 'Failed to save the configuration.'
+        render 'show_self_update'
+      end
+    else
+      render 'show_self_update'
+    end
+  end
+
+  ##
+  # Gets all known configuration items.
+  def self.get_config_items
+    ret = {}
+    rex = /^(show|update)_/
+
+    id_config_types.each { |item, provider| ret[item] = { require_id: true, id_provider: provider } }
+
+    self.instance_methods.sort.each do |meth|
+      meth = meth.to_s
+      if rex.match(meth)
+        action,_,item = meth.partition('_')
+        action = action.to_sym
+        item = item.to_sym
+        ret[item] ||= {}
+        ret[item][action] = true
+      end
+    end
+
+    ret.keep_if{ |_,v| v[:show] && v[:update] }
+
+    ret.each do |k,v|
+      ret[k][:route_name] = :"system_config_#{k}"
+      ret[k][:path_helper] = :"system_config_#{k}_path"
+      ret[k][:url_helper] = :"system_config_#{k}_url"
+    end
+
+    ret
+  end
+
+  private
+
+  def require_admin
+    authorize! true
+  end
+
+  def get_auth_params
+    BarkestCore::AuthConfig.new(params.require(:barkest_core_auth_config).permit(
+        :enable_db_auth, :enable_ldap_auth, :ldap_host, :ldap_port, :ldap_base_dn, :ldap_ssl,
+        :ldap_browse_user, :ldap_browse_password, :ldap_auto_activate, :ldap_system_admin_groups
+    ))
+  end
+
+  def get_email_params
+    BarkestCore::EmailConfig.new(params.require(:barkest_core_email_config).permit(
+        :config_mode, :default_sender, :default_recipient, :default_hostname,
+        :address, :port, :authentication, :ssl, :enable_starttls_auto,
+        :user_name, :password
+    ))
+  end
+
+  def get_db_params
+    BarkestCore::DatabaseConfig.new(@db_id, params.require(:barkest_core_database_config).permit(
+        :adapter, :host, :port, :timeout, :pool, :reconnect, :username, :password,
+        :encoding, :database,
+        :extra_1_name, :extra_1_type, :extra_1_value, :extra_1_label,
+        :extra_2_name, :extra_2_type, :extra_2_value, :extra_2_label,
+        :extra_3_name, :extra_3_type, :extra_3_value, :extra_3_label,
+        :extra_4_name, :extra_4_type, :extra_4_value, :extra_4_label,
+        :extra_5_name, :extra_5_type, :extra_5_value, :extra_5_label,
+        :update_username, :update_password
+    ))
+  end
+
+  def get_self_update_params
+    BarkestCore::SelfUpdateConfig.new(params.require(:barkest_core_self_update_config).permit(:host, :port, :user, :password))
+  end
+
+  def validate_db_id
+    @db_id = params[:id].to_s.downcase
+    if @db_id.blank?
+      flash[:danger] = 'Database ID must be specified.'
+      redirect_to system_config_url
+    elsif @db_id == 'barkest_core'
+      flash[:danger] = 'Database ID cannot be barkest_core.'
+      redirect_to system_config_url
+    elsif BarkestCore.db_config_is_file_based?(@db_id)
+      flash[:danger] = "Configuration for #{@db_id} is stored in database.yml."
+      redirect_to system_config_url
+    end
+  end
+
+end