[fin] comment

src/broker/modules/init.go

 package modules
 
 import (
+	"broker/modules/github.com/fatih/color"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/fatih/color"
 	"log"
 	"net"
 	"net/rpc"
 // TODO: RM 처리와 init.go 전반적으로 DI 이용하여 구현 RM 키등록 부분 구현 예정
 
 type Moscato struct {
-	queue               MsgQueue
-	SendQueue           chan myType
+	queue               MsgQueue //메세지 받는 큐
+	SendQueue           chan myType //Publish Message가 들어왔을때 매칭이 된 결과물이 담김
 	MicroServiceManager NodeManager `inject:""`
 	MatchingManager     match_manager
 	SubscriptionManager sub_manager
 }
 
 type myType struct {
-	subList []string
-	pubMsg  MsgUnit
+	subList []string //sub의 ip주소를 가지고 있음
+	pubMsg  MsgUnit //Publish Message
 	err     error
 }
 
 }
 
 type Args struct { // 매개변수
-	JsonMsg []byte
-	Kind    int
+	JsonMsg []byte //JSON 타입으로 바뀐 메세지
+	Kind    int //메세지 종류
 }
 
 /*
+MM:MessageMiddleWare
+MS:MicroService
 MS→MM
 
 -MM 실행되면 MM서버는 열려있음(MS은 자동으로 Client)(포트 8150)
 -MmReceive에서 msgType 검사 후 그것에 맞게 msgUnit으로 MM의 Receive로 보냄
 
 -MM의 Receive에서 해당 Message를 처리
-*/
+ */
 
-func (receiver Receiver) MmReceive(args Args, reply *Reply) error { //
-	// 메세지 별로 나눠서 언마샬
+func (receiver Receiver) MmReceive(args Args, reply *Reply) error {
+	// 메세지 타입별로 나눠서 언마샬
 	switch args.Kind {
 
-	case KSM:
+	case KSM://KeyShareMessage
 		var msg KeyShareMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 		if err != nil {
 			}
 		}()
 		reply.CompleteLog = "received"
-	case PM:
+	case PM://PublishMessage
 		var msg PublishMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 		if err != nil {
 			}
 		}()
 		reply.CompleteLog = "PM received"
-	case SM:
+	case SM://SubscriptionMessage
 		var msg SubscriptionMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 		if err != nil {
 			}
 		}()
 		reply.CompleteLog = "SM received"
-	case RM:
+	case RM://RegisterMessage
 		var msg RegisterMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 		if err != nil {
 			}
 		}()
 		reply.CompleteLog = "RM received"
-	case WM:
+	case WM://WithdrawMessage
 		var msg WithdrawMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 		if err != nil {
 			}
 		}()
 		reply.CompleteLog = "WM received"
-	default:
+	default://MM이 받을 타입의 메세지가 아닌 경우
+		reply.CompleteLog="This type is inappropriate"
 		return errors.New("message type Error: Not registered message type")
 	}
 	//reply.CompleteLog = "received completely"
 	return nil
 }
-
-func (moscato *Moscato) preProcessMsg(originalMsg MsgUnit) MsgUnit {
-	if originalMsg.CheckType() == PM {
-		pubMsg := originalMsg.(PublishMsg)
-		for index := 0; index < len(pubMsg.Topic); index++ {
-			pubMsg.Topic[index] = pubMsg.Topic[index] - moscato.SecureManager.GetNodeKey(pubMsg.From)
-		}
-		for index := 0; index < len(pubMsg.Value); index++ {
-			pubMsg.Value[index] = pubMsg.Value[index] - moscato.SecureManager.GetNodeKey(pubMsg.From)
-		}
-		return pubMsg
-	} else if originalMsg.CheckType() == SM {
-		subMsg := originalMsg.(SubscriptionMsg)
-		for index := 0; index < len(subMsg.Topic); index++ {
-			subMsg.Topic[index] = subMsg.Topic[index] - moscato.SecureManager.GetNodeKey(subMsg.From)
-		}
-		for index := 0; index < len(subMsg.Value); index++ {
-			subMsg.Value[index] = subMsg.Value[index] - moscato.SecureManager.GetNodeKey(subMsg.From)
-		}
-		return subMsg
-	}
-	return nil
-}
-
-func (moscato *Moscato) SendWithEncrypt() MsgUnit {
-	for {
-		mt := <-moscato.SendQueue
-		//fmt.Println(mt)
-		if mt.err == nil {
-			for index := 0; index < len(mt.subList); index++ {
-				tmpNode := mt.subList[index]
-				tmpNodeIpAddr, _ := moscato.MicroServiceManager.GetIpaddr(tmpNode)
-				//moscato.SecureManager.ReEncPubMsg(mt.pubMsg.(PublishMsg), tmpNode)
-				//fmt.Println("publish: ", mt.pubMsg)
-				//moscato.Send2MS(tmpNodeIpAddr, mt.pubMsg)
-				moscato.Send2MS(tmpNodeIpAddr, moscato.SecureManager.ReEncPubMsg(mt.pubMsg.(PublishMsg), tmpNode))
-			}
-		}
-		return nil
-	}
-}
-
-//Recieve - MM가 msg전달 받음
+//Recieve - MM가 MS로부터 메세지 전달받음
 func (moscato *Moscato) Receive(msg MsgUnit) (MsgUnit, error) {
-	//rpc call
 	var msg_type = msg.CheckType()
 	//메세지 타입에 따라 다르게 처리
 	switch msg_type {
 
-	case KSM: //Key share msg
-		
-	case PM: //Publish msg
+	case KSM: //KeyShareMessage - 추후 구현
+
+	case PM: //PublishMessage
 		log.Println("PM received")
 		moscato.queue.push(moscato.preProcessMsg(msg))
 
-	case SM: //Subscription msg
+	case SM: //SubscriptionMessage
 		log.Println("SM received")
 		err := moscato.SubscriptionManager.addSubscription(moscato.preProcessMsg(msg))
 		if err != nil {
 			println(err)
-			//return nil, err
 		}
 
-	case RM: //Register msg
+	case RM: //RegisterMessage
 		log.Println("RM received")
 		var newMsg RegisterMsg
 		newMsg = msg.(RegisterMsg)
 		ip := msg.(WithdrawMsg).From
 		moscato.MicroServiceManager.RemoveMicroservice(msg.(WithdrawMsg).From)
 		moscato.SecureManager.RemoveSecureKey(msg.(WithdrawMsg).From)
-		moscato.SubscriptionManager.delete(ip)
+		moscato.SubscriptionManager.delete(ip) //해당 Ip주소를 가진 Subscription 정보 삭제
 
-	default:
+	default://MM이 받을 메세지 타입이 아닌경우
+		log.Println("Message type Error: Not registered message type")
 		return nil, errors.New("Message type Error: Not registered message type")
 	}
 
 	log.Println(reply.CompleteLog)
 }
 
+//Matching을 용이하게 하기위한 메세지 가공 과정
+func (moscato *Moscato) preProcessMsg(originalMsg MsgUnit) MsgUnit {
+	if originalMsg.CheckType() == PM {
+		pubMsg := originalMsg.(PublishMsg)
+		for index := 0; index < len(pubMsg.Topic); index++ {
+			pubMsg.Topic[index] = pubMsg.Topic[index] - moscato.SecureManager.GetNodeKey(pubMsg.From)
+		}
+		for index := 0; index < len(pubMsg.Value); index++ {
+			pubMsg.Value[index] = pubMsg.Value[index] - moscato.SecureManager.GetNodeKey(pubMsg.From)
+		}
+		return pubMsg
+	} else if originalMsg.CheckType() == SM {
+		subMsg := originalMsg.(SubscriptionMsg)
+		for index := 0; index < len(subMsg.Topic); index++ {
+			subMsg.Topic[index] = subMsg.Topic[index] - moscato.SecureManager.GetNodeKey(subMsg.From)
+		}
+		for index := 0; index < len(subMsg.Value); index++ {
+			subMsg.Value[index] = subMsg.Value[index] - moscato.SecureManager.GetNodeKey(subMsg.From)
+		}
+		return subMsg
+	}
+	return nil
+}
+
+//암호화 해서 보내기
+func (moscato *Moscato) SendWithEncrypt() MsgUnit {
+	for {
+		mt := <-moscato.SendQueue
+		if mt.err == nil {
+			for index := 0; index < len(mt.subList); index++ { //sublist들을 돌면서 매세지를 encrypt하여 메세지 보냄
+				tmpNode := mt.subList[index]
+				tmpNodeIpAddr, _ := moscato.MicroServiceManager.GetIpaddr(tmpNode)
+				//moscato.SecureManager.ReEncPubMsg(mt.pubMsg.(PublishMsg), tmpNode)
+				//fmt.Println("publish: ", mt.pubMsg)
+				//moscato.Send2MS(tmpNodeIpAddr, mt.pubMsg)
+				moscato.Send2MS(tmpNodeIpAddr, moscato.SecureManager.ReEncPubMsg(mt.pubMsg.(PublishMsg), tmpNode))
+			}
+		}
+		return nil
+	}
+}
+
 func (moscato *Moscato) Run() {
 
 	config := AppConfig{moscato}
 	go func() {
 		for {
 			msg := moscato.queue.pop(true)
+			fmt.Println(msg)
 			go moscato.Matching(msg)
 			go moscato.SendWithEncrypt()
 		}
 
 	go Listen()
 	color.Blue("initializing complete.")
+
 	fmt.Scanln()
 }
 
 func Listen() {
 	/*
-		MS→MM일때 ⇒ port : 8160으로 열기
+	MS→MM일때 ⇒ port : 8160으로 열기
 
-		(MM이 Server, MS가 Client)
+	(MM이 Server, MS가 Client)
 	*/
 
 	l, err1 := net.Listen("tcp", ":8160")

src/broker/modules/manage.go

 
 //각 Microservice에 대한 정보 저장 노드
 type MSNode struct {
-	nodeName string
+	nodeName string //Nodename- 현재 데모에서는 IpAddress와 같음
 	ipAddr   string
 }
 
+//Nodename 반환
 func (node *MSNode) GetName() string {
 	return node.nodeName
 }
+
+//IpAddress 반환
 func (node *MSNode) GetIpaddr() string {
 	return node.ipAddr
 }
 
 type NodeManager interface {
-	GetIpaddr(nodeName string) (string, bool)
-	AddMicroservice(node MSNode) bool
-	RemoveMicroservice(nodeName string) bool
+	GetIpaddr(nodeName string) (string, bool) //IpAddress반환
+	AddMicroservice(node MSNode) bool //MS추가
+	RemoveMicroservice(nodeName string) bool //MS삭제
 }
 
 //모든 Microservice정보 저장
 	NodeTable map[string]MSNode
 }
 
+//MStable 생성자
 func NewMStable() *MStable {
 	defer fmt.Println("node manager setting complete.")
 	return &MStable{NodeTable: make(map[string]MSNode)}
 }
 
+//IpAddress반환
 func (manager *MStable) GetIpaddr(nodeName string) (string, bool) {
 	//해당 이름의 노드이름이 존재하는지 확인
 	node, exists := manager.NodeTable[nodeName]
 	}
 }
 
+//MS추가
 func (manager *MStable) AddMicroservice(node MSNode) bool {
 	//삽입 전 존재여부 확인
-	_, exists := manager.NodeTable[node.GetName()]
+	_, exists := manager.NodeTable[node.GetName()] ////해당 Node의 이름이 있는지 검색
 
 	if exists {
 		return false
-	} else {
+	} else { //존재안한다면 추가 (존재할경우 이미 있는것이기 때문에 추가할 필요 없음)
 		manager.NodeTable[node.GetName()] = node
 		return true
 	}
 }
 
+//MS삭제
 func (manager *MStable) RemoveMicroservice(nodeName string) bool {
 	//삭제 전 존재여부 확인
-	_, exists := manager.NodeTable[nodeName]
+	_, exists := manager.NodeTable[nodeName] //해당 이름을 가진 Node가 있는지 검색
 
 	if exists {
-		delete(manager.NodeTable, nodeName)
+		delete(manager.NodeTable, nodeName) //존재한다면 삭제
 		log.Println("[" + nodeName + "] : service quit")
 		return true
 	} else {