temporarily completed subscription.go

modules/subscription.go

 
 import (
 	"errors"
-	"fmt"
 )
 
 type sub_manager struct {
 	list NameList
 
 	/* sub# 관리 */
-	count_sub  int             // Subscription #
-	emptylist  []int           // To administrate sub #
-	num2sub    map[int]MsgUnit // num2sub[sub#] = msg
-	sub2num    map[MsgUnit]int // delete시에 관리를 위해
-	israngesub map[int]bool    // delete시에 관리를 위해
+	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시에 관리를 위해
 }
 
 //	### To Insert sub#
 func (manager *sub_manager) add_subscription(msg MsgUnit) error {
 
-	name := msg.(*SubscriptionMsg).subscription
+	topic := msg.(*SubscriptionMsg).topic
 	value := msg.(*SubscriptionMsg).value
+	operator := msg.(*SubscriptionMsg).operator
 	subnumber := 0
 
-	fmt.Println("name = ", name, " value = ", value) // for debugging
+	//fmt.Println("message = ", msg)
 
 	// * 1. 들어온 Msg -> sub#, sub# -> Msg로 매핑
 	if len(manager.emptylist) == 0 {
-		manager.num2sub[manager.count_sub] = msg
-		manager.sub2num[msg] = manager.count_sub
+		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.num2sub[subidx] = msg
-		manager.sub2num[msg] = subidx
+		manager.sub2ip[subidx] = msg.(*SubscriptionMsg).from
+		manager.ip2sub[msg.(*SubscriptionMsg).from] = append(manager.ip2sub[msg.(*SubscriptionMsg).from], subidx)
 		subnumber = subidx
 	}
 
 	//namelist에서 name찾고, 없으면 추가
 	for nameptr != nil {
 		// *  compare함수 구현되기 전 임시로 끼워넣은 것 (이 부분은 secure.go 완성되면 다시 확인)
-		if compare(nameptr.name, name) == 1 {
+		if compare(nameptr.topic, topic) == 0 {
 			findOk = true
 			break
 		}
 		nameptr = nameptr.next
 	}
 
-	if findOk == false {
-		newNode := &NameNode{name, nil, List{}}
+	if !findOk {
+		newNode := &NameNode{topic, nil, nil, List{}}
 		manager.list.tail.next = newNode
 		manager.list.tail = newNode
 		manager.list.size++
 		nameptr = manager.list.tail
 	}
 
-	// *  ---  가정  ---
-	// *  데이터의 value형식은 아래의 두 개 꼴로만 들어온다고 가정
-	// *  	(1). {enc(val), op}  == 부등식
-	// *       -> (ex)  {2, '<'} , { "baseball", == }
-	// *  	(2). {부등식, '&&', 부등식}  or {부등식, '||', 부등식}
-	// *       -> (ex1)  {2, '<=', '&&', 3 , '>'}   ==  {2 <= x < 3}
-	// *          (ex2)  {12, '<', '||', 5 , '>'}   ==  {12 < x || x < 5}
-	// *  -------------
-
 	// list[name]에 value추가
-	if len(value) == 2 { // 단일 식이라면 (single)
-		valptr := nameptr.list.getPos(conv(value[0]))
-		if valptr == nil{
-			nameptr.list.add_ValueNode(value[0], value[1], subnumber, true)
-		} else{
-			valptr.insert_Sub(value[1], subnumber, true)
+	if len(operator) == 1 { // 단일 식이라면 (single)
+		valptr := nameptr.list.getPos(value)
+		if valptr == nil {
+			nameptr.list.add_ValueNode(value)
+			valptr = nameptr.list.tail
 		}
+
+		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr)
+		valptr.insert_Sub(operator[0], subnumber, true)
+
 		return nil // add_subscription ok
 	} else {
-		// rangesub check
-		manager.israngesub[subnumber] = true
 
 		// '&&' , '||'로 묶여 있는 복합식에 대하여
-		logical_operator := value[2]
+		logical_operator := operator[1]
 
 		// find(namelist[name].list.val == value)인 노드
-		valptr1 := nameptr.list.getPos(conv(value[0]))
-		valptr2 := nameptr.list.getPos(conv(value[3]))
+		// * 이 부분 다시 봐야함..
+		valptr1 := nameptr.list.getPos(value)
+		valptr2 := nameptr.list.getPos(value)
+
+		if valptr1 == nil {
+			nameptr.list.add_ValueNode(value)
+			valptr1 = nameptr.list.tail
+		}
+		if valptr2 == nil {
+			nameptr.list.add_ValueNode(value)
+			valptr2 = nameptr.list.tail
+		}
+
+		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr1)
+		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr2)
 
 		if logical_operator == "&&" { // '&&'로 묶여있다면
-			if valptr1 != nil && valptr2 != nil { // val1, val2를 갖는 노드가 둘 다 존재
-				valptr1.insert_Sub(value[1], subnumber, false)
-				valptr2.insert_Sub(value[4], subnumber, false)
-			}
-			if valptr1 == nil {
-				nameptr.list.add_ValueNode(value[0], value[1], subnumber, false)
-			}
-			if valptr2 == nil {
-				nameptr.list.add_ValueNode(value[3], value[4], subnumber, false)
-			}
+			// rangesub check
+			manager.israngesub[subnumber] = true
+			valptr1.insert_Sub(operator[0], subnumber, false)
+			valptr2.insert_Sub(operator[2], subnumber, false)
+
 		} else {
 			// '||'로 묶여 있다면 두 식 모두 single로 처리가능
-			if valptr1 != nil && valptr2 != nil { // val1, val2를 갖는 노드가 둘 다 존재
-				valptr1.insert_Sub(value[1], subnumber, true)
-				valptr2.insert_Sub(value[4], subnumber, true)
-			}
-			if valptr1 == nil {
-				nameptr.list.add_ValueNode(value[0], value[1], subnumber, true)
-			}
-			if valptr2 == nil {
-				nameptr.list.add_ValueNode(value[3], value[4], subnumber, true)
-			}
+			valptr1.insert_Sub(operator[0], subnumber, true)
+			valptr2.insert_Sub(operator[2], subnumber, true)
 		}
 		return nil // add_subscription ok
 	}
 	return errors.New("Can't add_subscription")
 }
 
-//	* ### To delete sub#
-func (manager *sub_manager) delete(subnumber int) error {
-	s := errors.New("!23")
-	return s
-}
-
-// * string형태로 암호화 되어있는 value -> int64[]로 변환(임시)
-func conv(val string) []int64 {
-	ret := make([]int64, len(val))
-	return ret
+//	* To delete subscription
+func (manager *sub_manager) delete(from string) error {
+
+	ip := from
+	cand := manager.ip2sub[ip]
+
+	for i := 0; i < len(cand); i++ {
+
+		sub := cand[i]
+		node := manager.sub2node[sub]
+
+		if manager.israngesub[sub] {
+			for j := 0; j < len(node); j++ {
+				pos := findSub(node[j].range2sub_s, sub)
+				if pos != -1 {
+					node[j].range2sub_s = remove(node[j].range2sub_s, pos)
+					manager.emptylist = append(manager.emptylist, sub)
+				}
+
+				pos = findSub(node[j].range2sub_es, sub)
+				if pos != -1 {
+					node[j].range2sub_es = remove(node[j].range2sub_es, pos)
+					manager.emptylist = append(manager.emptylist, sub)
+				}
+
+				pos = findSub(node[j].range2sub_b, sub)
+				if pos != -1 {
+					node[j].range2sub_b = remove(node[j].range2sub_b, pos)
+					manager.emptylist = append(manager.emptylist, sub)
+				}
+
+				pos = findSub(node[j].range2sub_eb, sub)
+				if pos != -1 {
+					node[j].range2sub_eb = remove(node[j].range2sub_eb, pos)
+					manager.emptylist = append(manager.emptylist, sub)
+				}
+
+				// node가 비어있으면 delete
+				isempty := node[j].isempty()
+				if isempty && node[j] != nil {
+					prev_node := node[j].prev
+					next_node := node[j].next
+
+					prev_node.next = node[j].next
+					next_node.prev = node[j].prev
+				}
+			}
+		} else {
+			for j := 0; j < len(node); j++ {
+				pos := findSub(node[j].single2sub_s, sub)
+				if pos != -1 {
+					node[j].single2sub_s = remove(node[j].single2sub_s, pos)
+					manager.emptylist = append(manager.emptylist, sub)
+				}
+
+				pos = findSub(node[j].single2sub_es, sub)
+				if pos != -1 {
+					node[j].single2sub_es = remove(node[j].single2sub_es, pos)
+					manager.emptylist = append(manager.emptylist, sub)
+				}
+
+				pos = findSub(node[j].single2sub_b, sub)
+				if pos != -1 {
+					node[j].single2sub_b = remove(node[j].single2sub_b, pos)
+					manager.emptylist = append(manager.emptylist, sub)
+				}
+
+				pos = findSub(node[j].single2sub_eb, sub)
+				if pos != -1 {
+					node[j].single2sub_eb = remove(node[j].single2sub_eb, pos)
+					manager.emptylist = append(manager.emptylist, sub)
+				}
+
+				pos = findSub(node[j].single2sub_e, sub)
+				if pos != -1 {
+					node[j].single2sub_e = remove(node[j].single2sub_e, pos)
+					manager.emptylist = append(manager.emptylist, sub)
+				}
+
+				isempty := node[j].isempty()
+				// node가 비어있으면 delete
+				if isempty && node[j] != nil {
+					prev_node := node[j].prev
+					next_node := node[j].next
+
+					prev_node.next = node[j].next
+					next_node.prev = node[j].prev
+				}
+			}
+		}
+	}
+	manager.ip2sub[ip]=nil
+	return nil
 }
 
 // * 암호화된 두 value 비교함수 (임시)