// this function is the goroutine that owns this service - all thread-sensitive data needs to
// be manipulated only through here.
func (s *Service) mux() {
loop:
for {
select {
case slots := <-s.slotsChan:
s.Slots += slots
s.UpdateCluster()
case conn := <-s.connectionChan:
s.activeClients.Add(1)
// send the server handshake
sh := skynet.ServiceHandshake{
Registered: s.Registered,
}
encoder := bsonrpc.NewEncoder(conn)
err := encoder.Encode(sh)
if err != nil {
s.Log.Item(err)
s.activeClients.Done()
break
}
if !s.Registered {
conn.Close()
s.activeClients.Done()
break
}
// read the client handshake
var ch skynet.ClientHandshake
decoder := bsonrpc.NewDecoder(conn)
err = decoder.Decode(&ch)
if err != nil {
s.Log.Item(err)
s.activeClients.Done()
break
}
// here do stuff with the client handshake
go func() {
s.RPCServ.ServeCodec(bsonrpc.NewServerCodec(conn))
s.activeClients.Done()
}()
case register := <-s.registeredChan:
if register {
s.register()
} else {
s.unregister()
}
case _ = <-s.doneChan:
go func() {
for _ = range s.doneChan {
}
}()
s.RemoveFromCluster()
s.doozerChan <- doozerFinish{}
break loop
}
}
}
func (sa *ServiceAdmin) Listen(addr *skynet.BindAddr) {
listener, err := addr.Listen()
if err != nil {
panic(err)
}
sa.service.Log.Item(AdminListening{sa.service.Config})
for {
conn, err := listener.AcceptTCP()
if err != nil {
panic(err)
}
go sa.rpc.ServeCodec(bsonrpc.NewServerCodec(conn))
}
}
func (sa *ServiceAdmin) Listen(addr *skynet.BindAddr, bindWait *sync.WaitGroup) {
listener, err := addr.Listen()
if err != nil {
panic(err)
}
bindWait.Done()
sa.service.Log.Trace(fmt.Sprintf("%+v", AdminListening{sa.service.Config}))
for {
conn, err := listener.AcceptTCP()
if err != nil {
panic(err)
}
go sa.rpc.ServeCodec(bsonrpc.NewServerCodec(conn))
}
}
func (sa *ServiceAdmin) Listen(addr *BindAddr) {
laddr, err := net.ResolveTCPAddr("tcp", addr.String())
if err != nil {
panic(err)
}
listener, err := net.ListenTCP("tcp", laddr)
if err != nil {
panic(err)
}
sa.service.Log.Item(AdminListening{sa.service.Config})
for {
conn, err := listener.AcceptTCP()
if err != nil {
panic(err)
}
go sa.rpc.ServeCodec(bsonrpc.NewServerCodec(conn))
}
}
// this function is the goroutine that owns this service - all thread-sensitive data needs to
// be manipulated only through here.
func (s *Service) mux() {
loop:
for {
select {
case conn := <-s.connectionChan:
atomic.AddInt32(&s.Stats.Clients, 1)
clientID := skynet.UUID()
s.clientMutex.Lock()
s.clientInfo[clientID] = ClientInfo{
Address: conn.RemoteAddr(),
}
s.clientMutex.Unlock()
// send the server handshake
sh := skynet.ServiceHandshake{
Registered: s.Registered,
ClientID: clientID,
}
encoder := bsonrpc.NewEncoder(conn)
err := encoder.Encode(sh)
if err != nil {
s.Log.Item(err)
atomic.AddInt32(&s.Stats.Clients, -1)
break
}
if !s.Registered {
conn.Close()
atomic.AddInt32(&s.Stats.Clients, -1)
break
}
// read the client handshake
var ch skynet.ClientHandshake
decoder := bsonrpc.NewDecoder(conn)
err = decoder.Decode(&ch)
if err != nil {
s.Log.Item(err)
atomic.AddInt32(&s.Stats.Clients, -1)
break
}
// here do stuff with the client handshake
go func() {
s.RPCServ.ServeCodec(bsonrpc.NewServerCodec(conn))
atomic.AddInt32(&s.Stats.Clients, -1)
}()
case register := <-s.registeredChan:
if register {
s.register()
} else {
s.unregister()
}
case _ = <-s.doneChan:
go func() {
for _ = range s.doneChan {
}
}()
s.RemoveFromCluster()
s.doozerChan <- doozerFinish{}
break loop
case _ = <-s.updateTicker.C:
s.UpdateCluster()
}
}
}