Moscato_Messaging_Middleware/modules/subscription.go

package modules

import (
	"errors"
)

type sub_manager struct {
	// NameList의 노드들이 각각의 list를 갖음
	list NameList

	/* 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시에 관리를 위해
}

//	### To Insert sub#
func (manager *sub_manager) add_subscription(msg MsgUnit) error {

	topic := msg.(*SubscriptionMsg).topic
	value := msg.(*SubscriptionMsg).value
	operator := msg.(*SubscriptionMsg).operator
	subnumber := 0

	//fmt.Println("message = ", msg)

	// * 1. 들어온 Msg -> sub#, sub# -> Msg로 매핑
	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
	}

	// * 2. Sub 추가
	nameptr := manager.list.head
	findOk := false

	//namelist에서 name찾고, 없으면 추가
	for nameptr != nil {
		// *  compare함수 구현되기 전 임시로 끼워넣은 것 (이 부분은 secure.go 완성되면 다시 확인)
		if compare(nameptr.topic, topic) == 0 {
			findOk = true
			break
		}
		nameptr = nameptr.next
	}

	if !findOk {
		newNode := &NameNode{topic, nil, nil, List{}}
		manager.list.tail.next = newNode
		manager.list.tail = newNode
		manager.list.size++
		nameptr = manager.list.tail
	}

	// list[name]에 value추가
	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 {

		// '&&' , '||'로 묶여 있는 복합식에 대하여
		logical_operator := operator[1]

		// find(namelist[name].list.val == value)인 노드
		// * 이 부분 다시 봐야함..
		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 == "&&" { // '&&'로 묶여있다면
			// rangesub check
			manager.israngesub[subnumber] = true
			valptr1.insert_Sub(operator[0], subnumber, false)
			valptr2.insert_Sub(operator[2], subnumber, false)

		} else {
			// '||'로 묶여 있다면 두 식 모두 single로 처리가능
			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 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 비교함수 (임시)
func compare(v1 []int64, v2 []int64) int {
	return 1
}