cmd/rtmgr.go

   1 /*
   2 ==================================================================================
   3    Copyright (c) 2019 AT&T Intellectual Property.
   4    Copyright (c) 2019 Nokia
   5
   6    Licensed under the Apache License, Version 2.0 (the "License");
   7    you may not use this file except in compliance with the License.
   8    You may obtain a copy of the License at
   9
  10        http://www.apache.org/licenses/LICENSE-2.0
  11
  12    Unless required by applicable law or agreed to in writing, software
  13    distributed under the License is distributed on an "AS IS" BASIS,
  14    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15    See the License for the specific language governing permissions and
  16    limitations under the License.
  17
  18
  19    This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20    platform project (RICP).
  21
  22
  23 ==================================================================================
  24 */
  25 /*
  26         Mnemonic:       rtmgr.go
  27         Abstract:       Routing Manager Main file. Implemets the following functions:
  28                         - parseArgs: reading command line arguments
  29                         - init:Rtmgr initializing the service modules
  30                         - serve: running the loop
  31         Date:           12 March 2019
  32 */
  33 package main
  34
  35 //TODO: change flag to pflag (won't need any argument parse)
  36
  37 import (
  38         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  39         "os"
  40         "os/signal"
  41         "routing-manager/pkg/nbi"
  42         "routing-manager/pkg/rpe"
  43         "routing-manager/pkg/rtmgr"
  44         "routing-manager/pkg/sbi"
  45         "routing-manager/pkg/sdl"
  46         "syscall"
  47         "time"
  48         "sync"
  49 )
  50
  51 const SERVICENAME = "rtmgr"
  52 const INTERVAL time.Duration = 60
  53
  54 func initRtmgr() (nbiEngine nbi.Engine, sbiEngine sbi.Engine, sdlEngine sdl.Engine, rpeEngine rpe.Engine, err error) {
  55         if nbiEngine, err = nbi.GetNbi(xapp.Config.GetString("nbi")); err == nil && nbiEngine != nil {
  56                 if sbiEngine, err = sbi.GetSbi(xapp.Config.GetString("sbi")); err == nil && sbiEngine != nil {
  57                         if sdlEngine, err = sdl.GetSdl(xapp.Config.GetString("sdl")); err == nil && sdlEngine != nil {
  58                                 if rpeEngine, err = rpe.GetRpe(xapp.Config.GetString("rpe")); err == nil && rpeEngine != nil {
  59                                         return nbiEngine, sbiEngine, sdlEngine, rpeEngine, nil
  60                                 }
  61                         }
  62                 }
  63         }
  64         return nil, nil, nil, nil, err
  65 }
  66
  67
  68
  69 func serveSBI(triggerSBI <-chan bool, sbiEngine sbi.Engine, sdlEngine sdl.Engine, rpeEngine rpe.Engine, m *sync.Mutex) {
  70         for {
  71                 if <-triggerSBI {
  72                         m.Lock()
  73                         data, err := sdlEngine.ReadAll(xapp.Config.GetString("rtfile"))
  74                         m.Unlock()
  75                         if err != nil || data == nil {
  76                                 xapp.Logger.Error("Cannot get data from sdl interface due to: " + err.Error())
  77                                 continue
  78                         }
  79                         sbiEngine.UpdateEndpoints(data)
  80                         policies := rpeEngine.GeneratePolicies(rtmgr.Eps, data)
  81                         err = sbiEngine.DistributeAll(policies)
  82                         if err != nil {
  83                                 xapp.Logger.Error("Routing table cannot be published due to: " + err.Error())
  84                         }
  85                 }
  86         }
  87 }
  88
  89 func sendRoutesToAll(sbiEngine sbi.Engine, sdlEngine sdl.Engine, rpeEngine rpe.Engine) {
  90
  91         data, err := sdlEngine.ReadAll(xapp.Config.GetString("rtfile"))
  92         if err != nil || data == nil {
  93                 xapp.Logger.Error("Cannot get data from sdl interface due to: " + err.Error())
  94                 return
  95         }
  96         sbiEngine.UpdateEndpoints(data)
  97         policies := rpeEngine.GeneratePolicies(rtmgr.Eps, data)
  98         err = sbiEngine.DistributeAll(policies)
  99         if err != nil {
 100                 xapp.Logger.Error("Routing table cannot be published due to: " + err.Error())
 101                 return
 102         }
 103 }
 104
 105
 106 func serve(nbiEngine nbi.Engine, sbiEngine sbi.Engine, sdlEngine sdl.Engine, rpeEngine rpe.Engine, m *sync.Mutex) {
 107
 108         triggerSBI := make(chan bool)
 109
 110         nbiErr := nbiEngine.Initialize(xapp.Config.GetString("xmurl"), xapp.Config.GetString("nbiurl"), xapp.Config.GetString("rtfile"), xapp.Config.GetString("cfgfile"), xapp.Config.GetString("e2murl"),
 111                 sdlEngine, rpeEngine, triggerSBI, m)
 112         if nbiErr != nil {
 113                 xapp.Logger.Error("Failed to initialize nbi due to: " + nbiErr.Error())
 114                 return
 115         }
 116
 117         err := sbiEngine.Initialize(xapp.Config.GetString("sbiurl"))
 118         if err != nil {
 119                 xapp.Logger.Info("Failed to open push socket due to: " + err.Error())
 120                 return
 121         }
 122         defer nbiEngine.Terminate()
 123         defer sbiEngine.Terminate()
 124
 125         // This SBI Go routine is trtiggered by periodic main loop and when data is recieved on REST interface.
 126         go serveSBI(triggerSBI, sbiEngine, sdlEngine, rpeEngine, m)
 127
 128         for {
 129                 if xapp.Config.GetString("nbi") == "httpGetter" {
 130                         data, err := nbiEngine.(*nbi.HttpGetter).FetchAllXApps(xapp.Config.GetString("xmurl"))
 131                         if err != nil {
 132                                 xapp.Logger.Error("Cannot fetch xapp data due to: " + err.Error())
 133                         } else if data != nil {
 134                                 sdlEngine.WriteXApps(xapp.Config.GetString("rtfile"), data)
 135                         }
 136                 }
 137
 138                 sendRoutesToAll(sbiEngine, sdlEngine, rpeEngine)
 139
 140                 rtmgr.Rtmgr_ready = true
 141                 time.Sleep(INTERVAL * time.Second)
 142                 xapp.Logger.Debug("Periodic loop timed out. Setting triggerSBI flag to distribute updated routes.")
 143         }
 144 }
 145
 146 func SetupCloseHandler() {
 147         c := make(chan os.Signal, 2)
 148         signal.Notify(c, os.Interrupt, syscall.SIGTERM)
 149         go func() {
 150                 <-c
 151                 xapp.Logger.Info("\r- Ctrl+C pressed in Terminal")
 152                 os.Exit(0)
 153         }()
 154 }
 155
 156 func main() {
 157
 158         nbiEngine, sbiEngine, sdlEngine, rpeEngine, err := initRtmgr()
 159         if err != nil {
 160                 xapp.Logger.Error(err.Error())
 161                 os.Exit(1)
 162         }
 163
 164         SetupCloseHandler()
 165
 166         xapp.Logger.Info("Start " + SERVICENAME + " service")
 167         rtmgr.Eps = make(rtmgr.Endpoints)
 168         rtmgr.Rtmgr_ready = false
 169
 170         var m sync.Mutex
 171
 172 // RMR thread is starting port: 4560
 173         c := nbi.NewControl()
 174         go c.Run(sbiEngine, sdlEngine, rpeEngine, &m)
 175
 176 // Waiting for RMR to be ready
 177         time.Sleep(time.Duration(2) * time.Second)
 178         for xapp.Rmr.IsReady() == false {
 179                 time.Sleep(time.Duration(2) * time.Second)
 180         }
 181
 182         dummy_whid := int(xapp.Rmr.Openwh("localhost:4560"))
 183         xapp.Logger.Info("created dummy Wormhole ID for routingmanager and dummy_whid :%d", dummy_whid)
 184
 185         serve(nbiEngine, sbiEngine, sdlEngine, rpeEngine, &m)
 186         os.Exit(0)
 187 }