discourse/lib/discourse.rb

350 lines
9.0 KiB
Ruby
Raw Normal View History

require 'cache'
require_dependency 'plugin/instance'
require_dependency 'auth/default_current_user_provider'
require_dependency 'version'
2013-02-05 14:16:51 -05:00
module Discourse
require 'sidekiq/exception_handler'
class SidekiqExceptionHandler
extend Sidekiq::ExceptionHandler
end
# Log an exception.
#
2014-07-17 18:07:25 -04:00
# If your code is in a scheduled job, it is recommended to use the
# error_context() method in Jobs::Base to pass the job arguments and any
# other desired context.
# See app/jobs/base.rb for the error_context function.
def self.handle_job_exception(ex, context = {}, parent_logger = nil)
context ||= {}
parent_logger ||= SidekiqExceptionHandler
cm = RailsMultisite::ConnectionManagement
parent_logger.handle_exception(ex, {
current_db: cm.current_db,
current_hostname: cm.current_hostname
}.merge(context))
end
# Expected less matches than what we got in a find
class TooManyMatches < StandardError; end
2013-02-25 11:42:20 -05:00
# When they try to do something they should be logged in for
class NotLoggedIn < StandardError; end
2013-02-05 14:16:51 -05:00
# When the input is somehow bad
class InvalidParameters < StandardError; end
2013-02-05 14:16:51 -05:00
# When they don't have permission to do something
class InvalidAccess < StandardError; end
2013-02-05 14:16:51 -05:00
# When something they want is not found
class NotFound < StandardError; end
2013-02-05 14:16:51 -05:00
2013-06-04 18:34:53 -04:00
# When a setting is missing
class SiteSettingMissing < StandardError; end
2013-06-04 18:34:53 -04:00
2013-11-05 13:04:47 -05:00
# When ImageMagick is missing
class ImageMagickMissing < StandardError; end
2013-11-05 13:04:47 -05:00
2014-02-12 23:37:28 -05:00
# When read-only mode is enabled
class ReadOnly < StandardError; end
2014-02-12 23:37:28 -05:00
# Cross site request forgery
class CSRF < StandardError; end
2013-12-23 18:50:36 -05:00
def self.filters
2015-04-02 01:02:07 -04:00
@filters ||= [:latest, :unread, :new, :read, :posted, :bookmarks, :search]
2013-12-23 18:50:36 -05:00
end
def self.feed_filters
@feed_filters ||= [:latest]
end
2013-12-23 18:50:36 -05:00
def self.anonymous_filters
2015-04-02 01:30:34 -04:00
@anonymous_filters ||= [:latest, :top, :categories, :search]
2013-12-23 18:50:36 -05:00
end
def self.logged_in_filters
@logged_in_filters ||= Discourse.filters - Discourse.anonymous_filters
end
def self.top_menu_items
@top_menu_items ||= Discourse.filters + [:category, :categories, :top]
2013-12-23 18:50:36 -05:00
end
def self.anonymous_top_menu_items
@anonymous_top_menu_items ||= Discourse.anonymous_filters + [:category, :categories, :top]
2013-12-23 18:50:36 -05:00
end
def self.activate_plugins!
all_plugins = Plugin::Instance.find_all("#{Rails.root}/plugins")
@plugins = []
all_plugins.each do |p|
v = p.metadata.required_version || Discourse::VERSION::STRING
if Discourse.has_needed_version?(Discourse::VERSION::STRING, v)
p.activate!
@plugins << p
else
STDERR.puts "Could not activate #{p.metadata.name}, discourse does not meet required version (#{v})"
end
end
end
def self.recently_readonly?
return false unless @last_read_only
@last_read_only > 15.seconds.ago
end
def self.received_readonly!
@last_read_only = Time.now
end
def self.clear_readonly!
@last_read_only = nil
end
def self.disabled_plugin_names
plugins.select {|p| !p.enabled?}.map(&:name)
end
def self.plugins
@plugins ||= []
end
def self.assets_digest
@assets_digest ||= begin
digest = Digest::MD5.hexdigest(ActionView::Base.assets_manifest.assets.values.sort.join)
channel = "/global/asset-version"
message = MessageBus.last_message(channel)
unless message && message.data == digest
MessageBus.publish channel, digest
end
digest
end
end
def self.authenticators
# TODO: perhaps we don't need auth providers and authenticators maybe one object is enough
# NOTE: this bypasses the site settings and gives a list of everything, we need to register every middleware
# for the cases of multisite
# In future we may change it so we don't include them all for cases where we are not a multisite, but we would
# require a restart after site settings change
Users::OmniauthCallbacksController::BUILTIN_AUTH + auth_providers.map(&:authenticator)
end
def self.auth_providers
providers = []
plugins.each do |p|
next unless p.auth_providers
p.auth_providers.each do |prov|
providers << prov
end
end
providers
end
def self.cache
@cache ||= Cache.new
end
2013-02-05 14:16:51 -05:00
# Get the current base URL for the current site
def self.current_hostname
if SiteSetting.force_hostname.present?
SiteSetting.force_hostname
else
RailsMultisite::ConnectionManagement.current_hostname
end
end
2013-11-05 13:04:47 -05:00
def self.base_uri(default_value = "")
if !ActionController::Base.config.relative_url_root.blank?
2013-11-05 13:04:47 -05:00
ActionController::Base.config.relative_url_root
else
2013-11-05 13:04:47 -05:00
default_value
end
end
def self.base_url_no_prefix
default_port = 80
2013-02-05 14:16:51 -05:00
protocol = "http"
if SiteSetting.use_https?
protocol = "https"
default_port = 443
2013-05-30 18:39:52 -04:00
end
result = "#{protocol}://#{current_hostname}"
port = SiteSetting.port.present? && SiteSetting.port.to_i > 0 ? SiteSetting.port.to_i : default_port
result << ":#{SiteSetting.port}" if port != default_port
2013-05-30 18:39:52 -04:00
result
end
def self.base_url
return base_url_no_prefix + base_uri
end
2014-02-12 23:37:28 -05:00
def self.enable_readonly_mode
2015-02-11 15:50:17 -05:00
$redis.set(readonly_mode_key, 1)
MessageBus.publish(readonly_channel, true)
2015-02-11 15:50:17 -05:00
keep_readonly_mode
2013-02-05 14:16:51 -05:00
true
end
2015-02-11 15:50:17 -05:00
def self.keep_readonly_mode
# extend the expiry by 1 minute every 30 seconds
Thread.new do
while readonly_mode?
$redis.expire(readonly_mode_key, 1.minute)
sleep 30.seconds
end
end
end
2014-02-12 23:37:28 -05:00
def self.disable_readonly_mode
2015-02-11 15:50:17 -05:00
$redis.del(readonly_mode_key)
MessageBus.publish(readonly_channel, false)
2013-02-05 14:16:51 -05:00
true
end
2014-02-12 23:37:28 -05:00
def self.readonly_mode?
recently_readonly? || !!$redis.get(readonly_mode_key)
2013-02-05 14:16:51 -05:00
end
def self.request_refresh!
# Causes refresh on next click for all clients
#
# This is better than `MessageBus.publish "/file-change", ["refresh"]` because
# it spreads the refreshes out over a time period
MessageBus.publish '/global/asset-version', 'clobber'
end
def self.git_version
2013-02-25 11:42:20 -05:00
return $git_version if $git_version
2013-08-02 17:25:57 -04:00
# load the version stamped by the "build:stamp" task
f = Rails.root.to_s + "/config/version"
2013-02-18 02:00:49 -05:00
require f if File.exists?("#{f}.rb")
begin
2013-02-18 02:00:49 -05:00
$git_version ||= `git rev-parse HEAD`.strip
rescue
$git_version = "unknown"
end
end
2014-09-09 17:04:10 -04:00
def self.git_branch
return $git_branch if $git_branch
begin
$git_branch ||= `git rev-parse --abbrev-ref HEAD`.strip
rescue
$git_branch = "unknown"
end
end
# Either returns the site_contact_username user or the first admin.
def self.site_contact_user
user = User.find_by(username_lower: SiteSetting.site_contact_username.downcase) if SiteSetting.site_contact_username.present?
user ||= User.admins.real.order(:id).first
end
2013-02-05 14:16:51 -05:00
SYSTEM_USER_ID ||= -1
2014-06-24 20:45:20 -04:00
def self.system_user
2014-06-24 20:45:20 -04:00
User.find_by(id: SYSTEM_USER_ID)
end
def self.store
if SiteSetting.enable_s3_uploads?
@s3_store_loaded ||= require 'file_store/s3_store'
2013-11-05 13:04:47 -05:00
FileStore::S3Store.new
else
@local_store_loaded ||= require 'file_store/local_store'
2013-11-05 13:04:47 -05:00
FileStore::LocalStore.new
end
end
def self.current_user_provider
@current_user_provider || Auth::DefaultCurrentUserProvider
end
def self.current_user_provider=(val)
@current_user_provider = val
end
2013-11-05 13:04:47 -05:00
def self.asset_host
Rails.configuration.action_controller.asset_host
end
2014-02-12 23:37:28 -05:00
def self.readonly_mode_key
"readonly_mode"
end
2013-02-05 14:16:51 -05:00
2014-02-12 23:37:28 -05:00
def self.readonly_channel
"/site/read-only"
2013-02-05 14:16:51 -05:00
end
2014-02-12 23:37:28 -05:00
# all forking servers must call this
# after fork, otherwise Discourse will be
# in a bad state
def self.after_fork
# note: all this reconnecting may no longer be needed per https://github.com/redis/redis-rb/pull/414
current_db = RailsMultisite::ConnectionManagement.current_db
RailsMultisite::ConnectionManagement.establish_connection(db: current_db)
MessageBus.after_fork
SiteSetting.after_fork
$redis.client.reconnect
Rails.cache.reconnect
2014-05-07 18:05:28 -04:00
Logster.store.redis.reconnect
2014-04-22 21:01:17 -04:00
# shuts down all connections in the pool
Sidekiq.redis_pool.shutdown{|c| nil}
# re-establish
Sidekiq.redis = sidekiq_redis_config
2014-08-11 03:51:55 -04:00
start_connection_reaper
2014-05-07 18:05:28 -04:00
nil
2014-04-22 21:01:17 -04:00
end
def self.start_connection_reaper
return if GlobalSetting.connection_reaper_age < 1 ||
GlobalSetting.connection_reaper_interval < 1
2014-08-11 03:51:55 -04:00
# this helps keep connection counts in check
Thread.new do
while true
begin
sleep GlobalSetting.connection_reaper_interval
reap_connections(GlobalSetting.connection_reaper_age)
rescue => e
Discourse.handle_exception(e, {message: "Error reaping connections"})
2014-08-11 03:51:55 -04:00
end
end
end
end
def self.reap_connections(age)
pools = []
ObjectSpace.each_object(ActiveRecord::ConnectionAdapters::ConnectionPool){|pool| pools << pool}
pools.each do |pool|
pool.drain(age.seconds)
end
end
2014-04-22 21:01:17 -04:00
def self.sidekiq_redis_config
{ url: $redis.url, namespace: 'sidekiq' }
end
def self.static_doc_topic_ids
[SiteSetting.tos_topic_id, SiteSetting.guidelines_topic_id, SiteSetting.privacy_topic_id]
end
2013-02-05 14:16:51 -05:00
end