barkest_core 1.5.3.0

data/app/models/barkest_core/authorize_failure.rb

@@ -0,0 +1,7 @@
+module BarkestCore
+  ##
+  # A simple wrapper for a standard error to allow distinguishing authorization errors.
+  class AuthorizeFailure < StandardError
+
+  end
+end

data/app/models/barkest_core/contact_message.rb

@@ -0,0 +1,37 @@
+module BarkestCore
+  ##
+  # Defines the message generated by the generic contact form.
+  class ContactMessage
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    include BarkestCore::EmailTester
+
+    attr_accessor :your_name, :your_email, :related_to, :subject, :body, :remote_ip
+
+    validates :your_name, presence: true
+    validates :your_email, presence: true, format: { with: VALID_EMAIL_REGEX }
+    validates :related_to, presence: true
+    validates :subject, presence: true, if: :need_subject?
+    validates :body, presence: true
+
+    ##
+    # Gets the full subject for the message.
+    def full_subject
+      return related_to if subject.blank?
+      "#{related_to}: #{subject}"
+    end
+
+    ##
+    # Sends the message.
+    def send_message
+      BarkestCore::ContactForm.contact(self).deliver_now
+    end
+
+    private
+
+    def need_subject?
+      related_to.to_s.downcase == 'other'
+    end
+
+  end
+end

data/app/models/barkest_core/database_config.rb

@@ -0,0 +1,223 @@
+module BarkestCore
+
+  ##
+  # Defines a database configuration for a database other than the core database.
+  #
+  # The core database must be configurared in +database.yml+ since it defines the SystemConfig.
+  #
+  # Other databases (say for a 3rd party database) can easily be defined using SystemConfig
+  # and this class.
+  class DatabaseConfig
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :name, :adapter, :encoding, :reconnect, :database, :pool, :username, :password, :timeout, :host, :port
+    attr_accessor :extra_1_name, :extra_1_label, :extra_1_type
+    attr_accessor :extra_2_name, :extra_2_label, :extra_2_type
+    attr_accessor :extra_3_name, :extra_3_label, :extra_3_type
+    attr_accessor :extra_4_name, :extra_4_label, :extra_4_type
+    attr_accessor :extra_5_name, :extra_5_label, :extra_5_type
+    attr_writer :extra_1_value, :extra_2_value, :extra_3_value, :extra_4_value, :extra_5_value
+    attr_accessor :update_username, :update_password
+
+    VALID_ADAPTERS = %w(sqlite3 mysql2 postgresql sqlserver)
+
+    validates :adapter, inclusion: { in: VALID_ADAPTERS }
+    validates :name, presence: true, length: { maximum: 128 }
+    validates :database, presence: true
+    validates :pool, presence: true
+    validates :timeout, presence: true
+
+    EXTRA_REGEX = /^extra_(?<KEY>\d+)_(?<VAR>name|label|type|value)$/
+    VALID_EXTRA_KEY = (1..5)
+    private_constant :EXTRA_REGEX, :VALID_EXTRA_KEY
+
+    ##
+    # Initializes the configuration.
+    #
+    # Define the parameters as hash values.  A string without a key will be used to set the name.
+    def initialize(*args)
+      @extra = []
+      args.each do |arg|
+        if arg.is_a?(String)
+          self.name = arg
+        elsif arg.is_a?(Hash)
+          arg.each do |k,v|
+            if respond_to?(:"#{k}?")
+              send :"#{k}=", ((v === true || v === '1') ? '1' : '0')
+            elsif respond_to?(:"#{k}")
+              send :"#{k}=", v.to_s
+            elsif (extra = EXTRA_REGEX.match(k.to_s))
+              key = extra['KEY'].to_i
+              if VALID_EXTRA_KEY.include?(key)
+                send :"extra_#{key}_#{extra['VAR']}=", v.to_s
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # :nodoc:
+    def method_missing(m,*a,&b)
+      m = m.to_s
+
+      if (key = EXTRA_REGEX.match(m))
+        if key['VAR'] == 'value'
+          key = key['KEY'].to_i
+          if VALID_EXTRA_KEY.include?(key)
+            ivar = :"@#{m}"
+            val = instance_variable_defined?(ivar) ? instance_variable_get(ivar) : nil
+            tp = send("extra_#{key}_type")
+            if tp == 'boolean'
+              val = ((val === true) || (val == '1')) ? '1' : '0'
+            end
+            return val
+          end
+        end
+      end
+
+      super m, *a, &b
+    end
+
+    ##
+    # Is the database configured to reconnect?
+    def reconnect?
+      reconnect.to_s.to_i != 0
+    end
+
+    ##
+    # Gets the name for an extra value.
+    def extra_name(index)
+      return nil if index < 1 || index > 5
+      send "extra_#{index}_name"
+    end
+
+    ##
+    # Gets the label for an extra value.
+    def extra_label(index)
+      return nil if index < 1 || index > 5
+      txt = send("extra_#{index}_label")
+      txt = extra_name(index).to_s.humanize.capitalize if txt.blank?
+      txt
+    end
+
+    ##
+    # Gets the type for an extra value.
+    def extra_type(index)
+      return nil if index < 1 || index > 5
+      send "extra_#{index}_type"
+    end
+
+    ##
+    # Gets the field type for an extra value.
+    def extra_field_type(index)
+      t = extra_type(index).to_s
+      case t
+        when 'password'
+          'password'
+        when 'integer', 'float'
+          'number'
+        when 'boolean'
+          'checkbox'
+        else
+          if t.downcase.index('in:')
+            'select'
+          else
+            'text'
+          end
+      end
+    end
+
+    ##
+    # Gets the options for a select field.
+    def extra_field_options(index)
+      if extra_field_type(index) == 'select'
+        eval extra_type(index).partition(':')[2]
+      else
+        nil
+      end
+    end
+
+    ##
+    # Gets an extra value.
+    def extra_value(index, convert = false)
+      return nil if index < 1 || index > 5
+      val = send "extra_#{index}_value"
+      if convert
+        case extra_type(index)
+          when 'boolean'
+            BarkestCore::BooleanParser.parse_for_boolean_column(val)
+          when 'integer'
+            BarkestCore::NumberParser.parse_for_int_column(val)
+          when 'float'
+            BarkestCore::NumberParser.parse_for_float_column(val)
+          else
+            val.to_s
+        end
+      end
+    end
+
+
+    ##
+    # Converts this configuration into a hash.
+    def to_h(convert_extra = true)
+      ret = {
+          adapter: adapter.to_s,
+          database: database.to_s,
+          pool: pool.to_s.to_i,
+          timeout: timeout.to_s.to_i,
+          reconnect: reconnect?,
+          encoding: encoding ? encoding.to_s : nil,
+          host: host.blank? ? nil : host.to_s,
+          port: port.blank? ? nil : port.to_s.to_i,
+          username: username.blank? ? nil : username.to_s,
+          password: password.blank? ? nil : password.to_s,
+          update_username: update_username.blank? ? nil : update_username.to_s,
+          update_password: update_password.blank? ? nil : update_password.to_s,
+      }
+      VALID_EXTRA_KEY.each do |idx|
+        if convert_extra
+          unless extra_name(idx).blank?
+            ret[extra_name(idx).to_sym] = extra_value(idx, true)
+          end
+        else
+          ret[:"extra_#{idx}_name"] = send(:"extra_#{idx}_name")
+          ret[:"extra_#{idx}_label"] = send(:"extra_#{idx}_label")
+          ret[:"extra_#{idx}_type"] = send(:"extra_#{idx}_type")
+          ret[:"extra_#{idx}_value"] = send(:"extra_#{idx}_value")
+        end
+      end
+      ret
+    end
+
+    ##
+    # Saves this configuration (encrypted) to SystemConfig.
+    def save
+      SystemConfig.set name, to_h(false), true
+    end
+
+    ##
+    # Loads the configuration for the specified database from SystemConfig.
+    def DatabaseConfig.load(name)
+      DatabaseConfig.new(name, SystemConfig.get(name))
+    end
+
+    ##
+    # Gets a list of the registered databases for enumeration.
+    def DatabaseConfig.registered
+      @registered ||= []
+    end
+
+    ##
+    # Registers a database for enumeration.
+    def DatabaseConfig.register(db_id)
+      db_id = db_id.to_s.downcase
+      unless db_id.blank?
+        registered << db_id unless registered.include?(db_id)
+      end
+      nil
+    end
+
+  end
+end

data/app/models/barkest_core/db_table.rb

@@ -0,0 +1,21 @@
+# this shouldn't be necessary, but engines seem to have a few weak spots.
+require 'will_paginate/active_record'
+
+module BarkestCore
+
+  ##
+  # This class serves as a base class for other models.
+  #
+  # This way we can guarantee that all of our models can use an explicit configuration
+  # when desirable.
+  class DbTable < ActiveRecord::Base
+    self.abstract_class = true
+
+    # Ensure that we only establish a new connection if needed.
+    unless BarkestCore.db_config.symbolize_keys == ActiveRecord::Base.connection_config.symbolize_keys
+      establish_connection BarkestCore.db_config
+    end
+
+  end
+
+end

data/app/models/barkest_core/email_config.rb

@@ -0,0 +1,132 @@
+module BarkestCore
+  ##
+  # Defines the email configuration for the system.
+  class EmailConfig
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    attr_accessor :config_mode, :default_sender, :default_recipient, :default_hostname
+    attr_accessor :address, :port, :authentication, :ssl, :enable_starttls_auto, :user_name, :password
+
+    VALID_CONFIG_MODES = %w(none smtp test)
+    VALID_AUTH_MODES = %w(none plain login cram_md5 ntlm)
+
+    validates :config_mode, inclusion: { in: VALID_CONFIG_MODES }
+    validates :default_sender, presence: true
+    validates :default_recipient, presence: true
+    validates :default_hostname, presence: true
+
+    with_options if: :smtp?, presence: true do
+      validates :address
+      validates :port
+      validates :authentication, inclusion: { in: VALID_AUTH_MODES }
+    end
+
+    validate :smtp_validate, if: :smtp?
+
+    ##
+    # Initializes the configuration.
+    def initialize(*args)
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          arg.each do |k,v|
+            if respond_to?(:"#{k}?")
+              send :"#{k}=", ((v === true || v === '1') ? '1' : '0')
+            elsif respond_to?(k)
+              send :"#{k}=", v.to_s
+            end
+          end
+        end
+      end
+    end
+
+    ##
+    # Is SMTP enabled?
+    def smtp?
+      config_mode.to_s.downcase == 'smtp'
+    end
+
+    ##
+    # Is SSL enabled for SMTP?
+    def ssl?
+      ssl.to_s.to_i != 0
+    end
+
+    ##
+    # Is STARTTLS enabled for SMTP?
+    def enable_starttls_auto?
+      enable_starttls_auto.to_s.to_i != 0
+    end
+
+    ##
+    # Converts this configuration into a hash.
+    def to_h
+      {
+          config_mode: config_mode.to_s.to_sym,
+          default_sender: default_sender.to_s,
+          default_recipient: default_recipient.to_s,
+          default_hostname: default_hostname.to_s,
+          address: address.to_s,
+          port: port.to_s.to_i,
+          authentication: authentication.to_s.to_sym,
+          ssl: ssl?,
+          enable_starttls_auto: enable_starttls_auto?,
+          user_name: user_name.to_s,
+          password: password.to_s,
+      }
+    end
+
+    ##
+    # Saves this configuration (encrypted) to SystemConfig.
+    def save
+      SystemConfig.set :email, to_h, true
+    end
+
+    ##
+    # Loads the configuration from SystemConfig.
+    def EmailConfig.load
+      EmailConfig.new SystemConfig.get(:email)
+    end
+
+    private
+
+    def smtp_validate
+      return nil if Rails.env.test?
+
+      # no need to test unless we are configured for SMTP.
+      return nil unless smtp?
+
+      # already failed if these are missing.
+      return nil if address.blank? || port.blank? || authentication.blank?
+
+      # or these
+      return nil if default_sender.blank? || default_recipient.blank? || default_hostname.blank?
+
+      # send a test message.
+      begin
+        client = Net::SMTP.new(address, port)
+        begin
+          client.enable_ssl if ssl?
+          client.start(default_hostname, user_name, password, authentication.to_sym)
+          msgstr = <<-MESSAGE
+From: #{default_sender}
+To: #{default_recipient}
+Subject: Test message
+
+This is a test message sent with the new #{Rails.env} configuration for #{default_hostname}.
+This message was sent at #{Time.zone.now}.
+          MESSAGE
+          client.send_message(msgstr, default_sender, default_recipient)
+        ensure
+          client.finish rescue nil
+        end
+
+        nil
+      rescue =>e
+        errors.add :base, "Failed to send test message. " + e.message
+      end
+    end
+
+
+  end
+end

data/app/models/barkest_core/global_status.rb

@@ -0,0 +1,267 @@
+module BarkestCore
+  ##
+  # An interface to a global status/lock file.
+  #
+  # The global status/lock file is a simple two line file.
+  # The first line is the global status message.
+  # The second line is the global status progress.
+  #
+  # The real magic comes when we take advantage of exclusive locks.
+  # The process that will be managing the status takes an exclusive lock on the status/lock file.
+  # This prevents any other process from taking an exclusive lock.
+  # It does not prevent other processes from reading from the file.
+  #
+  # So the main process can update the file at any time, until it releases the lock.
+  # The other processes can read the file at any time, and test for the lock state to determine if the main
+  # process is still busy.
+  #
+  #
+  class GlobalStatus
+
+    ##
+    # The exception raised in the +lock_for+ method when +raise_on_failure+ is set.
+    FailureToLock = Class.new(StandardError)
+
+    ##
+    # Creates a new GlobalStatus object.
+    #
+    # If you specify a status file, then that file will be used for the locking and status reporting.
+    # Otherwise, the "global_lock" file will be used.
+    def initialize(status_file = nil)
+      @lock_handle = nil
+      @stat_handle = nil
+      @status_file_path = status_file
+    end
+
+    ##
+    # Gets the path to the global status file.
+    def status_file_path
+      @status_file_path ||= WorkPath.path_for('global_status')
+    end
+
+    ##
+    # Gets the path to the global lock file.
+    def lock_file_path
+      @lock_file_path ||= WorkPath.path_for('global_lock')
+    end
+
+    ##
+    # Determines if this instance has a lock on the status/lock file.
+    def have_lock?
+      !!@lock_handle
+    end
+
+    ##
+    # Determines if any process has a lock on the status/lock file.
+    def is_locked?
+      begin
+        return true if have_lock?
+        return true unless acquire_lock
+      ensure
+        release_lock
+      end
+      false
+    end
+
+    ##
+    # Gets the current status message from the status/lock file.
+    def get_message
+      get_status[:message]
+    end
+
+    ##
+    # Gets the current progress from the status/lock file.
+    def get_percentage
+      r = get_status[:percent]
+      r.blank? ? nil : r.to_i
+    end
+
+    ##
+    # Gets the current status from the status/lock file.
+    #
+    # Returns a hash with three elements:
+    #
+    # message::
+    #   The current status message.
+    #
+    # percent::
+    #   The current status progress.
+    #
+    # locked::
+    #   The current lock state of the status/lock file. (true for locked, false for unlocked)
+    #
+    def get_status
+      r = {}
+      if have_lock?
+        @stat_handle.rewind
+        r[:message] = (@stat_handle.eof? ? 'The current process is busy.' : @stat_handle.readline.strip)
+        r[:percent] = (@stat_handle.eof? ? '' : @stat_handle.readline.strip)
+        r[:locked] = true
+      elsif is_locked?
+        if File.exist?(status_file_path)
+          begin
+            File.open(status_file_path, 'r') do |f|
+              r[:message] = (f.eof? ? 'The system is busy.' : f.readline.strip)
+              r[:percent] = (f.eof? ? '' : f.readline.strip)
+            end
+          rescue
+            r[:message] = 'The system appears busy.'
+            r[:percent] = ''
+          end
+        else
+          r[:message] = 'No status file.'
+          r[:percent] = ''
+        end
+        r[:locked] = true
+      else
+        r[:message] = 'The system is no longer busy.'
+        r[:percent] = '-'
+        r[:locked] = false
+      end
+      r
+    end
+
+    ##
+    # Sets the status message if this instance has a lock on the status/lock file.
+    #
+    # Returns true after successfully setting the message.
+    # Returns false if this instance does not currently hold the lock.
+    #
+    def set_message(value)
+      return false unless have_lock?
+      cur = get_status
+      set_status(value, cur[:percent])
+    end
+
+    ##
+    # Sets the status progress if this instance has a lock on the status/lock file.
+    #
+    # Returns true after successfully setting the progress.
+    # Returns false if this instance does not currently hold the lock.
+    #
+    def set_percentage(value)
+      return false unless have_lock?
+      cur = get_status
+      set_status(cur[:message], value)
+    end
+
+    ##
+    # Sets the status message and progress if this instance has a lock on the status/lock file.
+    #
+    # Returns true after successfully setting the status.
+    # Returns false if this instance does not currently hold the lock.
+    #
+    def set_status(message, percentage)
+      return false unless have_lock?
+      @stat_handle.rewind
+      @stat_handle.truncate 0
+      @stat_handle.write(message.to_s.strip + "\n")
+      @stat_handle.write(percentage.to_s.strip + "\n")
+      @stat_handle.flush
+      true
+    end
+
+    ##
+    # Releases the lock on the status/lock file if this instance holds the lock.
+    #
+    # Returns true.
+    #
+    def release_lock
+      return true unless @lock_handle
+      begin
+        set_message ''
+        @lock_handle.flock(File::LOCK_UN)
+      ensure
+        @stat_handle.close rescue nil
+        @lock_handle.close rescue nil
+        @stat_handle = @lock_handle = nil
+      end
+
+      true
+    end
+
+    ##
+    # Acquires the lock on the status/lock file.
+    #
+    # Returns true on success or if this instance already holds the lock.
+    # Returns false if another process holds the lock.
+    #
+    def acquire_lock
+      return true if @lock_handle
+      begin
+        @lock_handle = File.open(lock_file_path, File::RDWR | File::CREAT)
+        raise StandardError.new('Already locked') unless @lock_handle.flock(File::LOCK_EX | File::LOCK_NB)
+        @lock_handle.rewind
+        @lock_handle.truncate 0
+        @stat_handle = File.open(status_file_path, File::RDWR | File::CREAT)
+        raise StandardError.new('Failed to open status') unless @stat_handle
+        @stat_handle.rewind
+        @stat_handle.truncate 0
+      rescue
+        if @stat_handle
+          @stat_handle.close rescue nil
+        end
+        if @lock_handle
+          @lock_handle.flock(File::LOCK_UN) rescue nil
+          @lock_handle.close rescue nil
+        end
+        @stat_handle = nil
+        @lock_handle = nil
+      end
+      !!@lock_handle
+    end
+
+    ##
+    # Determines if any process currently holds the lock on the status/lock file.
+    #
+    # Returns true if the file is locked, otherwise returns false.
+    #
+    def self.locked?
+      global_instance.is_locked?
+    end
+
+    ##
+    # Gets the current status from the status/lock file.
+    #
+    # See #get_status for a description of the returned hash.
+    #
+    def self.current
+      global_instance.get_status
+    end
+
+    ##
+    # Runs the provided block with a lock on the status/lock file.
+    #
+    # If a lock can be acquired, a GlobalStatus object is yielded to the block.
+    # The lock will automatically be released when the block exits.
+    #
+    # If a lock cannot be acquire, then false is yielded to the block.
+    # The block needs to test for this case to ensure that the appropriate
+    # error handling is performed.
+    #
+    # The only time that the block is not called is if +raise_on_failure+ is set,
+    # in which case an exception is raised instead of yielding to the block.
+    #
+    def self.lock_for(raise_on_failure = false, &block)
+      return unless block_given?
+      status = GlobalStatus.new
+      if status.acquire_lock
+        begin
+          yield status
+        ensure
+          status.release_lock
+        end
+      else
+        raise BarkestCore::GlobalStatus::FailureToLock.new if raise_on_failure
+        yield false
+      end
+    end
+
+    private
+
+    def self.global_instance
+      @global_instance ||= GlobalStatus.new
+    end
+
+  end
+end