src/discoverymgr/discovery_init.go : discovery init remove go chan

Change-Id: I6e6e5ad6892e1e3424a3c155d666c635c5ee1469

diff --git a/src/discoverymgr/discovery_init.go b/src/discoverymgr/discovery_init.go
index 461886f..c4330e0 100755 (executable)
--- a/src/discoverymgr/discovery_init.go
+++ b/src/discoverymgr/discovery_init.go
@@ -21,7 +21,6 @@ import (
        "errors"
        "log"
        "net"
-       "strings"
        "time"
 
        "grandcat/zeroconf"
@@ -31,111 +30,124 @@ var gServer *zeroconf.Server
 
 //InitDiscovery deploy Orchestration service
 func InitDiscovery() (err error) {
-       registerCh := make(chan error)
-       go registerDevice(nil, registerCh)
 
-       select {
-       case err = <-registerCh:
+       //NOTE : I don't know why only first time consume channel.
+       ExitPollingOutBoundCh = make(chan int, 1)
+       ExitChan = make(chan int, 1)
+
+       go func() {
+
+               gServer, err := registerDevice(getMacAddr(pollGettingOutBoundIP()))
+
                if err != nil {
-                       log.Println("[Fail] " + err.Error())
+                       log.Println(logPrefix, err)
                        return
                }
-       }
 
-       go discoveryBGR()
+               select {
+               case <-ExitChan:
+                       log.Printf("[%s] Orchestration Agent has been terminated", logPrefix)
+                       gServer.Shutdown()
+               }
+
+       }()
 
        return
 }
 
-func registerDevice(AppNames []string, ret chan error) {
-       macAddress, err := getMacAddr()
-       if err != nil {
-               ret <- err
-               return
+func IsNilServer() bool {
+       if gServer == nil {
+               return true
+       } else {
+               return false
        }
+}
 
-       hostName := "edge-" + macAddress
-       serviceName := "edge-orchestarition-" + macAddress
-       var hostIPAddr []string
+func getMacAddr(outboundIP string, pollingErr error) (macAddr string, err error) {
 
-       var netIface []net.Interface
-       ifaces, err := net.Interfaces()
-       for _, iface := range ifaces {
-               if iface.Name[0:2] == "wl" {
-                       log.Println(logPrefix, "[RegisterDevice] net.interface - wl:", iface)
-                       netIface = append(netIface, iface)
-                       addrs, _ := iface.Addrs()
-                       for _, address := range addrs {
-                               if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
-                                       if ipnet.IP.To4() != nil {
-                                               hostIPAddr = append(hostIPAddr, ipnet.IP.String())
-                                       }
-                               }
-                       }
-               }
+       if pollingErr != nil {
+               return
        }
 
-       log.Println("hostName: ", hostName)
-       log.Println("hostIpAddr: ", hostIPAddr)
-       log.Println("serviceName: ", serviceName)
-
-       server, err := zeroconf.RegisterProxy(serviceName, serviceType, domain, servicePort, hostName, hostIPAddr, AppNames, netIface)
-       // server, err := zeroconf.Register(serviceName, serviceType, domain, servicePort, AppNames, netIface)
+       ifas, err := net.Interfaces()
        if err != nil {
-               ret <- err
                return
        }
-       log.Println(logPrefix, "[RegisterDevice] zeroconf.Register: ", server)
-       gServer = server
-       defer server.Shutdown()
 
-       ret <- nil
+       //find macaddress where same ip address of infterface
+       for _, ifa := range ifas {
+               addrs, err := ifa.Addrs()
 
-       ExitChan = make(chan int, 1)
-       select {
-       case exit := <-ExitChan:
-               if exit == 1 {
-                       log.Printf("[%s] Orchestration Agent has been terminated", logPrefix)
+               if err != nil {
+                       return "", errors.New("there is nothing any inferfaces")
+               }
+
+               for _, addr := range addrs {
+                       if addr, ok := addr.(*net.IPNet); ok {
+                               if addr.IP.To4() != nil && addr.IP.String() == outboundIP {
+                                       macAddr = ifa.HardwareAddr.String()
+                                       return macAddr, nil
+
+                               }
+                       }
                }
        }
-}
 
-func getMacAddr() (macAddr string, err error) {
-       var outboundIP string
-       ipChan := make(chan string, 1)
+       return "", errors.New("Can't get Mac Address")
+}
 
-       go pollGettingOutBoundIP(ipChan)
+func registerDevice(macAddress string, err error) (*zeroconf.Server, error) {
 
-       select {
-       case outboundIP = <-ipChan:
-               log.Println("[outboundIP]", outboundIP)
+       if err != nil {
+               return nil, err
        }
 
-       ifas, err := net.Interfaces()
+       //NOTE : AppName is nil, because zeroconf txt is appName list. so first time, there is nothing in service of zeroconf.
+       var appName []string
+       var hostIPAddr []string
+       hostName := "edge-" + macAddress
+       serviceName := "edge-orchestarition-" + macAddress
+
+       //NOTE : in the future, come in eth, ... etc.
+       hostIPAddr, netIface := acceptWifi(hostIPAddr)
+
+       log.Println("hostName: ", hostName)
+       log.Println("hostIpAddr: ", hostIPAddr)
+       log.Println("serviceName: ", serviceName)
+
+       server, err := zeroconf.RegisterProxy(serviceName, serviceType, domain, servicePort, hostName, hostIPAddr, appName, netIface)
+       // server, err := zeroconf.Register(serviceName, serviceType, domain, servicePort, AppNames, netIface)
        if err != nil {
-               return
+               return nil, err
+       } else {
+               return server, nil
        }
 
-       for _, ifa := range ifas {
-               addrs, _ := ifa.Addrs()
+}
 
-               if len(addrs) != 0 {
-                       for _, addr := range addrs {
-                               if strings.Contains(addr.String(), outboundIP) == true {
-                                       macAddr = ifa.HardwareAddr.String()
-                                       if strings.Compare(macAddr, "") != 0 {
-                                               log.Println(macAddr)
-                                               return
+func acceptWifi(hostIPAddr []string) ([]string, []net.Interface) {
+
+       var netIface []net.Interface
+       ifaces, _ := net.Interfaces()
+       for _, iface := range ifaces {
+               if iface.Name[0:2] == "wl" {
+                       log.Println(logPrefix, "[RegisterDevice] net.interface - wl:", iface)
+                       netIface = append(netIface, iface)
+                       addrs, _ := iface.Addrs()
+                       for _, address := range addrs {
+                               if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
+                                       if ipnet.IP.To4() != nil {
+                                               hostIPAddr = append(hostIPAddr, ipnet.IP.String())
                                        }
                                }
                        }
                }
        }
 
-       return "", errors.New("Can't get Mac Address")
+       return hostIPAddr, netIface
 }
 
-func pollGettingOutBoundIP(outboundIP chan string) {
+func pollGettingOutBoundIP() (string, error) {
        ticker := time.NewTicker(time.Duration(1) * time.Second)
        defer func() { ticker.Stop() }()
 
@@ -145,9 +157,12 @@ func pollGettingOutBoundIP(outboundIP chan string) {
                        log.Println("pollGettingOutBoundIP")
                        ip, _ := common.GetOutboundIP()
                        if len(ip) != 0 {
-                               outboundIP <- ip
-                               break
+                               return ip, nil
                        }
+               case <-ExitPollingOutBoundCh:
+                       log.Printf("ExitPollingOutBoundCh")
+                       return "", errors.New("polling outboundIP terminated")
                }
+
        }
 }