[revise] RPC가 가능하도록 init.go 와 message 객체 수정

.idea/vcs.xml

 <project version="4">
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/src/github.com/bmizerany/assert" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/src/github.com/davecgh/go-spew" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/src/github.com/juliangruber/go-intersect" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/src/github.com/kr/pretty" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/src/github.com/kr/text" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/src/github.com/pmezard/go-difflib" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/src/github.com/rogpeppe/go-internal" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/src/github.com/stretchr/testify" vcs="Git" />
     <mapping directory="$PROJECT_DIR$/src/gopkg.in/yaml.v3" vcs="Git" />
   </component>

src/broker/modules/init.go

 package modules
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"log"
 )
 
 //temporary type for matching manager
-type match_manager struct{}
+//type match_manager struct{}
 
 func (match_mng *match_manager) matching(queue *MsgQueue) {
 	//msg := queue.pop(true)
 }
 
 type Reply struct {
-	ReceiveMsg MsgUnit
+	CompleteLog string
 }
 
-type Listner int
-
+type Receiver struct {
+	moscato *Moscato
+}
 
 //MS에서 보내는거-rpc call 사용
 /*func (l *Listner)MM_Receive(msg MsgUnit, reply *Reply)error{
 	return nil
 }*/
 
-func (moscato *Moscato)MM_Receive(msg MsgUnit, reply *Reply)error{
-	reply.ReceiveMsg=msg
-  	go moscato.Receive(reply)
+type Args struct { // 매개변수
+	JsonMsg []byte
+	Kind    int
+}
+
+func (receiver Receiver) MM_Receive(args Args, reply *Reply) error {
+	// 메세지 별로 나눠서 언마샬하면 됨
+
+	var msg PublishMsg
+
+	//msg
+	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"
 	return nil
 }
 
 //Recieve - MM가 msg전달 받음
-func (moscato *Moscato)Receive(reply *Reply) (MsgUnit, error) {
+func (moscato *Moscato) Receive(msg MsgUnit) (MsgUnit, error) {
 	//rpc call
-	var msg_type = reply.ReceiveMsg.CheckType()
+	var msg_type = msg.CheckType()
 	//메세지 타입에 따라 다르게 처리
 	switch msg_type {
 
 	case KSM: //Key share msg
 
 	case PM: //Publish msg
-		moscato.queue.push(reply.ReceiveMsg.(*PublishMsg))
+		moscato.queue.push(msg.(PublishMsg))
+		log.Println("popped queue: ", moscato.queue.pop(false))
 
 	case SM: //Subscription msg
-		moscato.match_mng.add_subscription(reply.ReceiveMsg.(*SubscriptionMsg))
+		moscato.match_mng.add_subscription(msg.(*SubscriptionMsg))
 
 	case RM: //Register msg
 		//var newmsg RegisterMsg
-		var newmsg = reply.ReceiveMsg.(*RegisterMsg)
-		newNode := MSnode{newmsg.From(), newmsg.From()}
+		var newmsg = msg.(*RegisterMsg)
+		newNode := MSnode{newmsg.From, newmsg.From}
 		moscato.ms_mng.add_microservice(newNode)
 
 	case WM: //Withdraw msg
-		moscato.ms_mng.remove_microservice(reply.ReceiveMsg.(*WithdrawMsg).From())
+		moscato.ms_mng.remove_microservice(msg.(*WithdrawMsg).From)
 
 	default:
 		return nil, errors.New("Message type Error: Not registered message type")
 	}
 
-	return reply.ReceiveMsg, nil
+	return msg, nil
 }
 
-
 func (moscato *Moscato) Run() {
 	//모스카토 구조체 변수 초기화
+	receiver := Receiver{moscato: moscato}
 	moscato.queue.queue_init()
 
 	//go routine -> matching 동작
 	go moscato.match_mng.matching(&moscato.queue)
 
-	//rpc 등록 -> Receive함수
-	rpc.Register(moscato)
-	moscato.Listen()
+	//rpc 등록 -> Receive 함수
+	err := rpc.Register(receiver)
+	if err != nil {
+		fmt.Println("fuck")
+		log.Println(err)
+		return
+	}
+	Listen()
+	log.Println("listen complete.")
+	fmt.Scanln()
 }
 
-func (moscato *Moscato) Listen() {
-	l, err := net.Listen("tcp", fmt.Sprintf(":%v", 8160))
+func Listen() {
+	//l, err := net.Listen("tcp", fmt.Sprintf(":%v", 8160))
+	l, err := net.Listen("tcp", "0.0.0.0:8160")
 
 	if err != nil {
 		log.Fatal(fmt.Sprintf("Unable to listen on given port: %s", err))

src/broker/modules/list.go

 }
 
 type valueNode struct {
-	val  []int64 // Encrypted topic
+	val  []int64 // Encrypted Topic
 	next *valueNode
 	prev *valueNode
 
 	return append(ary[:i], ary[i+1:]...)
 }
 
-// To find a specific sub# in a value node
+// To find a specific sub# in a Value node
 func findSub(ary []int, sub int) int {
 	for i := 0; i < len(ary); i++ {
 		if ary[i] == sub {
 	return -1
 }
 
-// To add a topic node to the topic list
-func (l *topicList) addTopicNode(topic []int64){
+// To add a Topic node to the Topic list
+func (l *topicList) addTopicNode(topic []int64) {
 	newNode := &topicNode{topic, nil, nil, valueList{}}
-	if l.head == nil{
+	if l.head == nil {
 		l.head = newNode
 		l.tail = l.head
-	} else{
+	} else {
 		newNode.prev = l.tail
 		l.tail.next = newNode
 		l.tail = newNode
 	l.size++
 }
 
-// To check if a specific value node is empty
+// To check if a specific Value node is empty
 func (n *valueNode) isEmpty() bool {
 	empty := true
 	if len(n.single2sub_s) != 0 {
 	return empty
 }
 
-// To insert sub# into the operator list of the value node
+// To insert sub# into the operator list of the Value node
 func (n *valueNode) insertSub(op string, sub int, issingle bool) {
 	if issingle == true {
 		switch op {
 	}
 }
 
-// To add a value node to the value list
+// To add a Value node to the Value list
 func (l *valueList) addValueNode(value []int64) {
 	newValNode := &valueNode{value, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil}
-	if l.head == nil{
+	if l.head == nil {
 		l.head = newValNode
 		l.tail = l.head
-	} else{
+	} else {
 		newValNode.prev = l.tail
 		l.tail.next = newValNode
 		l.tail = newValNode
 	l.size++
 }
 
-// To get the position of a topic node with a specific topic
+// To get the position of a Topic node with a specific Topic
 func (l *topicList) getTopicNodePos(topic []int64) *topicNode {
 	topicPtr := l.head
 	for topicPtr != nil {
-		if len(topicPtr.topic) == 0{
+		if len(topicPtr.topic) == 0 {
 			topicPtr = topicPtr.next
 			continue
 		}
 	return nil
 }
 
-// To get the position of a value node with a specific value
+// To get the position of a Value node with a specific Value
 func (l *valueList) getValueNodePos(value []int64) *valueNode {
 	valPtr := l.head
 	for valPtr != nil {
-		if len(valPtr.val) == 0{
+		if len(valPtr.val) == 0 {
 			valPtr = valPtr.next
 			continue
 		}
 func Compare(a []int64, b []int64) int {
 	if len(a) < len(b) {
 		return 1
-	} else if len(a) > len(b){
+	} else if len(a) > len(b) {
 		return -1
-	} else{
-		for i := 0; i < len(a); i++{
+	} else {
+		for i := 0; i < len(a); i++ {
 			if a[i] < b[i] {
 				return 1
-			} else if a[i] > b[i]{
+			} else if a[i] > b[i] {
 				return -1
 			}
 		}

src/broker/modules/list_test.go

 import (
 	"fmt"
 	_ "fmt"
-	"testing"
 	"github.com/stretchr/testify/assert"
+	"testing"
 )
 
 func Test_addTopicNode(t *testing.T) {
 
 	list := &topicList{nil, nil, 0}
-	ary := []int64{123,456,789,1234}
+	ary := []int64{123, 456, 789, 1234}
 
-	for i:=0; i< 4; i++{
+	for i := 0; i < 4; i++ {
 		tmp := []int64{ary[i]}
 		list.addTopicNode(tmp)
 		exp := []int64{ary[i]}
 func Test_addValueNode(t *testing.T) {
 
 	list := &valueList{nil, nil, 0}
-	ary := []int64{123,456,789,1234}
+	ary := []int64{123, 456, 789, 1234}
 
-	for i:=0; i< 4; i++{
+	for i := 0; i < 4; i++ {
 		tmp := []int64{ary[i]}
 		list.addValueNode(tmp)
 		exp := []int64{ary[i]}
 	}
 }
 
-func Test_findSub(t *testing.T){
+func Test_findSub(t *testing.T) {
 
-	ary := []int{1,2,3,4,5,6}
+	ary := []int{1, 2, 3, 4, 5, 6}
 	for i := 0; i < 6; i++ {
-		assert.Equal(t, findSub(ary, i + 1), i, "findSub is failed")
+		assert.Equal(t, findSub(ary, i+1), i, "findSub is failed")
 	}
 
 	// Don't Exist
 	assert.Equal(t, findSub(ary, 6), 4)
 }
 
-func Test_remove(t *testing.T){
+func Test_remove(t *testing.T) {
 	l := make([]int, 4)
 	var i int
-	for i = 0; i < 4; i++{
+	for i = 0; i < 4; i++ {
 		l[i] = i
 	}
 
 	// array = {0, 1, 2, 3} -> {0, 1, 3}
 	l = remove(l, 2)
-	assert.Equal(t, l,[]int{0, 1, 3}, "Array Delete is failed")
+	assert.Equal(t, l, []int{0, 1, 3}, "Array Delete is failed")
 
 	// array = {0, 1, 3} -> {1, 3}
 	l = remove(l, 0)
 	assert.Equal(t, l, []int{}, "Array Delete is failed")
 }
 
-func Test_isempty(t *testing.T){
-	node := &valueNode{next : nil, prev : nil}
+func Test_isempty(t *testing.T) {
+	node := &valueNode{next: nil, prev: nil}
 
 	// 1. One element in Node
 	node.single2sub_eb = append(node.single2sub_eb, 1)
 	node.single2sub_s = append(node.single2sub_s, 1)
 	node.single2sub_es = append(node.single2sub_es, 1)
 	node.single2sub_e = append(node.single2sub_e, 1)
-	assert.Equal(t, node.isEmpty(), false,"isEmpty is failed")
+	assert.Equal(t, node.isEmpty(), false, "isEmpty is failed")
 }
 
-func Test_insertSub(t *testing.T){
-	node := &valueNode{next : nil, prev : nil}
+func Test_insertSub(t *testing.T) {
+	node := &valueNode{next: nil, prev: nil}
 
-// 1. Single2sub
+	// 1. Single2sub
 
 	// (1) <
 	node.insertSub("<", 1, true)
-	assert.Equal(t, 0, findSub(node.single2sub_s, 1),"singleInsertSub (<) is failed")
+	assert.Equal(t, 0, findSub(node.single2sub_s, 1), "singleInsertSub (<) is failed")
 
 	// (2) <=
 	node.insertSub("<=", 2, true)
 	node.insertSub("==", 5, true)
 	assert.Equal(t, 0, findSub(node.single2sub_e, 5), "singleInsertSub (==) is failed")
 
-// 2. range2sub
+	// 2. range2sub
 
 	// (1) <
 	node.insertSub("<", 1, false)
-	assert.Equal(t, 0, findSub(node.range2sub_s, 1),"rangeInsertSub (<) is failed")
+	assert.Equal(t, 0, findSub(node.range2sub_s, 1), "rangeInsertSub (<) is failed")
 
 	// (2) <=
 	node.insertSub("<=", 2, false)
 
 }
 
-func Test_getTopicPos(t *testing.T){
+func Test_getTopicPos(t *testing.T) {
 	l := topicList{}
 	l.addTopicNode(nil)
 
 	// 1. find Topic in empty topiclist
-	if l.head.topic != nil{
+	if l.head.topic != nil {
 		fmt.Println("addTopicNode is failed")
 	}
 
 	// 2. find {{12},{34},{56},{78},{89},{90}} in topiclist
-	ary := [][]int64{{12},{34},{56},{78},{89},{90}}
-	if l.getTopicNodePos(ary[0]) != nil{
+	ary := [][]int64{{12}, {34}, {56}, {78}, {89}, {90}}
+	if l.getTopicNodePos(ary[0]) != nil {
 		fmt.Println("getTopicNodePos is failed")
 	}
 
-	for i := 0; i < 5; i++{
+	for i := 0; i < 5; i++ {
 		l.addTopicNode(ary[i])
 		assert.Equal(t, ary[i], l.tail.topic)
 	}
 
 }
 
-func Test_getValuePos(t *testing.T){
+func Test_getValuePos(t *testing.T) {
 	l := valueList{}
 	l.addValueNode(nil)
 
-	ary := [][]int64{{12},{34},{56},{78},{89},{90}}
+	ary := [][]int64{{12}, {34}, {56}, {78}, {89}, {90}}
 
 	// 1. find {{12},{34},{56},{78},{89},{90}} in topiclist
-	for i := 0; i < 5; i++{
+	for i := 0; i < 5; i++ {
 		l.addValueNode(ary[i])
 		assert.Equal(t, ary[i], l.tail.val)
 	}
-}
+}

src/broker/modules/matching.go

 )
 
 type match_manager struct {
-	match_count	int
+	match_count int
 }
 
 // Returns a list of IP addresses of matched subs
 func (match_mng *match_manager) Matching(queue *MsgQueue, sub_mng *sub_manager) ([]string, MsgUnit, error) {
 	msg := queue.pop(true)
-	topic := msg.(*PublishMsg).topic
-	value := msg.(*PublishMsg).value
+	topic := msg.(*PublishMsg).Topic
+	value := msg.(*PublishMsg).Value
 
 	// list
 	ret := make([]string, 0)
 	big := make([]int, 0)
 	small := make([]int, 0)
 
-	// 1. Find (topicNode[topic] == msg.topic) Node
+	// 1. Find (topicNode[Topic] == msg.Topic) Node
 	topicPtr := sub_mng.list
 	pos := topicPtr.getTopicNodePos(topic)
 
 	// Don't Exist topicNode
-	if pos == nil{
-		return nil,nil,errors.New("Don't Exist topicNode")
+	if pos == nil {
+		return nil, nil, errors.New("Don't Exist topicNode")
 	}
 
 	// 2. Traverse all valueNode -> and Match
 	valPtr := pos.list.head
-	for valPtr != nil{
+	for valPtr != nil {
 		compare := Compare(valPtr.val, value)
 		if compare < 0 { // sub.val > pub.val
-		// single : { >, >= }
+			// single : { >, >= }
 
 			// (1) case : >
-			for i := 0; i < len(valPtr.single2sub_b); i++{
+			for i := 0; i < len(valPtr.single2sub_b); i++ {
 				sub := valPtr.single2sub_b[i]
 				ip := sub_mng.sub2ip[sub]
 				ret = append(ret, ip)
 			}
 
 			// (2) case : >=
-			for i := 0; i < len(valPtr.single2sub_eb); i++{
+			for i := 0; i < len(valPtr.single2sub_eb); i++ {
 				sub := valPtr.single2sub_eb[i]
 				ip := sub_mng.sub2ip[sub]
 				ret = append(ret, ip)
 			}
-		// range : { >, >= }
+			// range : { >, >= }
 
 			// (1) case : >
-			for i := 0; i < len(valPtr.range2sub_b); i++{
+			for i := 0; i < len(valPtr.range2sub_b); i++ {
 				sub := valPtr.range2sub_b[i]
 				big = append(big, sub)
 			}
 
 			// (2) case : >=
-			for i := 0; i < len(valPtr.range2sub_eb); i++{
+			for i := 0; i < len(valPtr.range2sub_eb); i++ {
 				sub := valPtr.range2sub_eb[i]
 				big = append(big, sub)
 			}
 
 		} else if compare > 0 { // sub.val < pub.val
 
-		// single : { <, <= }
+			// single : { <, <= }
 
 			// (1) case : <
-			for i := 0; i < len(valPtr.single2sub_s); i++{
+			for i := 0; i < len(valPtr.single2sub_s); i++ {
 				sub := valPtr.single2sub_s[i]
 				ip := sub_mng.sub2ip[sub]
 				ret = append(ret, ip)
 			}
 
 			// (2) case : <=
-			for i := 0; i < len(valPtr.single2sub_es); i++{
+			for i := 0; i < len(valPtr.single2sub_es); i++ {
 				sub := valPtr.single2sub_es[i]
 				ip := sub_mng.sub2ip[sub]
 				ret = append(ret, ip)
 			}
 
-		// range : { <, <= }
+			// range : { <, <= }
 
 			// (1) case : <
-			for i := 0; i < len(valPtr.range2sub_s); i++{
+			for i := 0; i < len(valPtr.range2sub_s); i++ {
 				sub := valPtr.range2sub_s[i]
 				small = append(small, sub)
 			}
 			// (2) case : <=
-			for i := 0; i < len(valPtr.range2sub_es); i++{
+			for i := 0; i < len(valPtr.range2sub_es); i++ {
 				sub := valPtr.range2sub_es[i]
 				small = append(small, sub)
 			}
 
-		} else{ // sub.val == pub.val
+		} else { // sub.val == pub.val
 
-		// single : { <=, >=, ==}
+			// single : { <=, >=, ==}
 
 			// (1) case : <=
-			for i := 0; i < len(valPtr.single2sub_es); i++{
+			for i := 0; i < len(valPtr.single2sub_es); i++ {
 				sub := valPtr.single2sub_es[i]
 				ip := sub_mng.sub2ip[sub]
 				ret = append(ret, ip)
 			}
 
 			// (2) case : >=
-			for i := 0; i < len(valPtr.single2sub_eb); i++{
+			for i := 0; i < len(valPtr.single2sub_eb); i++ {
 				sub := valPtr.single2sub_eb[i]
 				ip := sub_mng.sub2ip[sub]
 				ret = append(ret, ip)
 			}
 
 			// (3) case : ==
-			for i := 0; i < len(valPtr.single2sub_e); i++{
+			for i := 0; i < len(valPtr.single2sub_e); i++ {
 				sub := valPtr.single2sub_e[i]
 				ip := sub_mng.sub2ip[sub]
 				ret = append(ret, ip)
 			}
 
-		// range : { <=, >= }
+			// range : { <=, >= }
 
 			// (1) case : <=
-			for i := 0; i < len(valPtr.range2sub_es); i++{
+			for i := 0; i < len(valPtr.range2sub_es); i++ {
 				sub := valPtr.range2sub_es[i]
 				small = append(small, sub)
 			}
 
 			// (2) case : >=
-			for i := 0; i < len(valPtr.range2sub_eb); i++{
+			for i := 0; i < len(valPtr.range2sub_eb); i++ {
 				sub := valPtr.range2sub_eb[i]
 				big = append(big, sub)
 			}
 
 	// Add the intersection IP address of two sets (large and small) to the return list
 	hash := intersect.Hash(small, big)
-	for i := 0; i < len(hash); i++{
+	for i := 0; i < len(hash); i++ {
 		sub := hash[i].(int)
 		ip := sub_mng.sub2ip[sub]
 		ret = append(ret, ip)

src/broker/modules/message.go

 //*****메세지 틀*****
 
 type Message struct {
-	from    string //ip주소
-	version string
-	time    string
-	kind    int //종류
-}
-
-func (msg Message) From() string {
-	return msg.from
-}
-
-func (msg Message) Version() string {
-	return msg.version
-}
-
-func (msg Message) Time() string {
-	return msg.time
-}
-
-func (msg Message) Kind() int {
-	return msg.kind
+	From    string //ip주소
+	Version string
+	Time    string
+	Kind    int //종류
 }
 
 type MsgUnit interface {
 	// ConvertToJson - send 전 json형식으로 바꾸는 함수
 	ConvertToJson() ([]byte, error)
+	//JsontoMsg
+	//JsontoMsg()(msg MsgUnit)
 	// CheckType - Message의 타입을 알려줌
 	CheckType() int
 }
 //전달할 내용을 담은 메세지
 type PublishMsg struct {
 	Message
-	topic []int64 //대주제
-	value []int64 //topic의 세부적인 내용
-	content []int64 // 내용
+	Topic   []int64 //대주제
+	Value   []int64 //topic의 세부적인 내용
+	Content []int64 // 내용
 }
 
 //구독 정보를 담은 메세지
 type SubscriptionMsg struct {
 	Message
-	topic []int64 //대주제
-	value []int64 //피연산자
+	topic    []int64  //대주제
+	value    []int64  //피연산자
 	operator []string //연산자
-  	isAlpha bool //value가 숫자인지 문자열인지
+	isAlpha  bool     //value가 숫자인지 문자열인지
 }
 
 //Microservice 등록 메세지
 
 //**************************
 
-func (msg *KeyGenMsg) ConvertToJson() ([]byte, error) {
+func (msg KeyGenMsg) ConvertToJson() ([]byte, error) {
 	js := msg
 	jsonBytes, err := json.Marshal(js)
 	return jsonBytes, err
 }
 
-func (msg *KeyShareMsg) ConvertToJson() ([]byte, error) {
+func (msg KeyShareMsg) ConvertToJson() ([]byte, error) {
 	js := msg
 	jsonBytes, err := json.Marshal(js)
 	return jsonBytes, err
 }
 
-func (msg *PublishMsg) ConvertToJson() ([]byte, error) {
+func (msg PublishMsg) ConvertToJson() ([]byte, error) {
 	js := msg
 	jsonBytes, err := json.Marshal(js)
 	return jsonBytes, err
 }
 
-func (msg *SubscriptionMsg) ConvertToJson() ([]byte, error) {
+func (msg SubscriptionMsg) ConvertToJson() ([]byte, error) {
 	js := msg
 	jsonBytes, err := json.Marshal(js)
 	return jsonBytes, err
 }
 
-func (msg *RegisterMsg) ConvertToJson() ([]byte, error) {
+func (msg RegisterMsg) ConvertToJson() ([]byte, error) {
 	js := msg
 	jsonBytes, err := json.Marshal(js)
 	return jsonBytes, err
 }
 
-func (msg *WithdrawMsg) ConvertToJson() ([]byte, error) {
+func (msg WithdrawMsg) ConvertToJson() ([]byte, error) {
 	js := msg
 	jsonBytes, err := json.Marshal(js)
 	return jsonBytes, err
 }
 
 func (msg Message) CheckType() int {
-	return msg.kind
+	return msg.Kind
 }
 
 //KeyGenMsg 생성자
-func NewKeyGenMsg(table *MStable) *KeyGenMsg{
-	m:= &KeyGenMsg{}
-	for _,value:= range table.NodeTable{
-		m.iptable=append(m.iptable,value.Getipaddr())
+func NewKeyGenMsg(table *MStable) *KeyGenMsg {
+	m := &KeyGenMsg{}
+	for _, value := range table.NodeTable {
+		m.iptable = append(m.iptable, value.Getipaddr())
 	}
 	return m
-}
+}

src/broker/modules/queue.go

 package modules
 
-import "errors"
+import (
+	"errors"
+	"log"
+)
 
 type MsgQueue struct {
 	queue     chan MsgUnit
 		return errors.New("Queue Hadlerer Error: Already initialized.")
 	} else if mq.queue == nil {
 		mq.queue = make(chan MsgUnit, 1000)
+		log.Println("queue is initialized.")
 		return nil
 	} else {
 		close(mq.queue)
 	return true
 }
 
-func (mq *MsgQueue) pop(wait bool) MsgUnit {
-	if wait == true {
+func (mq *MsgQueue) pop(block bool) MsgUnit {
+	if block == false {
 		if len(mq.queue) == 0 {
 			return nil
 		} else {

src/broker/modules/secure.go

 keyShareMsg 에서 각 노드의 private 키를 받아 keyMap 에 저장
 */
 func (sc Security) RegKey(ksm KeyShareMsg) {
-	sc.KeyMap[ksm.Message.From()] = ksm.key
+	sc.KeyMap[ksm.Message.From] = ksm.key
 }
 
 /**
 // topic과 value는 m+k로만 존재하므로 ReEnc과정에서 subscriber의 개인키만 더해주면 된다.
 func (sc Security) ReEncPubMsg(fromPubMsg PublishMsg, nodeName string) *PublishMsg {
 	toKey := sc.GetNodeKey(nodeName)
-	fromKey := sc.GetNodeKey(fromPubMsg.Message.From())
+	fromKey := sc.GetNodeKey(fromPubMsg.Message.From)
 
 	toPubMsg := new(PublishMsg)
 	toPubMsg.Message = fromPubMsg.Message
-	toPubMsg.topic = sc.ReEncryptWithoutPrivateKey(toKey, fromPubMsg.topic)
-	toPubMsg.value = sc.ReEncryptWithoutPrivateKey(toKey, fromPubMsg.value)
-	toPubMsg.content = sc.ReEncrypt(fromKey, toKey, fromPubMsg.content)
+	toPubMsg.Topic = sc.ReEncryptWithoutPrivateKey(toKey, fromPubMsg.Topic)
+	toPubMsg.Value = sc.ReEncryptWithoutPrivateKey(toKey, fromPubMsg.Value)
+	toPubMsg.Content = sc.ReEncrypt(fromKey, toKey, fromPubMsg.Content)
 
 	return toPubMsg
 }

src/broker/modules/secure_test.go

 	var sm SecurityManager
 	sm = security
 
-	ksm := KeyShareMsg{Message: Message{from: "1.1.1.1", version: "1", time: "2", kind: 1}, key: "1234"}
+	ksm := KeyShareMsg{Message: Message{From: "1.1.1.1", Version: "1", Time: "2", Kind: 1}, key: "1234"}
 	sm.RegKey(ksm)
-	sm.GetNodeKey(ksm.Message.From())
-	fmt.Println(sm.GetNodeKey(ksm.Message.From()))
+	sm.GetNodeKey(ksm.Message.From)
+	fmt.Println(sm.GetNodeKey(ksm.Message.From))
 	var targetKey []int64
 	targetKey = []int64{1234, 1235, 1236}
-	fmt.Println(sm.ReEncrypt(sm.GetNodeKey(ksm.Message.From()), 0, targetKey))
+	fmt.Println(sm.ReEncrypt(sm.GetNodeKey(ksm.Message.From), 0, targetKey))
 	//fmt.Println(sm.CompareDigit(1236, 1234))
 
 }
 	toPubMsg.Message = msg
 
 	intArr := []rune(topic)
-	//fmt.Print("topic length ")
+	//fmt.Print("Topic length ")
 	//fmt.Println(len(intArr))
-	//fmt.Println(len(toPubMsg.topic))
+	//fmt.Println(len(toPubMsg.Topic))
 	for index := 0; index < len(intArr); index++ {
-		toPubMsg.topic = append(toPubMsg.topic, int64(intArr[index]))
+		toPubMsg.Topic = append(toPubMsg.Topic, int64(intArr[index]))
 	}
-	//fmt.Println(len(toPubMsg.topic))
+	//fmt.Println(len(toPubMsg.Topic))
 	intArr = []rune(value)
 	for index := 0; index < len(intArr); index++ {
-		toPubMsg.value = append(toPubMsg.value, int64(intArr[index]))
+		toPubMsg.Value = append(toPubMsg.Value, int64(intArr[index]))
 	}
 	intArr = []rune(content)
 	for index := 0; index < len(intArr); index++ {
-		toPubMsg.content = append(toPubMsg.content, int64(intArr[index]))
+		toPubMsg.Content = append(toPubMsg.Content, int64(intArr[index]))
 	}
 
 	return toPubMsg
 }
 
 func EncryptionMsg(msg *PublishMsg, gyKey int64, privateKey int64) *PublishMsg {
-	for index := range msg.topic {
-		msg.topic[index] = msg.topic[index] + gyKey
+	for index := range msg.Topic {
+		msg.Topic[index] = msg.Topic[index] + gyKey
 	}
-	for index := range msg.value {
-		msg.value[index] = msg.value[index] + gyKey
+	for index := range msg.Value {
+		msg.Value[index] = msg.Value[index] + gyKey
 	}
-	for index := range msg.content {
-		msg.content[index] = msg.content[index] + gyKey + privateKey
+	for index := range msg.Content {
+		msg.Content[index] = msg.Content[index] + gyKey + privateKey
 	}
 
-
 	return msg
 }
 
 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.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.Value {
+		msg.Value[index] = msg.Value[index] - gyKey - privateKey
 	}
-	for index := range msg.content {
-		msg.content[index] = msg.content[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])))
+	for index := range msg.Topic {
+		runeArr = append(runeArr, rune(int(msg.Topic[index])))
 	}
-	fmt.Println("topic is: " + string(runeArr))
+	fmt.Println("Topic is: " + string(runeArr))
 	runeArr = nil
 
-	for index := range msg.value {
-		runeArr = append(runeArr, rune(int(msg.value[index])))
+	for index := range msg.Value {
+		runeArr = append(runeArr, rune(int(msg.Value[index])))
 	}
-	fmt.Println("value is: " + string(runeArr))
+	fmt.Println("Value is: " + string(runeArr))
 	runeArr = nil
 
-	for index := range msg.content {
-		runeArr = append(runeArr, rune(int(msg.content[index])))
+	for index := range msg.Content {
+		runeArr = append(runeArr, rune(int(msg.Content[index])))
 	}
-	fmt.Println("content is: " + string(runeArr))
+	fmt.Println("Content is: " + string(runeArr))
 	runeArr = nil
 
 }
 
-func printMsg(msg *PublishMsg){
+func printMsg(msg *PublishMsg) {
 	var runeArr []rune
-	for index := range msg.topic {
-		runeArr = append(runeArr, rune(int(msg.topic[index])))
+	for index := range msg.Topic {
+		runeArr = append(runeArr, rune(int(msg.Topic[index])))
 	}
-	fmt.Println("topic is: " + string(runeArr))
+	fmt.Println("Topic is: " + string(runeArr))
 	runeArr = nil
 
-	for index := range msg.value {
-		runeArr = append(runeArr, rune(int(msg.value[index])))
+	for index := range msg.Value {
+		runeArr = append(runeArr, rune(int(msg.Value[index])))
 	}
-	fmt.Println("value is: " + string(runeArr))
+	fmt.Println("Value is: " + string(runeArr))
 	runeArr = nil
 
-	for index := range msg.content {
-		runeArr = append(runeArr, rune(int(msg.content[index])))
+	for index := range msg.Content {
+		runeArr = append(runeArr, rune(int(msg.Content[index])))
 	}
-	fmt.Println("content is: " + string(runeArr) + "\n\n")
+	fmt.Println("Content is: " + string(runeArr) + "\n\n")
 	runeArr = nil
 }
 
-// from "1.1.1.1" to "3.3.3.3" node
+// From "1.1.1.1" to "3.3.3.3" node
 func TestReEnc(t *testing.T) {
 	var security = NewSecurity()
 	var sm SecurityManager
 	security.KeyMap["3.3.3.3"] = "99999"
 
 	//fmt.Println(sm.GetNodeKey("3.3.3.3"))
-	msg := Message{from: "1.1.1.1", version: "1", time: "123", kind: 3}
+	msg := Message{From: "1.1.1.1", Version: "1", Time: "123", Kind: 3}
 	//fmt.Println(msg)
 	publishMsg := CreatePubMsg(msg, "soccer123한글", "playerList", "Son and 10 players")
 	fmt.Println(publishMsg)
 	fmt.Println("decrypted publish message is...")
 	DecryptionMsg(reEncPublishMsg, 1234, 99999)
 }
-
-//func TestReEncUsingSHA(r *testing.T){
-//	var security = NewSecurity()
-//	var sm SecurityManager
-//	sm = security
-//	security.KeyMap["1.1.1.1"] = "56789"
-//	security.KeyMap["3.3.3.3"] = "99999"
-//}

src/broker/modules/subscription.go

 	list topicList
 
 	/* Manage sub# */
-	count_sub 	 int               // Subscription #
+	count_sub  int                  // Subscription #
 	emptylist  []int                // To administrate sub #
 	ip2sub     map[string][]int     // ip2sub[ip] = sub# ...
-	sub2ip	   map[int]string		// sub2ip[sub#] = ip
+	sub2ip     map[int]string       // sub2ip[sub#] = ip
 	sub2node   map[int][]*valueNode // sub2node[sub#] = node_addr ...
 	israngesub map[int]bool         // To manage when deleted
 }
 	// * 1. Mapping incoming IP address to sub #
 
 	if len(manager.emptylist) == 0 {
-		manager.ip2sub[msg.(*SubscriptionMsg).from] = append(manager.ip2sub[msg.(*SubscriptionMsg).from], manager.count_sub)
+		manager.ip2sub[msg.(*SubscriptionMsg).From] = append(manager.ip2sub[msg.(*SubscriptionMsg).From], manager.count_sub)
 		subnumber = manager.count_sub
 		manager.count_sub++
 	} else {
 		subidx := manager.emptylist[len(manager.emptylist)-1]
 		manager.emptylist = manager.emptylist[:len(manager.emptylist)-1]
-		manager.ip2sub[msg.(*SubscriptionMsg).from] = append(manager.ip2sub[msg.(*SubscriptionMsg).from], subidx)
+		manager.ip2sub[msg.(*SubscriptionMsg).From] = append(manager.ip2sub[msg.(*SubscriptionMsg).From], subidx)
 		subnumber = subidx
 	}
 
 		nameptr = manager.list.tail
 	}
 
-	// Add value to list[name]
+	// Add Value to list[name]
 	if len(operator) == 1 { // if single expression
 		valptr := nameptr.list.getValueNodePos(value)
 		if valptr == nil {
 		// (ex) { (234 < x) && (x <= 1293) } , { (234 < x) || ( x < 1293) }
 		logical_operator := operator[1]
 
-		// Find ValueNode = (namelist[name].list.val == value)
+		// Find ValueNode = (namelist[name].list.val == Value)
 		valptr1 := nameptr.list.getValueNodePos([]int64{value[0]})
 		valptr2 := nameptr.list.getValueNodePos([]int64{value[1]})
 
 		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr2)
 
 		if logical_operator == "&&" {
-			// If they are enclosed in '&&' -> Insert value to range_operator_list
+			// If they are enclosed in '&&' -> Insert Value to range_operator_list
 			manager.israngesub[subnumber] = true
 			valptr1.insertSub(operator[0], subnumber, false)
 			valptr2.insertSub(operator[2], subnumber, false)
 
 		} else {
-			// if they are enclosed in '||' -> Insert value to single_operator_list
+			// if they are enclosed in '||' -> Insert Value to single_operator_list
 			valptr1.insertSub(operator[0], subnumber, true)
 			valptr2.insertSub(operator[2], subnumber, true)
 		}
 			}
 		}
 	}
-	manager.ip2sub[ip]=nil // Delete sub#s mapped to Ip address
+	manager.ip2sub[ip] = nil // Delete sub#s mapped to Ip address
 	return nil
-}
+}

src/broker/modules/subscription_test.go

 package modules
 
-import (
-	"fmt"
-	_ "fmt"
-	"github.com/stretchr/testify/assert"
-	"math/rand"
-	"strconv"
-	"testing"
-	"time"
-)
-
-func makeData(isAlpha bool) MsgUnit{
-	rand.Seed(time.Now().UnixNano())
-	// Set Ipaddr
-	msg := Message{"", "1.0", "", SM}
-	for i := 0; i < 4; i++{
-		itoa := strconv.Itoa(rand.Int() % 256)
-		msg.from += itoa
-		if i != 3{
-			msg.from += "."
-		}
-	}
-
-	// Set Time
-	msg.time += strconv.Itoa(rand.Int()%24) + ":"
-	msg.time += strconv.Itoa(rand.Int()%60)
-
-	// Set Topic, Value, operator
-	topic := []int64{}
-	value := []int64{}
-	operator := []string{}
-	candOp := []string{">", ">=", "<=" ,"<", "=="}
-	logicalOp := []string{"&&", "||"}
-
-	if isAlpha {
-		topicLen := rand.Int() % 10 + 1
-		for i := 0 ; i < topicLen; i++{
-			topic = append(topic, rand.Int63())
-		}
-
-		valueLen := rand.Int() % 10 + 1
-		for i := 0 ; i < valueLen; i++{
-			value = append(value, rand.Int63())
-		}
-
-		operator = append(operator, "==")
-
-	} else{
-		valueLen := rand.Int() % 2 + 1
-
-		topic = append(topic, rand.Int63())
-		value = append(value, rand.Int63())
-
-		if valueLen == 1{
-			operator = append(operator, candOp[rand.Int()%5])
-		} else{
-			value = append(value, rand.Int63())
-			op := rand.Int()%2
-			operator = append(operator, candOp[rand.Int()%2])
-			if op == 0 {
-				operator = append(operator, logicalOp[0])
-			} else{
-				operator = append(operator, logicalOp[1])
-			}
-			operator = append(operator, candOp[rand.Int()%2 + 2])
-		}
-	}
-
-	return &SubscriptionMsg{msg, topic, value, operator, isAlpha}
-}
-
-func makeMsgList(dataLen int, isAlpha bool) []MsgUnit{
-	rand.Seed(time.Now().UnixNano())
-	var ret []MsgUnit
-	for i := 0 ; i < dataLen ; i++{
-		ret = append(ret, makeData(isAlpha))
-	}
-	return ret
-}
-
-func checkOperatorList(isSingle bool, sub int, operator string, l *valueNode) int{
-	ret := -1
-	if isSingle{
-		switch operator {
-		case "<":
-			ret = findSub(l.single2sub_s, sub)
-		case "<=":
-			ret = findSub(l.single2sub_es, sub)
-		case ">":
-			ret = findSub(l.single2sub_b, sub)
-		case ">=":
-			ret = findSub(l.single2sub_eb, sub)
-		case "==":
-			ret = findSub(l.single2sub_e, sub)
-		}
-
-	} else{
-		switch operator {
-		case "<":
-			ret = findSub(l.range2sub_s, sub)
-		case "<=":
-			ret = findSub(l.range2sub_es, sub)
-		case ">":
-			ret = findSub(l.range2sub_b, sub)
-		case ">=":
-			ret = findSub(l.range2sub_eb, sub)
-		}
-	}
-	return ret
-}
-
-func watchData(msgList []MsgUnit, dataLen int){
-	for i := 0; i < dataLen; i++{
-		msg := msgList[i]
-		fmt.Println(
-			"\nfrom = ", msg.(*SubscriptionMsg).Message.from,
-			"\ntime = ", msg.(*SubscriptionMsg).Message.time,
-			"\ntopic = ", msg.(*SubscriptionMsg).topic,
-			"\nvalue = ", msg.(*SubscriptionMsg).value,
-			"\noperator = ", msg.(*SubscriptionMsg).operator,
-			"\nisAlpha ?= ", msg.(*SubscriptionMsg).isAlpha,
-		)
-	}
-}
-
-//Test addSubScription(1) (dif all [topic, value, operator])
-func Test_addSubscription_allDif(t *testing.T) {
-	rand.Seed(time.Now().UnixNano())
-
-	// To Init sub_mng
-	s := sub_manager{
-		ip2sub:     make(map[string][]int),
-		sub2node:   make(map[int][]*valueNode),
-		israngesub: make(map[int]bool),
-	}
-	mos := Moscato{sub_mng: s}
-
-	// Make Data set(Subscription)
-	var msgList []MsgUnit
-	dataLen := 100
-	msgList = makeMsgList(dataLen, false)
-
-	//Watch Data set
-	//watchData(msgList, dataLen)
-
-	for i := 0; i < dataLen; i++ {
-		msg := msgList[i]
-		ip := msg.(*SubscriptionMsg).Message.from
-		topic := msg.(*SubscriptionMsg).topic
-		value := msg.(*SubscriptionMsg).value
-		operator := msg.(*SubscriptionMsg).operator
-		subnumber := mos.sub_mng.count_sub
-		isSingle := true
-
-		// 0. Check addSubscription
-		err := mos.sub_mng.addSubscription(msg)
-		assert.Equal(t, nil, err)
-
-		// 1. Check if ip mapping is correct
-		assert.Equal(t, subnumber, mos.sub_mng.ip2sub[ip][len(mos.sub_mng.ip2sub[ip])-1], "Ip mapping is failed")
-
-		// 2. Check topicNode
-		topicPtr := mos.sub_mng.list.head
-		for topicPtr != nil {
-			if Compare(topic, topicPtr.topic) == 0 {
-				break
-			}
-			topicPtr = topicPtr.next
-		}
-
-		assert.Equal(t, topic, topicPtr.topic, "topicNode Add is failed")
-
-		// Check isSingle ?
-		if len(operator) == 3 && operator[1] == "&&" {
-			isSingle = false
-		}
-
-		// 3. Check Value in ValueNode & Check Operator in ValueNode
-		if !isSingle || (len(operator) == 3 && operator[1] == "||") {
-			valptr1 := topicPtr.list.getValueNodePos([]int64{value[0]})
-			valptr2 := topicPtr.list.getValueNodePos([]int64{value[1]})
-
-			assert.Equal(t, []int64{value[0]}, valptr1.val)
-			assert.Equal(t, []int64{value[1]}, valptr2.val)
-
-			assert.NotEqual(t, -1, checkOperatorList(isSingle, subnumber, operator[0], valptr1))
-			assert.NotEqual(t, -1, checkOperatorList(isSingle, subnumber, operator[2], valptr2))
-
-		} else {
-			valptr := topicPtr.list.getValueNodePos(value)
-			assert.Equal(t, value, valptr.val)
-			assert.NotEqual(t, -1, checkOperatorList(isSingle, subnumber, operator[0], valptr))
-		}
-	}
-}
-
-// Test addSubScription(2) (same [topic, value] dif [operator])
-func Test_addSubscription_same_topicNvalue(t *testing.T) {
-	rand.Seed(time.Now().UnixNano())
-
-	// To Init sub_mng
-	s := sub_manager{
-		ip2sub:     make(map[string][]int),
-		sub2node:   make(map[int][]*valueNode),
-		israngesub: make(map[int]bool),
-	}
-
-	mos := Moscato{sub_mng: s}
-
-	// Fix Topic & Value
-	topicLen := rand.Int()%10 + 1
-	staticTopic := make([]int64, topicLen)
-	staticValue := []int64{rand.Int63()}
-
-
-	// Make Data
-	var msgList []MsgUnit
-	dataLen := 100
-	msgList = makeMsgList(dataLen, false)
-
-	for i := 0; i < topicLen; i++ {
-		staticTopic[i] = rand.Int63()
-	}
-
-	// Fix Same Topic & Value
-	for i := 0; i < dataLen; i++ {
-		operator := msgList[i].(*SubscriptionMsg).operator
-		msgList[i].(*SubscriptionMsg).topic = staticTopic
-
-		if len(operator) == 1{
-			msgList[i].(*SubscriptionMsg).value = staticValue
-		}
-	}
-
-	// Watch Data set
-	// watchData(msgList, dataLen)
-
-	for i := 0; i < dataLen; i++ {
-		msg := msgList[i]
-		err := mos.sub_mng.addSubscription(msg)
-		assert.Equal(t, nil, err)
-	}
-
-	topicPtr := mos.sub_mng.list.head
-	for topicPtr != nil {
-		if Compare(topicPtr.topic, staticTopic) == 0 {
-			break
-		}
-		topicPtr = topicPtr.next
-	}
-	watchValueNode(topicPtr.list.head)
-
-}
-
-func watchValueNode(ptr *valueNode) {
-	valPtr := ptr
-	for valPtr != nil{
-		fmt.Println("Value = ", valPtr.val)
-		if len(valPtr.single2sub_s) != 0 {
-			fmt.Println("Single2sub (<) List = ", valPtr.single2sub_s)
-		}
-		if len(valPtr.single2sub_es) != 0 {
-			fmt.Println("Single2sub (<=) List = ", valPtr.single2sub_es)
-		}
-		if len(valPtr.single2sub_b) != 0 {
-			fmt.Println("Single2sub (>) List = ", valPtr.single2sub_b)
-		}
-		if len(valPtr.single2sub_eb) != 0 {
-			fmt.Println("Single2sub (>=) List = ", valPtr.single2sub_eb)
-		}
-		if len(valPtr.single2sub_e) != 0 {
-			fmt.Println("Single2sub (==) List = ", valPtr.single2sub_e)
-		}
-
-		if len(valPtr.range2sub_s) != 0 {
-			fmt.Println("range2sub (<) List = ", valPtr.range2sub_s)
-		}
-		if len(valPtr.range2sub_es) != 0 {
-			fmt.Println("range2sub (<=) List = ", valPtr.range2sub_es)
-		}
-		if len(valPtr.range2sub_b) != 0 {
-			fmt.Println("range2sub (>) List = ", valPtr.range2sub_b)
-		}
-		if len(valPtr.range2sub_eb) != 0 {
-			fmt.Println("range2sub (>=) List = ", valPtr.range2sub_eb)
-		}
-		valPtr = valPtr.next
-	}
-}
+//
+//import (
+//	"fmt"
+//	_ "fmt"
+//	"github.com/stretchr/testify/assert"
+//	"math/rand"
+//	"strconv"
+//	"testing"
+//	"Time"
+//)
+//
+//func makeData(isAlpha bool) MsgUnit{
+//	rand.Seed(Time.Now().UnixNano())
+//	// Set Ipaddr
+//	msg := Message{"", "1.0", "", SM}
+//	for i := 0; i < 4; i++{
+//		itoa := strconv.Itoa(rand.Int() % 256)
+//		msg.From += itoa
+//		if i != 3{
+//			msg.From += "."
+//		}
+//	}
+//
+//	// Set Time
+//	msg.Time += strconv.Itoa(rand.Int()%24) + ":"
+//	msg.Time += strconv.Itoa(rand.Int()%60)
+//
+//	// Set Topic, Value, operator
+//	Topic := []int64{}
+//	Value := []int64{}
+//	operator := []string{}
+//	candOp := []string{">", ">=", "<=" ,"<", "=="}
+//	logicalOp := []string{"&&", "||"}
+//
+//	if isAlpha {
+//		topicLen := rand.Int() % 10 + 1
+//		for i := 0 ; i < topicLen; i++{
+//			Topic = append(Topic, rand.Int63())
+//		}
+//
+//		valueLen := rand.Int() % 10 + 1
+//		for i := 0 ; i < valueLen; i++{
+//			Value = append(Value, rand.Int63())
+//		}
+//
+//		operator = append(operator, "==")
+//
+//	} else{
+//		valueLen := rand.Int() % 2 + 1
+//
+//		Topic = append(Topic, rand.Int63())
+//		Value = append(Value, rand.Int63())
+//
+//		if valueLen == 1{
+//			operator = append(operator, candOp[rand.Int()%5])
+//		} else{
+//			Value = append(Value, rand.Int63())
+//			op := rand.Int()%2
+//			operator = append(operator, candOp[rand.Int()%2])
+//			if op == 0 {
+//				operator = append(operator, logicalOp[0])
+//			} else{
+//				operator = append(operator, logicalOp[1])
+//			}
+//			operator = append(operator, candOp[rand.Int()%2 + 2])
+//		}
+//	}
+//
+//	return &SubscriptionMsg{msg, Topic, Value, operator, isAlpha}
+//}
+//
+//func makeMsgList(dataLen int, isAlpha bool) []MsgUnit{
+//	rand.Seed(Time.Now().UnixNano())
+//	var ret []MsgUnit
+//	for i := 0 ; i < dataLen ; i++{
+//		ret = append(ret, makeData(isAlpha))
+//	}
+//	return ret
+//}
+//
+//func checkOperatorList(isSingle bool, sub int, operator string, l *valueNode) int{
+//	ret := -1
+//	if isSingle{
+//		switch operator {
+//		case "<":
+//			ret = findSub(l.single2sub_s, sub)
+//		case "<=":
+//			ret = findSub(l.single2sub_es, sub)
+//		case ">":
+//			ret = findSub(l.single2sub_b, sub)
+//		case ">=":
+//			ret = findSub(l.single2sub_eb, sub)
+//		case "==":
+//			ret = findSub(l.single2sub_e, sub)
+//		}
+//
+//	} else{
+//		switch operator {
+//		case "<":
+//			ret = findSub(l.range2sub_s, sub)
+//		case "<=":
+//			ret = findSub(l.range2sub_es, sub)
+//		case ">":
+//			ret = findSub(l.range2sub_b, sub)
+//		case ">=":
+//			ret = findSub(l.range2sub_eb, sub)
+//		}
+//	}
+//	return ret
+//}
+//
+//func watchData(msgList []MsgUnit, dataLen int){
+//	for i := 0; i < dataLen; i++{
+//		msg := msgList[i]
+//		fmt.Println(
+//			"\nFrom = ", msg.(*SubscriptionMsg).Message.From,
+//			"\nTime = ", msg.(*SubscriptionMsg).Message.Time,
+//			"\nTopic = ", msg.(*SubscriptionMsg).Topic,
+//			"\nValue = ", msg.(*SubscriptionMsg).Value,
+//			"\noperator = ", msg.(*SubscriptionMsg).operator,
+//			"\nisAlpha ?= ", msg.(*SubscriptionMsg).isAlpha,
+//		)
+//	}
+//}
+//
+////Test addSubScription(1) (dif all [Topic, Value, operator])
+//func Test_addSubscription_allDif(t *testing.T) {
+//	rand.Seed(Time.Now().UnixNano())
+//
+//	// To Init sub_mng
+//	s := sub_manager{
+//		ip2sub:     make(map[string][]int),
+//		sub2node:   make(map[int][]*valueNode),
+//		israngesub: make(map[int]bool),
+//	}
+//	mos := Moscato{sub_mng: s}
+//
+//	// Make Data set(Subscription)
+//	var msgList []MsgUnit
+//	dataLen := 100
+//	msgList = makeMsgList(dataLen, false)
+//
+//	//Watch Data set
+//	//watchData(msgList, dataLen)
+//
+//	for i := 0; i < dataLen; i++ {
+//		msg := msgList[i]
+//		ip := msg.(*SubscriptionMsg).Message.From
+//		Topic := msg.(*SubscriptionMsg).Topic
+//		Value := msg.(*SubscriptionMsg).Value
+//		operator := msg.(*SubscriptionMsg).operator
+//		subnumber := mos.sub_mng.count_sub
+//		isSingle := true
+//
+//		// 0. Check addSubscription
+//		err := mos.sub_mng.addSubscription(msg)
+//		assert.Equal(t, nil, err)
+//
+//		// 1. Check if ip mapping is correct
+//		assert.Equal(t, subnumber, mos.sub_mng.ip2sub[ip][len(mos.sub_mng.ip2sub[ip])-1], "Ip mapping is failed")
+//
+//		// 2. Check topicNode
+//		topicPtr := mos.sub_mng.list.head
+//		for topicPtr != nil {
+//			if Compare(Topic, topicPtr.Topic) == 0 {
+//				break
+//			}
+//			topicPtr = topicPtr.next
+//		}
+//
+//		assert.Equal(t, Topic, topicPtr.Topic, "topicNode Add is failed")
+//
+//		// Check isSingle ?
+//		if len(operator) == 3 && operator[1] == "&&" {
+//			isSingle = false
+//		}
+//
+//		// 3. Check Value in ValueNode & Check Operator in ValueNode
+//		if !isSingle || (len(operator) == 3 && operator[1] == "||") {
+//			valptr1 := topicPtr.list.getValueNodePos([]int64{Value[0]})
+//			valptr2 := topicPtr.list.getValueNodePos([]int64{Value[1]})
+//
+//			assert.Equal(t, []int64{Value[0]}, valptr1.val)
+//			assert.Equal(t, []int64{Value[1]}, valptr2.val)
+//
+//			assert.NotEqual(t, -1, checkOperatorList(isSingle, subnumber, operator[0], valptr1))
+//			assert.NotEqual(t, -1, checkOperatorList(isSingle, subnumber, operator[2], valptr2))
+//
+//		} else {
+//			valptr := topicPtr.list.getValueNodePos(Value)
+//			assert.Equal(t, Value, valptr.val)
+//			assert.NotEqual(t, -1, checkOperatorList(isSingle, subnumber, operator[0], valptr))
+//		}
+//	}
+//}
+//
+//// Test addSubScription(2) (same [Topic, Value] dif [operator])
+//func Test_addSubscription_same_topicNvalue(t *testing.T) {
+//	rand.Seed(Time.Now().UnixNano())
+//
+//	// To Init sub_mng
+//	s := sub_manager{
+//		ip2sub:     make(map[string][]int),
+//		sub2node:   make(map[int][]*valueNode),
+//		israngesub: make(map[int]bool),
+//	}
+//
+//	mos := Moscato{sub_mng: s}
+//
+//	// Fix Topic & Value
+//	topicLen := rand.Int()%10 + 1
+//	staticTopic := make([]int64, topicLen)
+//	staticValue := []int64{rand.Int63()}
+//
+//
+//	// Make Data
+//	var msgList []MsgUnit
+//	dataLen := 100
+//	msgList = makeMsgList(dataLen, false)
+//
+//	for i := 0; i < topicLen; i++ {
+//		staticTopic[i] = rand.Int63()
+//	}
+//
+//	// Fix Same Topic & Value
+//	for i := 0; i < dataLen; i++ {
+//		operator := msgList[i].(*SubscriptionMsg).operator
+//		msgList[i].(*SubscriptionMsg).Topic = staticTopic
+//
+//		if len(operator) == 1{
+//			msgList[i].(*SubscriptionMsg).Value = staticValue
+//		}
+//	}
+//
+//	// Watch Data set
+//	// watchData(msgList, dataLen)
+//
+//	for i := 0; i < dataLen; i++ {
+//		msg := msgList[i]
+//		err := mos.sub_mng.addSubscription(msg)
+//		assert.Equal(t, nil, err)
+//	}
+//
+//	topicPtr := mos.sub_mng.list.head
+//	for topicPtr != nil {
+//		if Compare(topicPtr.Topic, staticTopic) == 0 {
+//			break
+//		}
+//		topicPtr = topicPtr.next
+//	}
+//	watchValueNode(topicPtr.list.head)
+//
+//}
+//
+//func watchValueNode(ptr *valueNode) {
+//	valPtr := ptr
+//	for valPtr != nil{
+//		fmt.Println("Value = ", valPtr.val)
+//		if len(valPtr.single2sub_s) != 0 {
+//			fmt.Println("Single2sub (<) List = ", valPtr.single2sub_s)
+//		}
+//		if len(valPtr.single2sub_es) != 0 {
+//			fmt.Println("Single2sub (<=) List = ", valPtr.single2sub_es)
+//		}
+//		if len(valPtr.single2sub_b) != 0 {
+//			fmt.Println("Single2sub (>) List = ", valPtr.single2sub_b)
+//		}
+//		if len(valPtr.single2sub_eb) != 0 {
+//			fmt.Println("Single2sub (>=) List = ", valPtr.single2sub_eb)
+//		}
+//		if len(valPtr.single2sub_e) != 0 {
+//			fmt.Println("Single2sub (==) List = ", valPtr.single2sub_e)
+//		}
+//
+//		if len(valPtr.range2sub_s) != 0 {
+//			fmt.Println("range2sub (<) List = ", valPtr.range2sub_s)
+//		}
+//		if len(valPtr.range2sub_es) != 0 {
+//			fmt.Println("range2sub (<=) List = ", valPtr.range2sub_es)
+//		}
+//		if len(valPtr.range2sub_b) != 0 {
+//			fmt.Println("range2sub (>) List = ", valPtr.range2sub_b)
+//		}
+//		if len(valPtr.range2sub_eb) != 0 {
+//			fmt.Println("range2sub (>=) List = ", valPtr.range2sub_eb)
+//		}
+//		valPtr = valPtr.next
+//	}
+//}