seth
/
jam-cloud
mirror of https://bitbucket.org/jamkazam/jam-cloud.git
1
0
Fork 0
Code Issues Actions Packages Projects Releases Wiki Activity

Icecast modules and test

This commit is contained in:
jam 2014-01-14 21:22:05 +00:00
parent 72a97198ed
commit b15604c148
29 changed files with 625 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
db/up/icecast.sql
View File

@ -147,11 +147,11 @@ create table icecast_relays (
-- mount at server. eg /example.ogg
mount VARCHAR(128) not null,
-- eg /different.ogg
local_mount VARCHAR(128) not null,
local_mount VARCHAR(128) not null default '/relaymout.ogg',
-- eg joe. could be null
username VARCHAR(64) default NULL ,
username VARCHAR(64) not null default 'jkicerelayusr' ,
-- user password
password VARCHAR(64) default null ,
password VARCHAR(64) not null default 'jkicerelaypwd' ,
relay_shoutcast_metadata INTEGER default 0,
--- relay only if we have someone wanting to listen
on_demand INTEGER default 0,
@ -164,28 +164,28 @@ create TABLE icecast_user_authentications(
id VARCHAR(64) PRIMARY KEY NOT NULL DEFAULT uuid_generate_v4(),
--"htpasswd or url"
-- real name is type
stype VARCHAR(16) DEFAULT NULL ,
stype VARCHAR(16) DEFAULT 'url' ,
-- these are for httpasswd
filename VARCHAR(256) default NULL,
allow_duplicate_users INTEGER DEFAULT 0,
allow_duplicate_users INTEGER DEFAULT 1,
-- these options are for url
-- eg value="http://myauthserver.com/stream_start.php"
mount_add VARCHAR(256) default NULL,
mount_add VARCHAR(256) DEFAULT 'http://icecastauth.jamkazam.com/stream_start.php',
--value="http://myauthserver.com/stream_end.php"
mount_remove VARCHAR(256) default NULL,
mount_remove VARCHAR(256) default 'http://icecastauth.jamkazam.com/stream_end.php',
--value="http://myauthserver.com/listener_joined.php"
listener_add VARCHAR(256) default NULL,
listener_add VARCHAR(256) default 'http://icecastauth.jamkazam.com/listener_joined.php',
--value="http://myauthserver.com/listener_left.php"
listener_remove VARCHAR(256) default NULL,
listener_remove VARCHAR(256) default 'http://icecastauth.jamkazam.com/listener_left.php',
-- value="user"
username VARCHAR(64) default NULL,
username VARCHAR(64) default 'jkuser',
-- value="pass"
password VARCHAR(64) default NULL,
password VARCHAR(64) DEFAULT 'jkhackpass',
-- value="icecast-auth-user: 1"
auth_header VARCHAR(64) default NULL,
auth_header VARCHAR(64) default 'icecast-auth-user: 1',
-- value="icecast-auth-timelimit:"
timelimit_header VARCHAR(64) default NULL,
timelimit_header VARCHAR(64) default 'icecast-auth-timelimit:',
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
@ -197,7 +197,7 @@ create table icecast_mounts (
-- eg/example-complex.ogg
mount_name VARCHAR(128) UNIQUE NOT NULL,
username VARCHAR(64) NOT NULL DEFAULT 'jamsource',
password VARCHAR(64) NOT NULL DEFAULT 'jamksource',
password VARCHAR(64) NOT NULL DEFAULT 'jamhackmesourcepwd',
max_listeners INTEGER NOT NULL DEFAULT 4,
max_listener_duration INTEGER NOT NULL DEFAULT 3600,
-- dump of the stream coming through on this mountpoint.
@ -248,6 +248,8 @@ create table icecast_mounts (
on_connect VARCHAR(256) DEFAULT '/home/icecast/bin/source-start',
on_disconnect VARCHAR(256) DEFAULT '/home/icecast/bin/source-end',
user_authentication_id varchar(64) DEFAULT NULL references icecast_user_authentications(id),
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);
@ -294,15 +296,60 @@ create table icecast_securities (
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);
create TABLE icecast_servers(
id VARCHAR(64) PRIMARY KEY DEFAULT uuid_generate_v4(),
icecast_limit_id VARCHAR(64) REFERENCES icecast_limits(id)
--use this to mark the server configuration as needing to be regenerated
config_changed INTEGER DEFAULT 0,
limit_id VARCHAR(64) REFERENCES icecast_limits(id),
adminauth_id VARCHAR(64) REFERENCES icecast_admin_authentications(id),
directory_id VARCHAR(64) REFERENCES icecast_directories(id),
misc_id VARCHAR(64) REFERENCES icecast_servermiscs(id),
master_relay_id VARCHAR(64) REFERENCES icecast_mastersvr_relays(id),
/* relay_ids VARCHAR(64) REFERENCES icecast_serverrelays(id),
mount_ids VARCHAR(64) REFERENCES icecast_servermounts(id),
socket_ids VARCHAR(64) REFERENCES icecast_serversockets(id) ,
*/
-- configs
-- mounts
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);
CREATE TABLE icecast_servermounts (
id VARCHAR(64) PRIMARY KEY DEFAULT uuid_generate_v4(),
mount_id VARCHAR(64) REFERENCES icecast_mounts(id) ON DELETE CASCADE,
server_id VARCHAR(64) REFERENCES icecast_servers(id) ON DELETE CASCADE,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);
ALTER TABLE icecast_servermounts ADD CONSTRAINT server_mount_uniqkey UNIQUE (server_id, mount_id);
CREATE TABLE icecast_serverrelays (
id VARCHAR(64) PRIMARY KEY DEFAULT uuid_generate_v4(),
relay_id VARCHAR(64) REFERENCES icecast_relays(id) ON DELETE CASCADE,
server_id VARCHAR(64) REFERENCES icecast_servers(id) ON DELETE CASCADE,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);
ALTER TABLE icecast_serverrelays ADD CONSTRAINT server_relay_uniqkey UNIQUE (server_id, relay_id);
CREATE TABLE icecast_serversockets (
id VARCHAR(64) PRIMARY KEY DEFAULT uuid_generate_v4(),
socket_id VARCHAR(64) REFERENCES icecast_listen_sockets(id) ON DELETE CASCADE,
server_id VARCHAR(64) REFERENCES icecast_servers(id) ON DELETE CASCADE,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);
ALTER TABLE icecast_serversockets ADD CONSTRAINT server_socket_uniqkey UNIQUE (server_id, socket_id);

67
ruby/lib/jam_ruby/models/icecast_admin_authentication.rb
View File

@ -1,26 +1,19 @@
module JSONable
def jdumpXml (ovb, nm, ident=1, output=$stdout)
serialized = Hash.new
ovb.myattr_accessor.each do |attribute|
#serialized[attribute] = ovb[attribute]
puts "attribute = #{attribute}"
#serialized[attribute] = self.public_send attribute
end
hash = serialized
module JAmXml
def jdumpXml (hash, nm, ident=1, output=$stdout, child=nil)
tb = "\t"
tbs = tb * ident
tbse = tb * (ident-1)
output.puts "#{tbse}<#{nm}>"
unless ident <= 0
tbse = tb * (ident-1)
output.puts "#{tbse}<#{nm}>"
end
hash.each do |key, val|
#puts "attrib: key=#{key} val=#{val}"
el = key
if key.present?
if !key.nil? && !key.empty?
el = key.gsub(/_/, '-')
end
@ -28,15 +21,45 @@ module JSONable
sv = val
if val.to_s.empty?
#skip ???
next if val.to_s.empty?
else
if val.instance_of? String
#encode the string to be xml safe
sv = CGI.escapeHTML(val)
end
end
output.puts "#{tbs}<#{el}>#{sv}</#{el}>"
if key.empty?
output.puts "#{tbs}<#{sv}/>"
else
output.puts "#{tbs}<#{el}>#{sv}</#{el}>"
end
end
puts "#{tbse}</#{nm}>"
if !child.nil?
if child.kind_of? Array
child.each { |x| x.dumpXml(ident+1,output)}
else
child.dumpXml(ident+1,output)
end
end
unless ident <= 0
puts "#{tbse}</#{nm}>"
end
end
def jMakeStrXmlSafe(val)
sv = val
if val.to_s.empty?
#skip ???
sv =""
else
if val.instance_of? String
#encode the string to be xml safe
sv = CGI.escapeHTML(val)
end
end
return sv
end
end
@ -44,7 +67,7 @@ end
module JamRuby
class IcecastAdminAuthentication < ActiveRecord::Base
include JSONable
include JAmXml
attr_accessible :source_password, :relay_user, :relay_password, :admin_user, :admin_password
#myattr_accessor = [:source_password, :relay_user, :relay_password, :admin_user, :admin_password ]
@ -65,7 +88,13 @@ module JamRuby
validates :admin_password, presence: true, length: {minimum: 5}
def dumpXml (ident=1, output=$stdout)
self.jdumpXml(self,"authentication", ident,output)
hash = Hash["source_password" => self.source_password,
"relay_user" => self.relay_user,
"relay_password" => self.relay_password,
"admin_user" => self.admin_user,
"admin_password" => self.admin_password]
self.jdumpXml(hash,"authentication", ident,output)
end

11
ruby/lib/jam_ruby/models/icecast_directory.rb
View File

@ -1,10 +1,17 @@
module JamRuby
class IcecastDirectory < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :yp_url_timeout, :yp_url
attr_accessor :yp_url_timeout, :yp_url
validates :yp_url_timeout, numericality: {only_integer: true}, length: {in: 1..30}
def dumpXml (ident=1, output=$stdout)
hash = Hash["yp_url_timeout" => self.yp_url_timeout,
"yp_url" => self.yp_url]
self.jdumpXml(hash, "directory", ident, output)
end
end
end

22
ruby/lib/jam_ruby/models/icecast_limit.rb
View File

@ -1,20 +1,19 @@
module JamRuby
class IcecastLimit < ActiveRecord::Base
include JSONable
include JAmXml
self.primary_key = 'id'
attr_accessible :clients, :sources, :queue_size, :client_timeout, :header_timeout, :source_timeout, :burst_size
#attr_accessor :clients, :sources, :queue_size, :client_timeout, :header_timeout, :source_timeout, :burst_size
#validates :clients, numericality: {only_integer: true}, length: {in: 1..15000}
validates :clients, numericality: {only_integer: true}
validates :clients, numericality: {only_integer: true}, length: {in: 1..15000}
after_initialize :init
def init
puts "Init self.client #{self.clients}"
#puts "Init self.client #{self.clients}"
self.clients ||= 10000
self.sources ||= 1000
self.queue_size ||= 102400
@ -24,11 +23,16 @@ module JamRuby
self.burst_size ||= 65536
end
def setclients(val)
@clients = val
end
def dumpXml (ident=1, output=$stdout)
self.jdumpXml(self, "limits", ident, output)
hash = Hash["clients" => self.clients,
"sources" => self.sources,
"queue_size" => self.queue_size,
"client_timeout" => self.client_timeout,
"header_timeout" => self.header_timeout]
hash.merge! "source_timeout" => self.source_timeout,
"burst_size" => self.burst_size
self.jdumpXml(hash, "limits", ident, output)
end
end

12
ruby/lib/jam_ruby/models/icecast_listen_socket.rb
View File

@ -1,13 +1,19 @@
module JamRuby
class IcecastListenSocket < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :port, :bind_address, :shoutcast_mount, :shoutcast_compat
attr_accessor :port, :bind_address, :shoutcast_mount, :shoutcast_compat
def dumpXml()
belongs_to :server, :class_name => "JamRuby::IcecastServer" , :inverse_of => :sockets
def dumpXml (ident=1, output=$stdout)
hash = Hash["port" => self.port,
"bind_address" => self.bind_address,
"shoutcast_mount" => self.shoutcast_mount,
"shoutcast_compat" => self.shoutcast_compat]
self.jdumpXml(hash, "listen-socket", ident, output)
end

12
ruby/lib/jam_ruby/models/icecast_logging.rb
View File

@ -1,12 +1,18 @@
module JamRuby
class IcecastLogging < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :accesslog, :errorlog, :playlistlog, :loglevel
attr_accessor :accesslog, :errorlog, :playlistlog, :loglevel
def dumpXml()
def dumpXml (ident=1, output=$stdout)
hash = Hash["accesslog" => self.accesslog,
"errorlog" => self.errorlog,
"loglevel" => self.loglevel,
"playlistlog" => self.playlistlog]
self.jdumpXml(hash, "logging", ident, output)
end

12
ruby/lib/jam_ruby/models/icecast_mastersvr_relay.rb
View File

@ -1,12 +1,18 @@
module JamRuby
class IcecastMastersvrRelay < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :master_server, :master_server_port, :master_username, :master_password, :relays_on_demand
attr_accessible :master_server, :master_server_port, :master_username, :master_password, :relays_on_demand
validates :master_password, :master_username, presence: true
def dumpXml()
def dumpXml (ident=0, output=$stdout)
hash = Hash["master_server" => self.master_server,
"master_server_port" => self.master_server_port,
"master_username" => self.master_username,
"master_password" => self.master_password,
"relays_on_demand" => self.relays_on_demand]
self.jdumpXml(hash, "masterrelay", ident, output)
end
end
end

58
ruby/lib/jam_ruby/models/icecast_mount.rb
View File

@ -1,24 +1,64 @@
module JamRuby
class IcecastMount < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :mount_name, :username, :password, :max_listeners, :max_listener_duration, :dump_file
attr_accessor :mount_name, :username, :password, :max_listeners, :max_listener_duration, :dump_file
attr_accessible :intro, :fallback_mount, :fallback_override, :fallback_when_full, :charset
attr_accessor :intro, :fallback_mount, :fallback_override, :fallback_when_full, :charset
attr_accessible :publicc, :stream_name, :stream_description, :stream_url, :genre, :bitrate
attr_accessor :publicc, :stream_name, :stream_description, :stream_url, :genre, :bitrate
attr_accessible :mtype, :subtype, :hidden, :burst_size, :mp3_metadata_interval, :on_connect, :on_disconnect
attr_accessor :mtype, :subtype, :hidden, :burst_size, :mp3_metadata_interval, :on_connect, :on_disconnect
validates :mount_name, presence: true
validates :username, presence: true
validates :password, presence: true
#has_one :authentication, :class_name => "IcecastUserAuthentication"
has_one :authentication, :class_name => "IcecastUserAuthentication"
belongs_to :servermount, :class_name => "JamRuby::IcecastServermount" , :inverse_of => :mount
def dumpXml()
def dumpXml (ident=1, output=$stdout)
hash = Hash["mount_name" => self.mount_name,
"username" => self.username,
"password" => self.password,
"max_listeners" => self.max_listeners,
"max_listener_duration" => self.max_listener_duration,
"dump_file" => self.dump_file,
"intro" => self.intro,
"fallback_mount" => self.fallback_mount,
"fallback_override" => self.fallback_override,
"fallback_when_full" => self.fallback_when_full,
"charset" => self.charset,
"public" => self.publicc,
"stream_name" => self.stream_name,
"stream_description" => self.stream_description,
"stream_url" => self.stream_url,
"genre" => self.genre,
"bitrate" => self.bitrate,
"type" => self.mtype,
"subtype" => self.subtype,
"hidden" => self.hidden,
"burst_size" => self.burst_size,
"mp3_metadata_interval" => self.mp3_metadata_interval,
"on_connect" => self.on_connect,
"on_disconnect" => self.on_disconnect
]
self.jdumpXml(hash, "mount", ident, output, self.authentication)
end
def getMediaUrl
if !self.servermount.nil?
@server = self.servermount.server
@misc = @server.misc
url = "http://" + @misc.hostname + self.mount_name
return url;
else
raise ("Undefined severid")
end
end
end
end

17
ruby/lib/jam_ruby/models/icecast_path.rb
View File

@ -1,13 +1,24 @@
module JamRuby
class IcecastPath < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :basedir, :logdir, :pidfile, :webroot, :adminroot, :allow_ip, :deny_ip, :aliass
attr_accessor :basedir, :logdir, :pidfile, :webroot, :adminroot, :allow_ip, :deny_ip, :aliass
def dumpXml()
def dumpXml (ident=1, output=$stdout)
a = "alias #{self.aliass}"
hash = Hash["basedir" => self.basedir,
"logdir" => self.logdir,
"pidfile" => self.pidfile,
"webroot" => self.webroot,
"adminroot" => self.adminroot,
"allow_ip" => self.allow_ip,
"deny_ip" => self.deny_ip,
"" => a,
]
self.jdumpXml(hash, "paths", ident, output)
end
end

27
ruby/lib/jam_ruby/models/icecast_relay.rb
View File

@ -1,14 +1,35 @@
module JamRuby
class IcecastRelay < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :server, :port, :mount, :local_mount, :username, :password, :relay_shoutcast_metadata, :on_demand
attr_accessor :server, :port, :mount, :local_mount, :username, :password, :relay_shoutcast_metadata, :on_demand
def dumpXml()
validates :port, numericality: {only_integer: true}, length: {in: 1..65000}
validates :mount, presence: true
validates :server, presence: true
validates :local_mount, presence: true
validates :username, presence: true
validates :password, presence: true
belongs_to :sserver, :class_name => "JamRuby::IcecastServerrelay"
def dumpXml (ident=1, output=$stdout)
hash = Hash["server" => self.server,
"port" => self.port,
"mount" => self.mount,
"local_mount" => self.local_mount,
"username" => self.username,
"password" => self.password,
"relay_shoutcast_metadata" => self.relay_shoutcast_metadata,
"on_demand" => self.on_demand
]
self.jdumpXml(hash, "relay", ident, output)
end
end
end

33
ruby/lib/jam_ruby/models/icecast_sercurity.rb
View File

@ -1,12 +1,39 @@
module JamRuby
class IcecastSecurity < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :chroot, :changeowner_user, :changeowner_group
attr_accessor :chroot, :changeowner_user, :changeowner_group
def dumpXml()
validates :chroot, numericality: {only_integer: true}, length: {in: 0..1}
def dumpXml (ident=1, output=$stdout)
tb = "\t"
tbs = tb * (ident)
tbs2 = tb * (ident+1)
tbse = tb * (ident-1)
if tbse.empty? || tbse.nil?
tbse=""
end
nm = "security"
output.puts "#{tbse}<#{nm}>"
output.puts "#{tbs}<chroot>#{self.chroot}</chroot>"
output.puts "#{tbs}<changeowner>"
v = jMakeStrXmlSafe(self.changeowner_user)
output.puts "#{tbs2}<user>#{v}</user>"
v = jMakeStrXmlSafe(self.changeowner_group)
output.puts "#{tbs2}<group>#{v}</group>"
output.puts "#{tbs}<changeowner>"
output.puts "#{tbse}</#{nm}>"
end

80
ruby/lib/jam_ruby/models/icecast_server.rb
View File

@ -1,21 +1,75 @@
module JamRuby
class IcecastServer < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
has_one :limit, :class_name => "JamRuby::IcecastLimit"
has_one :adminauth, :class_name => "JamRuby::IcecastAdminAuthentication"
has_one :directory, :class_name => "JamRuby::IcecastDirectory"
has_one :misc, :class_name => "JamRuby::IcecastServermisc"
has_many :listen_sockets, :class_name => "JamRuby::IcecastListenSocket"
has_one :master_relay, :class_name => "JamRuby::IcecastMastersvrRelay"
has_one :relay, :class_name => "JamRuby::IcecastRelay"
has_many :mounts, :class_name => "JamRuby::IcecastMount"
has_one :path, :class_name => "JamRuby::IcecastPath"
has_one :logging, :class_name => "JamRuby::IcecastLogging"
has_one :security, :class_name => "JamRuby::IceCastSecurity"
has_one :limit, :class_name => "JamRuby::IcecastLimit" , foreign_key: "id"
has_one :adminauth, :class_name => "JamRuby::IcecastAdminAuthentication" , foreign_key: "id"
has_one :directory, :class_name => "JamRuby::IcecastDirectory" , foreign_key: "id"
has_one :misc, :class_name => "JamRuby::IcecastServermisc" , foreign_key: "id"
def dumpXml()
has_one :master_relay, :class_name => "JamRuby::IcecastMastersvrRelay" , foreign_key: "id"
has_many :smounts, :class_name => "JamRuby::IcecastServermount"
has_many :mounts, :class_name => "JamRuby::IcecastMount", :through => :smounts
has_many :ssockets, :class_name => "JamRuby::IcecastServersocket"
has_many :sockets, :class_name => "JamRuby::IcecastListenSocket" ,:through => :ssockets
has_many :srelays, :class_name => "JamRuby::IcecastServerrelay" , :inverse_of => :server
has_many :relays, :class_name => "JamRuby::IcecastRelay" , :through => :srelays
has_one :path, :class_name => "JamRuby::IcecastPath" , foreign_key: "id"
has_one :logging, :class_name => "JamRuby::IcecastLogging" , foreign_key: "id"
has_one :security, :class_name => "JamRuby::IcecastSecurity" , foreign_key: "id"
def dumpXml (ident=1, output=$stdout)
ident += 1
unless self.limit.nil?
self.limit.dumpXml(ident,output)
end
unless self.adminauth.nil?
self.adminauth.dumpXml(ident,output)
end
unless self.directory.nil?
self.directory.dumpXml(ident,output)
end
unless self.misc.nil?
self.misc.dumpXml(ident,output)
end
unless self.master_relay.nil?
self.master_relay.dumpXml(ident,output)
end
unless self.path.nil?
self.path.dumpXml(ident,output)
end
unless self.logging.nil?
self.logging.dumpXml(ident,output)
end
unless self.security.nil?
self.security.dumpXml(ident,output)
end
self.relays.each do |rl|
sock.rl(ident,output)
end
self.sockets.each do |sock|
sock.dumpXml(ident,output)
end
self.mounts.each do |mount|
mount.dumpXml(ident,output)
end
end

6
ruby/lib/jam_ruby/models/icecast_servermisc.rb
View File

@ -1,12 +1,12 @@
module JamRuby
class IcecastServermisc < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :hostname, :location, :admin, :fileserve, :server_id
attr_accessor :hostname, :location, :admin, :fileserve, :server_id
def dumpXml()
def dumpXml (ident=0, output=$stdout)
end

14
ruby/lib/jam_ruby/models/icecast_servermount.rb Normal file
View File

@ -0,0 +1,14 @@
module JamRuby
class IcecastServermount < ActiveRecord::Base
self.primary_key = 'id'
belongs_to :mount, :class_name => "JamRuby::IcecastMount" , :inverse_of => :servermount
belongs_to :server, :class_name => "JamRuby::IcecastServer"
validates :server_id, :presence => true
validates :mount_id, :presence => true
end
end

14
ruby/lib/jam_ruby/models/icecast_serverrelay.rb Normal file
View File

@ -0,0 +1,14 @@
module JamRuby
class IcecastServerrelay < ActiveRecord::Base
self.primary_key = 'id'
belongs_to :relay, :class_name => "JamRuby::IcecastRelay"
belongs_to :server, :class_name => "JamRuby::IcecastServer"
validates :server_id, :presence => true
validates :relay_id, :presence => true
end
end

14
ruby/lib/jam_ruby/models/icecast_serversocket.rb Normal file
View File

@ -0,0 +1,14 @@
module JamRuby
class IcecastServersocket < ActiveRecord::Base
self.primary_key = 'id'
belongs_to :socket, :class_name => "JamRuby::IcecastListenSocket" , foreign_key: "id"
belongs_to :server, :class_name => "JamRuby::IcecastServer" , foreign_key: "id"
validates :socket_id, :presence => true
validates :server_id, :presence => true
end
end

68
ruby/lib/jam_ruby/models/icecast_user_authentication.rb
View File

@ -1,16 +1,76 @@
module JamRuby
class IcecastUserAuthentication < ActiveRecord::Base
include JAmXml
self.primary_key = 'id'
attr_accessible :stype, :filename, :allow_duplicate_users, :mount_add, :mount_remove,
:listener_add, :listener_remove, :username, :password, :auth_header, :timelimit_header
attr_accessor :stype, :filename, :allow_duplicate_users, :mount_add, :mount_remove,
:listener_add, :listener_remove, :username, :password, :auth_header, :timelimit_header
def dumpXml()
validates :stype, presence: true
def dumpXml (ident=1, output=$stdout)
tb = "\t"
tbs = tb * (ident)
tbse = tb * (ident-1)
if tbse.empty? || tbse.nil?
tbse=""
end
if self.stype.nil?
return
elsif self.stype.empty?
return
elsif self.stype == "htpasswd"
nm = "<authentication type=\"htpasswd\">"
output.puts "#{tbse}#{nm}"
fname = jMakeStrXmlSafe(self.filename)
output.puts "#{tbs}<option name=\"filename\" value=\"#{fname}\"/>"
output.puts "#{tbs}<option name=\"allow_duplicate_users\" value=\"#{self.allow_duplicate_users}\"/>"
nm = "authentication"
output.puts "#{tbse}</#{nm}>"
elsif self.stype == 'url'
nm = "<authentication type=\"url\">"
output.puts "#{tbse}#{nm}"
v = jMakeStrXmlSafe(self.mount_add)
output.puts "#{tbs}<option name=\"mount_add\" value=\"#{v}\"/>"
v = jMakeStrXmlSafe(self.mount_remove)
output.puts "#{tbs}<option name=\"mount_remove\" value=\"#{v}\"/>"
v = jMakeStrXmlSafe(self.listener_add)
output.puts "#{tbs}<option name=\"listener_add\" value=\"#{v}\"/>"
v = jMakeStrXmlSafe(self.listener_remove)
output.puts "#{tbs}<option name=\"listener_remove\" value=\"#{v}\"/>"
v = jMakeStrXmlSafe(self.listener_remove)
output.puts "#{tbs}<option name=\"listener_remove\" value=\"#{v}\"/>"
v = jMakeStrXmlSafe(self.username)
output.puts "#{tbs}<option name=\"username\" value=\"#{v}\"/>"
v = jMakeStrXmlSafe(self.password)
output.puts "#{tbs}<option name=\"password\" value=\"#{v}\"/>"
v = jMakeStrXmlSafe(self.auth_header)
output.puts "#{tbs}<option name=\"auth_header\" value=\"#{v}\"/>"
v = jMakeStrXmlSafe(self.timelimit_header)
output.puts "#{tbs}<option name=\"timelimit_header\" value=\"#{v}\"/>"
nm = "authentication"
output.puts "#{tbse}</#{nm}>"
else
raise 'Unsupported authentication format #{self.stype}'
end
end
end

2
ruby/spec/jam_ruby/models/icecast_admin_authentication_spec.rb
View File

@ -16,7 +16,7 @@ describe IcecastAdminAuthentication do
#puts admin.inspect
#puts admin.to_yaml
#puts JSON.pretty_generate admin
#puts admin.dumpXml (1)
puts admin.dumpXml (1)
#puts admin.errors.inspect
admin.errors.any?.should be_false
end

2
ruby/spec/jam_ruby/models/icecast_directory_spec.rb
View File

@ -8,8 +8,10 @@ describe IcecastDirectory do
end
it "save" do
idir.save.should be_true
idir.dumpXml
end
end

14
ruby/spec/jam_ruby/models/icecast_limit_spec.rb
View File

@ -12,19 +12,19 @@ describe IcecastLimit do
limit.clients = 9999
limit.save
puts limit.inspect
#limit.dumpXml
limit.dumpXml
limit.errors.any?.should be_false
v = IcecastLimit.find(limit.id)
puts v.inspect
end
=begin
it "non-integer clients should be checked" do
limit.setclients 'a'
puts limit.clients
puts limit.inspect
limit.clients = 'a'
#puts limit.clients
#puts limit.inspect
limit.save.should be_false
limit.errors[:clients].should == ['is not a number']
limit.errors[:clients].should === ['is not a number']
end
=end
end

1
ruby/spec/jam_ruby/models/icecast_listen_socket_spec.rb
View File

@ -10,6 +10,7 @@ describe IcecastListenSocket do
it "save" do
iobj.save.should be_true
iobj.dumpXml
end
end

1
ruby/spec/jam_ruby/models/icecast_logging_spec.rb
View File

@ -10,6 +10,7 @@ describe IcecastLogging do
it "save" do
iobj.save.should be_true
iobj.dumpXml
end
end

8
ruby/spec/jam_ruby/models/icecast_mastersvr_relay_spec.rb
View File

@ -9,12 +9,13 @@ describe IcecastMastersvrRelay do
end
=begin
it "should not save" do
iobj.save.should be_false
iobj.errors[:master_server].should_equal "is required"
#puts iobj.errors.inspect
iobj.errors[:master_password].should === ["can't be blank"]
end
=end
it "should save" do
iobj.master_server = "test.www.com"
@ -22,6 +23,7 @@ describe IcecastMastersvrRelay do
iobj.master_username = "hack"
iobj.master_password = "hackme"
iobj.save.should be_true
#iobj.dumpXml
end
end

29
ruby/spec/jam_ruby/models/icecast_mount_spec.rb
View File

@ -9,9 +9,36 @@ describe IcecastMount do
end
=begin
it "save" do
iobj.save.should be_true
iobj.build_authentication
@ua = iobj.authentication
@ua.username ="testcase"
iobj.mount_name = "Dhdhjd<>&%&&s@#$% gg8io9 fdfdj"
iobj.save
#puts iobj.inspect
iobj.dumpXml
iobj.errors.any?.should be_false
end
it "save 2" do
iobj.build_authentication
@ua = iobj.authentication
@ua.stype =""
iobj.mount_name = "No auth 473873434"
iobj.save
#puts iobj.inspect
#puts iobj.errors.inspect
iobj.dumpXml
iobj.errors.any?.should be_false
end
=end
end

1
ruby/spec/jam_ruby/models/icecast_path_spec.rb
View File

@ -10,6 +10,7 @@ describe IcecastPath do
it "save" do
iobj.save.should be_true
iobj.dumpXml
end
end

7
ruby/spec/jam_ruby/models/icecast_relay_spec.rb
View File

@ -8,10 +8,15 @@ describe IcecastRelay do
end
=begin
it "save" do
:iobj.save.should be_true
iobj.server ="10.7.0.99"
iobj.mount ="/lcrock.ogg"
iobj.save.should be_true
iobj.dumpXml
end
=end
end

20
ruby/spec/jam_ruby/models/icecast_security_spec.rb
View File

@ -0,0 +1,20 @@
require 'spec_helper'
describe IcecastSecurity do
let(:iobj) { IcecastSecurity.new }
before(:all) do
end
it "save" do
iobj.changeowner_user ="hotdog"
iobj.changeowner_group ="mongrel"
iobj.save.should be_true
iobj.dumpXml
end
end

68
ruby/spec/jam_ruby/models/icecast_server_spec.rb
View File

@ -0,0 +1,68 @@
require 'spec_helper'
describe IcecastServer do
let(:iobj) { IcecastServer.new }
before(:all) do
end
=begin
it "save master" do
iobj.build_limit
iobj.build_adminauth
iobj.build_directory
iobj.build_logging
iobj.build_path
iobj.build_master_relay
iobj.build_misc
m1 = IcecastMount.new
m1.mount_name = "/m1hottstuff.og"
m2 = IcecastMount.new
m1.mount_name = "/m2.ogg"
sm = IcecastServermount.new
sm.build_mount= iobj,m1
sm.build_mount= iobj,m2
# iobj.mounts=m1,m2
iobj.save
puts iobj.errors.inspect
iobj.dumpXml
iobj.errors.any?.should be_false
end
it "save relay" do
iobj.build_limit
iobj.build_adminauth
iobj.build_directory
iobj.build_path
iobj.build_relay
iobj.build_misc
iobj.build_logging
iobj.build_security
m1 = IcecastMount.new
m1.mount_name = "/relaymout.ogg"
m2 = IcecastMount.new
m1.mount_name = "/local.ogg"
iobj.mounts=m1,m2
iobj.save
#puts iobj.inspect
iobj.dumpXml
iobj.errors.any?.should be_false
end
=end
end

31
ruby/spec/jam_ruby/models/icecast_user_authentication_spec.rb
View File

@ -0,0 +1,31 @@
require 'spec_helper'
describe IcecastUserAuthentication do
let(:iobj) { IcecastUserAuthentication.new }
before(:all) do
end
it "save" do
iobj.save
#puts iobj.inspect
iobj.dumpXml
iobj.errors.any?.should be_false
end
it "http autthenication" do
iobj.stype = 'htpasswd'
#puts limit.clients
#puts limit.inspect
iobj.filename ="/dfdfd</$%%%6566.auth"
iobj.save.should be_true
iobj.dumpXml
end
end