RIC:1060: Change in PTL

[ric-plt/xapp-frame.git] / pkg / xapp / xapp.go

diff --git a/pkg/xapp/xapp.go b/pkg/xapp/xapp.go
index 7ac0c2f..72a8d32 100755 (executable)
--- a/pkg/xapp/xapp.go
+++ b/pkg/xapp/xapp.go
@@ -48,35 +48,53 @@ type ShutdownCB func()
 
 var (
        // XApp is an application instance
-       Rmr           *RMRClient
-       Sdl           *SDLClient
-       SdlStorage    *SDLStorage
-       Rnib          *RNIBClient
-       Resource      *Router
-       Metric        *Metrics
-       Logger        *Log
-       Config        Configurator
-       Subscription  *Subscriber
-       Alarm         *AlarmClient
-       Util          *Utils
-       readyCb       ReadyCB
-       readyCbParams interface{}
-       shutdownCb    ShutdownCB
-       shutdownFlag  int32
-       shutdownCnt   int32
+       Rmr                *RMRClient
+       Sdl                *SDLClient
+       SdlStorage         *SDLStorage
+       Rnib               *RNIBClient
+       Resource           *Router
+       Metric             *Metrics
+       Logger             *Log
+       Config             Configurator
+       Subscription       *Subscriber
+       Alarm              *AlarmClient
+       Util               *Utils
+       readyCb            ReadyCB
+       readyCbParams      interface{}
+       shutdownCb         ShutdownCB
+       shutdownFlag       int32
+       shutdownCnt        int32
+       disableAlarmClient bool
+       isRegistered       bool
 )
 
+var startTime time.Time
+
+func XappUpTime() time.Duration {
+       return time.Since(startTime)
+}
+
+func init() {
+       startTime = time.Now()
+}
+
 func IsReady() bool {
        return Rmr != nil && Rmr.IsReady() && SdlStorage != nil && SdlStorage.IsReady()
 }
 
+func IsRegistered() bool {
+       return isRegistered
+}
+
 func SetReadyCB(cb ReadyCB, params interface{}) {
        readyCb = cb
        readyCbParams = params
 }
 
 func XappReadyCb(params interface{}) {
-       Alarm = NewAlarmClient(viper.GetString("moId"), viper.GetString("name"))
+       if disableAlarmClient == false {
+               Alarm = NewAlarmClient(viper.GetString("moId"), viper.GetString("name"))
+       }
        if readyCb != nil {
                readyCb(readyCbParams)
        }
@@ -96,18 +114,21 @@ func XappShutdownCb() {
        if shutdownCb != nil {
                shutdownCb()
        }
+
+       isRegistered = false
 }
 
 func registerXapp() {
        for {
                time.Sleep(5 * time.Second)
                if !IsHealthProbeReady() {
-                       Logger.Info("Application='%s' is not ready yet, waiting ...", viper.GetString("name"))
+                       Logger.Debug("Application='%s' is not ready yet, waiting ...", viper.GetString("name"))
                        continue
                }
 
                Logger.Debug("Application='%s' is now up and ready, continue with registration ...", viper.GetString("name"))
                if err := doRegister(); err == nil {
+                       isRegistered = true
                        Logger.Info("Registration done, proceeding with startup ...")
                        break
                }
@@ -142,9 +163,21 @@ func getPltNamespace(envName, defVal string) string {
 func doPost(pltNs, url string, msg []byte, status int) error {
        resp, err := http.Post(fmt.Sprintf(url, pltNs, pltNs), "application/json", bytes.NewBuffer(msg))
        if err != nil || resp == nil || resp.StatusCode != status {
-               Logger.Info("http.Post to '%s' failed with error: %v", fmt.Sprintf(url, pltNs, pltNs), err)
-               return err
+               logdesc := fmt.Sprintf("http.Post to '%s' failed with", fmt.Sprintf(url, pltNs, pltNs))
+               if resp != nil {
+                       logdesc += fmt.Sprintf(" status: %d != %d", resp.StatusCode, status)
+               } else {
+                       logdesc += fmt.Sprintf(" resp: nil")
+               }
+               if err != nil {
+                       logdesc += fmt.Sprintf(" err: %s", err.Error())
+               } else {
+                       logdesc += fmt.Sprintf(" err: nil")
+               }
+               Logger.Info(logdesc)
+               return fmt.Errorf(logdesc)
        }
+
        Logger.Info("Post to '%s' done, status:%v", fmt.Sprintf(url, pltNs, pltNs), resp.Status)
 
        return err
@@ -156,6 +189,7 @@ func doRegister() error {
        xappversion := viper.GetString("version")
        pltNs := getPltNamespace("PLT_NAMESPACE", DEFAULT_PLT_NS)
 
+       //httpEp, rmrEp := getService(xappname, SERVICE_HTTP), getService(xappname, SERVICE_RMR)
        httpEp, rmrEp := getService(host, SERVICE_HTTP), getService(host, SERVICE_RMR)
        if httpEp == "" || rmrEp == "" {
                Logger.Warn("Couldn't resolve service endpoints: httpEp=%s rmrEp=%s", httpEp, rmrEp)
@@ -273,34 +307,47 @@ func init() {
        InstallSignalHandler()
 }
 
-func getIpAdress() string {
-       var ip net.IP
-       itf, err := net.InterfaceByName(os.Getenv("INTERFACE_NAME"))
+func GetIpAddress() (string, error) {
+       ifname := os.Getenv("INTERFACE_NAME")
+       itf, err := net.InterfaceByName(ifname)
        if err != nil {
-               Logger.Info("Interface name is not able to resolve " + err.Error())
-               return ip.String()
+               return "<nil>", fmt.Errorf("Interface (%s) %w", ifname, err)
        }
        item, err := itf.Addrs()
        if err != nil {
-               Logger.Info("IP address is not able to resolve " + err.Error())
-               return ip.String()
+               return "<nil>", fmt.Errorf("Interface (%s) %w", ifname, err)
        }
        for _, addr := range item {
                switch v := addr.(type) {
                case *net.IPNet:
                        if !v.IP.IsLinkLocalUnicast() {
-                               ip = v.IP
+                               return v.IP.String(), nil
                        }
                }
        }
-       return ip.String()
+       return "<nil>", fmt.Errorf("Interface (%s) couldn't find ip", ifname)
 }
 
-func RunWithParams(c MessageConsumer, sdlcheck bool) {
+type RunParams struct {
+       SdlCheck           bool
+       DisableAlarmClient bool
+}
+
+func RunWithRunParams(c MessageConsumer, params RunParams) {
+
+       if params.DisableAlarmClient {
+               disableAlarmClient = true
+       } else {
+               disableAlarmClient = false
+       }
+
        Rmr = NewRMRClient()
 
        Rmr.SetReadyCB(XappReadyCb, nil)
-       ipString := getIpAdress()
+       ipString, err := GetIpAddress()
+       if err != nil {
+               Logger.Info("IP address is not able to resolve " + err.Error())
+       }
        var host string
        if ipString == "<nil>" {
                host = fmt.Sprintf(":%d", GetPortData("http").Port)
@@ -310,7 +357,7 @@ func RunWithParams(c MessageConsumer, sdlcheck bool) {
        go http.ListenAndServe(host, Resource.router)
        Logger.Info(fmt.Sprintf("Xapp started, listening on: %s", host))
 
-       if sdlcheck {
+       if params.SdlCheck {
                SdlStorage.TestConnection(viper.GetString("controls.db.namespace"))
        }
        go registerXapp()
@@ -318,6 +365,10 @@ func RunWithParams(c MessageConsumer, sdlcheck bool) {
        Rmr.Start(c)
 }
 
+func RunWithParams(c MessageConsumer, sdlcheck bool) {
+       RunWithRunParams(c, RunParams{SdlCheck: sdlcheck, DisableAlarmClient: false})
+}
+
 func Run(c MessageConsumer) {
        RunWithParams(c, true)
 }