Changeset 101 in code for trunk/server.go


Ignore:
Timestamp:
Mar 16, 2020, 10:18:41 AM (5 years ago)
Author:
contact
Message:

Split user logic into its own file

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/server.go

    r98 r101  
    4646        v = append([]interface{}{l.prefix}, v...)
    4747        l.logger.Printf("%v"+format, v...)
    48 }
    49 
    50 type network struct {
    51         Network
    52         user *user
    53         conn *upstreamConn
    54 }
    55 
    56 func newNetwork(user *user, record *Network) *network {
    57         return &network{
    58                 Network: *record,
    59                 user:    user,
    60         }
    61 }
    62 
    63 func (net *network) run() {
    64         var lastTry time.Time
    65         for {
    66                 if dur := time.Now().Sub(lastTry); dur < retryConnectMinDelay {
    67                         delay := retryConnectMinDelay - dur
    68                         net.user.srv.Logger.Printf("waiting %v before trying to reconnect to %q", delay.Truncate(time.Second), net.Addr)
    69                         time.Sleep(delay)
    70                 }
    71                 lastTry = time.Now()
    72 
    73                 uc, err := connectToUpstream(net)
    74                 if err != nil {
    75                         net.user.srv.Logger.Printf("failed to connect to upstream server %q: %v", net.Addr, err)
    76                         continue
    77                 }
    78 
    79                 uc.register()
    80 
    81                 net.user.lock.Lock()
    82                 net.conn = uc
    83                 net.user.lock.Unlock()
    84 
    85                 if err := uc.readMessages(); err != nil {
    86                         uc.logger.Printf("failed to handle messages: %v", err)
    87                 }
    88                 uc.Close()
    89 
    90                 net.user.lock.Lock()
    91                 net.conn = nil
    92                 net.user.lock.Unlock()
    93         }
    94 }
    95 
    96 type user struct {
    97         User
    98         srv *Server
    99 
    100         lock            sync.Mutex
    101         networks        []*network
    102         downstreamConns []*downstreamConn
    103 }
    104 
    105 func newUser(srv *Server, record *User) *user {
    106         return &user{
    107                 User: *record,
    108                 srv:  srv,
    109         }
    110 }
    111 
    112 func (u *user) forEachNetwork(f func(*network)) {
    113         u.lock.Lock()
    114         for _, network := range u.networks {
    115                 f(network)
    116         }
    117         u.lock.Unlock()
    118 }
    119 
    120 func (u *user) forEachUpstream(f func(uc *upstreamConn)) {
    121         u.lock.Lock()
    122         for _, network := range u.networks {
    123                 uc := network.conn
    124                 if uc == nil || !uc.registered || uc.closed {
    125                         continue
    126                 }
    127                 f(uc)
    128         }
    129         u.lock.Unlock()
    130 }
    131 
    132 func (u *user) forEachDownstream(f func(dc *downstreamConn)) {
    133         u.lock.Lock()
    134         for _, dc := range u.downstreamConns {
    135                 f(dc)
    136         }
    137         u.lock.Unlock()
    138 }
    139 
    140 func (u *user) getNetwork(name string) *network {
    141         for _, network := range u.networks {
    142                 if network.Addr == name {
    143                         return network
    144                 }
    145         }
    146         return nil
    147 }
    148 
    149 func (u *user) run() {
    150         networks, err := u.srv.db.ListNetworks(u.Username)
    151         if err != nil {
    152                 u.srv.Logger.Printf("failed to list networks for user %q: %v", u.Username, err)
    153                 return
    154         }
    155 
    156         u.lock.Lock()
    157         for _, record := range networks {
    158                 network := newNetwork(u, &record)
    159                 u.networks = append(u.networks, network)
    160 
    161                 go network.run()
    162         }
    163         u.lock.Unlock()
    164 }
    165 
    166 func (u *user) createNetwork(addr, nick string) (*network, error) {
    167         network := newNetwork(u, &Network{
    168                 Addr: addr,
    169                 Nick: nick,
    170         })
    171         err := u.srv.db.StoreNetwork(u.Username, &network.Network)
    172         if err != nil {
    173                 return nil, err
    174         }
    175         u.lock.Lock()
    176         u.networks = append(u.networks, network)
    177         u.lock.Unlock()
    178         go network.run()
    179         return network, nil
    18048}
    18149
Note: See TracChangeset for help on using the changeset viewer.