mao-service-discovery 1.6.0-commit-2023-07-24-04-32-53.0 → 1.6.0-commit-2023-07-24-06-22-14.0

package/cmd/lib/Email/smtp-email-module.go

@@ -1,229 +0,0 @@
-package Email
-
-import (
-	MaoApi "MaoServerDiscovery/cmd/api"
-	"MaoServerDiscovery/cmd/lib/MaoCommon"
-	"MaoServerDiscovery/cmd/lib/MaoEnhancedGolang"
-	"MaoServerDiscovery/util"
-	"crypto/tls"
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"strings"
-	"time"
-)
-
-const (
-	MODULE_NAME = "SMTP-Email-module"
-
-	URL_EMAIL_HOMEPAGE = "/configEmail"
-	URL_EMAIL_CONFIG   = "/addEmailInfo"
-	URL_EMAIL_SHOW   = "/getEmailInfo"
-
-	EMAIL_INFO_CONFIG_PATH = "/email"
-
-	SUBJECT_FIX_PREFIX = "MaoReport: "
-)
-
-type SmtpEmailModule struct {
-
-	username           string
-	password           string // Attention: password can't be outputted !!!
-	smtpServerAddrPort string // addr:port, default port for smtp is 25.
-	sender string
-	receiver []string
-
-
-	// input the message
-	sendEmailChannel chan *MaoApi.EmailMessage
-	lastSendTimestamp time.Time
-
-	// same as the other module, it is expected to be global
-	//checkInterval uint32
-
-	needShutdown bool
-}
-
-func (s *SmtpEmailModule) RequireShutdown() {
-	s.needShutdown = true
-}
-
-
-func (s *SmtpEmailModule) SendEmail(message *MaoApi.EmailMessage) {
-	s.sendEmailChannel <- message
-}
-
-func (s *SmtpEmailModule) checkEmailInfo() bool {
-
-	// password may be empty?
-	if s.username == "" || s.smtpServerAddrPort == "" || s.sender == "" || len(s.receiver) == 0 {
-		// can adapt to "s.receiver == nil"
-		return false
-	}
-	return true
-}
-
-
-func (s *SmtpEmailModule) sendEmail(m *MaoApi.EmailMessage) {
-
-	if !s.checkEmailInfo() {
-		util.MaoLogM(util.WARN, MODULE_NAME, "Fail to send email, please config email info first.")
-		return
-	}
-
-	// Set up authentication information everytime, that allows to update:
-	// username, password, smtpServerAddrPort, sender, receiver
-	auth := AuthLOGIN(s.username, s.password)
-
-	// TODO: how to build multiple receivers string?
-	// TODO: support multiple receivers
-	msg := fmt.Sprintf("To: %s\r\n" +
-		"Subject: %s%s\r\n" + "\r\n" +
-		"%s\r\n",
-		s.receiver[0], SUBJECT_FIX_PREFIX, m.Subject, m.Content)
-
-	//msg := []byte("To: @.com\r\n" +
-	//	"Subject: MaoReport: beijing tower\r\n" +
-	//	"\r\n" +
-	//	"This is the email body.\r\n")
-
-	// TODO: make it configurable
-	tlsConfig := &tls.Config{
-		InsecureSkipVerify: true,
-	}
-
-	// Connect to the server, authenticate, set the sender and recipient,
-	// and send the email all in one step.
-	err := MaoEnhancedGolang.SendMail(s.smtpServerAddrPort, auth, s.sender, s.receiver, []byte(msg), tlsConfig)
-	if err != nil {
-		util.MaoLogM(util.WARN, MODULE_NAME, "Fail to send email, %s", err.Error())
-	}
-}
-
-func (s *SmtpEmailModule) sendEmailLoop() {
-	checkInterval := time.Duration(1000) * time.Millisecond
-	checkShutdownTimer := time.NewTimer(checkInterval)
-	for {
-		select {
-		case message := <-s.sendEmailChannel:
-			if time.Now().Sub(s.lastSendTimestamp) < 10 * time.Second {
-				freezeTimer := time.NewTimer(time.Duration(10) * time.Second)
-				sent := false
-				for !sent {
-					select {
-					case <-freezeTimer.C:
-						util.MaoLogM(util.INFO, MODULE_NAME, "Sending email, pending: %d", len(s.sendEmailChannel))
-						s.sendEmail(message)
-						s.lastSendTimestamp = time.Now()
-						sent = true
-					case <-checkShutdownTimer.C:
-						util.MaoLogM(util.DEBUG, MODULE_NAME, "CheckShutdown while freezing, event queue len %d", len(s.sendEmailChannel))
-						if s.needShutdown {
-							util.MaoLogM(util.WARN, MODULE_NAME, "Exit while freezing, the sendEmailChannel len: %d", len(s.sendEmailChannel))
-							return
-						}
-						checkShutdownTimer.Reset(checkInterval)
-					}
-				}
-			} else {
-				util.MaoLogM(util.INFO, MODULE_NAME, "Sending email, pending: %d", len(s.sendEmailChannel))
-				s.sendEmail(message)
-				s.lastSendTimestamp = time.Now()
-			}
-		case <-checkShutdownTimer.C:
-			util.MaoLogM(util.DEBUG, MODULE_NAME, "CheckShutdown, event queue len %d", len(s.sendEmailChannel))
-			if s.needShutdown {
-				if len(s.sendEmailChannel) != 0 {
-					util.MaoLogM(util.WARN, MODULE_NAME, "Exiting, but the sendEmailChannel is not empty, len: %d", len(s.sendEmailChannel))
-				}
-				util.MaoLogM(util.INFO, MODULE_NAME, "Exit.")
-				return
-			}
-			checkShutdownTimer.Reset(checkInterval)
-		}
-	}
-}
-
-func (s *SmtpEmailModule) InitSmtpEmailModule() bool {
-	s.sendEmailChannel = make(chan *MaoApi.EmailMessage, 1024)
-	s.needShutdown = false
-
-	go s.sendEmailLoop()
-
-	s.configRestControlInterface()
-
-	return true
-}
-
-func (s *SmtpEmailModule) configRestControlInterface() {
-	restfulServer := MaoCommon.ServiceRegistryGetRestfulServerModule()
-	if restfulServer == nil {
-		util.MaoLogM(util.WARN, MODULE_NAME, "Fail to get RestfulServerModule, unable to register restful apis.")
-		return
-	}
-
-	restfulServer.RegisterUiPage(URL_EMAIL_HOMEPAGE, s.showEmailPage)
-	restfulServer.RegisterGetApi(URL_EMAIL_SHOW, s.showEmailInfo)
-	restfulServer.RegisterPostApi(URL_EMAIL_CONFIG, s.processEmailInfo)
-}
-
-func (s *SmtpEmailModule) showEmailPage(c *gin.Context) {
-	c.HTML(200, "index-email.html", nil)
-}
-
-func (s *SmtpEmailModule) showEmailInfo(c *gin.Context) {
-	data := make(map[string]interface{})
-	data["username"] = s.username
-	data["smtpServerAddrPort"] = s.smtpServerAddrPort
-	data["sender"] = s.sender
-	data["receiver"] = s.receiver
-
-	// Attention: password can't be outputted !!!
-	c.JSON(200, data)
-}
-
-func (s *SmtpEmailModule) processEmailInfo(c *gin.Context) {
-
-	// TODO: check email address, limit the length of username/password/email. Prevent injection attack
-
-	username, ok := c.GetPostForm("username")
-	if ok {
-		s.username = username
-	}
-
-	password, ok := c.GetPostForm("password")
-	if ok {
-		s.password = password
-	}
-
-	smtpServerAddrPort, ok := c.GetPostForm("smtpServerAddrPort")
-	if ok {
-		s.smtpServerAddrPort = smtpServerAddrPort
-	}
-
-	sender, ok := c.GetPostForm("sender")
-	if ok {
-		s.sender = sender
-	}
-
-	receiverStr, ok := c.GetPostForm("receiver")
-	if ok {
-		receivers := strings.Fields(receiverStr)
-		s.receiver = receivers
-	}
-
-	configModule := MaoCommon.ServiceRegistryGetConfigModule()
-	if configModule == nil {
-		util.MaoLogM(util.WARN, MODULE_NAME, "Fail to get config module instance, can't save email info")
-	} else {
-		data := make(map[string]interface{})
-		data["username"] = s.username
-		data["smtpServerAddrPort"] = s.smtpServerAddrPort
-		data["sender"] = s.sender
-		data["receiver"] = s.receiver
-
-		// Attention: password can't be outputted !!!
-		configModule.PutConfig(EMAIL_INFO_CONFIG_PATH, data)
-	}
-
-	s.showEmailPage(c)
-}

package/cmd/lib/Email/smtp-email-module_test.go

@@ -1,12 +0,0 @@
-package Email
-
-import (
-	"log"
-	"testing"
-)
-
-func TestSmtpEmailModule_InitSmtpEmailModule(t *testing.T) {
-	var receivers []string
-
-	log.Println(len(receivers))
-}

package/cmd/lib/GrpcKa/grpc-detect-module.go

@@ -1,269 +0,0 @@
-package GrpcKa
-
-import (
-	MaoApi "MaoServerDiscovery/cmd/api"
-	"MaoServerDiscovery/cmd/lib/MaoCommon"
-	pb "MaoServerDiscovery/grpc.maojianwei.com/server/discovery/api"
-	"MaoServerDiscovery/util"
-	"errors"
-	"fmt"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/peer"
-	"net"
-	"sort"
-	"sync"
-	"time"
-)
-
-const (
-	MODULE_NAME = "GRPC-Detect-module"
-)
-
-type GrpcDetectModule struct {
-	serverInfo sync.Map
-	mergeChannel chan *MaoApi.GrpcServiceNode
-	rttMergeChannel chan *MaoApi.GrpcServiceNode
-
-	server *grpc.Server
-	pb.UnimplementedMaoServerDiscoveryServer
-
-	checkInterval uint32 // milliseconds
-	leaveTimeout uint32 // milliseconds
-	refreshShowingInterval uint32 // milliseconds
-
-	// used for web showing, i.e. external get operation
-	// used for processing aux data
-	serverInfoMirror  []*MaoApi.GrpcServiceNode
-}
-
-// implement pb.UnimplementedMaoServerDiscoveryServer
-func (g *GrpcDetectModule) Report(reportStream pb.MaoServerDiscovery_ReportServer) error {
-	util.MaoLogM(util.DEBUG, MODULE_NAME, "Triggered new report session")
-	ctx := reportStream.Context()
-	peerCtx, okbool := peer.FromContext(ctx)
-	if !okbool {
-		util.MaoLogM(util.WARN, MODULE_NAME, "Fail to get peerCtx, @Report")
-		return errors.New("Fail to get peerCtx, @Report")
-	}
-	//peerMetadata, okbool := metadata.FromIncomingContext(ctx)
-	//if !okbool {
-	//	util.MaoLogM(util.WARN, MODULE_NAME, "Fail to get peerMetadata")
-	//	return errors.New("Fail to get peerMetadata")
-	//}
-	//transportstream := grpc.ServerTransportStreamFromContext(ctx)
-
-	util.MaoLogM(util.INFO, MODULE_NAME, "New server comming: %s", peerCtx.Addr.String())
-	_ = g.dealRecv(reportStream)
-	return nil
-}
-
-func (g *GrpcDetectModule) dealRecv(reportStream pb.MaoServerDiscovery_ReportServer) error {
-	ctx := reportStream.Context()
-	peerCtx, okbool := peer.FromContext(ctx)
-	var clientAddr string
-	if !okbool {
-		clientAddr = "Client-<unknown>"
-	}
-	clientAddr = peerCtx.Addr.String()
-
-	var count uint64 = 1
-	for {
-		report, err := reportStream.Recv()
-		if err != nil {
-			util.MaoLogM(util.ERROR, MODULE_NAME, "Report err: <%s> %s", clientAddr, err)
-			return err
-		}
-		util.MaoLogM(util.DEBUG, MODULE_NAME, "Report get: <%s> %s, %v", clientAddr, report.GetHostname(), report.GetIps())
-		if report.GetOk() {
-			g.mergeChannel <- &MaoApi.GrpcServiceNode{
-				ReportTimes:    count,
-				Hostname:       report.GetHostname(),
-				Ips:            report.GetIps(),
-				ServerDateTime: report.GetNowDatetime(),
-				OtherData:		report.GetAuxData(),
-				RealClientAddr: clientAddr,
-				LocalLastSeen:  time.Now(),
-				Alive:          true,
-			}
-		}
-		count++
-	}
-}
-
-
-func (g *GrpcDetectModule) RttMeasure(rttMeasureStream pb.MaoServerDiscovery_RttMeasureServer) error {
-	util.MaoLogM(util.DEBUG, MODULE_NAME, "Triggered new RTT measure session")
-	ctx := rttMeasureStream.Context()
-	peerCtx, okbool := peer.FromContext(ctx)
-	if !okbool {
-		util.MaoLogM(util.WARN, MODULE_NAME, "Fail to get peerCtx, @RttMeasure")
-		return errors.New("Fail to get peerCtx, @RttMeasure")
-	}
-	//peerMetadata, okbool := metadata.FromIncomingContext(ctx)
-	//transportstream := grpc.ServerTransportStreamFromContext(ctx)
-
-	util.MaoLogM(util.INFO, MODULE_NAME, "New RTT measure session for %s", peerCtx.Addr.String())
-	_ = g.doRttMeasure(rttMeasureStream, peerCtx.Addr.String())
-	return nil
-}
-
-func (g *GrpcDetectModule) doRttMeasure(rttMeasureStream pb.MaoServerDiscovery_RttMeasureServer, clientAddr string) error {
-	var count uint64 = 0
-	for {
-		count++
-
-		echoRequest := pb.RttEchoRequest{Seq: count}
-		t1 := time.Now()
-		if err := rttMeasureStream.Send(&echoRequest); err != nil {
-			util.MaoLogM(util.ERROR, MODULE_NAME, "Fail to send Rtt echo request to %s, %s", clientAddr, err)
-			return err
-		}
-
-		// gRPC is based on TCP now, so we don't need to do timeout setting.
-		// And, if the TCP connection broke, Recv() will return with error.
-		echoResponse, err := rttMeasureStream.Recv()
-		if err != nil {
-			util.MaoLogM(util.ERROR, MODULE_NAME, "Fail to recv Rtt echo response from %s, %s", clientAddr, err)
-			return err
-		}
-		t2 := time.Now()
-		if echoResponse.Ack == echoRequest.Seq {
-			duration := t2.Sub(t1) // nanosecond
-			g.rttMergeChannel <- &MaoApi.GrpcServiceNode{
-				Hostname:    echoResponse.GetHostname(),
-				RttDuration: duration,
-			}
-			util.MaoLogM(util.DEBUG, MODULE_NAME, "Calculated RTT delay %s for %s", duration.String(), echoResponse.GetHostname())
-		}
-
-		time.Sleep(1 * time.Second)
-	}
-}
-
-func (g *GrpcDetectModule) runGrpcServer(listener net.Listener) {
-	util.MaoLogM(util.INFO, MODULE_NAME, "Server running %s ...", listener.Addr().String())
-	if err := g.server.Serve(listener); err != nil {
-		util.MaoLogM(util.ERROR, MODULE_NAME, "%s", err)
-	}
-	util.MaoLogM(util.INFO, MODULE_NAME, "Serve over")
-}
-
-
-
-
-func (g *GrpcDetectModule) controlLoop() {
-	checkTimer := time.NewTimer(time.Duration(g.checkInterval) * time.Millisecond)
-	for {
-		select {
-		case serverNode := <-g.rttMergeChannel:
-			value, ok := g.serverInfo.Load(serverNode.Hostname)
-			if ok && value != nil {
-				server := value.(*MaoApi.GrpcServiceNode)
-				server.RttDuration = serverNode.RttDuration
-			}
-		case serverNode := <-g.mergeChannel:
-			value, ok := g.serverInfo.Load(serverNode.Hostname)
-			if ok && value != nil {
-				server := value.(*MaoApi.GrpcServiceNode)
-				if !server.Alive && serverNode.Alive {
-					emailModule := MaoCommon.ServiceRegistryGetEmailModule()
-					if emailModule == nil {
-						util.MaoLogM(util.WARN, MODULE_NAME, "Fail to get EmailModule, can't send UP notification")
-					} else {
-						emailModule.SendEmail(&MaoApi.EmailMessage{
-							Subject: "Grpc UP notification",
-							Content: fmt.Sprintf("Service: %s\r\nUp Time: %s\r\nDetail: %v\r\n",
-								serverNode.Hostname, time.Now().String(), serverNode),
-						})
-					}
-				}
-				server.ReportTimes = serverNode.ReportTimes
-				server.Hostname = serverNode.Hostname
-				server.Ips = serverNode.Ips
-				server.ServerDateTime = serverNode.ServerDateTime
-				server.OtherData = serverNode.OtherData
-				server.RealClientAddr = serverNode.RealClientAddr
-				server.LocalLastSeen = serverNode.LocalLastSeen
-				server.Alive = serverNode.Alive
-			} else {
-				// Attention, serverNode instance is not created always. 2023.07.24
-				// TODO: other place may need to be check.
-				g.serverInfo.Store(serverNode.Hostname, serverNode)
-			}
-		case <-checkTimer.C:
-			// aliveness checking
-			g.serverInfo.Range(func(key, value interface{}) bool {
-				service := value.(*MaoApi.GrpcServiceNode)
-				if service.Alive && time.Since(service.LocalLastSeen) > time.Duration(g.leaveTimeout) * time.Millisecond {
-					service.Alive = false
-					g.mergeChannel <- service
-
-					emailModule := MaoCommon.ServiceRegistryGetEmailModule()
-					if emailModule == nil {
-						util.MaoLogM(util.WARN, MODULE_NAME, "Fail to get EmailModule, can't send DOWN notification")
-					} else {
-						emailModule.SendEmail(&MaoApi.EmailMessage{
-							Subject: "Grpc DOWN notification",
-							Content: fmt.Sprintf("Service: %s\r\nDOWN Time: %s\r\nDetail: %v\r\n",
-								service.Hostname, time.Now().String(), service),
-						})
-					}
-				}
-				return true
-			})
-			checkTimer.Reset(time.Duration(g.checkInterval) * time.Millisecond)
-		}
-	}
-}
-
-
-
-func (g *GrpcDetectModule) refreshShowingService() {
-	for {
-		time.Sleep(time.Duration(g.refreshShowingInterval) * time.Millisecond)
-		serversTmp := make([]*MaoApi.GrpcServiceNode, 0)
-		g.serverInfo.Range(func(_, value interface{}) bool {
-			serversTmp = append(serversTmp, value.(*MaoApi.GrpcServiceNode))
-			return true
-		})
-		g.serverInfoMirror = serversTmp
-	}
-}
-
-func (g *GrpcDetectModule) GetServiceInfo() []*MaoApi.GrpcServiceNode {
-	servers := g.serverInfoMirror
-	sort.Slice(servers, func(i, j int) bool {
-		return servers[i].Hostname < servers[j].Hostname
-	})
-	return servers
-}
-
-
-
-func (g *GrpcDetectModule) InitGrpcModule(addrPort string) bool {
-	g.mergeChannel = make(chan *MaoApi.GrpcServiceNode, 1024)
-	g.rttMergeChannel = make(chan *MaoApi.GrpcServiceNode, 1024)
-
-	g.checkInterval = 500
-	g.leaveTimeout = 5000
-	g.refreshShowingInterval = 1000
-	g.serverInfoMirror = make([]*MaoApi.GrpcServiceNode, 0)
-
-
-	listener, err := net.Listen("tcp", addrPort)
-	if err != nil {
-		util.MaoLogM(util.WARN, MODULE_NAME, "Fail to create listener at %s, err: %s", addrPort, err.Error())
-		return false
-	}
-
-	g.server = grpc.NewServer()
-	pb.RegisterMaoServerDiscoveryServer(g.server, g)
-	go g.runGrpcServer(listener)
-
-
-	go g.controlLoop()
-	go g.refreshShowingService()
-
-	return true
-}
-

package/cmd/lib/GrpcKa/grpc-detect-module_test.go

@@ -1,26 +0,0 @@
-package GrpcKa
-
-import (
-	MaoApi "MaoServerDiscovery/cmd/api"
-	"fmt"
-	"log"
-	"testing"
-	"time"
-)
-
-func TestGrpcDetectModule_GetServiceInfo(t *testing.T) {
-	serverNode := &MaoApi.GrpcServiceNode{
-		ReportTimes:    666,
-		Hostname:       "qingdao-hostname",
-		Ips:            nil,
-		ServerDateTime: time.Now().String(),
-		OtherData:		"OtherDataOtherData",
-		RealClientAddr: "1.1.1.1",
-		LocalLastSeen:  time.Now(),
-		Alive:          true,
-	}
-	s := fmt.Sprintf("Service: %s\r\nUp Time: %s\r\nDetail: %v\r\n",
-		serverNode.Hostname, time.Now().String(), serverNode)
-
-	log.Println(s)
-}