[revise] 의존성 주입 AppConfig.go 분리

src/broker/modules/AppConfig.go

+package modules
+
+import (
+	"github.com/facebookgo/inject"
+)
+
+type AppConfig struct {
+	application *Moscato
+}
+
+func (app *AppConfig) config() *Moscato {
+	var graph inject.Graph
+
+	err := graph.Provide(
+		&inject.Object{Value: NewMStable()},
+		&inject.Object{Value: app.application},
+		&inject.Object{Value: NewSecurity()})
+	if err != nil {
+		println(err)
+		return nil
+	}
+
+	err = graph.Populate()
+	if err != nil {
+		println(err)
+		return nil
+	}
+	return app.application
+}

src/broker/modules/init.go

 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/facebookgo/inject"
 	"github.com/fatih/color"
 	"log"
 	"net"
 type Moscato struct {
 	queue               MsgQueue
 	MicroServiceManager NodeManager `inject:""`
-	match_mng           match_manager
+	MatchingManager     match_manager
 	SecureManager       SecurityManager `inject:""`
 }
 
 
 			}
 		}()
-		reply.CompleteLog = "received completely"
+		reply.CompleteLog = "received"
 	case PM:
 		var msg PublishMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 
 			}
 		}()
-		reply.CompleteLog = "PM received completely"
+		reply.CompleteLog = "PM received"
 	case SM:
 		var msg SubscriptionMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 
 			}
 		}()
-		reply.CompleteLog = "received completely"
+		reply.CompleteLog = "received"
 	case RM:
 		var msg RegisterMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 				fmt.Println(err)
 			}
 		}()
-		reply.CompleteLog = "RM received completely"
+		reply.CompleteLog = "RM received"
 	case WM:
 		var msg WithdrawMsg
 		err := json.Unmarshal(args.JsonMsg, &msg)
 
 			}
 		}()
-		reply.CompleteLog = "received completely"
+		reply.CompleteLog = "received"
 	default:
 		return errors.New("message type Error: Not registered message type")
 	}
 	case KSM: //Key share msg
 
 	case PM: //Publish msg
-		moscato.queue.push(msg.(PublishMsg))
 		log.Println("PM received")
+		moscato.queue.push(msg.(PublishMsg))
 
 	case SM: //Subscription msg
-		moscato.match_mng.add_subscription(msg.(*SubscriptionMsg))
+		moscato.MatchingManager.add_subscription(msg.(*SubscriptionMsg))
 
 	case RM: //Register msg
+		log.Println("RM received")
 		var newMsg RegisterMsg
 		newMsg = msg.(RegisterMsg)
 
 
 		addr, _ := moscato.MicroServiceManager.GetIpaddr(newMsg.From)
 		moscato.SecureManager.RegKey(newMsg)
-		fmt.Println(moscato.SecureManager.GetNodeKey(newMsg.From))
-		fmt.Println(addr)
+		fmt.Println("Registered microservice: address", addr,
+			"/ key", moscato.SecureManager.GetNodeKey(newMsg.From))
 
 		// ackRM 메세지 전송
 		go moscato.Send2MS(addr, newMsg)
 
-		log.Println("RM received")
-
 	case WM: //Withdraw msg
 		moscato.MicroServiceManager.RemoveMicroservice(msg.(*WithdrawMsg).From)
 
 	}
 	//log.Println(reply.CompleteLog) //잘 받았는지 확인 해줌
 	// 마이크로 서비스에게 받은 메시지는 노란색으로 출력
-	color.Yellow(reply.CompleteLog)
+	log.Println(reply.CompleteLog)
 }
 
 func (moscato *Moscato) Run() {
 
-	var graph inject.Graph
-
-	err := graph.Provide(
-		&inject.Object{Value: NewMStable()},
-		&inject.Object{Value: moscato},
-		&inject.Object{Value: NewSecurity()})
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	err = graph.Populate()
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
+	config := AppConfig{moscato}
+	config.config()
 
 	//모스카토 구조체 변수 초기화
 	receiver := Receiver{moscato: moscato}
-	err = moscato.queue.queue_init()
+	err := moscato.queue.queue_init()
 	if err != nil {
 		fmt.Println(err)
 		return
 	}
 
-	//moscato.MicroServiceManager = NewMStable()
-
 	//go routine -> matching 동작
-	go moscato.match_mng.matching(&moscato.queue)
+	go moscato.MatchingManager.matching(&moscato.queue)
 	go moscato.CheckQueue()
 
 	//rpc 등록 -> Receive 함수
 		return
 	}
 
-	Listen()
-	log.Println("listen complete.")
+	go Listen()
+	color.Blue("initializing complete.")
 	fmt.Scanln()
 }
 
 	if err1 != nil {
 		log.Fatal(fmt.Sprintf("Unable to listen on given port: %s", err1))
 	}
-	/*defer l1.Close()
+	defer l.Close()
 
-	if err2 != nil {
+	/*if err2 != nil {
 		log.Fatal(fmt.Sprintf("Unable to listen on given port: %s", err2))
 	}
 	defer l2.Close()*/

src/broker/modules/manage.go

 package modules
 
+import (
+	"fmt"
+)
+
 //각 Microservice에 대한 정보 저장 노드
 type MSNode struct {
 	nodeName string
 }
 
 func NewMStable() *MStable {
+	defer fmt.Println("node manager setting complete.")
 	return &MStable{NodeTable: make(map[string]MSNode)}
 }
 

src/broker/modules/queue.go

 
 import (
 	"errors"
-	"github.com/fatih/color"
+	"fmt"
 )
 
 type MsgQueue struct {
 	} else if mq.queue == nil {
 		mq.queue = make(chan MsgUnit, 1000)
 		//log.Println("queue is initialized.")
-		color.Blue("queue is initialized.")
+		fmt.Println("queue is initialized.")
 		return nil
 	} else {
 		close(mq.queue)

src/broker/modules/secure.go

 
 func NewSecurity() *Security {
 	security := &Security{map[string]string{}}
+	fmt.Println("security setting complete.")
 	return security
 }