import (
sdl "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
- "gitlabe1.ext.net.nokia.com/ric_dev/ue-nib/api"
- "gitlabe1.ext.net.nokia.com/ric_dev/ue-nib/pkg/uenibreader"
- "gitlabe1.ext.net.nokia.com/ric_dev/ue-nib/pkg/uenibwriter"
"sync"
"time"
)
}
type SDLClient struct {
- db *sdl.SdlInstance
- stat map[string]Counter
- mux sync.Mutex
-}
-
-type UENIBClient struct {
- reader *uenibreader.Reader
- writer *uenibwriter.Writer
+ db *sdl.SdlInstance
+ stat map[string]Counter
+ mux sync.Mutex
+ ready bool
}
type RNIBClient struct {
func NewSDLClient(ns string) *SDLClient {
return &SDLClient{
db: sdl.NewSdlInstance(ns, sdl.NewDatabase()),
+ stat: Metric.RegisterCounterGroup(SDLCounterOpts, "SDL"),
+ ready: false,
}
}
Logger.Warn("Database connection not ready, waiting ...")
time.Sleep(time.Duration(5 * time.Second))
}
+ s.ready = true
Logger.Info("Connection to database established!")
+}
- s.RegisterMetrics()
+func (s *SDLClient) IsReady() bool {
+ return s.ready
}
func (s *SDLClient) Store(key string, value interface{}) (err error) {
return
}
-func NewUENIBClient() *UENIBClient {
- return &UENIBClient{
- reader: uenibreader.NewReader(),
- writer: uenibwriter.NewWriter(),
- }
-}
-
-func (u *UENIBClient) StoreUeMeasurement(gNbId string, gNbUeX2ApId string, data *api.MeasResults) error {
- return u.writer.UpdateUeMeasurement(gNbId, gNbUeX2ApId, data)
-}
-
-func (u *UENIBClient) ReadUeMeasurement(gNbId string, gNbUeX2ApId string) (*api.MeasResults, error) {
- return u.reader.GetUeMeasurement(gNbId, gNbUeX2ApId)
-}
-
// To be removed ...
func NewRNIBClient(ns string) *RNIBClient {
return &RNIBClient{
mux sync.Mutex
stat map[string]Counter
consumers []MessageConsumer
+ readyCb ReadyCB
}
type MessageConsumer interface {
}
func NewRMRClient() *RMRClient {
- r := &RMRClient{}
- r.consumers = make([]MessageConsumer, 0)
-
p := C.CString(viper.GetString("rmr.protPort"))
m := C.int(viper.GetInt("rmr.maxSize"))
defer C.free(unsafe.Pointer(p))
- r.context = C.rmr_init(p, m, C.int(0))
- if r.context == nil {
+ ctx := C.rmr_init(p, m, C.int(0))
+ if ctx == nil {
Logger.Fatal("rmrClient: Initializing RMR context failed, bailing out!")
}
- return r
+ return &RMRClient{
+ context: ctx,
+ consumers: make([]MessageConsumer, 0),
+ stat: Metric.RegisterCounterGroup(RMRCounterOpts, "RMR"),
+ }
}
func (m *RMRClient) Start(c MessageConsumer) {
- m.RegisterMetrics()
-
for {
Logger.Info("rmrClient: Waiting for RMR to be ready ...")
go m.Worker("worker-"+strconv.Itoa(w), 0)
}
+ if m.readyCb != nil {
+ m.readyCb()
+ }
+
m.Wait()
}
func (m *RMRClient) GetRicMessageId(mid string) int {
return RICMessageTypes[mid]
}
+
+func (m *RMRClient) SetReadyCB(cb ReadyCB) {
+ m.readyCb = cb
+}
"net/http"
)
+type ReadyCB func()
+
var (
// XApp is an application instance
Rmr *RMRClient
Sdl *SDLClient
- UeNib *UENIBClient
Rnib *RNIBClient
Resource *Router
Metric *Metrics
Logger = LoadConfig()
Logger.SetLevel(viper.GetInt("logger.level"))
- Rmr = NewRMRClient()
Resource = NewRouter()
Config = Configurator{}
- UeNib = NewUENIBClient()
Metric = NewMetrics(viper.GetString("metrics.url"), viper.GetString("metrics.namespace"), Resource.router)
+ Rmr = NewRMRClient()
if viper.IsSet("db.namespaces") {
namespaces := viper.GetStringSlice("db.namespaces")
Sdl.TestConnection()
Rmr.Start(c)
}
+
+func IsReady() bool {
+ return Rmr.IsReady() && Sdl.IsReady()
+}
+
+func SetReadyCB(cb ReadyCB) {
+ Rmr.SetReadyCB(cb)
+}
\ No newline at end of file