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