ecs/servers/user/server.go

package main

import (
	"ecs/servers/user/handler"
	"ecs/servers/user/logic"
	"github.com/oylshe1314/framework/client/db"
	"github.com/oylshe1314/framework/client/sd"
	"github.com/oylshe1314/framework/client/sd/zk"
	"github.com/oylshe1314/framework/errors"
	"github.com/oylshe1314/framework/server"
	"github.com/oylshe1314/framework/util"
	"time"
)

type userServer struct {
	server.NamedServer

	InnerServer server.HttpServer

	dbConfig    *db.Config
	MongoClient db.MongoClient

	sdConfig       *sd.Config
	RegisterClient sd.RegisterClient

	userManager *logic.UserManager

	innerHandler *handler.InnerHandler
}

func NewUserServer() server.Server {
	return &userServer{}
}

func (this *userServer) WithDbConfig(config *db.Config) {
	this.dbConfig = config
}

func (this *userServer) WithSdConfig(config *sd.Config) {
	this.sdConfig = config
}

func (this *userServer) Init() (err error) {

	err = this.NamedServer.Init()
	if err != nil {
		return err
	}

	this.InnerServer.SetServer(this)
	err = this.InnerServer.Init()
	if err != nil {
		return errors.Errorf("the 'InnerServer' init failed, %v", err)
	}

	this.MongoClient = db.NewMongoClient(this.dbConfig)
	err = this.MongoClient.Init()
	if err != nil {
		return errors.Errorf("the 'MongoClient' init failed, %v", err)
	}

	this.RegisterClient = zk.NewRegisterClient(this, this.sdConfig, &this.InnerServer.Listener, nil)
	err = this.RegisterClient.Init()
	if err != nil {
		return errors.Errorf("the 'RegisterClient' init failed, %v", err)
	}

	this.userManager = logic.NewUserManager(this, this.MongoClient)
	err = this.userManager.Init()
	if err != nil {
		return errors.Errorf("the 'userManager' init failed, %v", err)
	}

	this.innerHandler = handler.NewInnerHandler(this, this.userManager)

	//register internal request handler
	this.InnerServer.GetHandler("/signUp", this.innerHandler.SignUp)
	this.InnerServer.PostHandler("/login", this.innerHandler.Login)
	this.InnerServer.PostHandler("/verify/token", this.innerHandler.TokenVerify)

	return
}

func (this *userServer) Serve() (err error) {
	return util.WaitAny(this.InnerServer.Serve, this.RegisterClient.Work)
}

func (this *userServer) Close() error {

	this.Logger().Info("The 'InnerServer' is closing")
	_ = this.InnerServer.Close()

	this.Logger().Info("The 'RegisterClient' is closing")
	_ = this.RegisterClient.Close()

	this.Logger().Info("Server closed")

	time.Sleep(time.Second)
	_ = this.NamedServer.Close()
	return nil
}