068b80814b
- When people click on the logout button, a event is sent to all
browser tabs (actually to a shared worker) to notify them of this
logout. This is done in a blocking fashion, to ensure every registered
channel (which realistically should be one for every user because of the
shared worker) for a user receives this message. While doing this, it
locks the mutex for the eventsource module.
- Codeberg is currently observing a deadlock that's caused by this
blocking behavior, a channel isn't receiving the logout event. We
currently don't have a good theory of why this is being caused. This in
turn is causing that the logout functionality is no longer working and
people no longer receive notifications, unless they refresh the page.
- This patchs makes this message non-blocking and thus making it
consistent with the other messages. We don't see a good reason why this
specific event needs to be blocking and the commit introducing it
doesn't offer a rationale either.
(cherry picked from commit 9c5c08859d)
68 lines
1.5 KiB
Go
68 lines
1.5 KiB
Go
// Copyright 2020 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package eventsource
|
|
|
|
import "sync"
|
|
|
|
// Messenger is a per uid message store
|
|
type Messenger struct {
|
|
mutex sync.Mutex
|
|
uid int64
|
|
channels []chan *Event
|
|
}
|
|
|
|
// NewMessenger creates a messenger for a particular uid
|
|
func NewMessenger(uid int64) *Messenger {
|
|
return &Messenger{
|
|
uid: uid,
|
|
channels: [](chan *Event){},
|
|
}
|
|
}
|
|
|
|
// Register returns a new chan []byte
|
|
func (m *Messenger) Register() <-chan *Event {
|
|
m.mutex.Lock()
|
|
// TODO: Limit the number of messengers per uid
|
|
channel := make(chan *Event, 1)
|
|
m.channels = append(m.channels, channel)
|
|
m.mutex.Unlock()
|
|
return channel
|
|
}
|
|
|
|
// Unregister removes the provider chan []byte
|
|
func (m *Messenger) Unregister(channel <-chan *Event) bool {
|
|
m.mutex.Lock()
|
|
defer m.mutex.Unlock()
|
|
for i, toRemove := range m.channels {
|
|
if channel == toRemove {
|
|
m.channels = append(m.channels[:i], m.channels[i+1:]...)
|
|
close(toRemove)
|
|
break
|
|
}
|
|
}
|
|
return len(m.channels) == 0
|
|
}
|
|
|
|
// UnregisterAll removes all chan []byte
|
|
func (m *Messenger) UnregisterAll() {
|
|
m.mutex.Lock()
|
|
defer m.mutex.Unlock()
|
|
for _, channel := range m.channels {
|
|
close(channel)
|
|
}
|
|
m.channels = nil
|
|
}
|
|
|
|
// SendMessage sends the message to all registered channels
|
|
func (m *Messenger) SendMessage(message *Event) {
|
|
m.mutex.Lock()
|
|
defer m.mutex.Unlock()
|
|
for i := range m.channels {
|
|
channel := m.channels[i]
|
|
select {
|
|
case channel <- message:
|
|
default:
|
|
}
|
|
}
|
|
}
|