新增工程

service/Service.go

@@ -0,0 +1,180 @@
+package service
+
+import (
+	"fmt"
+	"log"
+
+	"os"
+	"reflect"
+	"strings"
+	"sync"
+	"time"
+)
+
+type MethodInfo struct {
+	Fun       reflect.Value
+	ParamList []reflect.Value
+	types     reflect.Type
+}
+
+type IBaseModule interface {
+	SetModuleName(modulename string) bool
+	GetModuleName() string
+	OnInit() error
+	OnRun() error
+}
+
+type IService interface {
+	Init(Iservice interface{}, servicetype int) error
+	Run(service IService, exit chan bool, pwaitGroup *sync.WaitGroup) error
+	OnInit() error
+	OnEndInit() error
+	OnRun() error
+	OnDestory() error
+	OnFetchService(iservice IService) error
+	GetServiceType() int
+	GetServiceName() string
+	GetServiceId() int
+	IsTimeOutTick(microSecond int64) bool
+
+	AddModule(module IBaseModule, autorun bool) bool
+	GetModule(module string) IBaseModule
+	GetStatus() int
+}
+
+var Log *log.Logger
+var logFile *os.File
+
+func InitLog() {
+	fileName := "log.log"
+	var err error
+	logFile, err = os.Create(fileName)
+
+	if err != nil {
+		log.Fatalln("open file error")
+	}
+	Log = log.New(logFile, "", log.LstdFlags)
+}
+
+type BaseService struct {
+	serviceid   int
+	servicename string
+	servicetype int
+
+	tickTime int64
+	statTm   int64
+	Status   int
+
+	modulelist []IBaseModule
+}
+
+type BaseModule struct {
+	modulename string
+}
+
+func (slf *BaseModule) SetModuleName(modulename string) bool {
+	slf.modulename = modulename
+	return true
+}
+
+func (slf *BaseModule) GetModuleName() string {
+	return slf.modulename
+}
+
+func (slf *BaseService) GetServiceId() int {
+	return slf.serviceid
+}
+
+func (slf *BaseService) GetServiceType() int {
+	return slf.servicetype
+}
+
+func (slf *BaseService) GetServiceName() string {
+	return slf.servicename
+}
+
+func (slf *BaseService) GetStatus() int {
+	return slf.Status
+}
+
+func (slf *BaseService) OnEndInit() error {
+	return nil
+}
+
+func (slf *BaseService) OnFetchService(iservice IService) error {
+	return nil
+}
+
+func (slf *BaseService) Init(Iservice interface{}, servicetype int) error {
+	slf.servicename = fmt.Sprintf("%T", Iservice)
+	parts := strings.Split(slf.servicename, ".")
+	if len(parts) != 2 {
+		err := fmt.Errorf("BaseService.Init: service name is error: %q", slf.servicename)
+		return err
+	}
+
+	slf.servicename = parts[1]
+	slf.servicetype = servicetype
+	slf.serviceid = InstanceServiceMgr().GenServiceID()
+
+	return nil
+}
+
+func (slf *BaseService) Run(service IService, exit chan bool, pwaitGroup *sync.WaitGroup) error {
+	defer pwaitGroup.Done()
+	for {
+		select {
+		case <-exit:
+			fmt.Println("stopping...")
+			return nil
+		default:
+		}
+		slf.tickTime = time.Now().UnixNano() / 1e6
+		service.OnRun()
+		slf.tickTime = time.Now().UnixNano() / 1e6
+	}
+
+	return nil
+}
+
+func (slf *BaseService) RPC_CheckServiceTickTimeOut(microSecond int64) error {
+
+	if slf.IsTimeOutTick(microSecond) == true {
+		Log.Printf("service:%s is timeout,state:%d", slf.GetServiceName(), slf.GetStatus())
+	}
+
+	return nil
+}
+
+func (slf *BaseService) IsTimeOutTick(microSecond int64) bool {
+
+	nowtm := time.Now().UnixNano() / 1e6
+	return nowtm-slf.tickTime >= microSecond
+
+}
+
+func (slf *BaseService) AddModule(module IBaseModule, autorun bool) bool {
+	typename := fmt.Sprintf("%v", reflect.TypeOf(module))
+	parts := strings.Split(typename, ".")
+	if len(parts) < 2 {
+		return false
+	}
+	module.SetModuleName(parts[1])
+	slf.modulelist = append(slf.modulelist, module)
+	module.OnInit()
+	if autorun == true {
+		go module.OnRun()
+	}
+
+	return true
+}
+
+func (slf *BaseService) GetModule(module string) IBaseModule {
+	for _, v := range slf.modulelist {
+		if v.GetModuleName() == module {
+			return v
+		}
+	}
+
+	return nil
+}

service/servicemanager.go

@@ -0,0 +1,119 @@
+package service
+
+import (
+	"fmt"
+	"sync"
+	"time"
+)
+
+type IServiceManager interface {
+	Setup(s IService) bool
+	Init() bool
+	Start() bool
+	CreateServiceID() int
+}
+
+type CServiceManager struct {
+	//serviceList            []IService
+	genserviceid    int
+	localserviceMap map[string]IService
+}
+
+func (slf *CServiceManager) Setup(s IService) bool {
+
+	slf.localserviceMap[s.GetServiceName()] = s
+	return true
+}
+
+func (slf *CServiceManager) FindService(serviceName string) IService {
+	service, ok := slf.localserviceMap[serviceName]
+	if ok {
+		return service
+	}
+
+	return nil
+}
+
+type FetchService func(s IService) error
+
+func (slf *CServiceManager) FetchService(s FetchService) IService {
+	for _, se := range slf.localserviceMap {
+		s(se)
+	}
+
+	return nil
+}
+
+func (slf *CServiceManager) Init() bool {
+
+	for _, s := range slf.localserviceMap {
+		if s.OnInit() != nil {
+			return false
+		}
+	}
+
+	// 初始化结束
+	for _, s := range slf.localserviceMap {
+		if s.OnEndInit() != nil {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (slf *CServiceManager) Start(exit chan bool, pwaitGroup *sync.WaitGroup) bool {
+	for _, s := range slf.localserviceMap {
+		pwaitGroup.Add(1)
+		go s.Run(s, exit, pwaitGroup)
+	}
+
+	pwaitGroup.Add(1)
+	go slf.CheckServiceTimeTimeout(exit, pwaitGroup)
+	return true
+}
+
+func (slf *CServiceManager) CheckServiceTimeTimeout(exit chan bool, pwaitGroup *sync.WaitGroup) {
+	defer pwaitGroup.Done()
+	for {
+		select {
+		case <-exit:
+			fmt.Println("CheckServiceTimeTimeout stopping...")
+			return
+		default:
+		}
+
+		for _, s := range slf.localserviceMap {
+
+			if s.IsTimeOutTick(20000) == true {
+				Log.Printf("service:%s is timeout,state:%d", s.GetServiceName(), s.GetStatus())
+			}
+		}
+		time.Sleep(2 * time.Second)
+	}
+
+}
+
+func (slf *CServiceManager) GenServiceID() int {
+	slf.genserviceid += 1
+	return slf.genserviceid
+}
+
+func (slf *CServiceManager) Get() bool {
+	for _, s := range slf.localserviceMap {
+		go s.OnRun()
+	}
+
+	return true
+}
+
+var _self *CServiceManager
+
+func InstanceServiceMgr() *CServiceManager {
+	if _self == nil {
+		_self = new(CServiceManager)
+		_self.localserviceMap = make(map[string]IService)
+		return _self
+	}
+	return _self
+}