pkg/nbi/control.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    This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19    platform project (RICP).
  20
  21 ==================================================================================
  22 */
  23 package nbi
  24
  25 import "C"
  26
  27 import (
  28         "errors"
  29         //"fmt"
  30         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
  31         "os"
  32         "routing-manager/pkg/rpe"
  33         "routing-manager/pkg/rtmgr"
  34         "routing-manager/pkg/sbi"
  35         "routing-manager/pkg/sdl"
  36         "strconv"
  37         "sync"
  38         "time"
  39 )
  40
  41 var m sync.Mutex
  42
  43 var nbiEngine Engine
  44 var sbiEngine sbi.Engine
  45 var sdlEngine sdl.Engine
  46 var rpeEngine rpe.Engine
  47
  48 const INTERVAL time.Duration = 60
  49
  50 func NewControl() Control {
  51         return Control{make(chan *xapp.RMRParams)}
  52 }
  53
  54 type Control struct {
  55         rcChan chan *xapp.RMRParams
  56 }
  57
  58 func (c *Control) Run() {
  59         var err error
  60         go c.controlLoop()
  61         nbiEngine, sbiEngine, sdlEngine, rpeEngine, err = initRtmgr()
  62         if err != nil {
  63                 xapp.Logger.Error(err.Error())
  64                 os.Exit(1)
  65         }
  66         xapp.Run(c)
  67 }
  68
  69 func (c *Control) Consume(rp *xapp.RMRParams) (err error) {
  70         c.rcChan <- rp
  71         return
  72 }
  73
  74 func initRtmgr() (nbiEngine Engine, sbiEngine sbi.Engine, sdlEngine sdl.Engine, rpeEngine rpe.Engine, err error) {
  75         if nbiEngine, err = GetNbi(xapp.Config.GetString("nbi")); err == nil && nbiEngine != nil {
  76                 if sbiEngine, err = sbi.GetSbi(xapp.Config.GetString("sbi")); err == nil && sbiEngine != nil {
  77                         if sdlEngine, err = sdl.GetSdl(xapp.Config.GetString("sdl")); err == nil && sdlEngine != nil {
  78                                 if rpeEngine, err = rpe.GetRpe(xapp.Config.GetString("rpe")); err == nil && rpeEngine != nil {
  79                                         return nbiEngine, sbiEngine, sdlEngine, rpeEngine, nil
  80                                 }
  81                         }
  82                 }
  83         }
  84         return nil, nil, nil, nil, err
  85 }
  86
  87 func (c *Control) controlLoop() {
  88         for {
  89                 msg := <-c.rcChan
  90                 c.recievermr(msg)
  91                 /*
  92                         xapp_msg := sbi.RMRParams{msg}
  93                         switch msg.Mtype {
  94                         case xapp.RICMessageTypes["RMRRM_REQ_TABLE"]:
  95                                 if rtmgr.Rtmgr_ready == false {
  96                                         xapp.Logger.Info("Update Route Table Request(RMR to RM), message discarded as routing manager is not ready")
  97                                 } else {
  98                                         xapp.Logger.Info("Update Route Table Request(RMR to RM)")
  99                                         go c.handleUpdateToRoutingManagerRequest(msg)
 100                                 }
 101                         case xapp.RICMessageTypes["RMRRM_TABLE_STATE"]:
 102                                 xapp.Logger.Info("state of table to route mgr %s,payload %s", xapp_msg.String(), msg.Payload)
 103
 104                         default:
 105                                 err := errors.New("Message Type " + strconv.Itoa(msg.Mtype) + " is discarded")
 106                                 xapp.Logger.Error("Unknown message type: %v", err)
 107                         }
 108                         xapp.Rmr.Free(msg.Mbuf)*/
 109         }
 110 }
 111
 112 func (c *Control) recievermr(msg *xapp.RMRParams) {
 113         xapp_msg := sbi.RMRParams{msg}
 114         switch msg.Mtype {
 115         case xapp.RICMessageTypes["RMRRM_REQ_TABLE"]:
 116                 if rtmgr.Rtmgr_ready == false {
 117                         xapp.Logger.Info("Update Route Table Request(RMR to RM), message discarded as routing manager is not ready")
 118                 } else {
 119                         xapp.Logger.Info("Update Route Table Request(RMR to RM)")
 120                         go c.handleUpdateToRoutingManagerRequest(msg)
 121                 }
 122         case xapp.RICMessageTypes["RMRRM_TABLE_STATE"]:
 123                 xapp.Logger.Info("state of table to route mgr %s,payload %s", xapp_msg.String(), msg.Payload)
 124         default:
 125                 err := errors.New("Message Type " + strconv.Itoa(msg.Mtype) + " is discarded")
 126                 xapp.Logger.Error("Unknown message type: %v", err)
 127         }
 128         xapp.Rmr.Free(msg.Mbuf)
 129 }
 130
 131 func (c *Control) handleUpdateToRoutingManagerRequest(params *xapp.RMRParams) {
 132
 133         msg := sbi.RMRParams{params}
 134
 135         xapp.Logger.Info("Update Route Table Request, msg.String() : %s", msg.String())
 136         xapp.Logger.Info("Update Route Table Request, params.Payload : %s", string(params.Payload))
 137
 138         m.Lock()
 139         data, err := sdlEngine.ReadAll(xapp.Config.GetString("rtfile"))
 140         m.Unlock()
 141         if data == nil {
 142                 if err != nil {
 143                         xapp.Logger.Error("Cannot get data from sdl interface due to: " + err.Error())
 144                         return
 145                 } else {
 146                         xapp.Logger.Debug("Cannot get data from sdl interface")
 147                         return
 148                 }
 149         }
 150
 151         ep := sbiEngine.CheckEndpoint(string(params.Payload))
 152         if ep == nil {
 153                 xapp.Logger.Error("Update Routing Table Request can't handle due to end point %s is not avail in complete ep list: ", string(params.Payload))
 154                 return
 155         }
 156         epstr, whid := sbiEngine.CreateEndpoint(msg.String())
 157         if epstr == nil || whid < 0 {
 158                 xapp.Logger.Error("Wormhole Id creation failed %d for %s", whid, msg.String())
 159                 return
 160         }
 161
 162         /*This is to ensure the latest routes are sent.
 163         Assumption is that in this time interval the routes are built for this endpoint */
 164         time.Sleep(100 * time.Millisecond)
 165         policies := rpeEngine.GeneratePolicies(rtmgr.Eps, data)
 166         err = sbiEngine.DistributeToEp(policies, *epstr, whid)
 167         if err != nil {
 168                 xapp.Logger.Error("Routing table cannot be published due to: " + err.Error())
 169                 return
 170         }
 171 }
 172
 173 func sendRoutesToAll() (err error) {
 174
 175         m.Lock()
 176         data, err := sdlEngine.ReadAll(xapp.Config.GetString("rtfile"))
 177         //fmt.Printf("data = %v,%v,%v",data,sdlEngine,sbiEngine)
 178         m.Unlock()
 179         if data == nil {
 180                 if err != nil {
 181                         return errors.New("Cannot get data from sdl interface due to: " + err.Error())
 182                 } else {
 183                         xapp.Logger.Debug("Cannot get data from sdl interface, data is null")
 184                         return errors.New("Cannot get data from sdl interface")
 185                 }
 186         }
 187
 188         /*      if sbiEngine == nil {
 189                 fmt.Printf("SBI is nil")
 190         }*/
 191         sbiEngine.UpdateEndpoints(data)
 192         policies := rpeEngine.GeneratePolicies(rtmgr.Eps, data)
 193         err = sbiEngine.DistributeAll(policies)
 194         if err != nil {
 195                 return errors.New("Routing table cannot be published due to: " + err.Error())
 196         }
 197
 198         return nil
 199 }
 200
 201 func Serve() {
 202
 203         nbiErr := nbiEngine.Initialize(xapp.Config.GetString("xmurl"), xapp.Config.GetString("nbiurl"), xapp.Config.GetString("rtfile"), xapp.Config.GetString("cfgfile"), xapp.Config.GetString("e2murl"), sdlEngine, rpeEngine, &m)
 204         if nbiErr != nil {
 205                 xapp.Logger.Error("Failed to initialize nbi due to: " + nbiErr.Error())
 206                 return
 207         }
 208
 209         err := sbiEngine.Initialize(xapp.Config.GetString("sbiurl"))
 210         if err != nil {
 211                 xapp.Logger.Info("Failed to open push socket due to: " + err.Error())
 212                 return
 213         }
 214         defer nbiEngine.Terminate()
 215         defer sbiEngine.Terminate()
 216
 217         for {
 218                 sendRoutesToAll()
 219
 220                 rtmgr.Rtmgr_ready = true
 221                 time.Sleep(INTERVAL * time.Second)
 222                 xapp.Logger.Debug("Periodic loop timed out. Setting triggerSBI flag to distribute updated routes.")
 223         }
 224 }