[fix] 랜덤 키 생성시 시드 주입

src/main.go

 package main
+
 // TODO: 등록확인 되기 전에는 PM,SM 전송 불가하게 만들 것, 실행파일로 만든 후, AWS 이용해서 여러개 마이크로서비스 상태에서 테스트 해볼것
 
 import (
 	"strconv"
 	"strings"
 	"syscall"
+	"time"
 	"unicode"
 )
 
 
 type PublishMsg struct {
 	Message
-	Topic []int64 //대주제
-	Value []int64 //Topic 의 세부적인 내용
+	Topic   []int64 //대주제
+	Value   []int64 //Topic 의 세부적인 내용
 	Content []int64 // 내용
 }
 
 	Message
 }
 
-
-
 type Receiver struct {
 	thisNodeAddr string
 	microService MicroService
 }
 
 type MicroService struct {
-
 	ClientAddr string
 	PrivateKey int64
-	ShareKey int64
+	ShareKey   int64
 	// 메세지 미들웨어에 연결되어 있는가
 	IsConnected chan bool
-	MMAddress string
+	MMAddress   string
 }
 
-func (receiver Receiver) Receive(args Args, reply *Reply) error{
+func (receiver Receiver) Receive(args Args, reply *Reply) error {
 	switch args.Kind {
 
 	case KSM:
 	return nil
 }
 
-func (microService MicroService) Receive(msg MsgUnit){
+func (microService MicroService) Receive(msg MsgUnit) {
 	var msg_type = msg.CheckType()
 	//메세지 타입에 따라 다르게 처리
 	switch msg_type {
 
 	case PM: //Publish msg
 		fmt.Println("----- received PM ------")
-		DecryptionMsg(msg.(PublishMsg),microService.ShareKey, microService.PrivateKey)
+		DecryptionMsg(msg.(PublishMsg), microService.ShareKey, microService.PrivateKey)
 		fmt.Println("------------------------")
 
 	case SM: //Subscription msg
 	return
 }
 
-
 func (msg SubscriptionMsg) ConvertToJson() ([]byte, error) {
 	js := msg
 	jsonBytes, err := json.Marshal(js)
 	//fmt.Print("Topic length ")
 	//fmt.Println(len(intArr))
 	//fmt.Println(len(toPubMsg.Topic))
-	var topicInt [] int64
+	var topicInt []int64
 	for index := 0; index < len(intArr); index++ {
 		//toPubMsg.Topic = append(toPubMsg.Topic, int64(intArr[index]))
 		topicInt = append(topicInt, int64(intArr[index]))
 	//fmt.Println(len(toPubMsg.Topic))
 
 	intArr = []rune(value)
-	var valueInt [] int64
-	strInt64, _ :=  strconv.ParseInt(value, 10, 64)
-	if unicode.IsDigit(intArr[0]){
+	var valueInt []int64
+	strInt64, _ := strconv.ParseInt(value, 10, 64)
+	if unicode.IsDigit(intArr[0]) {
 		valueInt = append(valueInt, strInt64)
 	} else {
 		for index := 0; index < len(intArr); index++ {
 	}
 
 	intArr = []rune(content)
-	var contentInt [] int64
+	var contentInt []int64
 	for index := 0; index < len(intArr); index++ {
 		//toPubMsg.content = append(toPubMsg.content, int64(intArr[index]))
 		contentInt = append(contentInt, int64(intArr[index]))
 	}
 
-
-	return PublishMsg{msg,topicInt,valueInt,contentInt}
+	return PublishMsg{msg, topicInt, valueInt, contentInt}
 }
 
 func CreateSubMsg(msg Message, topic string, value string, operator string, isAlpha bool) SubscriptionMsg {
 	//fmt.Print("Topic length ")
 	//fmt.Println(len(intArr))
 	//fmt.Println(len(toPubMsg.Topic))
-	var topicInt [] int64
+	var topicInt []int64
 	for index := 0; index < len(intArr); index++ {
 		//toPubMsg.Topic = append(toPubMsg.Topic, int64(intArr[index]))
 		topicInt = append(topicInt, int64(intArr[index]))
 	}
 	//fmt.Println(len(toPubMsg.Topic))
-	var valueInt [] int64
+	var valueInt []int64
 	if isAlpha {
 		intArr = []rune(value)
 
 		}
 	} else {
 		stringSlice := strings.Split(value, " ")
-		for index:=0; index < len(stringSlice); index++ {
+		for index := 0; index < len(stringSlice); index++ {
 			strInt64, _ := strconv.ParseInt(stringSlice[index], 10, 64)
 			valueInt = append(valueInt, strInt64)
 		}
 	var operatorSlice []string
 	operatorSlice = strings.Split(operator, " ")
 
-
 	//intArr = []rune(content)
 	//var contentInt [] int64
 	//for index := 0; index < len(intArr); index++ {
 	//	contentInt = append(contentInt, int64(intArr[index]))
 	//}
 
-
-	return SubscriptionMsg{msg,topicInt,valueInt,operatorSlice, isAlpha}
+	return SubscriptionMsg{msg, topicInt, valueInt, operatorSlice, isAlpha}
 }
 
-
 type Args struct { // 매개변수
-	JsonMsg [] byte
-	Kind int
+	JsonMsg []byte
+	Kind    int
 }
 
 type Reply struct { // 리턴값
 }
 
 func generateRanUint64() uint64 {
+	rand.Seed(time.Now().UnixNano())
 	return uint64(rand.Uint32())<<32 + uint64(rand.Uint32())
 }
 
-func main(){
+func main() {
 
 	var argu string
 	for _, v := range os.Args {
 		if strings.Index(v, "-mma") == 0 {
-			argu = strings.Replace(v, "-mma=", "",-1)
+			argu = strings.Replace(v, "-mma=", "", -1)
 			break
 		}
 	}
 		return
 	}
 
-
 	args := new(Args)
 	reply := new(Reply)
 
 	privateKey := int64(generateRanUint64())
 	shareKey := int64(9999)
 
-	microService := MicroService{currentIP,privateKey, shareKey, make(chan bool), MMAddress}
-	receiver := Receiver{thisNodeAddr: currentIP,microService: microService}
+	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)+">")
+	color.Blue("<current machine address : " + currentIP + "> <MM address : " + MMAddress + ">")
+	color.Blue("<private key : " + strconv.FormatUint(uint64(privateKey), 10) + ">")
 
 	errReg := rpc.Register(receiver)
 	if errReg != nil {
 		return
 	}
 
-	client, err := rpc.Dial("tcp", microService.MMAddress + ":8160") // RPC 서버에 연결
+	client, err := rpc.Dial("tcp", microService.MMAddress+":8160") // RPC 서버에 연결
 	if err != nil {
 		fmt.Println(err)
 		return
 
 	go Listen()
 
-
 	// Register 메세지 생성
 	message := Message{From: microService.ClientAddr, Version: "1", Time: "1", Kind: RM}
 	regMsg := RegisterMsg{message, microService.PrivateKey}
-	RJsonMsg,_ := regMsg.ConvertToJson()
+	RJsonMsg, _ := regMsg.ConvertToJson()
 	args.JsonMsg = RJsonMsg
 	args.Kind = RM
 	err = client.Call("Receiver.MmReceive", args, reply)
 	}
 	color.Yellow("MM: " + reply.CompleteLog)
 
-
 	// 연결 되면 채널로 연결 확인이 되어야 다음 단계로 넘어감
-	checkConnect := <- microService.IsConnected
+	checkConnect := <-microService.IsConnected
 	_ = checkConnect
 	fmt.Scanln()
 	fmt.Println("***** sending Subscription messages *****")
 
 	/*
-	파일에서 subscription 읽어서 subscription 보내기
-	 **/
+		파일에서 subscription 읽어서 subscription 보내기
+		 **/
 	subFile, err := os.Open("subscription.txt")
 	if err != nil {
 		log.Fatalf("Error when opening file: %s", err)
 	fileScanner := bufio.NewScanner(subFile)
 	var subscriptionText string
 	numSub := 0
-	for fileScanner.Scan(){
+	for fileScanner.Scan() {
 		subscriptionText = fileScanner.Text()
 		subscriptionTextSlice := strings.Split(subscriptionText, "/")
 		subTopic := subscriptionTextSlice[0]
 		subValue := subscriptionTextSlice[1]
 		subOperator := subscriptionTextSlice[2]
 		var subIsAlpha bool
-		if subscriptionTextSlice[3] == "true"{
+		if subscriptionTextSlice[3] == "true" {
 			subIsAlpha = true
 		} else if subscriptionTextSlice[3] == "false" {
 			subIsAlpha = false
 		subMsg := CreateSubMsg(message, subTopic, subValue, subOperator, subIsAlpha)
 		//subMsg := CreateSubMsg(message, "soccer", "player", "==", true)
 		//fmt.Println(pubMsg)
-		subMsg = EncryptionSubMsg(subMsg,microService.ShareKey,microService.PrivateKey)
-		jsonMsg,_ := subMsg.ConvertToJson()
+		subMsg = EncryptionSubMsg(subMsg, microService.ShareKey, microService.PrivateKey)
+		jsonMsg, _ := subMsg.ConvertToJson()
 		args.JsonMsg = jsonMsg
 		args.Kind = subMsg.Kind
 		//fmt.Println(subMsg)
 
 		//fmt.Println(string(args.JsonMsg))
 		err = client.Call("Receiver.MmReceive", args, reply)
-		log.Println("SM sent! #:",numSub)
+		log.Println("SM sent! #:", numSub)
 		if err != nil {
 			fmt.Println(err)
 			return
 	fileScanner2 := bufio.NewScanner(pubFile)
 	var publishText string
 	numPub := 0
-	for fileScanner2.Scan(){
+	for fileScanner2.Scan() {
 		publishText = fileScanner2.Text()
 		publishTextSlice := strings.Split(publishText, "/")
 		//fmt.Println(publishTextSlice)
 		pubValue := publishTextSlice[1]
 		pubContent := publishTextSlice[2]
 
-
 		message = Message{From: microService.ClientAddr, Version: "1", Time: "1", Kind: PM}
 		pubMsg := CreatePubMsg(message, pubTopic, pubValue, pubContent)
 		//subMsg := CreateSubMsg(message, "soccer", "player", "==", true)
 		//fmt.Println("Pub.txt",pubMsg)
-		pubMsg = EncryptionPubMsg(pubMsg,microService.ShareKey,microService.PrivateKey)
-		jsonMsg,_ := pubMsg.ConvertToJson()
+		pubMsg = EncryptionPubMsg(pubMsg, microService.ShareKey, microService.PrivateKey)
+		jsonMsg, _ := pubMsg.ConvertToJson()
 		args.JsonMsg = jsonMsg
 		args.Kind = pubMsg.Kind
 		//fmt.Println(subMsg)
 
 		//fmt.Println(string(args.JsonMsg))
 		err = client.Call("Receiver.MmReceive", args, reply)
-		log.Println("PM sent! #:",numPub)
+		log.Println("PM sent! #:", numPub)
 		if err != nil {
 			fmt.Println(err)
 			return
 	return
 }
 
-func withDraw(msg Message, client *rpc.Client){
+func withDraw(msg Message, client *rpc.Client) {
 	msg.Kind = WM
 	wdMsg := WithdrawMsg{msg}
 	var args Args
 		msg.Content[index] = msg.Content[index] + gyKey + privateKey
 	}
 
-
 	return msg
 }
 
 		runeArr = append(runeArr, rune(int(msg.Value[index])))
 	}
 
-	if len(runeArr) == 1{
+	if len(runeArr) == 1 {
 		fmt.Println("Value is: ", runeArr)
 	} else {
 		fmt.Println("Value is:", string(runeArr))
 	}
 	defer l.Close()
 
-
 	for {
 		conn, _ := l.Accept()
 		go rpc.ServeConn(conn)
 	}
-}
+}