Changeset 69 in code for trunk/downstream.go


Ignore:
Timestamp:
Feb 19, 2020, 5:25:19 PM (5 years ago)
Author:
contact
Message:

Add functions to translate between upstream and downstream names

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/downstream.go

    r68 r69  
    4040}
    4141
     42type consumption struct {
     43        consumer     *RingConsumer
     44        upstreamConn *upstreamConn
     45}
     46
    4247type downstreamConn struct {
    43         net       net.Conn
    44         irc       *irc.Conn
    45         srv       *Server
    46         logger    Logger
    47         messages  chan *irc.Message
    48         consumers chan *RingConsumer
    49         closed    chan struct{}
     48        net          net.Conn
     49        irc          *irc.Conn
     50        srv          *Server
     51        logger       Logger
     52        messages     chan *irc.Message
     53        consumptions chan consumption
     54        closed       chan struct{}
    5055
    5156        registered bool
    … …  
    5863func newDownstreamConn(srv *Server, netConn net.Conn) *downstreamConn {
    5964        dc := &downstreamConn{
    60                 net:       netConn,
    61                 irc:       irc.NewConn(netConn),
    62                 srv:       srv,
    63                 logger:    &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", netConn.RemoteAddr())},
    64                 messages:  make(chan *irc.Message, 64),
    65                 consumers: make(chan *RingConsumer),
    66                 closed:    make(chan struct{}),
     65                net:          netConn,
     66                irc:          irc.NewConn(netConn),
     67                srv:          srv,
     68                logger:       &prefixLogger{srv.Logger, fmt.Sprintf("downstream %q: ", netConn.RemoteAddr())},
     69                messages:     make(chan *irc.Message, 64),
     70                consumptions: make(chan consumption),
     71                closed:       make(chan struct{}),
    6772        }
    6873
    … …  
    8792                // TODO: fill the host?
    8893        }
     94}
     95
     96func (dc *downstreamConn) marshalChannel(uc *upstreamConn, name string) string {
     97        return name
     98}
     99
     100func (dc *downstreamConn) unmarshalChannel(name string) (*upstreamConn, string, error) {
     101        // TODO: extract network name from channel name
     102        ch, err := dc.user.getChannel(name)
     103        if err != nil {
     104                return nil, "", err
     105        }
     106        return ch.conn, ch.Name, nil
     107}
     108
     109func (dc *downstreamConn) marshalNick(uc *upstreamConn, nick string) string {
     110        if nick == uc.nick {
     111                return dc.nick
     112        }
     113        return nick
     114}
     115
     116func (dc *downstreamConn) marshalUserPrefix(uc *upstreamConn, prefix *irc.Prefix) *irc.Prefix {
     117        if prefix.Name == uc.nick {
     118                return dc.prefix()
     119        }
     120        return prefix
    89121}
    90122
    … …  
    139171                        }
    140172                        err = dc.irc.WriteMessage(msg)
    141                 case consumer := <-dc.consumers:
     173                case consumption := <-dc.consumptions:
     174                        consumer, uc := consumption.consumer, consumption.upstreamConn
    142175                        for {
    143176                                msg := consumer.Peek()
    144177                                if msg == nil {
    145178                                        break
     179                                }
     180                                msg = msg.Copy()
     181                                switch msg.Command {
     182                                case "PRIVMSG":
     183                                        // TODO: detect whether it's a user or a channel
     184                                        msg.Params[0] = dc.marshalChannel(uc, msg.Params[0])
     185                                default:
     186                                        panic("expected to consume a PRIVMSG message")
    146187                                }
    147188                                if dc.srv.Debug {
    … …  
    304345                                select {
    305346                                case <-ch:
    306                                         dc.consumers <- consumer
     347                                        dc.consumptions <- consumption{consumer, uc}
    307348                                case <-dc.closed:
    308349                                        closed = true
    … …  
    339380                        uc.SendMessage(msg)
    340381                })
    341         case "JOIN":
     382        case "JOIN", "PART":
    342383                var name string
    343384                if err := parseMessageParams(msg, &name); err != nil {
    … …  
    345386                }
    346387
    347                 if ch, _ := dc.user.getChannel(name); ch != nil {
    348                         break // already joined
    349                 }
    350 
    351                 // TODO: extract network name from channel name
    352                 return ircError{&irc.Message{
    353                         Command: irc.ERR_NOSUCHCHANNEL,
    354                         Params:  []string{name, "Channel name ambiguous"},
    355                 }}
    356         case "PART":
    357                 var name string
    358                 if err := parseMessageParams(msg, &name); err != nil {
    359                         return err
    360                 }
    361 
    362                 ch, err := dc.user.getChannel(name)
     388                uc, upstreamName, err := dc.unmarshalChannel(name)
    363389                if err != nil {
    364                         return err
    365                 }
    366 
    367                 ch.conn.SendMessage(msg)
    368                 // TODO: remove channel from upstream config
     390                        return ircError{&irc.Message{
     391                                Command: irc.ERR_NOSUCHCHANNEL,
     392                                Params:  []string{name, err.Error()},
     393                        }}
     394                }
     395
     396                uc.SendMessage(&irc.Message{
     397                        Command: msg.Command,
     398                        Params:  []string{upstreamName},
     399                })
     400                // TODO: add/remove channel from upstream config
    369401        case "MODE":
     402                if msg.Prefix == nil {
     403                        return fmt.Errorf("missing prefix")
     404                }
     405
    370406                var name string
    371407                if err := parseMessageParams(msg, &name); err != nil {
    … …  
    379415
    380416                if msg.Prefix.Name != name {
    381                         ch, err := dc.user.getChannel(name)
     417                        uc, upstreamName, err := dc.unmarshalChannel(name)
    382418                        if err != nil {
    383419                                return err
    … …  
    385421
    386422                        if modeStr != "" {
    387                                 ch.conn.SendMessage(msg)
     423                                uc.SendMessage(&irc.Message{
     424                                        Prefix:  uc.prefix(),
     425                                        Command: "MODE",
     426                                        Params:  []string{upstreamName, modeStr},
     427                                })
    388428                        } else {
     429                                ch, ok := uc.channels[upstreamName]
     430                                if !ok {
     431                                        return ircError{&irc.Message{
     432                                                Command: irc.ERR_NOSUCHCHANNEL,
     433                                                Params:  []string{name, "No such channel"},
     434                                        }}
     435                                }
     436
    389437                                dc.SendMessage(&irc.Message{
    390438                                        Prefix:  dc.srv.prefix(),
    391439                                        Command: irc.RPL_CHANNELMODEIS,
    392                                         Params:  []string{ch.Name, string(ch.modes)},
     440                                        Params:  []string{name, string(ch.modes)},
    393441                                })
    394442                        }
    … …  
    403451                        if modeStr != "" {
    404452                                dc.user.forEachUpstream(func(uc *upstreamConn) {
    405                                         uc.SendMessage(msg)
     453                                        uc.SendMessage(&irc.Message{
     454                                                Prefix:  uc.prefix(),
     455                                                Command: "MODE",
     456                                                Params:  []string{uc.nick, modeStr},
     457                                        })
    406458                                })
    407459                        } else {
    … …  
    420472
    421473                for _, name := range strings.Split(targetsStr, ",") {
    422                         ch, err := dc.user.getChannel(name)
     474                        uc, upstreamName, err := dc.unmarshalChannel(name)
    423475                        if err != nil {
    424476                                return err
    425477                        }
    426478
    427                         ch.conn.SendMessage(&irc.Message{
    428                                 Prefix:  msg.Prefix,
     479                        uc.SendMessage(&irc.Message{
     480                                Prefix:  uc.prefix(),
    429481                                Command: "PRIVMSG",
    430                                 Params:  []string{name, text},
     482                                Params:  []string{upstreamName, text},
    431483                        })
    432484                }
Note: See TracChangeset for help on using the changeset viewer.