Changeset 55 in code for trunk/upstream.go


Ignore:
Timestamp:
Feb 17, 2020, 11:36:42 AM (5 years ago)
Author:
contact
Message:

Abbreviate {upstream,downstream}Conn with uc and dc

This makes it clearer than just c when we manipulate both kinds at the
same time.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/upstream.go

    r54 r55  
    5757
    5858        msgs := make(chan *irc.Message, 64)
    59         conn := &upstreamConn{
     59        uc := &upstreamConn{
    6060                upstream: upstream,
    6161                logger:   logger,
    … …  
    7171        go func() {
    7272                for msg := range msgs {
    73                         if err := conn.irc.WriteMessage(msg); err != nil {
    74                                 conn.logger.Printf("failed to write message: %v", err)
    75                         }
    76                 }
    77                 if err := conn.net.Close(); err != nil {
    78                         conn.logger.Printf("failed to close connection: %v", err)
     73                        if err := uc.irc.WriteMessage(msg); err != nil {
     74                                uc.logger.Printf("failed to write message: %v", err)
     75                        }
     76                }
     77                if err := uc.net.Close(); err != nil {
     78                        uc.logger.Printf("failed to close connection: %v", err)
    7979                } else {
    80                         conn.logger.Printf("connection closed")
     80                        uc.logger.Printf("connection closed")
    8181                }
    8282        }()
    8383
    84         return conn, nil
    85 }
    86 
    87 func (c *upstreamConn) Close() error {
    88         if c.closed {
     84        return uc, nil
     85}
     86
     87func (uc *upstreamConn) Close() error {
     88        if uc.closed {
    8989                return fmt.Errorf("upstream connection already closed")
    9090        }
    91         close(c.messages)
    92         c.closed = true
     91        close(uc.messages)
     92        uc.closed = true
    9393        return nil
    9494}
    9595
    96 func (c *upstreamConn) getChannel(name string) (*upstreamChannel, error) {
    97         ch, ok := c.channels[name]
     96func (uc *upstreamConn) getChannel(name string) (*upstreamChannel, error) {
     97        ch, ok := uc.channels[name]
    9898        if !ok {
    9999                return nil, fmt.Errorf("unknown channel %q", name)
    … …  
    102102}
    103103
    104 func (c *upstreamConn) handleMessage(msg *irc.Message) error {
     104func (uc *upstreamConn) handleMessage(msg *irc.Message) error {
    105105        switch msg.Command {
    106106        case "PING":
    107107                // TODO: handle params
    108                 c.messages <- &irc.Message{
     108                uc.messages <- &irc.Message{
    109109                        Command: "PONG",
    110                         Params:  []string{c.srv.Hostname},
     110                        Params:  []string{uc.srv.Hostname},
    111111                }
    112112                return nil
    … …  
    118118
    119119                if name == msg.Prefix.Name { // user mode change
    120                         if name != c.nick {
     120                        if name != uc.nick {
    121121                                return fmt.Errorf("received MODE message for unknow nick %q", name)
    122122                        }
    123                         return c.modes.Apply(modeStr)
     123                        return uc.modes.Apply(modeStr)
    124124                } else { // channel mode change
    125                         ch, err := c.getChannel(name)
     125                        ch, err := uc.getChannel(name)
    126126                        if err != nil {
    127127                                return err
    … …  
    132132                }
    133133
    134                 c.user.forEachDownstream(func(dc *downstreamConn) {
     134                uc.user.forEachDownstream(func(dc *downstreamConn) {
    135135                        dc.SendMessage(msg)
    136136                })
    137137        case "NOTICE":
    138                 c.logger.Print(msg)
     138                uc.logger.Print(msg)
    139139        case irc.RPL_WELCOME:
    140                 c.registered = true
    141                 c.logger.Printf("connection registered")
    142 
    143                 for _, ch := range c.upstream.Channels {
    144                         c.messages <- &irc.Message{
     140                uc.registered = true
     141                uc.logger.Printf("connection registered")
     142
     143                for _, ch := range uc.upstream.Channels {
     144                        uc.messages <- &irc.Message{
    145145                                Command: "JOIN",
    146146                                Params:  []string{ch},
    … …  
    148148                }
    149149        case irc.RPL_MYINFO:
    150                 if err := parseMessageParams(msg, nil, &c.serverName, nil, &c.availableUserModes, &c.availableChannelModes); err != nil {
     150                if err := parseMessageParams(msg, nil, &uc.serverName, nil, &uc.availableUserModes, &uc.availableChannelModes); err != nil {
    151151                        return err
    152152                }
    153153                if len(msg.Params) > 5 {
    154                         c.channelModesWithParam = msg.Params[5]
     154                        uc.channelModesWithParam = msg.Params[5]
    155155                }
    156156        case "NICK":
    … …  
    160160                }
    161161
    162                 if msg.Prefix.Name == c.nick {
    163                         c.logger.Printf("changed nick from %q to %q", c.nick, newNick)
    164                         c.nick = newNick
    165                 }
    166 
    167                 for _, ch := range c.channels {
     162                if msg.Prefix.Name == uc.nick {
     163                        uc.logger.Printf("changed nick from %q to %q", uc.nick, newNick)
     164                        uc.nick = newNick
     165                }
     166
     167                for _, ch := range uc.channels {
    168168                        if membership, ok := ch.Members[msg.Prefix.Name]; ok {
    169169                                delete(ch.Members, msg.Prefix.Name)
    … …  
    172172                }
    173173
    174                 c.user.forEachDownstream(func(dc *downstreamConn) {
     174                uc.user.forEachDownstream(func(dc *downstreamConn) {
    175175                        dc.SendMessage(msg)
    176176                })
    … …  
    182182
    183183                for _, ch := range strings.Split(channels, ",") {
    184                         if msg.Prefix.Name == c.nick {
    185                                 c.logger.Printf("joined channel %q", ch)
    186                                 c.channels[ch] = &upstreamChannel{
     184                        if msg.Prefix.Name == uc.nick {
     185                                uc.logger.Printf("joined channel %q", ch)
     186                                uc.channels[ch] = &upstreamChannel{
    187187                                        Name:    ch,
    188                                         conn:    c,
     188                                        conn:    uc,
    189189                                        Members: make(map[string]membership),
    190190                                }
    191191                        } else {
    192                                 ch, err := c.getChannel(ch)
     192                                ch, err := uc.getChannel(ch)
    193193                                if err != nil {
    194194                                        return err
    … …  
    198198                }
    199199
    200                 c.user.forEachDownstream(func(dc *downstreamConn) {
     200                uc.user.forEachDownstream(func(dc *downstreamConn) {
    201201                        dc.SendMessage(msg)
    202202                })
    … …  
    208208
    209209                for _, ch := range strings.Split(channels, ",") {
    210                         if msg.Prefix.Name == c.nick {
    211                                 c.logger.Printf("parted channel %q", ch)
    212                                 delete(c.channels, ch)
     210                        if msg.Prefix.Name == uc.nick {
     211                                uc.logger.Printf("parted channel %q", ch)
     212                                delete(uc.channels, ch)
    213213                        } else {
    214                                 ch, err := c.getChannel(ch)
     214                                ch, err := uc.getChannel(ch)
    215215                                if err != nil {
    216216                                        return err
    … …  
    220220                }
    221221
    222                 c.user.forEachDownstream(func(dc *downstreamConn) {
     222                uc.user.forEachDownstream(func(dc *downstreamConn) {
    223223                        dc.SendMessage(msg)
    224224                })
    … …  
    228228                        return err
    229229                }
    230                 ch, err := c.getChannel(name)
     230                ch, err := uc.getChannel(name)
    231231                if err != nil {
    232232                        return err
    … …  
    242242                        return err
    243243                }
    244                 ch, err := c.getChannel(name)
     244                ch, err := uc.getChannel(name)
    245245                if err != nil {
    246246                        return err
    … …  
    256256                        return err
    257257                }
    258                 ch, err := c.getChannel(name)
     258                ch, err := uc.getChannel(name)
    259259                if err != nil {
    260260                        return err
    … …  
    271271                        return err
    272272                }
    273                 ch, err := c.getChannel(name)
     273                ch, err := uc.getChannel(name)
    274274                if err != nil {
    275275                        return err
    … …  
    291291                        return err
    292292                }
    293                 ch, err := c.getChannel(name)
     293                ch, err := uc.getChannel(name)
    294294                if err != nil {
    295295                        return err
    … …  
    301301                ch.complete = true
    302302
    303                 c.user.forEachDownstream(func(dc *downstreamConn) {
     303                uc.user.forEachDownstream(func(dc *downstreamConn) {
    304304                        forwardChannel(dc, ch)
    305305                })
    306306        case "PRIVMSG":
    307                 c.ring.Produce(msg)
    308                 c.user.forEachDownstream(func(dc *downstreamConn) {
     307                uc.ring.Produce(msg)
     308                uc.user.forEachDownstream(func(dc *downstreamConn) {
    309309                        dc.SendMessage(msg)
    310310                })
    … …  
    320320                // Ignore
    321321        default:
    322                 c.logger.Printf("unhandled upstream message: %v", msg)
     322                uc.logger.Printf("unhandled upstream message: %v", msg)
    323323        }
    324324        return nil
    325325}
    326326
    327 func (c *upstreamConn) register() {
    328         c.nick = c.upstream.Nick
    329         c.messages <- &irc.Message{
     327func (uc *upstreamConn) register() {
     328        uc.nick = uc.upstream.Nick
     329        uc.messages <- &irc.Message{
    330330                Command: "NICK",
    331                 Params:  []string{c.upstream.Nick},
    332         }
    333         c.messages <- &irc.Message{
     331                Params:  []string{uc.upstream.Nick},
     332        }
     333        uc.messages <- &irc.Message{
    334334                Command: "USER",
    335                 Params:  []string{c.upstream.Username, "0", "*", c.upstream.Realname},
    336         }
    337 }
    338 
    339 func (c *upstreamConn) readMessages() error {
     335                Params:  []string{uc.upstream.Username, "0", "*", uc.upstream.Realname},
     336        }
     337}
     338
     339func (uc *upstreamConn) readMessages() error {
    340340        for {
    341                 msg, err := c.irc.ReadMessage()
     341                msg, err := uc.irc.ReadMessage()
    342342                if err == io.EOF {
    343343                        break
    … …  
    346346                }
    347347
    348                 if err := c.handleMessage(msg); err != nil {
    349                         c.logger.Printf("failed to handle message %q: %v", msg, err)
     348                if err := uc.handleMessage(msg); err != nil {
     349                        uc.logger.Printf("failed to handle message %q: %v", msg, err)
    350350                }
    351351        }
Note: See TracChangeset for help on using the changeset viewer.