optimize service initial logic

internal/servants/mobile/auth.go

@@ -1,3 +1,7 @@
+// Copyright 2022 ROC. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
 package mobile
 
 import (

internal/servants/mobile/mobile.go

@@ -1,3 +1,7 @@
+// Copyright 2022 ROC. All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
 package mobile
 
 import (

internal/service/admin.go

@@ -74,10 +74,11 @@ func newAdminEngine() *gin.Engine {
 
 func newAdminService() Service {
 	addr := conf.AdminServerSetting.HttpIp + ":" + conf.AdminServerSetting.HttpPort
-	server := httpServerFrom(addr, func() *httpServer {
+	server := httpServers.from(addr, func() *httpServer {
 		engine := newAdminEngine()
 		return &httpServer{
-			e: engine,
+			baseServer: newBaseServe(),
+			e:          engine,
 			server: &http.Server{
 				Addr:           addr,
 				Handler:        engine,

internal/service/bot.go

@@ -74,10 +74,11 @@ func newBotEngine() *gin.Engine {
 
 func newBotService() Service {
 	addr := conf.BotServerSetting.HttpIp + ":" + conf.BotServerSetting.HttpPort
-	server := httpServerFrom(addr, func() *httpServer {
+	server := httpServers.from(addr, func() *httpServer {
 		engine := newBotEngine()
 		return &httpServer{
-			e: engine,
+			baseServer: newBaseServe(),
+			e:          engine,
 			server: &http.Server{
 				Addr:           addr,
 				Handler:        engine,

internal/service/grpc_server.go

@@ -6,25 +6,20 @@ package service
 
 import (
 	"net"
-	"sync"
 
 	"google.golang.org/grpc"
 )
 
+var (
+	_ server = (*grpcServer)(nil)
+)
+
 // grpcServer wraper for grpc.Server
 type grpcServer struct {
-	sync.RWMutex
-
-	listener     net.Listener
-	server       *grpc.Server
-	serverStatus uint8
-}
-
-func (s *grpcServer) status() uint8 {
-	s.RLock()
-	defer s.RUnlock()
+	*baseServer
 
-	return s.serverStatus
+	listener net.Listener
+	server   *grpc.Server
 }
 
 func (s *grpcServer) start() error {

internal/service/http_server.go

@@ -7,25 +7,20 @@ package service
 import (
 	"context"
 	"net/http"
-	"sync"
 
 	"github.com/gin-gonic/gin"
 )
 
+var (
+	_ server = (*httpServer)(nil)
+)
+
 // httpServer wraper for gin.engine and http.Server
 type httpServer struct {
-	sync.RWMutex
-
-	e            *gin.Engine
-	server       *http.Server
-	serverStatus uint8
-}
-
-func (s *httpServer) status() uint8 {
-	s.RLock()
-	defer s.RUnlock()
+	*baseServer
 
-	return s.serverStatus
+	e      *gin.Engine
+	server *http.Server
 }
 
 func (s *httpServer) start() error {

internal/service/localoss.go

@@ -49,10 +49,11 @@ func newLocalossEngine() *gin.Engine {
 
 func newLocalossService() Service {
 	addr := conf.LocalossServerSetting.HttpIp + ":" + conf.LocalossServerSetting.HttpPort
-	server := httpServerFrom(addr, func() *httpServer {
+	server := httpServers.from(addr, func() *httpServer {
 		engine := newLocalossEngine()
 		return &httpServer{
-			e: engine,
+			baseServer: newBaseServe(),
+			e:          engine,
 			server: &http.Server{
 				Addr:           addr,
 				Handler:        engine,

internal/service/mobile.go

@@ -43,7 +43,7 @@ func (s *mobileService) String() string {
 
 func newMobileService() Service {
 	addr := conf.MobileServerSetting.Host + ":" + conf.MobileServerSetting.Port
-	server := grpcServerFrom(addr, func() *grpcServer {
+	server := grpcServers.from(addr, func() *grpcServer {
 		l, err := net.Listen("tcp", addr)
 		if err != nil {
 			// TODO: optimize error process
@@ -54,8 +54,9 @@ func newMobileService() Service {
 		s := grpc.NewServer()
 
 		return &grpcServer{
-			listener: l,
-			server:   s,
+			baseServer: newBaseServe(),
+			listener:   l,
+			server:     s,
 		}
 	})
 	return &mobileService{

internal/service/server.go

@@ -4,35 +4,70 @@
 
 package service
 
+import "sync"
+
 var (
-	httpServers = make(map[string]*httpServer)
-	grpcServers = make(map[string]*grpcServer)
+	httpServers = newServerPool[*httpServer]()
+	grpcServers = newServerPool[*grpcServer]()
 )
 
 const (
-	_statusServerInitilized uint8 = iota + 1
+	_statusServerUnknow uint8 = iota
+	_statusServerInitilized
 	_statusServerStarted
 	_statusServerStoped
 )
 
-func httpServerFrom(addr string, newServer func() *httpServer) *httpServer {
-	s, exist := httpServers[addr]
+type server interface {
+	status() uint8
+	setStatus(uint8)
+	start() error
+	stop() error
+}
+
+type serverPool[T server] struct {
+	servers map[string]T
+}
+
+type baseServer struct {
+	sync.RWMutex
+	serverStatus uint8
+}
+
+func (p *serverPool[T]) from(addr string, newServer func() T) T {
+	s, exist := p.servers[addr]
 	if exist {
 		return s
 	}
 	s = newServer()
-	s.serverStatus = _statusServerInitilized
-	httpServers[addr] = s
+	s.setStatus(_statusServerInitilized)
+	p.servers[addr] = s
 	return s
 }
 
-func grpcServerFrom(addr string, newServer func() *grpcServer) *grpcServer {
-	s, exist := grpcServers[addr]
-	if exist {
-		return s
+func (s *baseServer) setStatus(status uint8) {
+	s.RLock()
+	defer s.RUnlock()
+
+	s.serverStatus = status
+}
+
+func (s *baseServer) status() uint8 {
+	s.RLock()
+	defer s.RUnlock()
+
+	return s.serverStatus
+}
+
+func newServerPool[T server]() *serverPool[T] {
+	return &serverPool[T]{
+		servers: make(map[string]T),
+	}
+}
+
+func newBaseServe() *baseServer {
+	return &baseServer{
+		RWMutex:      sync.RWMutex{},
+		serverStatus: _statusServerUnknow,
 	}
-	s = newServer()
-	s.serverStatus = _statusServerInitilized
-	grpcServers[addr] = s
-	return s
 }

internal/service/space.go

@@ -74,10 +74,11 @@ func newSpaceXEngine() *gin.Engine {
 
 func newSpaceXService() Service {
 	addr := conf.SpaceXServerSetting.HttpIp + ":" + conf.SpaceXServerSetting.HttpPort
-	server := httpServerFrom(addr, func() *httpServer {
+	server := httpServers.from(addr, func() *httpServer {
 		engine := newSpaceXEngine()
 		return &httpServer{
-			e: engine,
+			baseServer: newBaseServe(),
+			e:          engine,
 			server: &http.Server{
 				Addr:           addr,
 				Handler:        engine,

internal/service/web.go

@@ -74,10 +74,11 @@ func newWebEngine() *gin.Engine {
 
 func newWebService() Service {
 	addr := conf.WebServerSetting.HttpIp + ":" + conf.WebServerSetting.HttpPort
-	server := httpServerFrom(addr, func() *httpServer {
+	server := httpServers.from(addr, func() *httpServer {
 		engine := newWebEngine()
 		return &httpServer{
-			e: engine,
+			baseServer: newBaseServe(),
+			e:          engine,
 			server: &http.Server{
 				Addr:           addr,
 				Handler:        engine,

internal/service/web_old.go

@@ -41,10 +41,11 @@ func (s *oldWebService) String() string {
 
 func newOldWebService() Service {
 	addr := conf.ServerSetting.HttpIp + ":" + conf.ServerSetting.HttpPort
-	server := httpServerFrom(addr, func() *httpServer {
+	server := httpServers.from(addr, func() *httpServer {
 		engine := newWebEngine()
 		return &httpServer{
-			e: engine,
+			baseServer: newBaseServe(),
+			e:          engine,
 			server: &http.Server{
 				Addr:           addr,
 				Handler:        engine,