- Add GetScore export API

diff --git a/src/scoringmgr/handlers.go b/src/scoringmgr/handlers.go
index b73018103c76ca0d6c64706f56dd053cc82ef12d..c02f69f7afe2266b8ade57a2ba90730e52e5ee57 100644 (file)
--- a/src/scoringmgr/handlers.go
+++ b/src/scoringmgr/handlers.go
@@ -1,76 +1,183 @@
 package scoringmgr
 
-import "unsafe"
-
 import (
-  confdescription  "configuremgr/description"
+       "encoding/json"
+       "errors"
+       "log"
+       "net"
+       "strconv"
+       "strings"
+       "unsafe"
+
+       confdescription "configuremgr/description"
 )
 
 type Handler struct {
-  handlerName   string
-  libPath       string
-  devicesScore  map[string]float64
-  intervalMs    int
-  resourceCount int
-  scoreValue    int
-  symbolPtr     unsafe.Pointer
-
+       handlerName   string
+       libPath       string
+       devicesScore  map[string]float64
+       intervalMs    int
+       resourceCount int
+       scoreValue    chan float64
+       symbolPtr     unsafe.Pointer
 }
 
 type Handlers struct {
-  table map[string]*Handler
+       table map[string]*Handler
 
-  Ch                  chan interface{}
-  IloadScoringLibrary func (string, int) ()
+       Ch                  chan interface{}
+       IloadScoringLibrary func(string, int, chan float64)
 }
 
+var (
+       handlers *Handlers
+)
+
+const (
+       // ConstLocalTarget is for knowing local environments
+       ConstLocalTarget = "localhost"
+
+       // ConstPrefixHTTP is "http://"
+       ConstPrefixHTTP = "http://"
 
-func Init() (handlers *Handlers){
+       // ConstWellknownPort is wellknonw port
+       ConstWellknownPort = 56001
+)
+
+func Init() *Handlers {
 
-  handlers = new(Handlers)
-  handlers.table = make(map[string]*Handler)
+       handlers = new(Handlers)
+       handlers.table = make(map[string]*Handler)
 
-  return
+       return handlers
 }
 
 //TODO : async notify lib loading
-func PushLibPath(libPath string, doc *confdescription.Doc,  handlersCh chan<- interface{}) (err error){
-  handlersCh <- pair{libPath, doc}
-  return nil
+func PushLibPath(libPath string, doc *confdescription.Doc, handlersCh chan<- interface{}) (err error) {
+       handlersCh <- pair{libPath, doc}
+       return nil
+}
+
+// GetScore is getting score of device
+func GetScore(target string, name string) (scoreValue float64, err error) {
+       if strings.Compare(target, getOutboundIP()) == 0 || strings.Compare(target, ConstLocalTarget) == 0 {
+               scoreValue, err = getScoreLocalEnv(name)
+       } else {
+               scoreValue, err = getScoreRemoteEnv(target, name)
+       }
+
+       DLog.Println("scoreValue", scoreValue)
+
+       return
 }
 
+// Listening function
 func (handlers *Handlers) Listening() {
 
-  go func(){
+       go func() {
 
-    ILog.Println("listening started")
-    for {
-      
-      select {
-        case obj := <- handlers.Ch :
+               ILog.Println("listening started")
+               for {
 
-          handlerObj := handlers.makeHandler(obj.(pair))
-          handlers.runScoring(handlerObj)
-      }
+                       select {
+                       case obj := <-handlers.Ch:
 
-    }
+                               handlerObj := handlers.makeHandler(obj.(pair))
+                               handlers.runScoring(handlerObj)
+                       }
+               }
 
-  }()
+       }()
+}
+
+func (handlers *Handlers) runScoring(handlerObj *Handler) {
+       go handlers.IloadScoringLibrary(handlerObj.libPath, handlerObj.intervalMs, handlerObj.scoreValue)
+       return
 }
 
 func (handlers *Handlers) makeHandler(pairObj pair) (handlerObj *Handler) {
-  handlerObj = new(Handler)
-  handlerObj.handlerName  = pairObj.libPath
-  handlerObj.libPath      = pairObj.libPath
-  handlerObj.intervalMs   = pairObj.doc.ResourceType.IntervalTimeMs
-  handlerObj.devicesScore = make(map[string]float64)
+       handlerObj = new(Handler)
+       handlerObj.handlerName = getLibName(pairObj.libPath)
+       handlerObj.libPath = pairObj.libPath
+       handlerObj.intervalMs = pairObj.doc.ResourceType.IntervalTimeMs
+       handlerObj.devicesScore = make(map[string]float64)
+
+       handlers.table[handlerObj.handlerName] = handlerObj
 
-  handlers.table[pairObj.libPath] = handlerObj
+       handlerObj.scoreValue = make(chan float64, 1)
 
-  return
+       return
 }
 
-func (handlers *Handlers) runScoring(handlerObj *Handler) {
-  go handlers.IloadScoringLibrary(handlerObj.libPath, handlerObj.intervalMs)
-  return
-}
\ No newline at end of file
+func getLibName(libPath string) string {
+       name := strings.Split(libPath, "/")
+       lastIdx := len(name)
+
+       libName := strings.Split(name[lastIdx-1], ".")
+       return strings.TrimPrefix(libName[0], "lib")
+}
+
+func getChan(name string) (score chan float64, err error) {
+       handlerObj := handlers.table[name]
+
+       if handlerObj == nil {
+               err = errors.New("Invalid Service Name")
+               return
+       }
+
+       score = handlerObj.scoreValue
+
+       return
+}
+
+func getScoreLocalEnv(name string) (scoreValue float64, err error) {
+       scoreChan, err := getChan(name)
+       if err != nil {
+               return
+       }
+
+       select {
+       case scoreValue = <-scoreChan:
+               DLog.Println(scoreValue)
+       }
+       return
+
+}
+
+func getScoreRemoteEnv(target string, name string) (scoreValue float64, err error) {
+       targetURL := ConstPrefixHTTP + target + ":" + strconv.Itoa(ConstWellknownPort) + "/" + name
+
+       respBytes, err := doGet(targetURL)
+       if checkError(err) == true {
+               return scoreValue, err
+       }
+
+       var responseMsg map[string]interface{}
+       err = json.Unmarshal(respBytes, &responseMsg)
+
+       if err == nil {
+               scoreValue = responseMsg["ScoreValue"].(float64)
+       }
+
+       return
+}
+
+func getOutboundIP() string {
+       conn, err := net.Dial("udp", "8.8.8.8:80")
+       if err != nil {
+               log.Fatal(err)
+       }
+       defer conn.Close()
+
+       localAddr := conn.LocalAddr().(*net.UDPAddr)
+
+       return localAddr.IP.String()
+}
+
+func checkError(err error) bool {
+       if err != nil {
+               log.Println(err.Error())
+               return true
+       }
+       return false
+}