Merge remote-tracking branch 'origin/master'

src/broker/modules/init.go

@@ -30,55 +30,57 @@ type Moscato struct {
 	secure_mng secure_manager
 }
 
-type MicroService struct {
-	receivemsg *SubscriptionMsg
+type Reply struct {
+	ReceiveMsg MsgUnit
 }
 
-//Recieve - MM가 msg전달 받음
-func (moscato *Moscato) Recieve(msg MsgUnit) (MsgUnit, error) {
-	msg_type := msg.CheckType()
+type Listner int
+
+
+//MS에서 보내는거-rpc call 사용
+/*func (l *Listner)MM_Receive(msg MsgUnit, reply *Reply)error{
+	reply.ReceiveMsg=msg
+
+	return nil
+}*/
+
+func (moscato *Moscato)MM_Receive(msg MsgUnit, reply *Reply)error{
+	reply.ReceiveMsg=msg
+  	go moscato.Receive(reply)
+	return nil
+}
 
+//Recieve - MM가 msg전달 받음
+func (moscato *Moscato)Receive(reply *Reply) (MsgUnit, error) {
+	//rpc call
+	var msg_type = reply.ReceiveMsg.CheckType()
 	//메세지 타입에 따라 다르게 처리
 	switch msg_type {
 
 	case KSM: //Key share msg
 
 	case PM: //Publish msg
-		moscato.queue.push(msg.(*PublishMsg))
+		moscato.queue.push(reply.ReceiveMsg.(*PublishMsg))
 
 	case SM: //Subscription msg
-		moscato.match_mng.add_subscription(msg.(*SubscriptionMsg))
+		moscato.match_mng.add_subscription(reply.ReceiveMsg.(*SubscriptionMsg))
 
 	case RM: //Register msg
 		//var newmsg RegisterMsg
-		var newmsg = msg.(*RegisterMsg)
+		var newmsg = reply.ReceiveMsg.(*RegisterMsg)
 		newNode := MSnode{newmsg.From(), newmsg.From()}
 		moscato.ms_mng.add_microservice(newNode)
 
 	case WM: //Withdraw msg
-		moscato.ms_mng.remove_microservice(msg.(*WithdrawMsg).From())
+		moscato.ms_mng.remove_microservice(reply.ReceiveMsg.(*WithdrawMsg).From())
 
 	default:
 		return nil, errors.New("Message type Error: Not registered message type")
 	}
 
-	return msg, nil
+	return reply.ReceiveMsg, nil
 }
 
-//Receive - MicorService가 msg 받음// MS.go들어가야할 함수
-/*func (ms *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
-		ms.receivemsg=msg.(*SubscriptionMsg)
-	}
-	return nil
-}*/
 
 func (moscato *Moscato) Run() {
 	//모스카토 구조체 변수 초기화

src/broker/modules/list.go

@@ -4,29 +4,29 @@ package modules
 	Sub정보들을 관리할 list
 */
 
-type NameList struct {
-	head *NameNode
-	tail *NameNode
+type topicList struct {
+	head *topicNode
+	tail *topicNode
 	size int
 }
 
-type NameNode struct {
+type topicNode struct {
 	topic []int64 // Encrypt된 topic
-	next  *NameNode
-	prev  *NameNode
-	list  List
+	next  *topicNode
+	prev  *topicNode
+	list  valueList
 }
 
-type List struct {
-	head *Node
-	tail *Node
+type valueList struct {
+	head *valueNode
+	tail *valueNode
 	size int
 }
 
-type Node struct {
+type valueNode struct {
 	val  []int64 // Encrypt된 value
-	next *Node
-	prev *Node
+	next *valueNode
+	prev *valueNode
 
 	// single //
 	single2sub_s  []int // (val < x) sub#
@@ -56,7 +56,20 @@ func findSub(ary []int, sub int) int {
 	return -1
 }
 
-func (n *Node) isempty() bool {
+func (l *topicList) addTopicNode(topic []int64){
+	newNode := &topicNode{topic, nil, nil, valueList{}}
+	if l.head == nil{
+		l.head = newNode
+		l.tail = l.head
+	} else{
+		newNode.prev = l.tail
+		l.tail.next = newNode
+		l.tail = newNode
+	}
+	l.size++
+}
+
+func (n *valueNode) isEmpty() bool {
 	empty := true
 	if len(n.single2sub_s) != 0 {
 		empty = false
@@ -89,7 +102,7 @@ func (n *Node) isempty() bool {
 }
 
 // 노드의 operator리스트에 sub#을 in
-func (l *Node) insert_Sub(op string, sub int, issingle bool) {
+func (l *valueNode) insertSub(op string, sub int, issingle bool) {
 	if issingle == true {
 		switch op {
 		case "<":
@@ -117,21 +130,88 @@ func (l *Node) insert_Sub(op string, sub int, issingle bool) {
 	}
 }
 
-func (l *List) add_ValueNode(value []int64) {
-	newValNode := &Node{value, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil}
-	l.tail.next = newValNode
-	l.tail = newValNode
+func (l *valueList) addValueNode(value []int64) {
+	newValNode := &valueNode{value, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil}
+	if l.head == nil{
+		l.head = newValNode
+		l.tail = l.head
+	} else{
+		newValNode.prev = l.tail
+		l.tail.next = newValNode
+		l.tail = newValNode
+	}
 	l.size++
 }
 
-func (l *List) getPos(value []int64) *Node {
-	valptr := l.head
-	for valptr != nil {
+func (l *topicList) getTopicNodePos(topic []int64) *topicNode {
+	topicPtr := l.head
+	for topicPtr != nil {
+		if len(topicPtr.topic) == 0{
+			topicPtr = topicPtr.next
+			continue
+		}
 		// * compare 완성된다면 다시보기
-		if compare(valptr.val, value) == 0 { // value와 같은 val을 갖는 노드가 존재한다면
-			return valptr
+		if l.CompareTopic(topicPtr.topic, topic) == 0 {
+			return topicPtr
 		}
-		valptr = valptr.next
+		topicPtr = topicPtr.next
 	}
 	return nil
 }
+
+func (l *topicList)CompareTopic(topic1 []int64, topic2 []int64) int {
+	// 길이 같은지 체크
+	if len(topic1) != len(topic2) {
+		return -1
+	}
+	for i := 0; i < len(topic2); i++ {
+		if topic1[i] != topic2[i] {
+			return -1
+		}
+	}
+	return 0
+}
+
+func (l *valueList) getValueNodePos(value []int64, isAlpha bool) *valueNode {
+	valPtr := l.head
+	for valPtr != nil {
+		if len(valPtr.val) == 0{
+			valPtr = valPtr.next
+			continue
+		}
+		if isAlpha{
+			if CompareAlpha(value, valPtr.val) == 0{
+				return valPtr
+			}
+		} else{
+			if CompareDigit(value[0], valPtr.val[0]) == 0{
+				return valPtr
+			}
+		}
+		valPtr = valPtr.next
+	}
+	return nil
+}
+
+
+func CompareDigit(value1 int64, value2 int64) int {
+	if value1 < value2 {
+		return 1
+	} else if value1 > value2 {
+		return -1
+	}
+	return 0
+}
+
+func CompareAlpha(value1 []int64, value2 []int64) int {
+	// 길이 같은지 체크
+	if len(value1) != len(value2) {
+		return -1
+	}
+	for i := 0; i < len(value2); i++ {
+		if value1[i] != value2[i] {
+			return -1
+		}
+	}
+	return 0
+}

src/broker/modules/list_test.go

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

src/broker/modules/message.go

@@ -73,7 +73,7 @@ type SubscriptionMsg struct {
 	topic []int64 //대주제
 	value []int64 //피연산자
 	operator []string //연산자
-	isAlpha bool // 범위연산인지 단순비교연산인지 구분 가능하게 함
+  	isAlpha bool //value가 숫자인지 문자열인지
 }
 
 //Microservice 등록 메세지

src/broker/modules/subscription.go

@@ -2,41 +2,55 @@ package modules
 
 import (
 	"errors"
+	"fmt"
 )
 
 type sub_manager struct {
 	// NameList의 노드들이 각각의 list를 갖음
-	list NameList
+	list topicList
 
 	/* sub# 관리 */
-	count_sub 	 int              // Subscription #
-	emptylist  []int            // To administrate sub #
-	sub2ip     map[int]string  // sub2ip[sub#] = ip
-	ip2sub     map[string][]int // ip2sub[ip]= sub#...
-	sub2node   map[int][]*Node  // sub2node[sub#] = node_addr
-	israngesub map[int]bool     // delete시에 관리를 위해
+	count_sub 	 int               // Subscription #
+	emptylist  []int                // To administrate sub #
+	ip2sub     map[string][]int     // ip2sub[ip]= sub#...
+	sub2node   map[int][]*valueNode // sub2node[sub#] = node_addr
+	israngesub map[int]bool         // delete시에 관리를 위해
+}
+
+// 초기화 시에 하고 싶은 처리
+func (self *sub_manager) Initialize() {
+	// Some initialize
+	self.ip2sub = make(map[string][]int)
+	self.sub2node = make(map[int][]*valueNode)
+	self.israngesub = make(map[int]bool)
+}
+
+// 생성자 함수를 정의
+func newSubmng() *sub_manager {
+	sub_mng := &sub_manager{}
+	sub_mng.Initialize()
+	return sub_mng
 }
 
 //	### To Insert sub#
-func (manager *sub_manager) add_subscription(msg MsgUnit) error {
+func (manager *sub_manager) addSubscription(msg MsgUnit) error {
 
 	topic := msg.(*SubscriptionMsg).topic
 	value := msg.(*SubscriptionMsg).value
 	operator := msg.(*SubscriptionMsg).operator
+	isAlpha := msg.(*SubscriptionMsg).isAlpha
 	subnumber := 0
 
 	//fmt.Println("message = ", msg)
 
-	// * 1. 들어온 Msg -> sub#, sub# -> Msg로 매핑
+	// * 1. 들어온 ipaddr -> sub# 매핑
 	if len(manager.emptylist) == 0 {
-		manager.sub2ip[manager.count_sub] = msg.(*SubscriptionMsg).from
 		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.sub2ip[subidx] = msg.(*SubscriptionMsg).from
 		manager.ip2sub[msg.(*SubscriptionMsg).from] = append(manager.ip2sub[msg.(*SubscriptionMsg).from], subidx)
 		subnumber = subidx
 	}
@@ -48,7 +62,7 @@ func (manager *sub_manager) add_subscription(msg MsgUnit) error {
 	//namelist에서 name찾고, 없으면 추가
 	for nameptr != nil {
 		// *  compare함수 구현되기 전 임시로 끼워넣은 것 (이 부분은 secure.go 완성되면 다시 확인)
-		if compare(nameptr.topic, topic) == 0 {
+		if nameptr.topic[0] == topic[0] {
 			findOk = true
 			break
 		}
@@ -56,25 +70,23 @@ func (manager *sub_manager) add_subscription(msg MsgUnit) error {
 	}
 
 	if !findOk {
-		newNode := &NameNode{topic, nil, nil, List{}}
-		manager.list.tail.next = newNode
-		manager.list.tail = newNode
-		manager.list.size++
+		manager.list.addTopicNode(topic)
 		nameptr = manager.list.tail
 	}
 
 	// list[name]에 value추가
 	if len(operator) == 1 { // 단일 식이라면 (single)
-		valptr := nameptr.list.getPos(value)
+		valptr := nameptr.list.getValueNodePos(value, isAlpha)
+		fmt.Println("pos = " ,valptr.val)
 		if valptr == nil {
-			nameptr.list.add_ValueNode(value)
+			nameptr.list.addValueNode(value)
 			valptr = nameptr.list.tail
 		}
 
 		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr)
-		valptr.insert_Sub(operator[0], subnumber, true)
+		valptr.insertSub(operator[0], subnumber, true)
 
-		return nil // add_subscription ok
+		return nil // addSubscription ok
 	} else {
 
 		// '&&' , '||'로 묶여 있는 복합식에 대하여
@@ -82,15 +94,15 @@ func (manager *sub_manager) add_subscription(msg MsgUnit) error {
 
 		// find(namelist[name].list.val == value)인 노드
 		// * 이 부분 다시 봐야함..
-		valptr1 := nameptr.list.getPos(value)
-		valptr2 := nameptr.list.getPos(value)
+		valptr1 := nameptr.list.getValueNodePos(value, isAlpha)
+		valptr2 := nameptr.list.getValueNodePos(value, isAlpha)
 
 		if valptr1 == nil {
-			nameptr.list.add_ValueNode(value)
+			nameptr.list.addValueNode(value)
 			valptr1 = nameptr.list.tail
 		}
 		if valptr2 == nil {
-			nameptr.list.add_ValueNode(value)
+			nameptr.list.addValueNode(value)
 			valptr2 = nameptr.list.tail
 		}
 
@@ -100,17 +112,17 @@ func (manager *sub_manager) add_subscription(msg MsgUnit) error {
 		if logical_operator == "&&" { // '&&'로 묶여있다면
 			// rangesub check
 			manager.israngesub[subnumber] = true
-			valptr1.insert_Sub(operator[0], subnumber, false)
-			valptr2.insert_Sub(operator[2], subnumber, false)
+			valptr1.insertSub(operator[0], subnumber, false)
+			valptr2.insertSub(operator[2], subnumber, false)
 
 		} else {
 			// '||'로 묶여 있다면 두 식 모두 single로 처리가능
-			valptr1.insert_Sub(operator[0], subnumber, true)
-			valptr2.insert_Sub(operator[2], subnumber, true)
+			valptr1.insertSub(operator[0], subnumber, true)
+			valptr2.insertSub(operator[2], subnumber, true)
 		}
-		return nil // add_subscription ok
+		return nil // addSubscription ok
 	}
-	return errors.New("Can't add_subscription")
+	return errors.New("Can't addSubscription")
 }
 
 //	* To delete subscription
@@ -151,7 +163,7 @@ func (manager *sub_manager) delete(from string) error {
 				}
 
 				// node가 비어있으면 delete
-				isempty := node[j].isempty()
+				isempty := node[j].isEmpty()
 				if isempty && node[j] != nil {
 					prev_node := node[j].prev
 					next_node := node[j].next
@@ -192,7 +204,7 @@ func (manager *sub_manager) delete(from string) error {
 					manager.emptylist = append(manager.emptylist, sub)
 				}
 
-				isempty := node[j].isempty()
+				isempty := node[j].isEmpty()
 				// node가 비어있으면 delete
 				if isempty && node[j] != nil {
 					prev_node := node[j].prev
@@ -206,9 +218,4 @@ func (manager *sub_manager) delete(from string) error {
 	}
 	manager.ip2sub[ip]=nil
 	return nil
-}
-
-// * 암호화된 두 value 비교함수 (임시)
-func compare(v1 []int64, v2 []int64) int {
-	return 1
-}
+}

src/broker/modules/subscription_test.go

@@ -0,0 +1,145 @@
+package modules
+
+import (
+	"fmt"
+	_ "fmt"
+	"math/rand"
+	"strconv"
+	"testing"
+	"time"
+	"github.com/stretchr/testify/assert"
+)
+
+func dataMake(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{"&&", "||"}
+
+	topic = append(topic, rand.Int63())
+
+	if isalpha{
+		value = append(value, rand.Int63())
+		operator = append(operator, "==")
+	} else{
+		len := rand.Int() % 2 + 1
+		value = append(value, rand.Int63())
+
+		if len == 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 Test_addSubscription(t *testing.T) {
+	rand.Seed(time.Now().UnixNano())
+
+	// To Init sub_mng
+	mos := Moscato{sub_mng : sub_manager{}}
+
+	// Make Data set(Subscription)
+	msgList := []MsgUnit{}
+	dataLen:= 3
+	for i := 0 ; i < dataLen ; i++{
+		seed := rand.Int()%2
+		if seed == 0{
+			msgList = append(msgList, dataMake(false))
+		} else{
+			msgList = append(msgList, dataMake(true))
+		}
+	}
+
+	// Watch Data set
+	for i := 0; i < dataLen ; i++{
+		msg := msgList[i]
+		fmt.Println(
+			" from = ", msg.(*SubscriptionMsg).Message.from,
+			" time = ", msg.(*SubscriptionMsg).Message.time,
+			" topic = ", msg.(*SubscriptionMsg).topic,
+			" value = ", msg.(*SubscriptionMsg).value,
+			" operator = ", msg.(*SubscriptionMsg).operator,
+			" isAlpha ?= ", msg.(*SubscriptionMsg).isAlpha)
+	}
+
+	// Test addSubScription
+	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
+		//isAlpha := msg.(*SubscriptionMsg).isAlpha
+		subnumber := mos.sub_mng.count_sub
+
+		mos.sub_mng.addSubscription(msg)
+
+
+		// 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
+		nameptr := mos.sub_mng.list.head
+		for nameptr != nil{
+			if nameptr.topic[0] == topic[0]{
+				break
+			}
+			nameptr = nameptr.next
+		}
+
+		for i := 0 ; i < len(topic); i++{
+			assert.Equal(t, topic[i], nameptr.topic[i], "topicNode Add is failed")
+		}
+
+		// 3. Check Value in ValueNode
+		valptr := nameptr.list.head
+		for valptr != nil{
+			for i:=0 ; i < len(value); i++{
+				find := true
+				if value[i] != valptr.val[i]{
+					find = false
+				}
+				if find{
+					break
+				}
+			}
+			valptr = valptr.next
+		}
+		fmt.Println("my value = ", valptr.val, " real value = ", value)
+
+		for i := 0; i < len(value); i++{
+			assert.Equal(t, value[i], valptr.val[i], "ValNode Add is failed")
+		}
+	}
+}