func (s *aliasStore) AddAlias(alias ct.Alias, room ct.RoomId) types.Error { inserted, err := s.idMap.Insert(ct.Id(alias), ct.Id(room)) if err != nil { return types.InternalError(err) } if !inserted { return types.RoomInUseError("room alias '" + alias.String() + "' already exists") } return nil }
func (s *aliasStore) RemoveAlias(alias ct.Alias, room ct.RoomId) types.Error { deleted, err := s.idMap.Delete(ct.Id(alias), ct.Id(room)) if err != nil { return types.InternalError(err) } if !deleted { return types.NotFoundError("room alias '" + alias.String() + "' doesn't exist") } return nil }
func (db *memberStore) AddMember(roomId ct.RoomId, userId ct.UserId) types.Error { inserted, err := db.idMap.Put(ct.Id(roomId), ct.Id(userId)) if err != nil { return types.InternalError(err) } if !inserted { msg := fmt.Sprintf("user %s is already a member of the room %s", userId, roomId) return types.ServerError(msg) } return nil }
func (db *memberStore) RemoveMember(roomId ct.RoomId, userId ct.UserId) types.Error { deleted, err := db.idMap.Delete(ct.Id(roomId), ct.Id(userId)) if err != nil { return types.InternalError(err) } if !deleted { msg := fmt.Sprintf("user %s is not a member of the room %s", userId, roomId) return types.ServerError(msg) } return nil }
func (db *roomDb) SetRoomState(roomId types.RoomId, userId types.UserId, content types.TypedContent, stateKey string) (*matrixTypes.State, matrixTypes.Error) { db.roomsLock.RLock() defer db.roomsLock.RUnlock() room := db.rooms[roomId] if room == nil { return nil, matrixTypes.NotFoundError("room '" + roomId.String() + "' doesn't exist") } var eventId = types.DeriveEventId(utils.RandomString(16), types.Id(userId)) stateId := stateId{content.GetEventType(), stateKey} state := new(matrixTypes.State) state.EventId = eventId state.RoomId = roomId state.UserId = userId state.EventType = content.GetEventType() state.StateKey = stateKey state.Timestamp = types.Timestamp{time.Now()} state.Content = content state.OldState = (*matrixTypes.OldState)(room.states[stateId]) room.stateLock.Lock() defer room.stateLock.Unlock() room.states[stateId] = state return state, nil }
func (b *fanInTestBuffer) Send(id string, user string, expectedIndex uint64) { index, err := b.buffer.Send(types.EventInfo{ EventId: types.Id(types.NewEventId(id, "test")), Sender: types.Id(types.NewUserId("tester", "test")), ContextId: types.Id(types.NewRoomId("room1", "test")), EventType: "m.test", }, types.Id(types.NewUserId(user, "test"))) if err != nil { debug.PrintStack() b.t.Fatal("error pushing signal: ", err) } if index != expectedIndex { debug.PrintStack() b.t.Fatal("invalid index, expected %d but got %d", expectedIndex, index) } }
func (db *userDb) UserPasswordHash(id ct.UserId) (string, types.Error) { value, err := db.State(ct.Id(id), passwordHashKey) if err != nil { return "", types.InternalError(err) } return string(value), nil }
func (b *fanOutTestBuffer) Select(user string, from, to, expectedFromIndex, expectedToIndex uint64, expected ...string) { signals, fromIndex, toIndex, err := b.buffer.SelectForwards(types.Id(types.NewUserId(user, "test")), from, to) if err != nil { debug.PrintStack() b.t.Fatal("failed to get signal range: ", err) } if len(signals) != len(expected) { debug.PrintStack() b.t.Fatalf("invalid signal count, expected %d but got %d", len(expected), len(signals)) } if expectedFromIndex != fromIndex { debug.PrintStack() b.t.Fatalf("invalid from index, expected %d but got %d", expectedFromIndex, fromIndex) } if expectedToIndex != toIndex { debug.PrintStack() b.t.Fatalf("invalid to index, expected %d but got %d", expectedToIndex, toIndex) } for i, signal := range signals { if signal.EventId.Id != expected[i] { debug.PrintStack() b.t.Fatalf("invalid event id: expected %s, got %s", expected[i], signal.EventId.Id) } } }
func (s *aliasStore) Room(alias ct.Alias) (*ct.RoomId, types.Error) { room, err := s.idMap.Lookup(ct.Id(alias)) if err != nil { return nil, types.InternalError(err) } return (*ct.RoomId)(room), nil }
func (s *aliasStore) Aliases(room ct.RoomId) ([]ct.Alias, types.Error) { ids, err := s.idMap.ReverseLookup(ct.Id(room)) if err != nil { return nil, types.InternalError(err) } aliases := *(*[]ct.Alias)(unsafe.Pointer(&ids)) return aliases, nil }
func (b *fanOutTestBuffer) Push(id string, expectedIndex uint64, users ...string) { userIds := make([]types.Id, len(users)) for i, user := range users { userIds[i] = types.Id(types.NewUserId(user, "test")) } index, err := b.buffer.Send(types.EventInfo{ EventId: types.Id(types.NewEventId(id, "test")), Sender: types.Id(types.NewUserId("tester", "test")), ContextId: types.Id(types.NewRoomId("room1", "test")), EventType: "m.test", }, userIds) if err != nil { b.t.Fatal("error pushing signal: ", err) } if index != expectedIndex { debug.PrintStack() b.t.Fatal("invalid index, expected %d but got %d", expectedIndex, index) } }
func (db *memberStore) Peers(userId ct.UserId) (map[ct.UserId]struct{}, types.Error) { peers := map[ct.UserId]struct{}{} rooms, err := db.idMap.ReverseLookup(ct.Id(userId)) if err != nil { return nil, types.InternalError(err) } for _, room := range rooms { members, err := db.idMap.Lookup(room) if err != nil { return nil, types.InternalError(err) } for _, member := range members { peers[ct.UserId(member)] = struct{}{} } } return peers, nil }
func (s roomService) sendMessage( room ct.RoomId, user ct.UserId, content types.TypedContent, ) (*types.Message, types.Error) { log.Printf("Sending message: %#v, %#v, %#v, %#v", room, user, content) message := new(types.Message) message.EventId = ct.DeriveEventId(utils.RandomString(16), ct.Id(user)) message.RoomId = room message.UserId = user message.EventType = content.GetEventType() message.Timestamp = ct.Timestamp{time.Now()} message.Content = content _, err := s.eventSink.Send(message) if err != nil { return nil, err } return message, nil }
func (s *messageStream) Event( user ct.UserId, eventId ct.EventId, ) (types.Event, types.Error) { s.lock.RLock() indexed := s.byId[ct.Id(eventId)] s.lock.RUnlock() extraUser := extraUserForEvent(indexed.event) if extraUser != nil && *extraUser == user { return indexed.event, nil } rooms, err := s.members.Rooms(user) if err != nil { return nil, err } for _, room := range rooms { if room == *indexed.event.GetRoomId() { return indexed.event, nil } } return nil, nil }
func (e *TypingEvent) GetEventKey() ct.Id { return ct.Id(e.RoomId) }
func (e *Message) GetEventKey() ct.Id { return ct.Id(e.EventId) }
func (e *PresenceEvent) GetEventKey() ct.Id { return ct.Id(e.Content.UserId) }
func (db *userDb) SetUserPasswordHash(id ct.UserId, hash string) types.Error { _, err := db.SetState(ct.Id(id), passwordHashKey, []byte(hash)) return types.InternalError(err) }
func (db *userDb) UserExists(id ct.UserId) (bool, types.Error) { exists, err := db.BucketExists(ct.Id(id)) return exists, types.InternalError(err) }
func (db *userDb) CreateUser(id ct.UserId) (bool, types.Error) { exists, err := db.CreateBucket(ct.Id(id)) return exists, types.InternalError(err) }
func (db *memberStore) Users(roomId ct.RoomId) ([]ct.UserId, types.Error) { ids, err := db.idMap.Lookup(ct.Id(roomId)) users := *(*[]ct.UserId)(unsafe.Pointer(&ids)) return users, types.InternalError(err) }
func (db *memberStore) Rooms(userId ct.UserId) ([]ct.RoomId, types.Error) { ids, err := db.idMap.ReverseLookup(ct.Id(userId)) rooms := *(*[]ct.RoomId)(unsafe.Pointer(&ids)) return rooms, types.InternalError(err) }