client.go

   1 package main
   2
   3 import (
   4         "errors"
   5         "github.com/anon55555/mt"
   6         "github.com/dragonfireclient/hydra-dragonfire/convert"
   7         "github.com/yuin/gopher-lua"
   8         "net"
   9         "sync"
  10 )
  11
  12 type clientState uint8
  13
  14 const (
  15         csNew clientState = iota
  16         csConnected
  17         csDisconnected
  18 )
  19
  20 type Component interface {
  21         create(client *Client, l *lua.LState)
  22         push() lua.LValue
  23         connect()
  24         process(pkt *mt.Pkt)
  25 }
  26
  27 type Client struct {
  28         mu         sync.Mutex
  29         address    string
  30         state      clientState
  31         conn       mt.Peer
  32         queue      chan *mt.Pkt
  33         wildcard   bool
  34         subscribed map[string]struct{}
  35         components map[string]Component
  36         userdata   *lua.LUserData
  37 }
  38
  39 var clientFuncs = map[string]lua.LGFunction{
  40         "address":     l_client_address,
  41         "state":       l_client_state,
  42         "connect":     l_client_connect,
  43         "poll":        l_client_poll,
  44         "close":       l_client_close,
  45         "enable":      l_client_enable,
  46         "subscribe":   l_client_subscribe,
  47         "unsubscribe": l_client_unsubscribe,
  48         "wildcard":    l_client_wildcard,
  49         "send":        l_client_send,
  50 }
  51
  52 func getClient(l *lua.LState) *Client {
  53         return l.CheckUserData(1).Value.(*Client)
  54 }
  55
  56 func getClients(l *lua.LState) []*Client {
  57         tbl := l.CheckTable(1)
  58         n := tbl.MaxN()
  59
  60         clients := make([]*Client, 0, n)
  61         for i := 1; i <= n; i++ {
  62                 clients = append(clients, l.RawGetInt(tbl, i).(*lua.LUserData).Value.(*Client))
  63         }
  64
  65         return clients
  66 }
  67
  68 func getStrings(l *lua.LState) []string {
  69         n := l.GetTop()
  70
  71         strs := make([]string, 0, n-1)
  72         for i := 2; i <= n; i++ {
  73                 strs = append(strs, l.CheckString(i))
  74         }
  75
  76         return strs
  77 }
  78
  79 func (client *Client) closeConn() {
  80         client.mu.Lock()
  81         defer client.mu.Unlock()
  82
  83         if client.state == csConnected {
  84                 client.conn.Close()
  85         }
  86 }
  87
  88 func l_client(l *lua.LState) int {
  89         client := &Client{}
  90
  91         client.address = l.CheckString(1)
  92         client.state = csNew
  93         client.wildcard = false
  94         client.subscribed = map[string]struct{}{}
  95         client.components = map[string]Component{}
  96         client.userdata = l.NewUserData()
  97         client.userdata.Value = client
  98         l.SetMetatable(client.userdata, l.GetTypeMetatable("hydra.client"))
  99
 100         l.Push(client.userdata)
 101         return 1
 102 }
 103
 104 func l_client_index(l *lua.LState) int {
 105         client := getClient(l)
 106         key := l.CheckString(2)
 107
 108         if fun, exists := clientFuncs[key]; exists {
 109                 l.Push(l.NewFunction(fun))
 110         } else if component, exists := client.components[key]; exists {
 111                 l.Push(component.push())
 112         } else {
 113                 l.Push(lua.LNil)
 114         }
 115
 116         return 1
 117 }
 118
 119 func l_client_address(l *lua.LState) int {
 120         client := getClient(l)
 121         l.Push(lua.LString(client.address))
 122         return 1
 123 }
 124
 125 func l_client_state(l *lua.LState) int {
 126         client := getClient(l)
 127         switch client.state {
 128         case csNew:
 129                 l.Push(lua.LString("new"))
 130         case csConnected:
 131                 l.Push(lua.LString("connected"))
 132         case csDisconnected:
 133                 l.Push(lua.LString("disconnected"))
 134         }
 135         return 1
 136 }
 137
 138 func l_client_connect(l *lua.LState) int {
 139         client := getClient(l)
 140
 141         if client.state != csNew {
 142                 panic("can't reconnect")
 143         }
 144
 145         addr, err := net.ResolveUDPAddr("udp", client.address)
 146         if err != nil {
 147                 panic(err)
 148         }
 149
 150         conn, err := net.DialUDP("udp", nil, addr)
 151         if err != nil {
 152                 panic(err)
 153         }
 154
 155         client.state = csConnected
 156         client.conn = mt.Connect(conn)
 157         client.queue = make(chan *mt.Pkt, 1024)
 158
 159         go func() {
 160                 for {
 161                         pkt, err := client.conn.Recv()
 162
 163                         if err == nil {
 164                                 client.mu.Lock()
 165                                 for _, component := range client.components {
 166                                         component.process(&pkt)
 167                                 }
 168                                 _, subscribed := client.subscribed[string(convert.PushPktType(&pkt))]
 169                                 client.mu.Unlock()
 170
 171                                 if subscribed || client.wildcard {
 172                                         client.queue <- &pkt
 173                                 }
 174                         } else if errors.Is(err, net.ErrClosed) {
 175                                 close(client.queue)
 176                                 return
 177                         }
 178                 }
 179         }()
 180
 181         client.mu.Lock()
 182         for _, component := range client.components {
 183                 component.connect()
 184         }
 185         client.mu.Unlock()
 186
 187         return 0
 188 }
 189
 190 func l_client_poll(l *lua.LState) int {
 191         client := getClient(l)
 192         _, pkt, timeout := doPoll(l, []*Client{client})
 193
 194         l.Push(convert.PushPkt(l, pkt))
 195         l.Push(lua.LBool(timeout))
 196         return 2
 197 }
 198
 199 func l_client_close(l *lua.LState) int {
 200         client := getClient(l)
 201         client.closeConn()
 202         return 0
 203 }
 204
 205 func l_client_enable(l *lua.LState) int {
 206         client := getClient(l)
 207         client.mu.Lock()
 208         defer client.mu.Unlock()
 209
 210         for _, compname := range getStrings(l) {
 211                 if component, exists := client.components[compname]; !exists {
 212                         switch compname {
 213                         case "auth":
 214                                 component = &Auth{}
 215                         default:
 216                                 panic("invalid component: " + compname)
 217                         }
 218
 219                         client.components[compname] = component
 220                         component.create(client, l)
 221                 }
 222         }
 223
 224         return 0
 225 }
 226
 227 func l_client_subscribe(l *lua.LState) int {
 228         client := getClient(l)
 229         client.mu.Lock()
 230         defer client.mu.Unlock()
 231
 232         for _, pkt := range getStrings(l) {
 233                 client.subscribed[pkt] = struct{}{}
 234         }
 235
 236         return 0
 237 }
 238
 239 func l_client_unsubscribe(l *lua.LState) int {
 240         client := getClient(l)
 241         client.mu.Lock()
 242         defer client.mu.Unlock()
 243
 244         for _, pkt := range getStrings(l) {
 245                 delete(client.subscribed, pkt)
 246         }
 247
 248         return 0
 249 }
 250
 251 func l_client_wildcard(l *lua.LState) int {
 252         client := getClient(l)
 253         client.wildcard = l.ToBool(2)
 254         return 0
 255 }
 256
 257 func l_client_send(l *lua.LState) int {
 258         client := getClient(l)
 259
 260         if client.state != csConnected {
 261                 panic("not connected")
 262         }
 263
 264         cmd := convert.ReadCmd(l)
 265         doAck := l.ToBool(4)
 266
 267         client.mu.Lock()
 268         defer client.mu.Unlock()
 269
 270         if client.state == csConnected {
 271                 ack, err := client.conn.SendCmd(cmd)
 272                 if err != nil {
 273                         panic(err)
 274                 }
 275
 276                 if doAck && !cmd.DefaultPktInfo().Unrel {
 277                         <-ack
 278                 }
 279         }
 280
 281         return 0
 282 }