[fin]RPC

src/microservice/modules/init.go

@@ -1,6 +1,8 @@
 package modules
 
 import (
+	"encoding/json"
+	"errors"
 	"fmt"
 	"log"
 	"net"
@@ -13,117 +15,130 @@ type Microservice struct {
 type Moscato struct {
 }
 
-type Reply struct {
-	receivemsg MsgUnit
+type Receiver struct{
+	microservice *Microservice
 }
 
-func (microservice *Microservice)MS_Receive(msg MsgUnit, reply *Reply)error{
-	go microservice.Receive(msg)
-	return nil
-}
-
-//Receive - MicroService가 msg 받음// MS.go들어가야할 함수
-func (microservice *Microservice)Receive(msg MsgUnit)error{
-	msg_type:=msg.CheckType()
-
-	switch msg_type{
-	case KGM://Key Gen Msg
-
-	case KSM://Key Share Msg
-
-	case SM://Subscription Msg
-
-	}
-	return nil
+type Reply struct {
+	CompleteLog string
 }
 
-func (microservice *Microservice) Send2MM(client *rpc.Client,msg MsgUnit) {
-	reply:=new(Reply)
-	err:=client.Call("Moscato.MM_Receive", msg,reply)
-	if err !=nil{
-		fmt.Println(err)
-		return
-	}
+type Args struct {
+	JsonMsg []byte
+	Kind int
 }
 
-func (microservice *Microservice) Listen() {
-	l, err := net.Listen("tcp", fmt.Sprintf(":%v", 8160))
+//MM에서 MS로 보냄 rpc call
+func (receiver Receiver)MsReceive(args Args, reply *Reply)error{
+	switch args.Kind{
+	case KGM://Key Gen Msg
+		var msg KeyGenMsg
+		err:=json.Unmarshal(args.JsonMsg,&msg)
+		if err != nil {
+			return err
+		}
+		go func() {
+			_, err := receiver.microservice.Receive(&msg)
+			if err != nil {
 
-	if err != nil {
-		log.Fatal(fmt.Sprintf("Unable to listen on given port: %s", err))
-	}
-	defer l.Close()
+			}
+		}()
+		reply.CompleteLog = "received completely"
 
-	for {
-		conn, _ := l.Accept()
-		go rpc.ServeConn(conn)
-	}
-}
+	case KSM://Key Share Msg
+		var msg KeyShareMsg
+		err:=json.Unmarshal(args.JsonMsg,&msg)
+		if err != nil {
+			return err
+		}
+		go func() {
+			_, err := receiver.microservice.Receive(&msg)
+			if err != nil {
 
+			}
+		}()
+		reply.CompleteLog = "received completely"
 
-func handleSum(ln net.Listener){
-	for {
-		conn, err := ln.Accept() // 클라이언트가 연결되면 TCP 연결을 리턴
+	case SM://Subscription Msg
+		var msg SubscriptionMsg
+		err:=json.Unmarshal(args.JsonMsg,&msg)
 		if err != nil {
-			continue
+			return err
 		}
-
-		defer func(conn net.Conn) {
-			err := conn.Close()
+		go func() {
+			_, err := receiver.microservice.Receive(&msg)
 			if err != nil {
 
 			}
-		}(conn)             // main 함수가 끝나기 직전에 TCP 연결을 닫음
-
-		go rpc.ServeConn(conn) // RPC를 처리하는 함수를 고루틴으로 실행
+		}()
+		reply.CompleteLog = "received completely"
+	default:
+		return errors.New("This msgtype is not appropriate")
 	}
+	return nil
 }
 
-func callRPC(client *rpc.Client, msg MsgUnit, err error){
-	reply := new(MsgUnit)
-	err = client.Call("Moscato.MM_Receive", msg, reply) // Calc.Sum 함수 호출
-	if err != nil {
-		fmt.Println(err)
-		return
+//Receive - MicroService가 msg 받음 MS.go들어가야할 함수
+func (microservice *Microservice)Receive(msg MsgUnit)(MsgUnit,error) {
+	msgType:=msg.CheckType()
+	switch msgType {
+	case KGM:
+		//KeyGen 일 때 할 행동
+	case KSM:
+		//KeyShare 일 때 할 행동
+	case SM:
+		//SubM 일 때 할 행동
 	}
+	return msg, nil
 }
 
-func (microservice *Microservice) Run() {
-	err := rpc.Register(new(Microservice))
-	if err != nil {
-		return
-	} // Calc 타입의 인스턴스를 생성하여 RPC 서버에 등록
-	ln, err := net.Listen("tcp", ":6000") // TCP 프로토콜에 6000번 포트로 연결을 받음 local 나중에 8150
-	ln1, err1 := net.Listen("tcp", ":6001") // TCP 프로토콜에 6000번 포트로 연결을 받음 나중에 8160
-
-	if err != nil {
+func (microservice *Microservice) Send2MM(ipaddress string,msg MsgUnit) {
+	client,err:=rpc.Dial("tcp",ipaddress+":8160")
+	if err!=nil{
 		fmt.Println(err)
 		return
 	}
-	if err1 != nil {
+	reply:=new(Reply)
+	jmsg,_:=msg.ConvertToJson()
+	args:=Args{
+		JsonMsg: jmsg,
+		Kind: msg.CheckType(),
+	}
+	err:=client.Call("receiver.MmReceive",args,reply)
+	if err !=nil{
 		fmt.Println(err)
 		return
 	}
-	defer func(ln net.Listener) {
-		err := ln.Close()
-		if err != nil {
+	fmt.Println(reply.CompleteLog)
+}
 
-		}
-	}(ln)             // main 함수가 종료되기 직전에 연결 대기를 닫음
-	defer func(ln1 net.Listener) {
-		err := ln1.Close()
-		if err != nil {
 
-		}
-	}(ln1) // main 함수가 종료되기 직전에 연결 대기를 닫음
 
-	/*client1, err := rpc.Dial("tcp", "127.0.0.1:6000") // RPC 서버에 연결
+func (microservice *Microservice) Run() {
+	receiver := Receiver{microservice:microservice}
+	//rpc 등록 -> Receive 함수
+	err := rpc.Register(receiver)
 	if err != nil {
-		fmt.Println(err)
+		log.Println(err)
 		return
-	}*/
+	}
+	Listen()
+	log.Println("listen complete.")
+	fmt.Scanln()
+}
+
+func Listen() {
+	//l, err := net.Listen("tcp", fmt.Sprintf(":%v", 8160))
+	//MS port : 8150
+	l, err := net.Listen("tcp", ":8150")//MS port
 
-	go handleSum(ln)
-	go handleSum(ln1)
-	fmt.Scanln() // main 함수가 종료되지 않도록 대기=
+	if err != nil {
+		log.Fatal(fmt.Sprintf("Unable to listen on given port: %s", err))
+	}
+	defer l.Close()
+
+	for {
+		conn, _ := l.Accept()
+		go rpc.ServeConn(conn)
+	}
 }