init commit

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/

.idea/TestClient.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="Go" enabled="true" />
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/TestClient.iml" filepath="$PROJECT_DIR$/.idea/TestClient.iml" />
+    </modules>
+  </component>
+</project>

src/example.json

@@ -0,0 +1,36 @@
+{
+  "||": [
+    {
+      "&&": [
+        {
+          "==": {
+            "attribute": "job",
+            "value": "doctor"
+          }
+        },
+        {
+          ">=": {
+            "attribute": "age",
+            "value": 40
+          }
+        }
+      ]
+    },
+    {
+      "&&" : [
+        {
+          "==": {
+          "attribute": "job",
+          "value": "programmer"
+          }
+        },
+        {
+          "<": {
+            "atrribute": "age",
+            "value": 30
+          }
+        }
+      ]
+    }
+  ]
+}

src/getIpaddr.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"net"
+)
+
+func getCurrentIPAddr() string {
+	addrs, err := net.InterfaceAddrs()
+
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	var currentIP string
+
+	for _, address := range addrs {
+
+		// check the address type and if it is not a loopback the display it
+		// = GET LOCAL IP ADDRESS
+		if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
+			if ipnet.IP.To4() != nil {
+				//fmt.Println("Current IP address : ", ipnet.IP.String())
+				currentIP = ipnet.IP.String()
+			}
+		}
+	}
+	return currentIP
+}

src/github.com/fatih/go.mod

@@ -0,0 +1,8 @@
+module github.com/fatih/color
+
+go 1.13
+
+require (
+	github.com/mattn/go-colorable v0.1.8
+	github.com/mattn/go-isatty v0.0.13
+)

src/github.com/fatih/go.sum

@@ -0,0 +1,8 @@
+github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+github.com/mattn/go-isatty v0.0.13 h1:qdl+GuBjcsKKDco5BsxPJlId98mSWNKqYA+Co0SC1yA=
+github.com/mattn/go-isatty v0.0.13/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae h1:/WDfKMnPU+m5M4xB+6x4kaepxRw6jWvR5iDRdvjHgy8=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

src/logConfig.go

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,733 @@
+package main
+
+// TODO: 등록확인 되기 전에는 PM,SM 전송 불가하게 만들 것, 실행파일로 만든 후, AWS 이용해서 여러개 마이크로서비스 상태에서 테스트 해볼것
+
+import (
+	"bufio"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"math/rand"
+	"net"
+	"net/rpc"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+	"unicode"
+)
+
+const (
+	KGM = 1 + iota
+	KSM
+	PM
+	SM
+	RM
+	WM
+)
+
+type Message struct {
+	From    string //ip 주소
+	Version string
+	Time    string
+	Kind    int //종류
+}
+
+type MsgUnit interface {
+	// ConvertToJson - send 전 json 형식으로 바꾸는 함수
+	ConvertToJson() ([]byte, error)
+	// CheckType - Message 의 타입을 알려줌
+	CheckType() int
+}
+
+type RegisterImgMsg struct {
+	Message
+	PrivateKey float64
+}
+
+type RegisterMsg struct {
+	Message
+	PrivateKey int64
+}
+
+type SubscriptionImage struct {
+	Message
+	Topic []float64 //
+}
+
+type SubscriptionMsg struct {
+	Message
+	Topic    []int64  //대주제
+	Value    []int64  //피연산자
+	Operator []string //연산자
+	IsAlpha  bool     //value가 숫자인지 문자열인지
+}
+
+type PublishImage struct {
+	Message
+	Topic []float64 // 이미지 vector
+}
+type PublishMsg struct {
+	Message
+	Topic   []int64 //대주제
+	Value   []int64 //Topic 의 세부적인 내용
+	Content []int64 // 내용
+}
+
+type WithdrawMsg struct {
+	Message
+}
+
+//type ImgReceiver struct {
+//	thisNodeAddr string
+//	microService MicroImgService
+//}
+
+type Receiver struct {
+	thisNodeAddr string
+	microService MicroService
+}
+
+//type MicroImgService struct {
+//	ClientAddr string
+//	PrivateKey float64
+//	ShareKey   float64
+//	// 메세지 미들웨어에 연결되어 있는가
+//	IsConnected chan bool
+//	MMAddress   string
+//}
+
+type MicroService struct {
+	ClientAddr string
+	PrivateKey float64
+	ShareKey   float64
+	// 메세지 미들웨어에 연결되어 있는가
+	IsConnected chan bool
+	MMAddress   string
+}
+
+func (receiver Receiver) Receive(args Args, reply *Reply) error {
+	switch args.Kind {
+
+	case KSM:
+		//var msg KeyShareMsg
+		//err := json.Unmarshal(args.JsonMsg, &msg)
+		//if err != nil {
+		//	return err
+		//}
+		//go func() {
+		//	_, err := receiver.moscato.Receive(msg)
+		//	if err != nil {
+		//
+		//	}
+		//}()
+		//reply.CompleteLog = "received completely"
+	case PM:
+		var msg PublishImage
+		err := json.Unmarshal(args.JsonMsg, &msg)
+		if err != nil {
+			return err
+		}
+		go func() {
+			receiver.microService.Receive(msg)
+		}()
+		reply.CompleteLog = "[" + receiver.thisNodeAddr + "] : pubMsg received"
+		//var msg PublishMsg
+		//err := json.Unmarshal(args.JsonMsg, &msg)
+		//if err != nil {
+		//	return err
+		//}
+		//
+		//go func() {
+		//	_, err := receiver.moscato.Receive(msg)
+		//	if err != nil {
+		//
+		//	}
+		//}()
+		//reply.CompleteLog = "PM received completely"
+	case SM:
+		//var msg SubscriptionMsg
+		//err := json.Unmarshal(args.JsonMsg, &msg)
+		//if err != nil {
+		//	return err
+		//}
+		//go func() {
+		//	_, err := receiver.moscato.Receive(msg)
+		//	if err != nil {
+		//
+		//	}
+		//}()
+		//reply.CompleteLog = "received completely"
+	case RM:
+		var msg RegisterMsg
+		err := json.Unmarshal(args.JsonMsg, &msg)
+		if err != nil {
+			return err
+		}
+		go func() {
+			receiver.microService.Receive(msg)
+		}()
+		reply.CompleteLog = "[" + receiver.thisNodeAddr + "] : ackRM received"
+	case WM:
+		//var msg WithdrawMsg
+		//err := json.Unmarshal(args.JsonMsg, &msg)
+		//if err != nil {
+		//	return err
+		//}
+		//go func() {
+		//	_, err := receiver.moscato.Receive(msg)
+		//	if err != nil {
+		//
+		//	}
+		//}()
+		//reply.CompleteLog = "received completely"
+	default:
+		return errors.New("message type Error: Not registered message type")
+	}
+	//reply.CompleteLog = "received completely"
+	return nil
+}
+
+func (microService MicroService) Receive(msg MsgUnit) {
+	logger := NewMyLogger()
+	logger.Sync()
+
+	var msg_type = msg.CheckType()
+	//메세지 타입에 따라 다르게 처리
+	switch msg_type {
+
+	case KSM: //Key share msg
+
+	case PM: //Publish msg
+		fmt.Println("----- received PM ------")
+		DecryptionImg(msg.(PublishImage), microService.ShareKey, microService.PrivateKey)
+		fmt.Println("Topic is", FloatSlice2String(msg.(PublishImage).Topic))
+		fmt.Println("------------------------")
+
+	case SM: //Subscription msg
+
+	case RM: //Register msg
+
+		microService.IsConnected <- true
+		logger.Info("MM Registered this node Complete!")
+
+	case WM: //Withdraw msg
+		//moscato.MicroServiceManager.RemoveMicroservice(msg.(*WithdrawMsg).From)
+
+	default:
+		errors.New("message type Error: Not registered message type")
+	}
+
+	return
+}
+
+func (msg RegisterImgMsg) ConvertToJson() ([]byte, error) {
+	js := msg
+	jsonBytes, err := json.Marshal(js)
+	return jsonBytes, err
+}
+
+func (msg SubscriptionImage) ConvertToJson() ([]byte, error) {
+	js := msg
+	jsonBytes, err := json.Marshal(js)
+	return jsonBytes, err
+}
+
+func (msg SubscriptionMsg) ConvertToJson() ([]byte, error) {
+	js := msg
+	jsonBytes, err := json.Marshal(js)
+	return jsonBytes, err
+}
+
+func (msg PublishImage) ConvertToJson() ([]byte, error) {
+	js := msg
+	jsonBytes, err := json.Marshal(js)
+	return jsonBytes, err
+}
+
+func (msg PublishMsg) ConvertToJson() ([]byte, error) {
+	js := msg
+	jsonBytes, err := json.Marshal(js)
+	return jsonBytes, err
+}
+
+func (msg RegisterMsg) ConvertToJson() ([]byte, error) {
+	js := msg
+	jsonBytes, err := json.Marshal(js)
+	return jsonBytes, err
+}
+
+func (msg WithdrawMsg) ConvertToJson() ([]byte, error) {
+	js := msg
+	jsonBytes, err := json.Marshal(js)
+	return jsonBytes, err
+}
+
+func (msg Message) CheckType() int {
+	return msg.Kind
+}
+
+func CreatePubImage(msg Message, topic string) PublishImage {
+
+	publishTextSlice := strings.Split(topic, " ")
+	var topicFloat []float64
+	for index := 0; index < len(publishTextSlice); index++ {
+		float, _ := strconv.ParseFloat(publishTextSlice[index], 8)
+		topicFloat = append(topicFloat, float)
+	}
+	return PublishImage{msg, topicFloat}
+}
+func CreatePubMsg(msg Message, topic string, value string, content string) PublishMsg {
+	//toPubMsg := new(PublishMsg)
+	//toPubMsg.Message = msg
+
+	intArr := []rune(topic)
+	//fmt.Print("Topic length ")
+	//fmt.Println(len(intArr))
+	//fmt.Println(len(toPubMsg.Topic))
+	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]) {
+		valueInt = append(valueInt, strInt64)
+	} else {
+		for index := 0; index < len(intArr); index++ {
+			//toPubMsg.Value = append(toPubMsg.Value, int64(intArr[index]))
+			valueInt = append(valueInt, int64(intArr[index]))
+		}
+	}
+
+	intArr = []rune(content)
+	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}
+}
+func CreateSubImage(msg Message, topic string) SubscriptionImage {
+
+	publishTextSlice := strings.Split(topic, " ")
+	var topicFloat []float64
+	for index := 0; index < len(publishTextSlice); index++ {
+		float, _ := strconv.ParseFloat(publishTextSlice[index], 8)
+		topicFloat = append(topicFloat, float)
+	}
+	return SubscriptionImage{msg, topicFloat}
+}
+
+func CreateSubMsg(msg Message, topic string, value string, operator string, isAlpha bool) SubscriptionMsg {
+	//toPubMsg := new(PublishMsg)
+	//toPubMsg.Message = msg
+
+	intArr := []rune(topic)
+	//fmt.Print("Topic length ")
+	//fmt.Println(len(intArr))
+	//fmt.Println(len(toPubMsg.Topic))
+	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
+	if isAlpha {
+		intArr = []rune(value)
+
+		for index := 0; index < len(intArr); index++ {
+			//toPubMsg.Value = append(toPubMsg.Value, int64(intArr[index]))
+			valueInt = append(valueInt, int64(intArr[index]))
+		}
+	} else {
+		stringSlice := strings.Split(value, " ")
+		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++ {
+	//	//toPubMsg.content = append(toPubMsg.content, int64(intArr[index]))
+	//	contentInt = append(contentInt, int64(intArr[index]))
+	//}
+
+	return SubscriptionMsg{msg, topicInt, valueInt, operatorSlice, isAlpha}
+}
+
+type Args struct { // 매개변수
+	JsonMsg []byte
+	Kind    int
+}
+
+type Reply struct { // 리턴값
+	CompleteLog string
+}
+
+func generateRanUint64() uint64 {
+	rand.Seed(time.Now().UnixNano())
+	//return uint64(rand.Uint32())<<32 + uint64(rand.Uint32())
+	return uint64(0 + uint64(rand.Uint32()))
+}
+
+func main() {
+	logger := NewMyLogger()
+	logger.Sync()
+
+	var argu string
+	for _, v := range os.Args {
+		if strings.Index(v, "-mma") == 0 {
+			argu = strings.Replace(v, "-mma=", "", -1)
+			break
+		}
+	}
+	MMAddress := argu
+	if argu == "" {
+		logger.Fatal("there is no Message Middleware address")
+		return
+	}
+
+	args := new(Args)
+	reply := new(Reply)
+
+	currentIP := getCurrentIPAddr()
+
+	const debugPK = 12345
+	privateKey := float64(generateRanUint64())
+	//privateKey := int64(generateRanUint64())
+	shareKey := float64(9999)
+	//shareKey := int64(9999)
+
+	microService := MicroService{currentIP, privateKey, shareKey, make(chan bool), MMAddress}
+	//microService := MicroService{currentIP, privateKey, shareKey, make(chan bool), MMAddress}
+	receiver := Receiver{thisNodeAddr: currentIP, microService: microService}
+
+	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 {
+		log.Println(errReg)
+		return
+	}
+
+	client, err := rpc.Dial("tcp", microService.MMAddress+":8160") // RPC 서버에 연결
+	if err != nil {
+		logger.Fatal(err.Error())
+		return
+	}
+	defer client.Close() // main 함수가 끝나기 직전에 RPC 연결을 닫음
+
+	go Listen()
+
+	// Register 메세지 생성
+	message := Message{From: microService.ClientAddr, Version: "1", Time: "1", Kind: RM}
+	regMsg := RegisterImgMsg{message, microService.PrivateKey}
+	RJsonMsg, _ := regMsg.ConvertToJson()
+	args.JsonMsg = RJsonMsg
+	args.Kind = RM
+	// arguments로 MMReceive호출해서 MM으로 보냄
+	err = client.Call("Receiver.MmReceive", args, reply)
+	logger.Info("RM sent")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	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()
+	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()
+	fileScanner := bufio.NewScanner(subFile)
+	var subscriptionText string
+	numSub := 0
+	file1, _ := os.Create("./subTimeLog.log")
+	defer file1.Close()
+	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" {
+		//	subIsAlpha = true
+		//} else if subscriptionTextSlice[3] == "false" {
+		//	subIsAlpha = false
+		//} else {
+		//	println(numSub, "subscription isAlpha type error.")
+		//}
+		fmt.Println(subscriptionText)
+		numSub++
+		message = Message{From: microService.ClientAddr, Version: "1", Time: "1", Kind: SM}
+
+		// 메세지 생성시간 측정
+		subMakingStartTime := time.Now()
+
+		subMsg := CreateSubImage(message, subscriptionText)
+		//logger.Debug("subMsg #" + strconv.Itoa(numSub) + " topic: " + subTopic + " / value: " + subValue + " / operator: " + subOperator)
+		logger.Debug("before enc subMsg #" + strconv.Itoa(numSub) + " topic: " + FloatSlice2String(subMsg.Topic))
+
+		//subMsg := CreateSubMsg(message, "soccer", "player", "==", true)
+		//fmt.Println(pubMsg)
+
+		// enc 필요없으므로 일단 주석
+		subMsg = EncryptionSubImage(subMsg, microService.ShareKey, microService.PrivateKey)
+		//fmt.Println(subMsg)
+		logger.Debug("after enc subMsg #" + strconv.Itoa(numSub) + " topic: " + FloatSlice2String(subMsg.Topic))
+		jsonMsg, _ := subMsg.ConvertToJson()
+		args.JsonMsg = jsonMsg
+		args.Kind = subMsg.Kind
+		//fmt.Println(subMsg)
+
+		//fmt.Println(string(args.JsonMsg))
+		subMakingElapsedTime := time.Since(subMakingStartTime)
+
+		// 메세지 생성 완료시간 측정
+		fmt.Printf("sub 생성시간: %d\n", subMakingElapsedTime.Nanoseconds())
+
+		fmt.Fprintln(file1, subMakingElapsedTime.Nanoseconds())
+
+		err = client.Call("Receiver.MmReceive", args, reply)
+		logger.Info("SM sent! #" + strconv.Itoa(numSub))
+
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		//log.Println(reply.CompleteLog)
+		logger.Debug("[MM] " + reply.CompleteLog)
+
+	}
+
+	fmt.Scanln()
+	logger.Info("sending Publish messages")
+
+	pubFile, err := os.Open("publish.txt")
+	if err != nil {
+		log.Fatalf("Error when opening file: %s", err)
+	}
+	defer pubFile.Close()
+	fileScanner2 := bufio.NewScanner(pubFile)
+	var publishText string
+	numPub := 0
+	file2, _ := os.Create("./pubTimeLog.log")
+	defer file2.Close()
+
+	for fileScanner2.Scan() {
+		publishText = fileScanner2.Text()
+		//publishTextSlice := strings.Split(publishText, " ")
+		//fmt.Println(publishTextSlice)
+		pubTopic := publishText
+		//pubValue := publishTextSlice[1]
+		//pubContent := publishTextSlice[2]
+
+		numPub++
+		message = Message{From: microService.ClientAddr, Version: "1", Time: "1", Kind: PM}
+		pubMakingStartTime := time.Now()
+
+		pubMsg := CreatePubImage(message, pubTopic)
+		logger.Debug("pubMsg #" + strconv.Itoa(numPub) + " topic: " + pubTopic)
+		logger.Debug("before enc pubMsg #" + strconv.Itoa(numPub) + " topic: " + FloatSlice2String(pubMsg.Topic))
+
+		// pubMsg Encryption
+		fmt.Println("Publisher Private Key :", strconv.FormatUint(uint64(microService.PrivateKey), 10))
+		pubMsg = EncryptionPubImage(pubMsg, microService.ShareKey, microService.PrivateKey)
+		logger.Debug("after enc pubMsg #" + strconv.Itoa(numPub) + " topic: " + FloatSlice2String(pubMsg.Topic))
+
+		jsonMsg, _ := pubMsg.ConvertToJson()
+		fmt.Println(jsonMsg)
+		args.JsonMsg = jsonMsg
+		args.Kind = pubMsg.Kind
+
+		pubMakingElapsedTime := time.Since(pubMakingStartTime)
+
+		fmt.Printf("pub 생성시간: %d\n\n", pubMakingElapsedTime.Nanoseconds())
+		fmt.Fprintln(file2, pubMakingElapsedTime.Nanoseconds())
+
+		err = client.Call("Receiver.MmReceive", args, reply)
+		logger.Info("PM sent! #" + strconv.Itoa(numPub))
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+
+		logger.Debug("[MM]: " + reply.CompleteLog)
+
+	}
+
+	<-done
+	return
+}
+
+func withDraw(msg Message, client *rpc.Client) {
+	msg.Kind = WM
+	wdMsg := WithdrawMsg{msg}
+	var args Args
+	args.JsonMsg, _ = wdMsg.ConvertToJson()
+	args.Kind = WM
+	var reply Reply
+	client.Call("Receiver.MmReceive", args, reply)
+}
+
+func EncryptionPubImage(msg PublishImage, gyKey float64, privateKey float64) PublishImage {
+	for index := range msg.Topic {
+		msg.Topic[index] = msg.Topic[index] + gyKey + privateKey
+	}
+	return msg
+}
+
+func EncryptionPubMsg(msg PublishMsg, gyKey int64, privateKey int64) PublishMsg {
+	for index := range msg.Topic {
+		msg.Topic[index] = msg.Topic[index] + gyKey + privateKey
+	}
+	for index := range msg.Value {
+		msg.Value[index] = msg.Value[index] + gyKey + privateKey
+	}
+	for index := range msg.Content {
+		msg.Content[index] = msg.Content[index] + gyKey + privateKey
+	}
+
+	return msg
+}
+
+func EncryptionSubImage(msg SubscriptionImage, gyKey float64, privateKey float64) SubscriptionImage {
+	for index := range msg.Topic {
+		msg.Topic[index] = msg.Topic[index] + gyKey + privateKey
+	}
+	return msg
+}
+
+func EncryptionSubMsg(msg SubscriptionMsg, gyKey int64, privateKey int64) SubscriptionMsg {
+	for index := range msg.Topic {
+		msg.Topic[index] = msg.Topic[index] + gyKey + privateKey
+	}
+	for index := range msg.Value {
+		msg.Value[index] = msg.Value[index] + gyKey + privateKey
+	}
+	return msg
+}
+
+func DecryptionImg(msg PublishImage, gyKey float64, privateKey float64) {
+	for index := range msg.Topic {
+		msg.Topic[index] = msg.Topic[index] - gyKey - privateKey
+	}
+
+	var runeArr []rune
+	for index := range msg.Topic {
+		runeArr = append(runeArr, rune(int(msg.Topic[index])))
+	}
+	//fmt.Println("Topic is: " + string(runeArr))
+	runeArr = nil
+
+}
+
+func DecryptionMsg(msg PublishMsg, gyKey int64, privateKey int64) {
+	for index := range msg.Topic {
+		msg.Topic[index] = msg.Topic[index] - gyKey - privateKey
+	}
+	for index := range msg.Value {
+		msg.Value[index] = msg.Value[index] - gyKey - privateKey
+	}
+	for index := range msg.Content {
+		msg.Content[index] = msg.Content[index] - gyKey - privateKey
+	}
+
+	var runeArr []rune
+	for index := range msg.Topic {
+		runeArr = append(runeArr, rune(int(msg.Topic[index])))
+	}
+	fmt.Println("Topic is: " + string(runeArr))
+	runeArr = nil
+
+	for index := range msg.Value {
+		runeArr = append(runeArr, rune(int(msg.Value[index])))
+	}
+
+	if len(runeArr) == 1 {
+		fmt.Println("Value is: ", runeArr)
+	} else {
+		fmt.Println("Value is:", string(runeArr))
+	}
+
+	runeArr = nil
+
+	for index := range msg.Content {
+		runeArr = append(runeArr, rune(int(msg.Content[index])))
+	}
+	fmt.Println("Content is: " + string(runeArr))
+	runeArr = nil
+
+}
+
+func Listen() {
+	l, err1 := net.Listen("tcp", ":8150") //MM로 부터 받는거
+	if err1 != nil {
+		log.Fatal(fmt.Sprintf("Unable to listen on given port: %s", err1))
+	}
+	defer l.Close()
+
+	for {
+		conn, _ := l.Accept()
+		go rpc.ServeConn(conn)
+	}
+}
+func FloatSlice2String(target []float64) string {
+	var targetString string
+	targetString = ""
+	for _, value := range target {
+		targetString += strconv.FormatFloat(float64(value), 'f', -1, 64) + " "
+	}
+	return targetString
+}
+
+func IntSlice2String(target []int64) string {
+	var targetString string
+	targetString = ""
+	for _, value := range target {
+		targetString += strconv.FormatInt(int64(value), 10) + " "
+	}
+	return targetString
+}

src/parseJson_test.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"testing"
+)
+
+func parseJson(dat []byte) {
+	data := make(map[string]interface{})
+	err := json.Unmarshal([]byte(dat), &data)
+	if err != nil {
+		fmt.Println(err)
+	}
+	traverseCheck(data)
+}
+
+
+func traverseCheck(el map[string]interface{}) {
+	for key, val := range el{
+		_ = val
+		if key == "==" || key == ">=" || key == "<=" || key == "<" || key == ">"{
+			//fmt.Println("****************")
+			tmpMap := el[key].(map[string]interface{})
+			fmt.Println(key)
+			for k, v := range tmpMap{
+				fmt.Println(k, v)
+			}
+			//fmt.Println("****************")
+
+		} else if key == "||" || key == "&&"{
+			tmpSlice := el[key].([]interface{})
+			fmt.Println(key)
+			for _, obj := range tmpSlice{
+				data := obj.(map[string]interface{})
+				traverseCheck(data)
+			}
+		}
+	}
+}
+
+func TestParseJson(t *testing.T) {
+
+	dat, err := ioutil.ReadFile("./example.json")
+	if err != nil {
+		fmt.Println(err)
+	}
+	parseJson(dat)
+}

src/pubTimeLog.log

@@ -0,0 +1 @@
+198000

src/publish.txt

@@ -0,0 +1 @@
+10.123123 30.3214135 20.2541531 40.523412 12.542321 43.532123 51.31242 32.25234132413

src/subTimeLog.log

@@ -0,0 +1 @@
+1033875

src/subscription.txt

@@ -0,0 +1 @@
+1.0 2.0 3.0 4.0 5.0 6.0

test.log

@@ -0,0 +1,41 @@
+2022-01-02T15:43:21.444+0900	INFO	current machine address : 192.168.0.77 / MM address : 127.0.0.1
+2022-01-02T15:43:21.445+0900	DEBUG	private key : 3547138460
+2022-01-02T15:43:21.447+0900	INFO	RM sent
+2022-01-02T15:43:21.447+0900	DEBUG	[MM] RM received
+2022-01-02T15:43:21.453+0900	INFO	MM Registered this node Complete!
+2022-01-02T15:46:14.173+0900	INFO	current machine address : 192.168.0.77 / MM address : 127.0.0.1
+2022-01-02T15:46:14.174+0900	DEBUG	private key : 1652718355
+2022-01-02T15:46:14.175+0900	INFO	RM sent
+2022-01-02T15:46:14.175+0900	DEBUG	[MM] RM received
+2022-01-02T15:46:14.181+0900	INFO	MM Registered this node Complete!
+2022-01-02T15:46:25.988+0900	INFO	sending Subscription messages
+2022-01-02T15:48:06.443+0900	INFO	current machine address : 192.168.0.77 / MM address : 127.0.0.1
+2022-01-02T15:48:06.443+0900	DEBUG	private key : 2580440694
+2022-01-02T15:48:06.445+0900	INFO	RM sent
+2022-01-02T15:48:06.445+0900	DEBUG	[MM] RM received
+2022-01-02T15:48:19.445+0900	INFO	current machine address : 192.168.0.77 / MM address : 127.0.0.1
+2022-01-02T15:48:19.445+0900	DEBUG	private key : 2861559125
+2022-01-02T15:48:19.448+0900	INFO	RM sent
+2022-01-02T15:48:19.452+0900	DEBUG	[MM] RM received
+2022-01-02T15:48:19.458+0900	INFO	MM Registered this node Complete!
+2022-01-02T15:48:22.290+0900	INFO	sending Subscription messages
+2022-01-02T15:59:46.422+0900	INFO	current machine address : 192.168.0.77 / MM address : 127.0.0.1
+2022-01-02T15:59:46.422+0900	DEBUG	private key : 1320653589
+2022-01-02T15:59:46.424+0900	INFO	RM sent
+2022-01-02T15:59:46.424+0900	DEBUG	[MM] RM received
+2022-01-02T15:59:46.437+0900	INFO	MM Registered this node Complete!
+2022-01-02T15:59:49.270+0900	INFO	sending Subscription messages
+2022-01-02T16:00:17.004+0900	INFO	current machine address : 192.168.0.77 / MM address : 127.0.0.1
+2022-01-02T16:00:17.005+0900	DEBUG	private key : 560452067
+2022-01-02T16:00:17.006+0900	INFO	RM sent
+2022-01-02T16:00:17.006+0900	DEBUG	[MM] RM received
+2022-01-02T16:00:29.424+0900	INFO	current machine address : 192.168.0.77 / MM address : 127.0.0.1
+2022-01-02T16:00:29.424+0900	DEBUG	private key : 213155866
+2022-01-02T16:00:29.426+0900	INFO	RM sent
+2022-01-02T16:00:29.426+0900	DEBUG	[MM] RM received
+2022-01-02T16:00:29.440+0900	INFO	MM Registered this node Complete!
+2022-01-02T16:00:32.131+0900	INFO	sending Subscription messages
+2022-01-02T16:08:17.494+0900	INFO	current machine address : 192.168.0.77 / MM address : 127.0.0.1
+2022-01-02T16:08:17.496+0900	INFO	RM sent
+2022-01-02T16:08:17.503+0900	INFO	MM Registered this node Complete!
+2022-01-02T16:08:20.647+0900	INFO	sending Subscription messages