source: code/trunk/user.go@ 682

Last change on this file since 682 was 682, checked in by contact, 4 years ago

Add a queue for WHO commands

This has the following upsides:

  • We can now routes WHO replies to the correct client, without broadcasting them to everybody.
  • We are less likely to hit server rate limits when multiple downstreams are issuing WHO commands at the same time.
File size: 22.1 KB
Line 
1package soju
2
3import (
4 "context"
5 "crypto/sha256"
6 "encoding/binary"
7 "encoding/hex"
8 "fmt"
9 "time"
10
11 "gopkg.in/irc.v3"
12)
13
14type event interface{}
15
16type eventUpstreamMessage struct {
17 msg *irc.Message
18 uc *upstreamConn
19}
20
21type eventUpstreamConnectionError struct {
22 net *network
23 err error
24}
25
26type eventUpstreamConnected struct {
27 uc *upstreamConn
28}
29
30type eventUpstreamDisconnected struct {
31 uc *upstreamConn
32}
33
34type eventUpstreamError struct {
35 uc *upstreamConn
36 err error
37}
38
39type eventDownstreamMessage struct {
40 msg *irc.Message
41 dc *downstreamConn
42}
43
44type eventDownstreamConnected struct {
45 dc *downstreamConn
46}
47
48type eventDownstreamDisconnected struct {
49 dc *downstreamConn
50}
51
52type eventChannelDetach struct {
53 uc *upstreamConn
54 name string
55}
56
57type eventBroadcast struct {
58 msg *irc.Message
59}
60
61type eventStop struct{}
62
63type eventUserUpdate struct {
64 password *string
65 admin *bool
66 done chan error
67}
68
69type deliveredClientMap map[string]string // client name -> msg ID
70
71type deliveredStore struct {
72 m deliveredCasemapMap
73}
74
75func newDeliveredStore() deliveredStore {
76 return deliveredStore{deliveredCasemapMap{newCasemapMap(0)}}
77}
78
79func (ds deliveredStore) HasTarget(target string) bool {
80 return ds.m.Value(target) != nil
81}
82
83func (ds deliveredStore) LoadID(target, clientName string) string {
84 clients := ds.m.Value(target)
85 if clients == nil {
86 return ""
87 }
88 return clients[clientName]
89}
90
91func (ds deliveredStore) StoreID(target, clientName, msgID string) {
92 clients := ds.m.Value(target)
93 if clients == nil {
94 clients = make(deliveredClientMap)
95 ds.m.SetValue(target, clients)
96 }
97 clients[clientName] = msgID
98}
99
100func (ds deliveredStore) ForEachTarget(f func(target string)) {
101 for _, entry := range ds.m.innerMap {
102 f(entry.originalKey)
103 }
104}
105
106func (ds deliveredStore) ForEachClient(f func(clientName string)) {
107 clients := make(map[string]struct{})
108 for _, entry := range ds.m.innerMap {
109 delivered := entry.value.(deliveredClientMap)
110 for clientName := range delivered {
111 clients[clientName] = struct{}{}
112 }
113 }
114
115 for clientName := range clients {
116 f(clientName)
117 }
118}
119
120type network struct {
121 Network
122 user *user
123 logger Logger
124 stopped chan struct{}
125
126 conn *upstreamConn
127 channels channelCasemapMap
128 delivered deliveredStore
129 lastError error
130 casemap casemapping
131}
132
133func newNetwork(user *user, record *Network, channels []Channel) *network {
134 logger := &prefixLogger{user.logger, fmt.Sprintf("network %q: ", record.GetName())}
135
136 m := channelCasemapMap{newCasemapMap(0)}
137 for _, ch := range channels {
138 ch := ch
139 m.SetValue(ch.Name, &ch)
140 }
141
142 return &network{
143 Network: *record,
144 user: user,
145 logger: logger,
146 stopped: make(chan struct{}),
147 channels: m,
148 delivered: newDeliveredStore(),
149 casemap: casemapRFC1459,
150 }
151}
152
153func (net *network) forEachDownstream(f func(*downstreamConn)) {
154 net.user.forEachDownstream(func(dc *downstreamConn) {
155 if dc.network == nil && dc.caps["soju.im/bouncer-networks"] {
156 return
157 }
158 if dc.network != nil && dc.network != net {
159 return
160 }
161 f(dc)
162 })
163}
164
165func (net *network) isStopped() bool {
166 select {
167 case <-net.stopped:
168 return true
169 default:
170 return false
171 }
172}
173
174func userIdent(u *User) string {
175 // The ident is a string we will send to upstream servers in clear-text.
176 // For privacy reasons, make sure it doesn't expose any meaningful user
177 // metadata. We just use the base64-encoded hashed ID, so that people don't
178 // start relying on the string being an integer or following a pattern.
179 var b [64]byte
180 binary.LittleEndian.PutUint64(b[:], uint64(u.ID))
181 h := sha256.Sum256(b[:])
182 return hex.EncodeToString(h[:16])
183}
184
185func (net *network) run() {
186 if !net.Enabled {
187 return
188 }
189
190 var lastTry time.Time
191 for {
192 if net.isStopped() {
193 return
194 }
195
196 if dur := time.Now().Sub(lastTry); dur < retryConnectDelay {
197 delay := retryConnectDelay - dur
198 net.logger.Printf("waiting %v before trying to reconnect to %q", delay.Truncate(time.Second), net.Addr)
199 time.Sleep(delay)
200 }
201 lastTry = time.Now()
202
203 uc, err := connectToUpstream(net)
204 if err != nil {
205 net.logger.Printf("failed to connect to upstream server %q: %v", net.Addr, err)
206 net.user.events <- eventUpstreamConnectionError{net, fmt.Errorf("failed to connect: %v", err)}
207 continue
208 }
209
210 if net.user.srv.Identd != nil {
211 net.user.srv.Identd.Store(uc.RemoteAddr().String(), uc.LocalAddr().String(), userIdent(&net.user.User))
212 }
213
214 uc.register()
215 if err := uc.runUntilRegistered(); err != nil {
216 text := err.Error()
217 if regErr, ok := err.(registrationError); ok {
218 text = string(regErr)
219 }
220 uc.logger.Printf("failed to register: %v", text)
221 net.user.events <- eventUpstreamConnectionError{net, fmt.Errorf("failed to register: %v", text)}
222 uc.Close()
223 continue
224 }
225
226 // TODO: this is racy with net.stopped. If the network is stopped
227 // before the user goroutine receives eventUpstreamConnected, the
228 // connection won't be closed.
229 net.user.events <- eventUpstreamConnected{uc}
230 if err := uc.readMessages(net.user.events); err != nil {
231 uc.logger.Printf("failed to handle messages: %v", err)
232 net.user.events <- eventUpstreamError{uc, fmt.Errorf("failed to handle messages: %v", err)}
233 }
234 uc.Close()
235 net.user.events <- eventUpstreamDisconnected{uc}
236
237 if net.user.srv.Identd != nil {
238 net.user.srv.Identd.Delete(uc.RemoteAddr().String(), uc.LocalAddr().String())
239 }
240 }
241}
242
243func (net *network) stop() {
244 if !net.isStopped() {
245 close(net.stopped)
246 }
247
248 if net.conn != nil {
249 net.conn.Close()
250 }
251}
252
253func (net *network) detach(ch *Channel) {
254 if ch.Detached {
255 return
256 }
257
258 net.logger.Printf("detaching channel %q", ch.Name)
259
260 ch.Detached = true
261
262 if net.user.msgStore != nil {
263 nameCM := net.casemap(ch.Name)
264 lastID, err := net.user.msgStore.LastMsgID(&net.Network, nameCM, time.Now())
265 if err != nil {
266 net.logger.Printf("failed to get last message ID for channel %q: %v", ch.Name, err)
267 }
268 ch.DetachedInternalMsgID = lastID
269 }
270
271 if net.conn != nil {
272 uch := net.conn.channels.Value(ch.Name)
273 if uch != nil {
274 uch.updateAutoDetach(0)
275 }
276 }
277
278 net.forEachDownstream(func(dc *downstreamConn) {
279 dc.SendMessage(&irc.Message{
280 Prefix: dc.prefix(),
281 Command: "PART",
282 Params: []string{dc.marshalEntity(net, ch.Name), "Detach"},
283 })
284 })
285}
286
287func (net *network) attach(ch *Channel) {
288 if !ch.Detached {
289 return
290 }
291
292 net.logger.Printf("attaching channel %q", ch.Name)
293
294 detachedMsgID := ch.DetachedInternalMsgID
295 ch.Detached = false
296 ch.DetachedInternalMsgID = ""
297
298 var uch *upstreamChannel
299 if net.conn != nil {
300 uch = net.conn.channels.Value(ch.Name)
301
302 net.conn.updateChannelAutoDetach(ch.Name)
303 }
304
305 net.forEachDownstream(func(dc *downstreamConn) {
306 dc.SendMessage(&irc.Message{
307 Prefix: dc.prefix(),
308 Command: "JOIN",
309 Params: []string{dc.marshalEntity(net, ch.Name)},
310 })
311
312 if uch != nil {
313 forwardChannel(dc, uch)
314 }
315
316 if detachedMsgID != "" {
317 dc.sendTargetBacklog(net, ch.Name, detachedMsgID)
318 }
319 })
320}
321
322func (net *network) deleteChannel(ctx context.Context, name string) error {
323 ch := net.channels.Value(name)
324 if ch == nil {
325 return fmt.Errorf("unknown channel %q", name)
326 }
327 if net.conn != nil {
328 uch := net.conn.channels.Value(ch.Name)
329 if uch != nil {
330 uch.updateAutoDetach(0)
331 }
332 }
333
334 if err := net.user.srv.db.DeleteChannel(ctx, ch.ID); err != nil {
335 return err
336 }
337 net.channels.Delete(name)
338 return nil
339}
340
341func (net *network) updateCasemapping(newCasemap casemapping) {
342 net.casemap = newCasemap
343 net.channels.SetCasemapping(newCasemap)
344 net.delivered.m.SetCasemapping(newCasemap)
345 if net.conn != nil {
346 net.conn.channels.SetCasemapping(newCasemap)
347 for _, entry := range net.conn.channels.innerMap {
348 uch := entry.value.(*upstreamChannel)
349 uch.Members.SetCasemapping(newCasemap)
350 }
351 }
352}
353
354func (net *network) storeClientDeliveryReceipts(clientName string) {
355 if !net.user.hasPersistentMsgStore() {
356 return
357 }
358
359 var receipts []DeliveryReceipt
360 net.delivered.ForEachTarget(func(target string) {
361 msgID := net.delivered.LoadID(target, clientName)
362 if msgID == "" {
363 return
364 }
365 receipts = append(receipts, DeliveryReceipt{
366 Target: target,
367 InternalMsgID: msgID,
368 })
369 })
370
371 if err := net.user.srv.db.StoreClientDeliveryReceipts(context.TODO(), net.ID, clientName, receipts); err != nil {
372 net.logger.Printf("failed to store delivery receipts for client %q: %v", clientName, err)
373 }
374}
375
376func (net *network) isHighlight(msg *irc.Message) bool {
377 if msg.Command != "PRIVMSG" && msg.Command != "NOTICE" {
378 return false
379 }
380
381 text := msg.Params[1]
382
383 nick := net.Nick
384 if net.conn != nil {
385 nick = net.conn.nick
386 }
387
388 // TODO: use case-mapping aware comparison here
389 return msg.Prefix.Name != nick && isHighlight(text, nick)
390}
391
392func (net *network) detachedMessageNeedsRelay(ch *Channel, msg *irc.Message) bool {
393 highlight := net.isHighlight(msg)
394 return ch.RelayDetached == FilterMessage || ((ch.RelayDetached == FilterHighlight || ch.RelayDetached == FilterDefault) && highlight)
395}
396
397type user struct {
398 User
399 srv *Server
400 logger Logger
401
402 events chan event
403 done chan struct{}
404
405 networks []*network
406 downstreamConns []*downstreamConn
407 msgStore messageStore
408}
409
410func newUser(srv *Server, record *User) *user {
411 logger := &prefixLogger{srv.Logger, fmt.Sprintf("user %q: ", record.Username)}
412
413 var msgStore messageStore
414 if srv.LogPath != "" {
415 msgStore = newFSMessageStore(srv.LogPath, record.Username)
416 } else {
417 msgStore = newMemoryMessageStore()
418 }
419
420 return &user{
421 User: *record,
422 srv: srv,
423 logger: logger,
424 events: make(chan event, 64),
425 done: make(chan struct{}),
426 msgStore: msgStore,
427 }
428}
429
430func (u *user) forEachNetwork(f func(*network)) {
431 for _, network := range u.networks {
432 f(network)
433 }
434}
435
436func (u *user) forEachUpstream(f func(uc *upstreamConn)) {
437 for _, network := range u.networks {
438 if network.conn == nil {
439 continue
440 }
441 f(network.conn)
442 }
443}
444
445func (u *user) forEachDownstream(f func(dc *downstreamConn)) {
446 for _, dc := range u.downstreamConns {
447 f(dc)
448 }
449}
450
451func (u *user) getNetwork(name string) *network {
452 for _, network := range u.networks {
453 if network.Addr == name {
454 return network
455 }
456 if network.Name != "" && network.Name == name {
457 return network
458 }
459 }
460 return nil
461}
462
463func (u *user) getNetworkByID(id int64) *network {
464 for _, net := range u.networks {
465 if net.ID == id {
466 return net
467 }
468 }
469 return nil
470}
471
472func (u *user) run() {
473 defer func() {
474 if u.msgStore != nil {
475 if err := u.msgStore.Close(); err != nil {
476 u.logger.Printf("failed to close message store for user %q: %v", u.Username, err)
477 }
478 }
479 close(u.done)
480 }()
481
482 networks, err := u.srv.db.ListNetworks(context.TODO(), u.ID)
483 if err != nil {
484 u.logger.Printf("failed to list networks for user %q: %v", u.Username, err)
485 return
486 }
487
488 for _, record := range networks {
489 record := record
490 channels, err := u.srv.db.ListChannels(context.TODO(), record.ID)
491 if err != nil {
492 u.logger.Printf("failed to list channels for user %q, network %q: %v", u.Username, record.GetName(), err)
493 continue
494 }
495
496 network := newNetwork(u, &record, channels)
497 u.networks = append(u.networks, network)
498
499 if u.hasPersistentMsgStore() {
500 receipts, err := u.srv.db.ListDeliveryReceipts(context.TODO(), record.ID)
501 if err != nil {
502 u.logger.Printf("failed to load delivery receipts for user %q, network %q: %v", u.Username, network.GetName(), err)
503 return
504 }
505
506 for _, rcpt := range receipts {
507 network.delivered.StoreID(rcpt.Target, rcpt.Client, rcpt.InternalMsgID)
508 }
509 }
510
511 go network.run()
512 }
513
514 for e := range u.events {
515 switch e := e.(type) {
516 case eventUpstreamConnected:
517 uc := e.uc
518
519 uc.network.conn = uc
520
521 uc.updateAway()
522
523 netIDStr := fmt.Sprintf("%v", uc.network.ID)
524 uc.forEachDownstream(func(dc *downstreamConn) {
525 dc.updateSupportedCaps()
526
527 if !dc.caps["soju.im/bouncer-networks"] {
528 sendServiceNOTICE(dc, fmt.Sprintf("connected to %s", uc.network.GetName()))
529 }
530
531 dc.updateNick()
532 dc.updateRealname()
533 })
534 u.forEachDownstream(func(dc *downstreamConn) {
535 if dc.caps["soju.im/bouncer-networks-notify"] {
536 dc.SendMessage(&irc.Message{
537 Prefix: dc.srv.prefix(),
538 Command: "BOUNCER",
539 Params: []string{"NETWORK", netIDStr, "state=connected"},
540 })
541 }
542 })
543 uc.network.lastError = nil
544 case eventUpstreamDisconnected:
545 u.handleUpstreamDisconnected(e.uc)
546 case eventUpstreamConnectionError:
547 net := e.net
548
549 stopped := false
550 select {
551 case <-net.stopped:
552 stopped = true
553 default:
554 }
555
556 if !stopped && (net.lastError == nil || net.lastError.Error() != e.err.Error()) {
557 net.forEachDownstream(func(dc *downstreamConn) {
558 sendServiceNOTICE(dc, fmt.Sprintf("failed connecting/registering to %s: %v", net.GetName(), e.err))
559 })
560 }
561 net.lastError = e.err
562 case eventUpstreamError:
563 uc := e.uc
564
565 uc.forEachDownstream(func(dc *downstreamConn) {
566 sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s: %v", uc.network.GetName(), e.err))
567 })
568 uc.network.lastError = e.err
569 case eventUpstreamMessage:
570 msg, uc := e.msg, e.uc
571 if uc.isClosed() {
572 uc.logger.Printf("ignoring message on closed connection: %v", msg)
573 break
574 }
575 if err := uc.handleMessage(msg); err != nil {
576 uc.logger.Printf("failed to handle message %q: %v", msg, err)
577 }
578 case eventChannelDetach:
579 uc, name := e.uc, e.name
580 c := uc.network.channels.Value(name)
581 if c == nil || c.Detached {
582 continue
583 }
584 uc.network.detach(c)
585 if err := uc.srv.db.StoreChannel(context.TODO(), uc.network.ID, c); err != nil {
586 u.logger.Printf("failed to store updated detached channel %q: %v", c.Name, err)
587 }
588 case eventDownstreamConnected:
589 dc := e.dc
590
591 if err := dc.welcome(); err != nil {
592 dc.logger.Printf("failed to handle new registered connection: %v", err)
593 break
594 }
595
596 u.downstreamConns = append(u.downstreamConns, dc)
597
598 dc.forEachNetwork(func(network *network) {
599 if network.lastError != nil {
600 sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s: %v", network.GetName(), network.lastError))
601 }
602 })
603
604 u.forEachUpstream(func(uc *upstreamConn) {
605 uc.updateAway()
606 })
607 case eventDownstreamDisconnected:
608 dc := e.dc
609
610 for i := range u.downstreamConns {
611 if u.downstreamConns[i] == dc {
612 u.downstreamConns = append(u.downstreamConns[:i], u.downstreamConns[i+1:]...)
613 break
614 }
615 }
616
617 dc.forEachNetwork(func(net *network) {
618 net.storeClientDeliveryReceipts(dc.clientName)
619 })
620
621 u.forEachUpstream(func(uc *upstreamConn) {
622 uc.updateAway()
623 })
624 case eventDownstreamMessage:
625 msg, dc := e.msg, e.dc
626 if dc.isClosed() {
627 dc.logger.Printf("ignoring message on closed connection: %v", msg)
628 break
629 }
630 err := dc.handleMessage(msg)
631 if ircErr, ok := err.(ircError); ok {
632 ircErr.Message.Prefix = dc.srv.prefix()
633 dc.SendMessage(ircErr.Message)
634 } else if err != nil {
635 dc.logger.Printf("failed to handle message %q: %v", msg, err)
636 dc.Close()
637 }
638 case eventBroadcast:
639 msg := e.msg
640 u.forEachDownstream(func(dc *downstreamConn) {
641 dc.SendMessage(msg)
642 })
643 case eventUserUpdate:
644 // copy the user record because we'll mutate it
645 record := u.User
646
647 if e.password != nil {
648 record.Password = *e.password
649 }
650 if e.admin != nil {
651 record.Admin = *e.admin
652 }
653
654 e.done <- u.updateUser(context.TODO(), &record)
655
656 // If the password was updated, kill all downstream connections to
657 // force them to re-authenticate with the new credentials.
658 if e.password != nil {
659 u.forEachDownstream(func(dc *downstreamConn) {
660 dc.Close()
661 })
662 }
663 case eventStop:
664 u.forEachDownstream(func(dc *downstreamConn) {
665 dc.Close()
666 })
667 for _, n := range u.networks {
668 n.stop()
669
670 n.delivered.ForEachClient(func(clientName string) {
671 n.storeClientDeliveryReceipts(clientName)
672 })
673 }
674 return
675 default:
676 panic(fmt.Sprintf("received unknown event type: %T", e))
677 }
678 }
679}
680
681func (u *user) handleUpstreamDisconnected(uc *upstreamConn) {
682 uc.network.conn = nil
683
684 uc.endPendingCommands()
685
686 for _, entry := range uc.channels.innerMap {
687 uch := entry.value.(*upstreamChannel)
688 uch.updateAutoDetach(0)
689 }
690
691 netIDStr := fmt.Sprintf("%v", uc.network.ID)
692 uc.forEachDownstream(func(dc *downstreamConn) {
693 dc.updateSupportedCaps()
694 })
695
696 // If the network has been removed, don't send a state change notification
697 found := false
698 for _, net := range u.networks {
699 if net == uc.network {
700 found = true
701 break
702 }
703 }
704 if !found {
705 return
706 }
707
708 u.forEachDownstream(func(dc *downstreamConn) {
709 if dc.caps["soju.im/bouncer-networks-notify"] {
710 dc.SendMessage(&irc.Message{
711 Prefix: dc.srv.prefix(),
712 Command: "BOUNCER",
713 Params: []string{"NETWORK", netIDStr, "state=disconnected"},
714 })
715 }
716 })
717
718 if uc.network.lastError == nil {
719 uc.forEachDownstream(func(dc *downstreamConn) {
720 if !dc.caps["soju.im/bouncer-networks"] {
721 sendServiceNOTICE(dc, fmt.Sprintf("disconnected from %s", uc.network.GetName()))
722 }
723 })
724 }
725}
726
727func (u *user) addNetwork(network *network) {
728 u.networks = append(u.networks, network)
729 go network.run()
730}
731
732func (u *user) removeNetwork(network *network) {
733 network.stop()
734
735 u.forEachDownstream(func(dc *downstreamConn) {
736 if dc.network != nil && dc.network == network {
737 dc.Close()
738 }
739 })
740
741 for i, net := range u.networks {
742 if net == network {
743 u.networks = append(u.networks[:i], u.networks[i+1:]...)
744 return
745 }
746 }
747
748 panic("tried to remove a non-existing network")
749}
750
751func (u *user) checkNetwork(record *Network) error {
752 for _, net := range u.networks {
753 if net.GetName() == record.GetName() && net.ID != record.ID {
754 return fmt.Errorf("a network with the name %q already exists", record.GetName())
755 }
756 }
757 return nil
758}
759
760func (u *user) createNetwork(ctx context.Context, record *Network) (*network, error) {
761 if record.ID != 0 {
762 panic("tried creating an already-existing network")
763 }
764
765 if err := u.checkNetwork(record); err != nil {
766 return nil, err
767 }
768
769 if u.srv.MaxUserNetworks >= 0 && len(u.networks) >= u.srv.MaxUserNetworks {
770 return nil, fmt.Errorf("maximum number of networks reached")
771 }
772
773 network := newNetwork(u, record, nil)
774 err := u.srv.db.StoreNetwork(ctx, u.ID, &network.Network)
775 if err != nil {
776 return nil, err
777 }
778
779 u.addNetwork(network)
780
781 idStr := fmt.Sprintf("%v", network.ID)
782 attrs := getNetworkAttrs(network)
783 u.forEachDownstream(func(dc *downstreamConn) {
784 if dc.caps["soju.im/bouncer-networks-notify"] {
785 dc.SendMessage(&irc.Message{
786 Prefix: dc.srv.prefix(),
787 Command: "BOUNCER",
788 Params: []string{"NETWORK", idStr, attrs.String()},
789 })
790 }
791 })
792
793 return network, nil
794}
795
796func (u *user) updateNetwork(ctx context.Context, record *Network) (*network, error) {
797 if record.ID == 0 {
798 panic("tried updating a new network")
799 }
800
801 // If the realname is reset to the default, just wipe the per-network
802 // setting
803 if record.Realname == u.Realname {
804 record.Realname = ""
805 }
806
807 if err := u.checkNetwork(record); err != nil {
808 return nil, err
809 }
810
811 network := u.getNetworkByID(record.ID)
812 if network == nil {
813 panic("tried updating a non-existing network")
814 }
815
816 if err := u.srv.db.StoreNetwork(ctx, u.ID, record); err != nil {
817 return nil, err
818 }
819
820 // Most network changes require us to re-connect to the upstream server
821
822 channels := make([]Channel, 0, network.channels.Len())
823 for _, entry := range network.channels.innerMap {
824 ch := entry.value.(*Channel)
825 channels = append(channels, *ch)
826 }
827
828 updatedNetwork := newNetwork(u, record, channels)
829
830 // If we're currently connected, disconnect and perform the necessary
831 // bookkeeping
832 if network.conn != nil {
833 network.stop()
834 // Note: this will set network.conn to nil
835 u.handleUpstreamDisconnected(network.conn)
836 }
837
838 // Patch downstream connections to use our fresh updated network
839 u.forEachDownstream(func(dc *downstreamConn) {
840 if dc.network != nil && dc.network == network {
841 dc.network = updatedNetwork
842 }
843 })
844
845 // We need to remove the network after patching downstream connections,
846 // otherwise they'll get closed
847 u.removeNetwork(network)
848
849 // The filesystem message store needs to be notified whenever the network
850 // is renamed
851 fsMsgStore, isFS := u.msgStore.(*fsMessageStore)
852 if isFS && updatedNetwork.GetName() != network.GetName() {
853 if err := fsMsgStore.RenameNetwork(&network.Network, &updatedNetwork.Network); err != nil {
854 network.logger.Printf("failed to update FS message store network name to %q: %v", updatedNetwork.GetName(), err)
855 }
856 }
857
858 // This will re-connect to the upstream server
859 u.addNetwork(updatedNetwork)
860
861 // TODO: only broadcast attributes that have changed
862 idStr := fmt.Sprintf("%v", updatedNetwork.ID)
863 attrs := getNetworkAttrs(updatedNetwork)
864 u.forEachDownstream(func(dc *downstreamConn) {
865 if dc.caps["soju.im/bouncer-networks-notify"] {
866 dc.SendMessage(&irc.Message{
867 Prefix: dc.srv.prefix(),
868 Command: "BOUNCER",
869 Params: []string{"NETWORK", idStr, attrs.String()},
870 })
871 }
872 })
873
874 return updatedNetwork, nil
875}
876
877func (u *user) deleteNetwork(ctx context.Context, id int64) error {
878 network := u.getNetworkByID(id)
879 if network == nil {
880 panic("tried deleting a non-existing network")
881 }
882
883 if err := u.srv.db.DeleteNetwork(ctx, network.ID); err != nil {
884 return err
885 }
886
887 u.removeNetwork(network)
888
889 idStr := fmt.Sprintf("%v", network.ID)
890 u.forEachDownstream(func(dc *downstreamConn) {
891 if dc.caps["soju.im/bouncer-networks-notify"] {
892 dc.SendMessage(&irc.Message{
893 Prefix: dc.srv.prefix(),
894 Command: "BOUNCER",
895 Params: []string{"NETWORK", idStr, "*"},
896 })
897 }
898 })
899
900 return nil
901}
902
903func (u *user) updateUser(ctx context.Context, record *User) error {
904 if u.ID != record.ID {
905 panic("ID mismatch when updating user")
906 }
907
908 realnameUpdated := u.Realname != record.Realname
909 if err := u.srv.db.StoreUser(ctx, record); err != nil {
910 return fmt.Errorf("failed to update user %q: %v", u.Username, err)
911 }
912 u.User = *record
913
914 if realnameUpdated {
915 // Re-connect to networks which use the default realname
916 var needUpdate []Network
917 u.forEachNetwork(func(net *network) {
918 if net.Realname == "" {
919 needUpdate = append(needUpdate, net.Network)
920 }
921 })
922
923 var netErr error
924 for _, net := range needUpdate {
925 if _, err := u.updateNetwork(ctx, &net); err != nil {
926 netErr = err
927 }
928 }
929 if netErr != nil {
930 return netErr
931 }
932 }
933
934 return nil
935}
936
937func (u *user) stop() {
938 u.events <- eventStop{}
939 <-u.done
940}
941
942func (u *user) hasPersistentMsgStore() bool {
943 if u.msgStore == nil {
944 return false
945 }
946 _, isMem := u.msgStore.(*memoryMessageStore)
947 return !isMem
948}
Note: See TracBrowser for help on using the repository browser.