Changeset 37 in code


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

Per-user connections

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/cmd/jounce/main.go

    r19 r37  
    1616        }
    1717
     18        srv := jounce.NewServer()
    1819        // TODO: load from config/DB
    19         s := jounce.Server{
    20                 Hostname: "localhost",
    21                 Logger:   log.New(log.Writer(), "", log.LstdFlags),
    22                 Upstreams: []jounce.Upstream{{
    23                         Addr:     "chat.freenode.net:6697",
    24                         Nick:     "jounce",
    25                         Username: "jounce",
    26                         Realname: "jounce",
    27                         Channels: []string{"#jounce"},
    28                 }},
    29         }
     20        srv.Hostname = "localhost"
     21        srv.Upstreams = []jounce.Upstream{{
     22                Addr:     "chat.freenode.net:6697",
     23                Nick:     "jounce",
     24                Username: "jounce",
     25                Realname: "jounce",
     26                Channels: []string{"#jounce"},
     27        }}
    3028
    3129        log.Printf("Server listening on %v", addr)
    32         go s.Run()
    33         log.Fatal(s.Serve(ln))
     30        go srv.Run()
     31        log.Fatal(srv.Serve(ln))
    3432}

  • trunk/downstream.go

    r31 r37  
    4747
    4848        registered bool
     49        user       *user
    4950        closed     bool
    5051        nick       string
    … …  
    167168
    168169func (c *downstreamConn) register() error {
     170        c.srv.lock.Lock()
     171        u, ok := c.srv.users[c.username]
     172        c.srv.lock.Unlock()
     173
     174        if !ok {
     175                c.messages <- &irc.Message{
     176                        Prefix:  c.srv.prefix(),
     177                        Command: irc.ERR_PASSWDMISMATCH,
     178                        Params:  []string{"*", "Invalid username or password"},
     179                }
     180                return nil
     181        }
     182
    169183        c.registered = true
     184        c.user = u
    170185
    171186        c.messages <- &irc.Message{
    … …  
    174189                Params:  []string{c.nick, "Welcome to jounce, " + c.nick},
    175190        }
    176 
    177191        c.messages <- &irc.Message{
    178192                Prefix:  c.srv.prefix(),
    … …  
    180194                Params:  []string{c.nick, "Your host is " + c.srv.Hostname},
    181195        }
    182 
    183196        c.messages <- &irc.Message{
    184197                Prefix:  c.srv.prefix(),
    … …  
    186199                Params:  []string{c.nick, "This server was created <datetime>"}, // TODO
    187200        }
    188 
    189201        c.messages <- &irc.Message{
    190202                Prefix:  c.srv.prefix(),
    … …  
    192204                Params:  []string{c.nick, c.srv.Hostname, "jounce", "aiwroO", "OovaimnqpsrtklbeI"},
    193205        }
    194 
    195206        c.messages <- &irc.Message{
    196207                Prefix:  c.srv.prefix(),
    … …  
    199210        }
    200211
    201         c.srv.lock.Lock()
    202         for _, uc := range c.srv.upstreamConns {
     212        u.lock.Lock()
     213        for _, uc := range u.upstreamConns {
    203214                // TODO: fix races accessing upstream connection data
    204215                if !uc.registered {
    … …  
    211222                }
    212223        }
    213         c.srv.lock.Unlock()
     224        u.lock.Unlock()
    214225
    215226        return nil

  • trunk/server.go

    r29 r37  
    33import (
    44        "fmt"
     5        "log"
    56        "net"
    67        "sync"
    … …  
    3132}
    3233
     34type user struct {
     35        username string
     36        srv      *Server
     37
     38        lock          sync.Mutex
     39        upstreamConns []*upstreamConn
     40}
     41
    3342type Upstream struct {
    3443        Addr     string
    … …  
    4554
    4655        lock            sync.Mutex
     56        users           map[string]*user
    4757        downstreamConns []*downstreamConn
    48         upstreamConns   []*upstreamConn
     58}
     59
     60func NewServer() *Server {
     61        return &Server{
     62                Logger: log.New(log.Writer(), "", log.LstdFlags),
     63                users:  make(map[string]*user),
     64        }
    4965}
    5066
    … …  
    5470
    5571func (s *Server) Run() {
     72        // TODO: multi-user
     73        u := &user{username: "jounce", srv: s}
     74
     75        s.lock.Lock()
     76        s.users[u.username] = u
     77        s.lock.Unlock()
     78
    5679        for i := range s.Upstreams {
    5780                upstream := &s.Upstreams[i]
    5881                // TODO: retry connecting
    5982                go func() {
    60                         conn, err := connectToUpstream(s, upstream)
     83                        conn, err := connectToUpstream(u, upstream)
    6184                        if err != nil {
    6285                                s.Logger.Printf("failed to connect to upstream server %q: %v", upstream.Addr, err)
    … …  
    6487                        }
    6588
    66                         s.lock.Lock()
    67                         s.upstreamConns = append(s.upstreamConns, conn)
    68                         s.lock.Unlock()
     89                        u.lock.Lock()
     90                        u.upstreamConns = append(u.upstreamConns, conn)
     91                        u.lock.Unlock()
    6992
    7093                        if err := conn.readMessages(); err != nil {
    … …  
    7295                        }
    7396
    74                         s.lock.Lock()
    75                         for i, c := range s.upstreamConns {
     97                        u.lock.Lock()
     98                        for i, c := range u.upstreamConns {
    7699                                if c == conn {
    77                                         s.upstreamConns = append(s.upstreamConns[:i], s.upstreamConns[i+1:]...)
     100                                        u.upstreamConns = append(u.upstreamConns[:i], u.upstreamConns[i+1:]...)
    78101                                        break
    79102                                }
    80103                        }
    81                         s.lock.Unlock()
     104                        u.lock.Unlock()
    82105                }()
    83106        }

  • trunk/upstream.go

    r36 r37  
    3030        irc      *irc.Conn
    3131        srv      *Server
     32        user     *user
    3233        messages chan<- *irc.Message
    3334
    … …  
    4344}
    4445
    45 func connectToUpstream(s *Server, upstream *Upstream) (*upstreamConn, error) {
    46         logger := &prefixLogger{s.Logger, fmt.Sprintf("upstream %q: ", upstream.Addr)}
     46func connectToUpstream(u *user, upstream *Upstream) (*upstreamConn, error) {
     47        logger := &prefixLogger{u.srv.Logger, fmt.Sprintf("upstream %q: ", upstream.Addr)}
    4748        logger.Printf("connecting to server")
    4849
    … …  
    5859                net:      netConn,
    5960                irc:      irc.NewConn(netConn),
    60                 srv:      s,
     61                srv:      u.srv,
     62                user:     u,
    6163                messages: msgs,
    6264                channels: make(map[string]*upstreamChannel),
Note: See TracChangeset for help on using the changeset viewer.