[add] 암호화 과정 로그 및 기본적인 로그 추가

src/logConfig.go

+package main
+
+import (
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+func MyEncoderConfig() zapcore.EncoderConfig {
+	return zapcore.EncoderConfig{
+		// Keys can be anything except the empty string.
+		TimeKey:  "T",
+		LevelKey: "L",
+		NameKey:  "N",
+		//CallerKey:      "C",
+		FunctionKey:    zapcore.OmitKey,
+		MessageKey:     "M",
+		StacktraceKey:  "S",
+		LineEnding:     zapcore.DefaultLineEnding,
+		EncodeLevel:    zapcore.CapitalColorLevelEncoder,
+		EncodeTime:     zapcore.ISO8601TimeEncoder,
+		EncodeDuration: zapcore.StringDurationEncoder,
+		EncodeCaller:   zapcore.ShortCallerEncoder,
+	}
+}
+
+func NewMyLogger() *zap.Logger {
+	cfg := zap.Config{
+		Level:            zap.NewAtomicLevelAt(zap.DebugLevel),
+		Development:      true,
+		Encoding:         "console",
+		EncoderConfig:    MyEncoderConfig(),
+		OutputPaths:      []string{"stdout", "./test.log"},
+		ErrorOutputPaths: []string{"stderr"},
+	}
+	logger, err := cfg.Build()
+	if err != nil {
+		panic(err)
+	}
+	return logger
+}

src/main.go

 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/fatih/color"
 	"log"
 	"math/rand"
 	"net"
 }
 
 func (microService MicroService) Receive(msg MsgUnit) {
+	logger := NewMyLogger()
+	logger.Sync()
+
 	var msg_type = msg.CheckType()
 	//메세지 타입에 따라 다르게 처리
 	switch msg_type {
 	case RM: //Register msg
 
 		microService.IsConnected <- true
-		log.Println("you received RM: Registered Complete!")
+		logger.Info("MM Registered this node Complete!")
 
 	case WM: //Withdraw msg
 		//moscato.MicroServiceManager.RemoveMicroservice(msg.(*WithdrawMsg).From)
 }
 
 func main() {
+	logger := NewMyLogger()
+	logger.Sync()
 
 	var argu string
 	for _, v := range os.Args {
 	}
 	MMAddress := argu
 	if argu == "" {
-		println("there is no Message Middleware address")
+		logger.Fatal("there is no Message Middleware address")
 		return
 	}
 
 	microService := MicroService{currentIP, privateKey, shareKey, make(chan bool), MMAddress}
 	receiver := Receiver{thisNodeAddr: currentIP, microService: microService}
 
-	color.Blue("<current machine address : " + currentIP + "> <MM address : " + MMAddress + ">")
-	color.Blue("<private key : " + strconv.FormatUint(uint64(privateKey), 10) + ">")
+	logger.Info("current machine address : " + currentIP + " / MM address : " + MMAddress)
+	logger.Debug("private key : " + strconv.FormatUint(uint64(privateKey), 10))
 
 	errReg := rpc.Register(receiver)
 	if errReg != nil {
 
 	client, err := rpc.Dial("tcp", microService.MMAddress+":8160") // RPC 서버에 연결
 	if err != nil {
-		fmt.Println(err)
+		logger.Fatal(err.Error())
 		return
 	}
 	defer client.Close() // main 함수가 끝나기 직전에 RPC 연결을 닫음
 	args.JsonMsg = RJsonMsg
 	args.Kind = RM
 	err = client.Call("Receiver.MmReceive", args, reply)
-	log.Println("RM sent!")
+	logger.Info("RM sent")
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
-	color.Yellow("MM: " + reply.CompleteLog)
+	logger.Debug("[MM] " + reply.CompleteLog)
+
+	sigs := make(chan os.Signal, 1)
+	done := make(chan bool, 1)
+
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+
+	go func() {
+		sig := <-sigs
+		withDraw(message, client)
+		//fmt.Println(sig)
+		_ = sig
+		done <- true
+		fmt.Println("\nquit Moscato Successful and terminate microservice")
+		os.Exit(0)
+	}()
 
 	// 연결 되면 채널로 연결 확인이 되어야 다음 단계로 넘어감
 	checkConnect := <-microService.IsConnected
 	_ = checkConnect
 	fmt.Scanln()
-	fmt.Println("***** sending Subscription messages *****")
+	logger.Info("sending Subscription messages")
 
 	/*
 		파일에서 subscription 읽어서 subscription 보내기
 		 **/
 	subFile, err := os.Open("subscription.txt")
 	if err != nil {
+		fmt.Println("sub")
 		log.Fatalf("Error when opening file: %s", err)
 	}
 	defer subFile.Close()
 			println(numSub, "subscription isAlpha type error.")
 		}
 
+		numSub++
 		message = Message{From: microService.ClientAddr, Version: "1", Time: "1", Kind: SM}
 		subMsg := CreateSubMsg(message, subTopic, subValue, subOperator, subIsAlpha)
+		logger.Debug("subMsg #" + strconv.Itoa(numSub) + " topic: " + subTopic + " / value: " + subValue + " / operator: " + subOperator)
+		logger.Debug("before enc subMsg #" + strconv.Itoa(numSub) + " topic: " + IntSlice2String(subMsg.Topic))
+
 		//subMsg := CreateSubMsg(message, "soccer", "player", "==", true)
 		//fmt.Println(pubMsg)
 		subMsg = EncryptionSubMsg(subMsg, microService.ShareKey, microService.PrivateKey)
+		logger.Debug("after enc subMsg #" + strconv.Itoa(numSub) + " topic: " + IntSlice2String(subMsg.Topic))
 		jsonMsg, _ := subMsg.ConvertToJson()
 		args.JsonMsg = jsonMsg
 		args.Kind = subMsg.Kind
 
 		//fmt.Println(string(args.JsonMsg))
 		err = client.Call("Receiver.MmReceive", args, reply)
-		log.Println("SM sent! #:", numSub)
+		logger.Info("SM sent! #" + strconv.Itoa(numSub))
+
 		if err != nil {
 			fmt.Println(err)
 			return
 		}
 		//log.Println(reply.CompleteLog)
-		color.Yellow("MM: " + reply.CompleteLog)
+		logger.Debug("[MM] " + reply.CompleteLog)
 
 	}
 
 	fmt.Scanln()
-	fmt.Println("***** sending Publish messages *****")
+	logger.Info("sending Publish messages")
 
 	pubFile, err := os.Open("publish.txt")
 	if err != nil {
 		pubValue := publishTextSlice[1]
 		pubContent := publishTextSlice[2]
 
+		numPub++
 		message = Message{From: microService.ClientAddr, Version: "1", Time: "1", Kind: PM}
 		pubMsg := CreatePubMsg(message, pubTopic, pubValue, pubContent)
+		logger.Debug("pubMsg #" + strconv.Itoa(numSub) + " topic: " + pubTopic + " / value: " + pubValue + " / content: " + pubContent)
+		logger.Debug("before enc pubMsg #" + strconv.Itoa(numPub) + " topic: " + IntSlice2String(pubMsg.Topic))
 		//subMsg := CreateSubMsg(message, "soccer", "player", "==", true)
 		//fmt.Println("Pub.txt",pubMsg)
 		pubMsg = EncryptionPubMsg(pubMsg, microService.ShareKey, microService.PrivateKey)
+		logger.Debug("after enc pubMsg #" + strconv.Itoa(numPub) + " topic: " + IntSlice2String(pubMsg.Topic))
 		jsonMsg, _ := pubMsg.ConvertToJson()
 		args.JsonMsg = jsonMsg
 		args.Kind = pubMsg.Kind
 
 		//fmt.Println(string(args.JsonMsg))
 		err = client.Call("Receiver.MmReceive", args, reply)
-		log.Println("PM sent! #:", numPub)
+		logger.Info("PM sent! #" + strconv.Itoa(numSub))
 		if err != nil {
 			fmt.Println(err)
 			return
 		}
 		//log.Println(reply.CompleteLog)
-		color.Yellow("MM: " + reply.CompleteLog)
+		logger.Debug("[MM]: " + reply.CompleteLog)
 
 	}
 
-	sigs := make(chan os.Signal, 1)
-	done := make(chan bool, 1)
-
-	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
-
-	go func() {
-		sig := <-sigs
-		withDraw(message, client)
-		//fmt.Println(sig)
-		_ = sig
-		done <- true
-		fmt.Println("\nquit Moscato Successful and terminate microservice")
-	}()
-
 	<-done
 	return
 }
 	} else {
 		fmt.Println("Value is:", string(runeArr))
 	}
-	//if unicode.IsDigit(runeArr[0]){
-	//	fmt.Println("Value is: " + string(runeArr))
-	//} else {
-	//	//for index := 0; index < len(intArr); index++ {
-	//	//	//toPubMsg.Value = append(toPubMsg.Value, int64(intArr[index]))
-	//	//	valueInt = append(valueInt, int64(intArr[index]))
-	//	//}
-	//}
 
 	runeArr = nil
 
 		go rpc.ServeConn(conn)
 	}
 }
+
+func IntSlice2String(target []int64) string {
+	var targetString string
+	targetString = ""
+	for _, value := range target {
+		targetString += strconv.FormatInt(int64(value), 10) + " "
+	}
+	return targetString
+}