[revise] 길호님 수정하다 만 버전

src/broker/modules/AppConfig.go

 		&inject.Object{Value: NewMStable()},
 		&inject.Object{Value: app.application},
 		&inject.Object{Value: NewSecurity()})
+
 	if err != nil {
 		println(err)
 		return nil

src/broker/modules/init.go

 	"encoding/json"
 	"errors"
 	"fmt"
-	_ "github.com/fatih/color"
+	"github.com/fatih/color"
 	"log"
 	"net"
 	"net/rpc"
 
 type Moscato struct {
 	queue               MsgQueue
-	SendQueue			chan myType
+	SendQueue           chan myType
 	MicroServiceManager NodeManager `inject:""`
 	MatchingManager     match_manager
-	Subscriptionmanager	sub_manager
+	SubscriptionManager sub_manager
 	SecureManager       SecurityManager `inject:""`
 }
 
-type myType struct{
-	subList	[]string
-	pubMsg	MsgUnit
-	err		error
+type myType struct {
+	subList []string
+	pubMsg  MsgUnit
+	err     error
 }
 
 type Reply struct {
 
 			}
 		}()
-		reply.CompleteLog = "received"
+		reply.CompleteLog = "SM received"
 	case RM:
 		var msg RegisterMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 
 	case PM: //Publish msg
 		log.Println("PM received")
+		fmt.Println("PM: ", msg)
 		moscato.queue.push(msg.(PublishMsg))
 
 	case SM: //Subscription msg
-		moscato.Subscriptionmanager.addSubscription(msg.(*SubscriptionMsg))
+		fmt.Println("SM: ", msg)
+		moscato.SubscriptionManager.addSubscription(msg)
 
 	case RM: //Register msg
 		log.Println("RM received")
 	receiver := Receiver{moscato: moscato}
 	err := moscato.queue.queue_init()
 	moscato.SendQueue = make(chan myType)
-	moscato.Subscriptionmanager.Initialize()
+	moscato.SubscriptionManager.Initialize()
 
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
 
-
 	//go routine -> matching 동작
 	go moscato.Matching()
-	go moscato.CheckQueue()
+
+	//go moscato.CheckQueue()
 
 	//rpc 등록 -> Receive 함수
 	err = rpc.Register(receiver)
 	}
 
 	go Listen()
-	//color.Blue("initializing complete.")
+	color.Blue("initializing complete.")
 	fmt.Scanln()
 }
 
 		conn, _ := l2.Accept()
 		go rpc.ServeConn(conn)
 	}*/
-}
+}

src/broker/modules/list.go

 	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 {

src/broker/modules/matching.go

 import (
 	"errors"
 	_ "errors"
+	"fmt"
 	"github.com/juliangruber/go-intersect"
 	"reflect"
 )
 }
 
 // Matching -> Return (list of IP addresses of matched subs, Pub Msg, error)
-func (moscato * Moscato) Matching() {
+func (moscato *Moscato) Matching() {
 	msg := moscato.queue.pop(true)
-	topic := msg.(*PublishMsg).Topic
-	value := msg.(*PublishMsg).Value
-	sub_mng := moscato.Subscriptionmanager
-	// list
+	topic := msg.(PublishMsg).Topic
+	value := msg.(PublishMsg).Value
+	sub_mng := moscato.SubscriptionManager
+
+	fmt.Println("matchßing st")
+
+	fmt.Println("value = ", value)
+
+	// listß
 	ret := make([]string, 0)
 
 	// list for matched range subscriptions
 	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)
 
 			ret = append(ret, ip)
 		}
 
+		fmt.Println("Big =", big)
+		fmt.Println("small =", small)
+
+		fmt.Println("matching: ", ret)
 		moscato.MatchingManager.match_count++
 		moscato.SendQueue <- myType{ret, msg, nil}
 	}
-}
+}

src/broker/modules/message.go

 //구독 정보를 담은 메세지
 type SubscriptionMsg struct {
 	Message
-	topic    []int64  //대주제
-	value    []int64  //피연산자
-	operator []string //연산자
-	isAlpha  bool     //value가 숫자인지 문자열인지
+	Topic    []int64  //대주제
+	Value    []int64  //피연산자
+	Operator []string //연산자
+	IsAlpha  bool     //value가 숫자인지 문자열인지
 }
 
 //Microservice 등록 메세지

src/broker/modules/subscription.go

 
 import (
 	"errors"
+	"fmt"
 )
 
 type sub_manager struct {
 //	### To Insert sub#
 func (manager *sub_manager) addSubscription(msg MsgUnit) error {
 
-	topic := msg.(*SubscriptionMsg).topic
-	value := msg.(*SubscriptionMsg).value
-	operator := msg.(*SubscriptionMsg).operator
+	topic := msg.(SubscriptionMsg).Topic
+	value := msg.(SubscriptionMsg).Value
+	operator := msg.(SubscriptionMsg).Operator
 	subnumber := 0
-
 	// * 1. Mapping incoming IP address to sub #
 
+	fmt.Println("add sub st")
+	fmt.Println("sub val", value)
+
 	if len(manager.emptylist) == 0 {
 		subnumber = manager.count_sub
-		manager.ip2sub[msg.(*SubscriptionMsg).From] = append(manager.ip2sub[msg.(*SubscriptionMsg).From], manager.count_sub)
-		manager.sub2ip[subnumber] = msg.(*SubscriptionMsg).From
+		manager.ip2sub[msg.(SubscriptionMsg).From] = append(manager.ip2sub[msg.(SubscriptionMsg).From], manager.count_sub)
+		manager.sub2ip[subnumber] = msg.(SubscriptionMsg).From
 		manager.count_sub++
 	} else {
 		subnumber := 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], subnumber)
-		manager.sub2ip[subnumber] = msg.(*SubscriptionMsg).From
+		manager.ip2sub[msg.(SubscriptionMsg).From] = append(manager.ip2sub[msg.(SubscriptionMsg).From], subnumber)
+		manager.sub2ip[subnumber] = msg.(SubscriptionMsg).From
 	}
 
 	nameptr := manager.list.head
 		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 {
 
 		// For compound expressions bounded by '&&' and '||'
 		// (ex) { (234 < x) && (x <= 1293) } , { (234 < x) || ( x < 1293) }
-		logical_operator := operator[1]
+		logical_operator := operator[2]
 
-		// 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]})
+		valptr2 := nameptr.list.getValueNodePos([]int64{value[2]})
 
 		if valptr1 == nil {
 			nameptr.list.addValueNode([]int64{value[0]})
 			valptr1 = nameptr.list.tail
 		}
 		if valptr2 == nil {
-			nameptr.list.addValueNode([]int64{value[1]})
+			nameptr.list.addValueNode([]int64{value[2]})
 			valptr2 = nameptr.list.tail
 		}
 
 		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)
+			valptr2.insertSub(operator[4], 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)
+			valptr2.insertSub(operator[4], subnumber, true)
 		}
 
 		return nil // addSubscription ok