124 lines
5.7 KiB
Ruby
124 lines
5.7 KiB
Ruby
module JamRuby
|
|
class IcecastServer < ActiveRecord::Base
|
|
|
|
attr_accessor :skip_config_changed_flag
|
|
|
|
attr_accessible :template_id, :limit_id, :admin_auth_id, :directory_id, :master_relay_id, :path_id, :logging_id,
|
|
:security_id, :config_changed, :hostname, :location, :admin_email, :fileserve, as: :admin
|
|
|
|
belongs_to :template, :class_name => "JamRuby::IcecastTemplate", foreign_key: 'template_id', :inverse_of => :servers
|
|
|
|
# all are overrides, because the template defines all of these as well. When building the XML, we will prefer these if set
|
|
belongs_to :limit, :class_name => "JamRuby::IcecastLimit", foreign_key: 'limit_id', :inverse_of => :servers
|
|
belongs_to :admin_auth, :class_name => "JamRuby::IcecastAdminAuthentication", foreign_key: 'admin_auth_id', :inverse_of => :servers
|
|
belongs_to :directory, :class_name => "JamRuby::IcecastDirectory", foreign_key: 'directory_id', :inverse_of => :servers
|
|
belongs_to :master_relay, :class_name => "JamRuby::IcecastMasterServerRelay", foreign_key: 'master_relay_id', :inverse_of => :servers
|
|
belongs_to :path, :class_name => "JamRuby::IcecastPath", foreign_key: 'path_id', :inverse_of => :servers
|
|
belongs_to :logging, :class_name => "JamRuby::IcecastLogging", foreign_key: 'logging_id', :inverse_of => :servers
|
|
belongs_to :security, :class_name => "JamRuby::IcecastSecurity", foreign_key: 'security_id', :inverse_of => :servers
|
|
has_many :listen_socket_servers, :class_name => "JamRuby::IcecastServerSocket", :inverse_of => :server
|
|
has_many :listen_sockets, :class_name => "JamRuby::IcecastListenSocket", :through => :listen_socket_servers, :source => :socket
|
|
|
|
# mounts and relays are naturally server-specific, though
|
|
has_many :server_mounts, :class_name => "JamRuby::IcecastServerMount", :inverse_of => :server
|
|
has_many :mounts, :class_name => "JamRuby::IcecastMount", :through => :server_mounts, :source => :mount
|
|
|
|
has_many :server_relays, :class_name => "JamRuby::IcecastServerRelay", :inverse_of => :relay
|
|
has_many :relays, :class_name => "JamRuby::IcecastRelay", :through => :server_relays, :source => :relay
|
|
|
|
validates :config_changed, :inclusion => {:in => [0, 1]}
|
|
validates :hostname, presence: true
|
|
validates :fileserve, :inclusion => {:in => [0, 1]}, :if => lambda {|s| s.fileserve.present? }
|
|
validates :server_id, presence: true
|
|
|
|
validates :template, presence: true
|
|
|
|
before_save :before_save, unless: lambda { skip_config_changed_flag }
|
|
before_save :sanitize_active_admin
|
|
after_save :after_save
|
|
|
|
def before_save
|
|
self.config_changed = 1
|
|
end
|
|
|
|
def sanitize_active_admin
|
|
self.template_id = nil if self.template_id == ''
|
|
self.limit_id = nil if self.limit_id == ''
|
|
self.admin_auth_id = nil if self.admin_auth_id == ''
|
|
self.directory_id = nil if self.directory_id == ''
|
|
self.master_relay_id = nil if self.master_relay_id == ''
|
|
self.path_id = nil if self.path_id == ''
|
|
self.logging_id = nil if self.logging_id == ''
|
|
self.security_id = nil if self.security_id == ''
|
|
end
|
|
|
|
def after_save
|
|
# if we set config_changed, then queue up a job
|
|
if config_changed_was == 0 && config_changed == 1
|
|
IcecastConfigWriter.enqueue(self.server_id)
|
|
end
|
|
end
|
|
|
|
# this method is the correct way to set config_changed to false
|
|
# if you don't do it this way, then likely you'll get into a loop
|
|
# config_changed = true, enqueued job, job executes, job accidentally flags config_changed by touching the model, and repeat
|
|
def config_updated
|
|
self.skip_config_changed_flag = true
|
|
|
|
self.config_changed = 0
|
|
begin
|
|
self.save!
|
|
rescue
|
|
raise
|
|
ensure
|
|
self.skip_config_changed_flag = false
|
|
end
|
|
end
|
|
|
|
def to_s
|
|
return server_id
|
|
end
|
|
|
|
def dumpXml (output=$stdout, indent=1)
|
|
|
|
builder = ::Builder::XmlMarkup.new(:target => output, :indent => indent)
|
|
|
|
builder.tag! 'icecast' do |root|
|
|
root.tag! 'hostname', hostname
|
|
root.tag! 'location', (location.nil? || location.empty?) ? template.location : location
|
|
root.tag! 'server-id', server_id
|
|
root.tag! 'admin', (admin_email.nil? || admin_email.empty?) ? template.admin_email : admin_email
|
|
root.tag! 'fileserve', fileserve.nil? ? template.fileserve : fileserve
|
|
|
|
# do we have an override specified? or do we go with the template
|
|
current_limit = limit ? limit : template.limit
|
|
current_admin_auth = admin_auth ? admin_auth : template.admin_auth
|
|
current_directory = directory ? directory : template.directory
|
|
current_master_relay = master_relay ? master_relay : template.master_relay
|
|
current_path = path ? path : template.path
|
|
current_logging = logging ? logging : template.logging
|
|
current_security = security ? security : template.security
|
|
current_listen_sockets = listen_sockets.length > 0 ? listen_sockets : template.listen_sockets
|
|
|
|
current_limit.dumpXml(builder) unless current_limit.nil?
|
|
current_admin_auth.dumpXml(builder) unless current_admin_auth.nil?
|
|
current_directory.dumpXml(builder) unless current_directory.nil?
|
|
current_master_relay.dumpXml(builder) unless current_master_relay.nil?
|
|
current_path.dumpXml(builder) unless current_path.nil?
|
|
current_logging.dumpXml(builder) unless current_logging.nil?
|
|
current_security.dumpXml(builder) unless current_security.nil?
|
|
current_listen_sockets.each do |listen_socket|
|
|
listen_socket.dumpXml(builder)
|
|
end
|
|
|
|
relays.each do |relay|
|
|
relay.dumpXml(builder)
|
|
end
|
|
|
|
mounts.each do |mount|
|
|
mount.dumpXml(builder)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end |