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

* VRFS-1022 finished

This commit is contained in:
Seth Call 2014-01-25 14:03:14 -06:00
parent 35466433ca
commit 96768b7979
21 changed files with 516 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
db/manifest
View File

@ -90,4 +90,5 @@ mix_job_watch.sql
music_session_constraints.sql
mixes_drop_manifest_add_retry.sql
music_sessions_unlogged.sql
integrate_icecast_into_sessions.sql
integrate_icecast_into_sessions.sql
icecast_config_changed.sql

2
db/up/icecast_config_changed.sql Normal file
View File

@ -0,0 +1,2 @@
-- track when config_changed is set to 0, so that we know roughly which music_sessions (mounts) are valid
ALTER TABLE icecast_servers ADD COLUMN config_updated_at TIMESTAMP;

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

@ -191,10 +191,10 @@ module JamRuby
end
def get_media_url
raise "Unassociated server to mount" if self.server_mount.nil?
def url
raise "Unassociated server to mount" if self.server.nil?
"http://" + server_mount.server.hostname + self.name
"http://#{server.hostname}:#{server.pick_listen_socket(:port)}#{self.name}"
end

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

@ -4,7 +4,7 @@ module JamRuby
attr_accessor :skip_config_changed_flag
attr_accessible :template_id, :mount_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, :icecast_server_group_id, as: :admin
:security_id, :config_changed, :config_updated_at, :hostname, :location, :admin_email, :fileserve, :icecast_server_group_id, as: :admin
belongs_to :template, class_name: "JamRuby::IcecastTemplate", foreign_key: 'template_id', inverse_of: :servers
@ -58,7 +58,7 @@ module JamRuby
def after_save
# if we set config_changed, then queue up a job
if config_changed_was == 0 && config_changed == 1
if config_changed == 1
IcecastConfigWriter.enqueue(self.server_id)
end
end
@ -70,6 +70,7 @@ module JamRuby
self.skip_config_changed_flag = true
self.config_changed = 0
self.config_updated_at = Time.now
begin
self.save!
rescue
@ -83,7 +84,7 @@ module JamRuby
def pick_listen_socket(field)
current_listen_sockets = listen_sockets.length > 0 ? listen_sockets : template.listen_sockets
socket = current_listen_sockets.first
socket[:field] if socket
socket[field] if socket
end

30
ruby/lib/jam_ruby/models/music_session.rb
View File

@ -75,7 +75,13 @@ module JamRuby
# This is a little confusing. You can specify *BOTH* friends_only and my_bands_only to be true
# If so, then it's an OR condition. If both are false, you can get sessions with anyone.
def self.index(current_user, participants = nil, genres = nil, friends_only = false, my_bands_only = false, keyword = nil)
def self.index(current_user, options = {})
participants = options[:participants]
genres = options[:genres]
keyword = options[:keyword]
friends_only = options[:friends_only].nil? ? false : options[:friends_only]
my_bands_only = options[:my_bands_only].nil? ? false : options[:my_bands_only]
as_musician = options[:as_musician].nil? ? true : options[:as_musician]
query = MusicSession
.joins(
@ -118,13 +124,23 @@ module JamRuby
music_sessions.created_at DESC
}
)
.where(
%Q{
musician_access = true
OR
invitations.id IS NOT NULL
}
if as_musician
query = query.where(
%Q{
musician_access = true
OR
invitations.id IS NOT NULL
}
)
else
# if you are trying to join the session as a fan/listener,
# we have to have a mount, fan_access has to be true, and we have to allow for the reload of icecast to have taken effect
query = query.joins('INNER JOIN icecast_mounts ON icecast_mounts.music_session_id = music_sessions.id INNER JOIN icecast_servers ON icecast_mounts.icecast_server_id = icecast_servers.id')
query = query.where(:fan_access => true)
query = query.where("
(music_sessions.created_at < icecast_servers.config_updated_at AND NOW() - icecast_servers.config_updated_at > interval '#{APP_CONFIG.icecast_reload_slush} seconds')")
end
query = query.where("music_sessions.description like '%#{keyword}%'") unless keyword.nil?
query = query.where("connections.user_id" => participants.split(',')) unless participants.nil?

2
ruby/lib/jam_ruby/resque/icecast_config_writer.rb
View File

@ -53,7 +53,7 @@ module JamRuby
def validate
raise "icecast_server_id not spceified" unless icecast_server_id
raise "queue routing mismatch error" unless icecast_server_id == APP_CONFIG.icecast_server_id
raise "queue routing mismatch error. requested icecast_server_id: #{icecast_server_id}, configured icceast_server_id: #{APP_CONFIG.icecast_server_id}" unless icecast_server_id == APP_CONFIG.icecast_server_id
end
def execute(cmd)

14
ruby/spec/factories.rb
View File

@ -23,6 +23,13 @@ FactoryGirl.define do
factory :admin do
admin true
end
factory :single_user_session do
after(:create) do |user, evaluator|
music_session = FactoryGirl.create(:music_session, :creator => user)
connection = FactoryGirl.create(:connection, :user => user, :music_session => music_session)
end
end
end
factory :music_session, :class => JamRuby::MusicSession do
@ -34,6 +41,11 @@ FactoryGirl.define do
legal_terms true
genres [JamRuby::Genre.first]
association :creator, :factory => :user
factory :music_session_with_mount do
association :mount, :factory => :icecast_mount
end
end
factory :music_session_history, :class => JamRuby::MusicSessionHistory do
@ -249,7 +261,7 @@ FactoryGirl.define do
factory :icecast_server, :class => JamRuby::IcecastServer do
sequence(:hostname) { |n| "hostname-#{n}"}
sequence(:server_id) { |n| "server-#{n}"}
sequence(:server_id) { |n| "test-server-#{n}"}
factory :icecast_server_minimal do
association :template, :factory => :icecast_template_minimal

494
ruby/spec/jam_ruby/models/music_session_spec.rb
View File

@ -4,6 +4,8 @@ describe MusicSession do
before(:each) do
MusicSession.delete_all
IcecastServer.delete_all
IcecastMount.delete_all
end
it 'can grant access to valid user' do
@ -79,175 +81,237 @@ describe MusicSession do
end
it "orders two sessions by created_at starting with most recent" do
creator = FactoryGirl.create(:user)
creator2 = FactoryGirl.create(:user)
describe "index" do
it "orders two sessions by created_at starting with most recent" do
creator = FactoryGirl.create(:user)
creator2 = FactoryGirl.create(:user)
earlier_session = FactoryGirl.create(:music_session, :creator => creator, :description => "Earlier Session")
FactoryGirl.create(:connection, :user => creator, :music_session => earlier_session)
earlier_session = FactoryGirl.create(:music_session, :creator => creator, :description => "Earlier Session")
FactoryGirl.create(:connection, :user => creator, :music_session => earlier_session)
later_session = FactoryGirl.create(:music_session, :creator => creator2, :description => "Later Session")
FactoryGirl.create(:connection, :user => creator2, :music_session => later_session)
later_session = FactoryGirl.create(:music_session, :creator => creator2, :description => "Later Session")
FactoryGirl.create(:connection, :user => creator2, :music_session => later_session)
user = FactoryGirl.create(:user)
user = FactoryGirl.create(:user)
#ActiveRecord::Base.logger = Logger.new(STDOUT)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 2
music_sessions.first.id.should == later_session.id
#ActiveRecord::Base.logger = Logger.new(STDOUT)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 2
music_sessions.first.id.should == later_session.id
end
it "orders sessions with inviteds first, even if created first" do
creator1 = FactoryGirl.create(:user)
creator2 = FactoryGirl.create(:user)
earlier_session = FactoryGirl.create(:music_session, :creator => creator1, :description => "Earlier Session")
FactoryGirl.create(:connection, :user => creator1, :music_session => earlier_session)
later_session = FactoryGirl.create(:music_session, :creator => creator2, :description => "Later Session")
FactoryGirl.create(:connection, :user => creator2, :music_session => later_session)
user = FactoryGirl.create(:user)
FactoryGirl.create(:connection, :user => creator1, :music_session => earlier_session)
FactoryGirl.create(:friendship, :user => creator1, :friend => user)
FactoryGirl.create(:friendship, :user => user, :friend => creator1)
FactoryGirl.create(:invitation, :sender => creator1, :receiver => user, :music_session => earlier_session)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 2
music_sessions.first.id.should == earlier_session.id
end
it "orders sessions with friends in the session first, even if created first" do
creator1 = FactoryGirl.create(:user)
creator2 = FactoryGirl.create(:user)
earlier_session = FactoryGirl.create(:music_session, :creator => creator1, :description => "Earlier Session")
FactoryGirl.create(:connection, :user => creator1, :music_session => earlier_session)
later_session = FactoryGirl.create(:music_session, :creator => creator2, :description => "Later Session")
FactoryGirl.create(:connection, :user => creator2, :music_session => later_session)
user = FactoryGirl.create(:user)
FactoryGirl.create(:friendship, :user => creator1, :friend => user)
FactoryGirl.create(:friendship, :user => user, :friend => creator1)
FactoryGirl.create(:connection, :user => creator1, :music_session => earlier_session)
FactoryGirl.create(:connection, :user => creator2, :music_session => earlier_session)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 2
music_sessions.first.id.should == earlier_session.id
end
it "doesn't list a session if musician_access is set to false" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :musician_access => false)
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 0
end
it "does list a session if musician_access is set to false but user was invited" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :musician_access => false)
user = FactoryGirl.create(:user)
FactoryGirl.create(:connection, :user => creator, :music_session => session)
FactoryGirl.create(:friendship, :user => creator, :friend => user)
FactoryGirl.create(:friendship, :user => user, :friend => creator)
FactoryGirl.create(:invitation, :sender => creator, :receiver => user, :music_session => session)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 1
end
it "lists a session if the genre matches" do
creator = FactoryGirl.create(:user)
genre = FactoryGirl.create(:genre)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :genres => [genre])
FactoryGirl.create(:connection, :user => creator, :music_session => session)
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user, genres: [genre.id])
music_sessions.length.should == 1
end
it "does not list a session if the genre fails to match" do
creator = FactoryGirl.create(:user)
genre1 = FactoryGirl.create(:genre)
genre2 = FactoryGirl.create(:genre)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :genres => [genre1])
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user, genres: [genre2.id])
music_sessions.length.should == 0
end
it "does not list a session if friends_only is set and no friends are in it" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session")
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user, friends_only: true)
music_sessions.length.should == 0
end
it "lists a session properly if a friend is in it" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session")
user = FactoryGirl.create(:user)
FactoryGirl.create(:friendship, :user => creator, :friend => user)
FactoryGirl.create(:friendship, :user => user, :friend => creator)
FactoryGirl.create(:connection, :user => creator, :music_session => session)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 1
music_sessions = MusicSession.index(user, friends_only: true)
music_sessions.length.should == 1
music_sessions = MusicSession.index(user, friends_only: false, my_bands_only: true)
music_sessions.length.should == 0
music_sessions = MusicSession.index(user, friends_only: true, my_bands_only: true)
music_sessions.length.should == 1
end
it "does not list a session if it has no participants" do
# it's a design goal that there should be no sessions with 0 connections;
# however, this bug continually crops up so the .index method will protect against this common bug
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session")
session.connections.delete_all # should leave a bogus, 0 participant session around
music_sessions = MusicSession.index(creator)
music_sessions.length.should == 0
end
it "does not list a session if my_bands_only is set and it's not my band" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session")
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user, friends_only: false, my_bands_only: true)
music_sessions.length.should == 0
end
it "lists a session properly if it's my band's session" do
band = FactoryGirl.create(:band)
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :band => band)
FactoryGirl.create(:connection, :user => creator, :music_session => session)
user = FactoryGirl.create(:user)
FactoryGirl.create(:band_musician, :band => band, :user => creator)
FactoryGirl.create(:band_musician, :band => band, :user => user)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 1
music_sessions = MusicSession.index(user, friends_only: true)
music_sessions.length.should == 0
music_sessions = MusicSession.index(user, friends_only: false, my_bands_only: true)
music_sessions.length.should == 1
music_sessions = MusicSession.index(user, friends_only: true, my_bands_only: true)
music_sessions.length.should == 1
end
describe "index(as_musician: false)" do
let(:fan_access) { true }
let(:creator) { FactoryGirl.create(:user) }
let(:session) { FactoryGirl.create(:music_session, creator: creator, fan_access: fan_access ) }
let(:connection) { FactoryGirl.create(:connection, user: creator, :music_session => session) }
let(:user) {FactoryGirl.create(:user) }
describe "no mount" do
before(:each) do
session.mount.should be_nil
end
it "no session listed if mount is nil" do
connection.touch
sessions = MusicSession.index(user, as_musician: false)
sessions.length.should == 0
end
end
describe "with mount" do
let(:session_with_mount) { FactoryGirl.create(:music_session_with_mount) }
let(:connection_with_mount) { FactoryGirl.create(:connection, user: creator, :music_session => session_with_mount) }
before(:each) {
session_with_mount.mount.should_not be_nil
}
it "no session listed if icecast_server config hasn't been updated" do
connection_with_mount.touch
sessions = MusicSession.index(user, as_musician: false)
sessions.length.should == 0
end
it "no session listed if icecast_server config was updated but still before slush time" do
connection_with_mount.touch
session_with_mount.created_at = 2.minutes.ago
session_with_mount.save!(:validate => false)
session_with_mount.mount.server.config_updated_at = (APP_CONFIG.icecast_reload_slush - 1).second.ago
session_with_mount.mount.server.save!(:validate => false)
sessions = MusicSession.index(user, as_musician: false)
sessions.length.should == 0
end
it "session listed if icecast_server config has been updated" do
connection_with_mount.touch
session_with_mount.created_at = 2.minutes.ago
session_with_mount.save!(:validate => false)
session_with_mount.mount.server.config_updated_at = 1.minute.ago
session_with_mount.mount.server.save!(:validate => false)
sessions = MusicSession.index(user, as_musician: false)
sessions.length.should == 1
end
end
end
end
it "orders sessions with inviteds first, even if created first" do
creator1 = FactoryGirl.create(:user)
creator2 = FactoryGirl.create(:user)
earlier_session = FactoryGirl.create(:music_session, :creator => creator1, :description => "Earlier Session")
FactoryGirl.create(:connection, :user => creator1, :music_session => earlier_session)
later_session = FactoryGirl.create(:music_session, :creator => creator2, :description => "Later Session")
FactoryGirl.create(:connection, :user => creator2, :music_session => later_session)
user = FactoryGirl.create(:user)
FactoryGirl.create(:connection, :user => creator1, :music_session => earlier_session)
FactoryGirl.create(:friendship, :user => creator1, :friend => user)
FactoryGirl.create(:friendship, :user => user, :friend => creator1)
FactoryGirl.create(:invitation, :sender => creator1, :receiver => user, :music_session => earlier_session)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 2
music_sessions.first.id.should == earlier_session.id
end
it "orders sessions with friends in the session first, even if created first" do
creator1 = FactoryGirl.create(:user)
creator2 = FactoryGirl.create(:user)
earlier_session = FactoryGirl.create(:music_session, :creator => creator1, :description => "Earlier Session")
FactoryGirl.create(:connection, :user => creator1, :music_session => earlier_session)
later_session = FactoryGirl.create(:music_session, :creator => creator2, :description => "Later Session")
FactoryGirl.create(:connection, :user => creator2, :music_session => later_session)
user = FactoryGirl.create(:user)
FactoryGirl.create(:friendship, :user => creator1, :friend => user)
FactoryGirl.create(:friendship, :user => user, :friend => creator1)
FactoryGirl.create(:connection, :user => creator1, :music_session => earlier_session)
FactoryGirl.create(:connection, :user => creator2, :music_session => earlier_session)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 2
music_sessions.first.id.should == earlier_session.id
end
it "doesn't list a session if musician_access is set to false" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :musician_access => false)
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 0
end
it "does list a session if musician_access is set to false but user was invited" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :musician_access => false)
user = FactoryGirl.create(:user)
FactoryGirl.create(:connection, :user => creator, :music_session => session)
FactoryGirl.create(:friendship, :user => creator, :friend => user)
FactoryGirl.create(:friendship, :user => user, :friend => creator)
FactoryGirl.create(:invitation, :sender => creator, :receiver => user, :music_session => session)
music_sessions = MusicSession.index(user)
music_sessions.length.should == 1
end
it "lists a session if the genre matches" do
creator = FactoryGirl.create(:user)
genre = FactoryGirl.create(:genre)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :genres => [genre])
FactoryGirl.create(:connection, :user => creator, :music_session => session)
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user, nil, [genre.id])
music_sessions.length.should == 1
end
it "does not list a session if the genre fails to match" do
creator = FactoryGirl.create(:user)
genre1 = FactoryGirl.create(:genre)
genre2 = FactoryGirl.create(:genre)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :genres => [genre1])
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user, nil, [genre2.id])
music_sessions.length.should == 0
end
it "does not list a session if friends_only is set and no friends are in it" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session")
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user, nil, nil, true)
music_sessions.length.should == 0
end
it "lists a session properly if a friend is in it" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session")
user = FactoryGirl.create(:user)
FactoryGirl.create(:friendship, :user => creator, :friend => user)
FactoryGirl.create(:friendship, :user => user, :friend => creator)
FactoryGirl.create(:connection, :user => creator, :music_session => session)
music_sessions = MusicSession.index(user, nil, nil)
music_sessions.length.should == 1
music_sessions = MusicSession.index(user, nil, nil, true)
music_sessions.length.should == 1
music_sessions = MusicSession.index(user, nil, nil, false, true)
music_sessions.length.should == 0
music_sessions = MusicSession.index(user, nil, nil, true, true)
music_sessions.length.should == 1
end
it "does not list a session if it has no participants" do
# it's a design goal that there should be no sessions with 0 connections;
# however, this bug continually crops up so the .index method will protect against this common bug
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session")
session.connections.delete_all # should leave a bogus, 0 participant session around
music_sessions = MusicSession.index(creator, nil, nil)
music_sessions.length.should == 0
end
it "does not list a session if my_bands_only is set and it's not my band" do
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session")
user = FactoryGirl.create(:user)
music_sessions = MusicSession.index(user, nil, nil, false, true)
music_sessions.length.should == 0
end
it "lists a session properly if it's my band's session" do
band = FactoryGirl.create(:band)
creator = FactoryGirl.create(:user)
session = FactoryGirl.create(:music_session, :creator => creator, :description => "Session", :band => band)
FactoryGirl.create(:connection, :user => creator, :music_session => session)
user = FactoryGirl.create(:user)
FactoryGirl.create(:band_musician, :band => band, :user => creator)
FactoryGirl.create(:band_musician, :band => band, :user => user)
music_sessions = MusicSession.index(user, nil, nil)
music_sessions.length.should == 1
music_sessions = MusicSession.index(user, nil, nil, true)
music_sessions.length.should == 0
music_sessions = MusicSession.index(user, nil, nil, false, true)
music_sessions.length.should == 1
music_sessions = MusicSession.index(user, nil, nil, true, true)
music_sessions.length.should == 1
end
it "updates the fields of a music session properly" do
genre1 = FactoryGirl.create(:genre)
@ -264,110 +328,6 @@ describe MusicSession do
session.genres[0].id.should == genre1.id
end
=begin
# mslemmer:
# I'm going to clean this up into smaller tasks.
it 'can list sessions with appropriate sort order' do
user1 = FactoryGirl.create(:user)
user2 = FactoryGirl.create(:user)
user3 = FactoryGirl.create(:user)
user4 = FactoryGirl.create(:user)
user5 = FactoryGirl.create(:user)
music_session = FactoryGirl.create(:music_session, :creator => user1, :musician_access => false)
FactoryGirl.create(:connection, :user => user1, :music_session => music_session)
music_sessions = MusicSession.index(user2)
music_sessions.length.should == 0
music_session2 = FactoryGirl.create(:music_session, :creator => user3, :musician_access => true)
FactoryGirl.create(:connection, :user => user3, :music_session => music_session2)
music_sessions = MusicSession.index(user2)
music_sessions.length.should == 1
music_sessions[0].connections[0].user.friends.length == 0
# users 1 and 5 are friends
FactoryGirl.create(:friendship, :user => user1, :friend => user5)
FactoryGirl.create(:friendship, :user => user5, :friend => user1)
# users 1 and 2 are friends
FactoryGirl.create(:friendship, :user => user1, :friend => user2)
FactoryGirl.create(:friendship, :user => user2, :friend => user1)
# users 2 and 4 are friends
FactoryGirl.create(:friendship, :user => user2, :friend => user4)
FactoryGirl.create(:friendship, :user => user4, :friend => user2)
# user 2 should now be able to see this session, because his friend is in the session
music_sessions = MusicSession.index(user2)
music_sessions.length.should == 2
music_sessions[0].id.should == music_session.id
music_sessions[0].connections[0].user.id.should == user1.id
music_sessions[0].connections[0].user.friends.length == 1
music_sessions[1].id.should == music_session2.id
FactoryGirl.create(:invitation, :sender => user1, :receiver => user2, :music_session => music_session)
music_sessions = MusicSession.index(user2)
music_sessions.length.should == 2
music_sessions[0].id.should == music_session.id
music_sessions[1].id.should == music_session2.id
# create another, but friendy usic session with user 4
music_session3 = FactoryGirl.create(:music_session, :creator => user4, :musician_access => false, :created_at => 1.week.ago)
FactoryGirl.create(:connection, :user => user4, :music_session => music_session3)
music_sessions = MusicSession.index(user2)
music_sessions.length.should == 3
music_sessions[0].id.should == music_session.id
music_sessions[1].id.should == music_session3.id
music_sessions[2].id.should == music_session2.id
# verify we can inspect the data
music_session.invitations.length.should == 1
music_session4 = FactoryGirl.create(:music_session, :creator => user5, :musician_access => false, :created_at => 2.week.ago)
FactoryGirl.create(:connection, :user => user5, :music_session => music_session4)
music_sessions = MusicSession.index(user2)
music_sessions.length.should == 3
# make this session public now
music_session4.musician_access = true
music_session4.save
music_sessions = MusicSession.index(user2)
music_sessions.length.should == 4
music_sessions[0].id.should == music_session.id
music_sessions[1].id.should == music_session3.id
music_sessions[2].id.should == music_session2.id
music_sessions[3].id.should == music_session4.id
# ok let's make the public session that we just made, become a 'friendy' one
# make user2/5 friends
FactoryGirl.create(:friendship, :user => user2, :friend => user5)
FactoryGirl.create(:friendship, :user => user5, :friend => user2)
music_sessions = MusicSession.index(user2)
music_sessions.length.should == 4
music_sessions[0].id.should == music_session.id
music_sessions[1].id.should == music_session3.id
music_sessions[2].id.should == music_session4.id
music_sessions[3].id.should == music_session2.id
# and finally make it an invite
FactoryGirl.create(:invitation, :sender => user5, :receiver => user2, :music_session => music_session4 )
music_sessions = MusicSession.index(user2)
music_sessions.length.should == 4
music_sessions[0].id.should == music_session.id
music_sessions[1].id.should == music_session4.id
music_sessions[2].id.should == music_session3.id
music_sessions[3].id.should == music_session2.id
end
=end
it 'uninvited users cant join approval-required sessions without invitation' do
user1 = FactoryGirl.create(:user) # in the jam session
user2 = FactoryGirl.create(:user) # in the jam session

4
ruby/spec/jam_ruby/resque/icecast_config_worker_spec.rb
View File

@ -75,8 +75,10 @@ describe IcecastConfigWriter do
end
it "should have been enqueued because the config changed" do
server.touch
ResqueSpec.reset!
server.save!
# the act of just creating the IcecastServer puts a message on the queue
# the act of just touching the IcecastServer puts a message on the queue, because config_changed = true
IcecastConfigWriter.should have_queue_size_of(1)
end

13
ruby/spec/spec_helper.rb
View File

@ -40,17 +40,6 @@ CarrierWave.configure do |config|
config.enable_processing = false
end
#Resque::Failure::Notifier.configure do |config|
# config.from = 'dummy@jamkazam.com' # from address
# config.to = 'dummy@jamkazam.com' # to address
# config.include_payload = true # enabled by default
#end
#Resque::Failure::Multiple.classes = [Resque::Failure::Redis, Resque::Failure::Notifier]
#Resque::Failure.backend = Resque::Failure::Multiple
#uncomment the following line to use spork with the debugger
#require 'spork/ext/ruby-debug'
@ -58,7 +47,7 @@ Spork.prefork do
# Loading more in this block will cause your tests to run faster. However,
# if you change any configuration or code from libraries loaded here, you'll
# need to restart spork for it take effect.
# This file is copied to spec/ when you run 'rails generate rspec:install'
# This file is copied to spec/ when you run 'rails generate rspec:install'
#ENV["RAILS_ENV"] ||= 'test'
#require File.expand_path("../../config/environment", __FILE__)
require 'rspec/autorun'

4
ruby/spec/support/utilities.rb
View File

@ -41,6 +41,10 @@ def app_config
15 # 15 seconds
end
def icecast_reload_slush
3 # 3 seconds
end
def rabbitmq_host
"localhost"
end

8
web/app/controllers/api_music_sessions_controller.rb
View File

@ -15,7 +15,13 @@ class ApiMusicSessionsController < ApiController
# params[:friends_only] does the obvious.
# params[:my_bands_only] also does the obvious.
# Importantly, friends and my_bands are ORed not ANDed. So, if you specify both as true, you'll get more results, not fewer.
@music_sessions = MusicSession.index(current_user, params[:participants], params[:genres], params[:friends_only], params[:my_bands_only], params[:keyword])
@music_sessions = MusicSession.index(current_user,
participants: params[:participants],
genres: params[:genres],
friends_only: params[:friends_only],
my_bands_only: params[:my_bands_only],
keyword: params[:keyword],
as_musician: params[:as_musician])
end
def create

7
web/app/controllers/spikes_controller.rb
View File

@ -36,4 +36,11 @@ class SpikesController < ApplicationController
render :json => ret_contacts
end
def listen_in
#as_musician = false is the critical search criteria for sessions to list correctly
@music_sessions = MusicSession.index(current_user, as_musician: false)
render :layout => 'web'
end
end

6
web/app/views/api_music_sessions/show.rabl
View File

@ -25,6 +25,7 @@ child(:connections => :participants) {
}
}
child({:invitations => :invitations}) {
attributes :id, :sender_id, :receiver_id
}
@ -65,3 +66,8 @@ node(:claimed_recording, :if => lambda { |music_session| music_session.users.exi
}
}
end
# only show mount info if fan_acces is public. Eventually we'll also need to show this in other scenarios, like if invited
child({:mount => :mount}, :if => lambda { |music_session| music_session.fan_access}) {
attributes :id, :name, :sourced, :listeners, :bitrate, :mime_type, :subtype
}

16
web/app/views/spikes/listen_in.html.erb Normal file
View File

@ -0,0 +1,16 @@
<% provide(:title, 'Listen In') %>
<div class="content-wrapper">
<h2>Listing all Sessions Supposedly On Going</h2>
<% @music_sessions.each do |music_session| %>
<h3><%= music_session.description %></h3>
<div>created at: <%= music_session.created_at %> </div>
<audio controls>
<source src="<%= music_session.mount.url %>" type="<%= music_session.mount.resolve_string(:mime_type) %>">
</audio>
<% end %>
</div>

6
web/app/views/users/new.html.erb
View File

@ -1,7 +1,7 @@
<% provide(:title, 'Register') %>
<% provide(:title, 'Register') %>
<div class="content-wrapper register-page">
<h2>Create a JamKazam account</h2>
<div class="content-wrapper register-page">
<h2>Create a JamKazam account</h2>
<%= form_for(@user, :url => @signup_postback) do |f| %>

1
web/config/application.rb
View File

@ -178,6 +178,7 @@ include JamRuby
config.icecast_server_id = ENV['ICECAST_SERVER_ID'] || 'localhost'
config.icecast_max_missing_check = 2 * 60 # 2 minutes
config.icecast_max_sourced_changed = 15 # 15 seconds
config.icecast_reload_slush = 3 # 3 seconds
config.email_alerts_alias = 'nobody@jamkazam.com' # should be used for 'oh no' server down/service down sorts of emails
config.email_generic_from = 'nobody@jamkazam.com'

1
web/config/routes.rb
View File

@ -57,6 +57,7 @@ SampleApp::Application.routes.draw do
# spikes
match '/facebook_invite', to: 'spikes#facebook_invite'
match '/gmail_contacts', to: 'spikes#gmail_contacts'
match '/listen_in', to: 'spikes#listen_in'
# password reset
match '/request_reset_password' => 'users#request_reset_password', :via => :get

2
web/lib/music_session_manager.rb
View File

@ -32,13 +32,11 @@ MusicSessionManager < BaseManager
end
end
if fan_access
# create an icecast mount since regular users can listen in to the broadcast
music_session.mount = IcecastMount.build_session_mount(music_session)
end
music_session.save
unless music_session.errors.any?

166
web/spec/factories.rb
View File

@ -143,4 +143,170 @@ FactoryGirl.define do
sequence(:lng) { |n| [-78.85029, -122.4155311][(n-1).modulo(2)] }
end
factory :icecast_limit, :class => JamRuby::IcecastLimit do
clients 5
sources 1
queue_size 102400
client_timeout 30
header_timeout 15
source_timeout 10
burst_size 65536
end
factory :icecast_admin_authentication, :class => JamRuby::IcecastAdminAuthentication do
source_pass Faker::Lorem.characters(10)
admin_user Faker::Lorem.characters(10)
admin_pass Faker::Lorem.characters(10)
relay_user Faker::Lorem.characters(10)
relay_pass Faker::Lorem.characters(10)
end
factory :icecast_directory, :class => JamRuby::IcecastDirectory do
yp_url_timeout 15
yp_url Faker::Lorem.characters(10)
end
factory :icecast_master_server_relay, :class => JamRuby::IcecastMasterServerRelay do
master_server Faker::Lorem.characters(10)
master_server_port 8000
master_update_interval 120
master_username Faker::Lorem.characters(10)
master_pass Faker::Lorem.characters(10)
relays_on_demand 1
end
factory :icecast_path, :class => JamRuby::IcecastPath do
base_dir Faker::Lorem.characters(10)
log_dir Faker::Lorem.characters(10)
pid_file Faker::Lorem.characters(10)
web_root Faker::Lorem.characters(10)
admin_root Faker::Lorem.characters(10)
end
factory :icecast_logging, :class => JamRuby::IcecastLogging do
access_log Faker::Lorem.characters(10)
error_log Faker::Lorem.characters(10)
log_level 3
log_archive nil
log_size 10000
end
factory :icecast_security, :class => JamRuby::IcecastSecurity do
chroot 0
end
factory :icecast_mount, :class => JamRuby::IcecastMount do
name "/" + Faker::Lorem.characters(10)
source_username Faker::Lorem.characters(10)
source_pass Faker::Lorem.characters(10)
max_listeners 100
max_listener_duration 3600
fallback_mount Faker::Lorem.characters(10)
fallback_override 1
fallback_when_full 1
is_public -1
stream_name Faker::Lorem.characters(10)
stream_description Faker::Lorem.characters(10)
stream_url Faker::Lorem.characters(10)
genre Faker::Lorem.characters(10)
hidden 0
association :server, factory: :icecast_server_with_overrides
factory :icecast_mount_with_auth do
association :authentication, :factory => :icecast_user_authentication
factory :iceast_mount_with_template do
association :mount_template, :factory => :icecast_mount_template
factory :iceast_mount_with_music_session do
association :music_session, :factory => :music_session
end
end
end
end
factory :icecast_listen_socket, :class => JamRuby::IcecastListenSocket do
port 8000
end
factory :icecast_relay, :class => JamRuby::IcecastRelay do
port 8000
mount Faker::Lorem.characters(10)
server Faker::Lorem.characters(10)
on_demand 1
end
factory :icecast_user_authentication, :class => JamRuby::IcecastUserAuthentication do
authentication_type 'url'
unused_username Faker::Lorem.characters(10)
unused_pass Faker::Lorem.characters(10)
mount_add Faker::Lorem.characters(10)
mount_remove Faker::Lorem.characters(10)
listener_add Faker::Lorem.characters(10)
listener_remove Faker::Lorem.characters(10)
auth_header 'icecast-auth-user: 1'
timelimit_header 'icecast-auth-timelimit:'
end
factory :icecast_server, :class => JamRuby::IcecastServer do
sequence(:hostname) { |n| "hostname-#{n}"}
sequence(:server_id) { |n| "server-#{n}"}
factory :icecast_server_minimal do
association :template, :factory => :icecast_template_minimal
association :mount_template, :factory => :icecast_mount_template
factory :icecast_server_with_overrides do
association :limit, :factory => :icecast_limit
association :admin_auth, :factory => :icecast_admin_authentication
association :path, :factory => :icecast_path
association :logging, :factory => :icecast_logging
association :security, :factory => :icecast_security
before(:create) do |server|
server.listen_sockets << FactoryGirl.build(:icecast_listen_socket)
end
end
end
end
factory :icecast_template, :class => JamRuby::IcecastTemplate do
sequence(:name) { |n| "name-#{n}"}
sequence(:location) { |n| "location-#{n}"}
factory :icecast_template_minimal do
association :limit, :factory => :icecast_limit
association :admin_auth, :factory => :icecast_admin_authentication
association :path, :factory => :icecast_path
association :logging, :factory => :icecast_logging
association :security, :factory => :icecast_security
before(:create) do |template|
template.listen_sockets << FactoryGirl.build(:icecast_listen_socket)
end
end
end
factory :icecast_mount_template, :class => JamRuby::IcecastMountTemplate do
sequence(:name) { |n| "name-#{n}"}
source_username Faker::Lorem.characters(10)
source_pass Faker::Lorem.characters(10)
max_listeners 100
max_listener_duration 3600
fallback_mount Faker::Lorem.characters(10)
fallback_override 1
fallback_when_full 1
is_public -1
stream_name Faker::Lorem.characters(10)
stream_description Faker::Lorem.characters(10)
stream_url Faker::Lorem.characters(10)
genre Faker::Lorem.characters(10)
hidden 0
association :authentication, :factory => :icecast_user_authentication
end
end

26
web/spec/requests/music_sessions_api_spec.rb
View File

@ -585,6 +585,32 @@ describe "Music Session API ", :type => :api do
last_response.status.should eql(422)
JSON.parse(last_response.body)["errors"]["music_session"][0].should == ValidationMessages::CANT_JOIN_RECORDING_SESSION
end
it "shows mount info based on fan_access" do
# create the session
server = FactoryGirl.create(:icecast_server_minimal)
user2 = FactoryGirl.create(:user) # in the music session
client = FactoryGirl.create(:connection, :user => user, :ip_address => "1.1.1.10", :client_id => "mount_info")
post '/api/sessions.json', defopts.merge({:client_id => client.client_id, :fan_access => true}).to_json, "CONTENT_TYPE" => 'application/json'
last_response.status.should eql(201)
session = JSON.parse(last_response.body)
music_session = MusicSession.find(session["id"])
session["mount"].should_not be_nil
session["mount"]["name"].should == music_session.mount.name
session["mount"]["listeners"].should == music_session.mount.listeners
session["mount"]["sourced"].should == music_session.mount.sourced
# set gfan_access to false, which should cause the mount info to hide
music_session.fan_access = false
music_session.save!
get "/api/sessions/#{session["id"]}.json"
last_response.status.should eql(200)
session = JSON.parse(last_response.body)
session["mount"].should be_nil
end
end
it "Finds a single open session" do