Move room type names to constants and don't expose roomworker properties.

go/channelling/api.go

@@ -21,6 +21,11 @@
 
 package channelling
 
+const (
+	RoomTypeConference = "Conference"
+	RoomTypeRoom       = "Room"
+)
+
 type ChannellingAPI interface {
 	OnConnect(*Client, *Session) (interface{}, error)
 	OnDisconnect(*Client, *Session)

go/channelling/api/api_test.go

@@ -77,7 +77,7 @@ func (fake *fakeRoomManager) UpdateRoom(_ *channelling.Session, _ *channelling.D
 
 func (fake *fakeRoomManager) MakeRoomID(roomName, roomType string) string {
 	if roomType == "" {
-		roomType = "Room"
+		roomType = channelling.RoomTypeRoom
 	}
 	return fmt.Sprintf("%s:%s", roomType, roomName)
 }
@@ -98,7 +98,7 @@ func NewTestChannellingAPI() (channelling.ChannellingAPI, *fakeClient, *channell
 }
 
 func Test_ChannellingAPI_OnIncoming_HelloMessage_JoinsTheSelectedRoom(t *testing.T) {
-	roomID, roomName, ua := "Room:foobar", "foobar", "unit tests"
+	roomID, roomName, ua := channelling.RoomTypeRoom+":foobar", "foobar", "unit tests"
 	api, client, session, roomManager := NewTestChannellingAPI()
 
 	api.OnIncoming(client, session, &channelling.DataIncoming{Type: "Hello", Hello: &channelling.DataHello{Id: roomName, Ua: ua}})
@@ -122,7 +122,7 @@ func Test_ChannellingAPI_OnIncoming_HelloMessage_JoinsTheSelectedRoom(t *testing
 }
 
 func Test_ChannellingAPI_OnIncoming_HelloMessage_LeavesAnyPreviouslyJoinedRooms(t *testing.T) {
-	roomID, roomName := "Room:foobar", "foobar"
+	roomID, roomName := channelling.RoomTypeRoom+":foobar", "foobar"
 	api, client, session, roomManager := NewTestChannellingAPI()
 
 	api.OnIncoming(client, session, &channelling.DataIncoming{Type: "Hello", Hello: &channelling.DataHello{Id: roomName}})
@@ -204,7 +204,7 @@ func Test_ChannellingAPI_OnIncoming_RoomMessage_RespondsWithAndBroadcastsTheUpda
 		t.Fatalf("Unexpected error %v", err)
 	}
 
-	reply, err := api.OnIncoming(client, session, &channelling.DataIncoming{Type: "Room", Room: &channelling.DataRoom{Name: roomName}})
+	reply, err := api.OnIncoming(client, session, &channelling.DataIncoming{Type: channelling.RoomTypeRoom, Room: &channelling.DataRoom{Name: roomName}})
 	if err != nil {
 		t.Fatalf("Unexpected error %v", err)
 	}
@@ -236,7 +236,7 @@ func Test_ChannellingAPI_OnIncoming_RoomMessage_RespondsWithAnErrorIfUpdatingThe
 	if err != nil {
 		t.Fatalf("Unexpected error %v", err)
 	}
-	_, err = api.OnIncoming(client, session, &channelling.DataIncoming{Type: "Room", Room: &channelling.DataRoom{Name: roomName}})
+	_, err = api.OnIncoming(client, session, &channelling.DataIncoming{Type: channelling.RoomTypeRoom, Room: &channelling.DataRoom{Name: roomName}})
 
 	assertDataError(t, err, "a_room_error")
 }

go/channelling/api/handle_conference.go

@@ -28,7 +28,7 @@ import (
 )
 
 func (api *channellingAPI) HandleConference(session *channelling.Session, conference *channelling.DataConference) {
-	if room, ok := api.RoomStatusManager.Get(session.Roomid); ok && room.GetType() == "Conference" {
+	if room, ok := api.RoomStatusManager.Get(session.Roomid); ok && room.GetType() == channelling.RoomTypeConference {
 		log.Println("Refusing client-side conference update for server-managed conferences.")
 		return
 	}

go/channelling/api/handle_room.go

@@ -42,7 +42,7 @@ func (api *channellingAPI) RoomProcessed(sender channelling.Sender, session *cha
 
 func (api *channellingAPI) SendConferenceRoomUpdate(session *channelling.Session) {
 	// If user joined a server-managed conference room, send list of session ids to all participants.
-	if room, ok := api.RoomStatusManager.Get(session.Roomid); ok && room.GetType() == "Conference" {
+	if room, ok := api.RoomStatusManager.Get(session.Roomid); ok && room.GetType() == channelling.RoomTypeConference {
 		if sessionids := room.SessionIDs(); len(sessionids) > 1 {
 			cid := session.Roomid
 			session.Broadcaster.Broadcast("", session.Roomid, &channelling.DataOutgoing{

go/channelling/room_manager_test.go

@@ -23,11 +23,13 @@ package channelling
 
 import (
 	"testing"
+
+	"github.com/strukturag/spreed-webrtc/go/channelling"
 )
 
 func NewTestRoomManager() (RoomManager, *Config) {
 	config := &Config{
-		RoomTypeDefault: "Room",
+		RoomTypeDefault: channelling.RoomTypeRoom,
 	}
 	return NewRoomManager(config, nil), config
 }
@@ -38,16 +40,16 @@ func Test_RoomManager_JoinRoom_ReturnsAnErrorForUnauthenticatedSessionsWhenCreat
 	config.AuthorizeRoomCreation = true
 
 	unauthenticatedSession := &Session{}
-	_, err := roomManager.JoinRoom("Room:foo", "foo", "Room", nil, unauthenticatedSession, false, nil)
+	_, err := roomManager.JoinRoom(channelling.RoomTypeRoom+":foo", "foo", channelling.RoomTypeRoom, nil, unauthenticatedSession, false, nil)
 	assertDataError(t, err, "room_join_requires_account")
 
 	authenticatedSession := &Session{userid: "9870457"}
-	_, err = roomManager.JoinRoom("Room:foo", "foo", "Room", nil, authenticatedSession, true, nil)
+	_, err = roomManager.JoinRoom(channelling.RoomTypeRoom+":foo", "foo", channelling.RoomTypeRoom, nil, authenticatedSession, true, nil)
 	if err != nil {
 		t.Fatalf("Unexpected error %v joining room while authenticated", err)
 	}
 
-	_, err = roomManager.JoinRoom("Room:foo", "foo", "Room", nil, unauthenticatedSession, false, nil)
+	_, err = roomManager.JoinRoom(channelling.RoomTypeRoom+":foo", "foo", channelling.RoomTypeRoom, nil, unauthenticatedSession, false, nil)
 	if err != nil {
 		t.Fatalf("Unexpected error %v joining room while unauthenticated", err)
 	}
@@ -59,16 +61,16 @@ func Test_RoomManager_JoinRoom_ReturnsAnErrorForUnauthenticatedSessionsWhenJoinR
 	config.AuthorizeRoomJoin = true
 
 	unauthenticatedSession := &Session{}
-	_, err := roomManager.JoinRoom("Room:foo", "foo", "Room", nil, unauthenticatedSession, false, nil)
+	_, err := roomManager.JoinRoom(channelling.RoomTypeRoom+":foo", "foo", channelling.RoomTypeRoom, nil, unauthenticatedSession, false, nil)
 	assertDataError(t, err, "room_join_requires_account")
 
 	authenticatedSession := &Session{userid: "9870457"}
-	_, err = roomManager.JoinRoom("Room:foo", "foo", "Room", nil, authenticatedSession, true, nil)
+	_, err = roomManager.JoinRoom(channelling.RoomTypeRoom+":foo", "foo", channelling.RoomTypeRoom, nil, authenticatedSession, true, nil)
 	if err != nil {
 		t.Fatalf("Unexpected error %v joining room while authenticated", err)
 	}
 
-	_, err = roomManager.JoinRoom("Room:foo", "foo", "Room", nil, unauthenticatedSession, false, nil)
+	_, err = roomManager.JoinRoom(channelling.RoomTypeRoom+":foo", "foo", channelling.RoomTypeRoom, nil, unauthenticatedSession, false, nil)
 	assertDataError(t, err, "room_join_requires_account")
 }
 
@@ -81,20 +83,20 @@ func Test_RoomManager_UpdateRoom_ReturnsAnErrorIfNoRoomHasBeenJoined(t *testing.
 
 func Test_RoomManager_UpdateRoom_ReturnsAnErrorIfUpdatingAnUnjoinedRoom(t *testing.T) {
 	roomManager, _ := NewTestRoomManager()
-	session := &Session{Hello: true, Roomid: "Room:foo"}
+	session := &Session{Hello: true, Roomid: channelling.RoomTypeRoom + ":foo"}
 	_, err := roomManager.UpdateRoom(session, &DataRoom{Name: "bar"})
 	assertDataError(t, err, "not_in_room")
 }
 
 func Test_RoomManager_UpdateRoom_ReturnsACorrectlyTypedDocument(t *testing.T) {
 	roomManager, _ := NewTestRoomManager()
-	session := &Session{Hello: true, Roomid: "Room:foo"}
+	session := &Session{Hello: true, Roomid: channelling.RoomTypeRoom + ":foo"}
 	room, err := roomManager.UpdateRoom(session, &DataRoom{Name: "foo"})
 	if err != nil {
 		t.Fatalf("Unexpected error %v updating room", err)
 	}
 
-	if room.Type != "Room" {
+	if room.Type != channelling.RoomTypeRoom {
-		t.Errorf("Expected document type to be Room, but was %v", room.Type)
+		t.Errorf("Expected document type to be %s, but was %v", channelling.RoomTypeRoom, room.Type)
 	}
 }

go/channelling/roomworker.go

@@ -61,8 +61,8 @@ type roomWorker struct {
 
 	// Metadata.
 	id          string
-	Name        string
+	name        string
-	Type        string
+	roomType    string
 	credentials *DataRoomCredentials
 }
 
@@ -77,8 +77,8 @@ func NewRoomWorker(manager *roomManager, roomID, roomName, roomType string, cred
 	r := &roomWorker{
 		manager:  manager,
 		id:       roomID,
-		Name:    roomName,
+		name:     roomName,
-		Type:    roomType,
+		roomType: roomType,
 		workers:  make(chan func(), roomMaxWorkers),
 		expired:  make(chan bool),
 		users:    make(map[string]*roomUser),
@@ -148,7 +148,7 @@ func (r *roomWorker) Users() []*roomUser {
 }
 
 func (r *roomWorker) GetType() string {
-	return r.Type
+	return r.roomType
 }
 
 func (r *roomWorker) Run(f func()) bool {
@@ -166,8 +166,8 @@ func (r *roomWorker) Update(room *DataRoom) error {
 	worker := func() {
 		r.mutex.Lock()
 		// Enforce room type and name.
-		room.Type = r.Type
+		room.Type = r.roomType
-		room.Name = r.Name
+		room.Name = r.name
 		// Update credentials.
 		if room.Credentials != nil {
 			if len(room.Credentials.PIN) > 0 {
@@ -275,7 +275,7 @@ func (r *roomWorker) Join(credentials *DataRoomCredentials, session *Session, se
 		r.users[session.Id] = &roomUser{session, sender}
 		// NOTE(lcooper): Needs to be a copy, else we risk races with
 		// a subsequent modification of room properties.
-		result := joinResult{&DataRoom{Name: r.Name, Type: r.Type}, nil}
+		result := joinResult{&DataRoom{Name: r.name, Type: r.roomType}, nil}
 		r.mutex.Unlock()
 		results <- result
 	}

go/channelling/roomworker_test.go

@@ -23,12 +23,14 @@ package channelling
 
 import (
 	"testing"
+
+	"github.com/strukturag/spreed-webrtc/go/channelling"
 )
 
 const (
-	testRoomID   string = "Room:a-room-name"
+	testRoomID   string = channelling.RoomTypeRoom + ":a-room-name"
 	testRoomName string = "a-room-name"
-	testRoomType string = "Room"
+	testRoomType string = channelling.RoomTypeRoom
 )
 
 func NewTestRoomWorker() RoomWorker {

go/channelling/server/config.go

@@ -34,12 +34,12 @@ import (
 )
 
 const (
-	defaultRoomType = "Room"
+	defaultRoomType = channelling.RoomTypeRoom
 )
 
 var (
 	knownRoomTypes = map[string]bool{
-		"Conference": true,
+		channelling.RoomTypeConference: true,
 	}
 )