--- /dev/null
+[gerrit]
+host=gerrit.o-ran-sc.org
+port=29418
+project=ric-plt/nodeb-rnib
+defaultbranch=master
\ No newline at end of file
--- /dev/null
+module gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/common
+
+go 1.12
+
+require github.com/stretchr/testify v1.3.0
--- /dev/null
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package common
+/*
+ISdlInstance integrates (wraps) the functionality that sdlgo library provides
+ */
+type ISdlInstance interface {
+ SubscribeChannel(cb func(string, ...string), channels ...string) error
+ UnsubscribeChannel(channels ...string) error
+ Close() error
+ SetAndPublish(channelsAndEvents []string, pairs ...interface{}) error
+ Set(pairs ...interface{}) error
+ Get(keys []string) (map[string]interface{}, error)
+ SetIfAndPublish(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error)
+ SetIf(key string, oldData, newData interface{}) (bool, error)
+ SetIfNotExistsAndPublish(channelsAndEvents []string, key string, data interface{}) (bool, error)
+ SetIfNotExists(key string, data interface{}) (bool, error)
+ RemoveAndPublish(channelsAndEvents []string, keys []string) error
+ Remove(keys []string) error
+ RemoveIfAndPublish(channelsAndEvents []string, key string, data interface{}) (bool, error)
+ RemoveIf(key string, data interface{}) (bool, error)
+ GetAll() ([]string, error)
+ RemoveAll() error
+ RemoveAllAndPublish(channelsAndEvents []string) error
+ AddMember(group string, member ...interface{}) error
+ RemoveMember(group string, member ...interface{}) error
+ RemoveGroup(group string) error
+ GetMembers(group string) ([]string, error)
+ IsMember(group string, member interface{}) (bool, error)
+ GroupSize(group string) (int64, error)
+}
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package common
+
+import "fmt"
+
+const(
+ RESOURCE_NOT_FOUND int = 1
+ INTERNAL_ERROR int = 2
+ VALIDATION_ERROR int = 3
+)
+
+var rNibError_names = map[int]string{
+ RESOURCE_NOT_FOUND:"RESOURCE_NOT_FOUND",
+ INTERNAL_ERROR:"INTERNAL_ERROR",
+ VALIDATION_ERROR:"VALIDATION_ERROR",
+}
+
+type IRNibError interface{
+ error
+ GetCode() int
+ GetError() error
+}
+
+type RNibError struct{
+ err error
+ errorCode int
+}
+
+func NewResourceNotFoundError(error error) IRNibError {
+ return IRNibError(&RNibError{err:error, errorCode:RESOURCE_NOT_FOUND})
+}
+
+func NewInternalError(error error) IRNibError {
+ return IRNibError(&RNibError{err:error, errorCode:INTERNAL_ERROR})
+}
+
+func NewValidationError(error error) IRNibError {
+ return IRNibError(&RNibError{err:error, errorCode:VALIDATION_ERROR})
+}
+
+func (e RNibError) GetError() error {
+ return e.err
+}
+
+func (e RNibError) GetCode() int {
+ return e.errorCode
+}
+
+func (e RNibError) Error() string {
+ return fmt.Sprintf("%d %s - %s", e.errorCode, rNibError_names[e.errorCode], e.err)
+}
\ No newline at end of file
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package common
+
+import (
+ "fmt"
+ "github.com/pkg/errors"
+ "github.com/stretchr/testify/assert"
+ "testing"
+)
+
+func TestNewResourceNotFoundError(t *testing.T){
+ e := errors.New("Expected error")
+ expectedErr := NewResourceNotFoundError(e)
+ assert.NotNil(t, expectedErr)
+ assert.Equal(t, RESOURCE_NOT_FOUND, expectedErr.GetCode())
+ assert.Contains(t, expectedErr.Error(), fmt.Sprintf("%d",expectedErr.GetCode()))
+ assert.Contains(t, expectedErr.Error(), rNibError_names[expectedErr.GetCode()])
+ assert.Contains(t, expectedErr.Error(), e.Error())
+ assert.Equal(t, RESOURCE_NOT_FOUND, expectedErr.GetCode())
+}
+
+func TestNewInternalError(t *testing.T){
+ e := errors.New("Expected error")
+ expectedErr := NewInternalError(e)
+ assert.NotNil(t, expectedErr)
+ assert.Equal(t, INTERNAL_ERROR, expectedErr.GetCode())
+ assert.Contains(t, expectedErr.Error(), fmt.Sprintf("%d",expectedErr.GetCode()))
+ assert.Contains(t, expectedErr.Error(), rNibError_names[expectedErr.GetCode()])
+ assert.Contains(t, expectedErr.Error(), e.Error())
+ assert.Equal(t, INTERNAL_ERROR, expectedErr.GetCode())
+}
+
+func TestNewValidationError(t *testing.T){
+ e := errors.New("Expected error")
+ expectedErr := NewValidationError(e)
+ assert.NotNil(t, expectedErr)
+ assert.Equal(t, VALIDATION_ERROR, expectedErr.GetCode())
+ assert.Contains(t, expectedErr.Error(), fmt.Sprintf("%d",expectedErr.GetCode()))
+ assert.Contains(t, expectedErr.Error(), rNibError_names[expectedErr.GetCode()])
+ assert.Contains(t, expectedErr.Error(), e.Error())
+ assert.Equal(t, VALIDATION_ERROR, expectedErr.GetCode())
+}
+
+func TestNewRNibErrorWithEmptyError(t *testing.T){
+ var e error
+ expectedErr := NewResourceNotFoundError(e)
+ assert.NotNil(t, expectedErr)
+ assert.Equal(t, RESOURCE_NOT_FOUND, expectedErr.GetCode())
+ assert.Contains(t, expectedErr.Error(), fmt.Sprintf("%d",expectedErr.GetCode()))
+ assert.Contains(t, expectedErr.Error(), rNibError_names[expectedErr.GetCode()])
+ assert.Equal(t, 1, expectedErr.GetCode())
+}
+
+func TestGetError(t *testing.T){
+ e := errors.New("Expected error")
+ expectedErr := NewInternalError(e)
+ assert.NotNil(t, expectedErr)
+ assert.NotNil(t, expectedErr.GetError())
+ assert.Equal(t, expectedErr.GetError(), e)
+}
+
+func TestGetCodeInternalError(t *testing.T){
+ e := errors.New("Expected error")
+ expectedErr := NewInternalError(e)
+ assert.NotNil(t, expectedErr)
+ assert.NotNil(t, expectedErr.GetError())
+ assert.Equal(t, INTERNAL_ERROR, expectedErr.GetCode())
+}
+
+func TestGetCodeNotFoundError(t *testing.T){
+ e := errors.New("Expected error")
+ expectedErr := NewResourceNotFoundError(e)
+ assert.NotNil(t, expectedErr)
+ assert.NotNil(t, expectedErr.GetError())
+ assert.Equal(t, RESOURCE_NOT_FOUND, expectedErr.GetCode())
+}
+
+func TestGetCodeValidationError(t *testing.T){
+ e := errors.New("Expected error")
+ expectedErr := NewValidationError(e)
+ assert.NotNil(t, expectedErr)
+ assert.NotNil(t, expectedErr.GetError())
+ assert.Equal(t, VALIDATION_ERROR, expectedErr.GetCode())
+}
\ No newline at end of file
--- /dev/null
+package common
+
+import (
+ "sync/atomic"
+)
+
+type Pool struct {
+ New func() interface{}
+ Destroy func(interface{})
+ pool chan interface{}
+ created int32 //Number of objects created
+}
+
+/*
+NewPool creates thread safe Pool object and returns a pointer to it.
+poolSize int - sets the capacity of the pool
+newObj func - specifies a function to generate a value (pool element)
+destroyObj func - specifies a function to destroy a value (pool element)
+*/
+func NewPool(poolSize int, newObj func() interface{}, destroyObj func(interface{})) *Pool{
+ return &Pool{
+ New: newObj,
+ Destroy: destroyObj,
+ pool: make(chan interface{}, poolSize),
+ }
+}
+
+/*
+Retrieve an object from the pool.
+If the pool is empty and the number of used object is less than capacity, a new object is created by calling New.
+Otherwise, the method blocks until an object is returned to the pool.
+*/
+func (p *Pool) Get() interface{} {
+ select {
+ case obj := <-p.pool:
+ return obj
+ default:
+ if atomic.AddInt32(&p.created, 1) <= int32(cap(p.pool)) && p.New != nil {
+ p.pool <- p.New()
+ }
+ }
+ return <-p.pool //block waiting
+}
+
+/*
+Return an object to the pool.
+If capacity is exceeded the object is discarded after calling Destroy on it if Destroy is not nil.
+*/
+func (p *Pool) Put(obj interface{}) {
+ if obj != nil {
+ select {
+ case p.pool <- obj:
+ default:
+ if p.Destroy != nil {
+ p.Destroy(obj)
+ }
+ }
+ }
+}
+
+/*
+ Closes the pool and if Destroy is not nil, call Destroy on each object in the pool
+ The pool must not be used once this method is called.
+*/
+func (p *Pool) Close() {
+ close(p.pool)
+ available := len(p.pool)
+ if p.Destroy != nil {
+ for obj := range p.pool {
+ p.Destroy(obj)
+
+ }
+ }
+ atomic.AddInt32(&p.created, -int32(available))
+}
+/*
+Return statistics.
+available - the number of available instances
+created - the number of created instances
+*/
+func (p *Pool) Stats() (available int, created int) {
+ return len(p.pool), int(p.created)
+}
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package common
+
+import (
+ "github.com/stretchr/testify/assert"
+ "sync"
+ "sync/atomic"
+ "testing"
+ "time"
+)
+
+var max int32
+var counter int32
+var poolGlob *Pool
+type instance struct{}
+
+func(instance) up(){
+ tmpc := atomic.AddInt32(&counter, 1)
+ swapped:= false
+ for !swapped {
+ tmpm := atomic.LoadInt32(&max)
+ if tmpc >tmpm {
+ swapped = atomic.CompareAndSwapInt32(&max, tmpm, tmpc)
+ } else {
+ break
+ }
+ }
+}
+
+func(instance) down(){
+ atomic.AddInt32(&counter, - 1)
+}
+
+func TestPoolMax(t *testing.T){
+ counter = 0
+ max = 0
+ validateMaxLimit(1, 1, t)
+ counter = 0
+ max = 0
+ validateMaxLimit(1, 2, t)
+ counter = 0
+ max = 0
+ validateMaxLimit(5, 10, t)
+}
+
+func validateMaxLimit(size int, iterations int, t *testing.T) {
+ poolGlob = NewPool(size, func() interface{} {
+ inst := instance{}
+ return inst
+ },
+ func(obj interface{}) {
+ },
+ )
+ group := sync.WaitGroup{}
+ for i := 0; i < iterations; i++ {
+ go getPutInstance(group)
+ }
+ time.Sleep(time.Second)
+ group.Wait()
+ assert.Equal(t, int32(size), max)
+}
+
+func getPutInstance(group sync.WaitGroup) {
+ group.Add(1)
+ inst := poolGlob.Get().(instance)
+ inst.up()
+ time.Sleep(time.Millisecond*10)
+ inst.down()
+ poolGlob.Put(inst)
+ group.Done()
+}
+
+func TestNewPool(t *testing.T){
+ size := 5
+ pool := NewPool(size, func() interface{} {
+ inst := instance{}
+ return inst
+ },
+ func(obj interface{}) {
+ },
+ )
+ assert.NotNil(t, pool)
+ assert.NotNil(t, pool.New)
+ assert.NotNil(t, pool.Destroy)
+ assert.NotNil(t, pool.pool)
+ assert.Equal(t, cap(pool.pool), size, "the capacity of the pool should be " + string(size))
+}
+
+func TestGetCreated(t *testing.T) {
+ pool := NewPool(1, func() interface{} {
+ inst := instance{}
+ return inst
+ },
+ func(obj interface{}) {
+ },
+ )
+ pool.Get()
+ available, created := pool.Stats()
+ assert.Equal(t, 0, available, "number of available objects in the pool should be 0")
+ assert.Equal(t, 1, created, "number of created objects in the pool should be 1")
+ pool.Close()
+}
+
+func TestGetAndPut(t *testing.T) {
+ pool := NewPool(1, func() interface{} {
+ inst := instance{}
+ return inst
+ },
+ func(obj interface{}) {
+ },
+ )
+ pool.Put(pool.Get())
+ available, created := pool.Stats()
+ assert.Equal(t, 1, available, "number of available objects in the pool should be 1")
+ assert.Equal(t, 1, created, "number of created objects in the pool should be 1")
+ pool.Close()
+}
+
+func TestPutOutOfCapacity(t *testing.T) {
+ pool := NewPool(1, func() interface{} {
+ inst := instance{}
+ return inst
+ },
+ func(obj interface{}) {
+ },
+ )
+ pool.Put(pool.Get())
+ pool.Put(new(instance))
+ available, created := pool.Stats()
+ assert.Equal(t, 1, available, "number of available objects in the pool should be 1")
+ assert.Equal(t, 1, created, "number of created objects in the pool should be 1")
+ pool.Close()
+}
+
+func TestNotInitializedPut(t *testing.T) {
+ var poolEmpty Pool
+ poolEmpty.Put(new(instance))
+ available, created := poolEmpty.Stats()
+ assert.Equal(t, 0, available, "number of available objects in the pool should be 0")
+ assert.Equal(t, 0, created, "number of created objects in the pool should be 0")
+}
+
+func TestPutNilObject(t *testing.T) {
+ var poolEmpty Pool
+ poolEmpty.Put(nil)
+ available, created := poolEmpty.Stats()
+ assert.Equal(t, 0, available, "number of available objects in the pool should be 0")
+ assert.Equal(t, 0, created, "number of created objects in the pool should be 0")
+}
+
+func TestGet(t *testing.T) {
+ pool := NewPool(2, func() interface{} {
+ inst := instance{}
+ return inst
+ },
+ func(obj interface{}) {
+ },
+ )
+ i1 := pool.Get()
+ i2 := pool.Get()
+ available, created := pool.Stats()
+ assert.Equal(t, 0, available, "number of available objects in the pool should be 0")
+ assert.Equal(t, 2, created, "number of created objects in the pool should be 2")
+ pool.Put(i1)
+ pool.Put(i2)
+ pool.Put(new(instance))
+ available, created = pool.Stats()
+ assert.Equal(t, 2, available, "number of available objects in the pool should be 2")
+ assert.Equal(t, 2, created, "number of created objects in the pool should be 2")
+}
+
+func TestClose(t *testing.T) {
+ pool := NewPool(3, func() interface{} {
+ inst := instance{}
+ return inst
+ },
+ func(obj interface{}) {
+ },
+ )
+ i1 := pool.Get()
+ i2 := pool.Get()
+ i3 := pool.Get()
+ available, created := pool.Stats()
+ assert.Equal(t, 0, available, "number of available objects in the pool should be 0")
+ assert.Equal(t, 3, created, "number of created objects in the pool should be 3")
+ pool.Put(i1)
+ pool.Put(i2)
+ pool.Put(i3)
+ available, created = pool.Stats()
+ assert.Equal(t, 3, available, "number of available objects in the pool should be 3")
+ assert.Equal(t, 3, created, "number of created objects in the pool should be 3")
+ pool.Close()
+ i := pool.Get()
+ assert.Nil(t, i)
+ available, created = pool.Stats()
+ assert.Equal(t, 0, available, "number of available objects in the pool should be 0")
+ assert.Equal(t, 0, created, "number of created objects in the pool should be 0")
+}
+
+func TestPoolPutPanicsOnClosedChannel(t *testing.T){
+ pool := NewPool(1, func() interface{} {
+ inst := instance{}
+ return inst
+ },
+ func(obj interface{}) {
+ },
+ )
+ close(pool.pool)
+ assert.Panics(t, func(){pool.Put(instance{})})
+}
+
+func TestPoolClosePanicsOnClosedChannel(t *testing.T) {
+ pool := NewPool(1, func() interface{} {
+ inst := instance{}
+ return inst
+ },
+ func(obj interface{}) {
+ },
+ )
+ close(pool.pool)
+ assert.Panics(t, func(){pool.Close()})
+}
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package common
+
+import (
+ "errors"
+ "fmt"
+)
+/*
+ValidateAndBuildCellIdKey builds key according to the specified format returns the resulting string
+ */
+func ValidateAndBuildCellIdKey(cellId string) (string, IRNibError) {
+ if cellId == "" {
+ e := errors.New("#utils.ValidateAndBuildCellIdKey - an empty cell id received")
+ return "", NewValidationError(e)
+ }
+ return fmt.Sprintf("CELL:%s", cellId), nil
+}
+/*
+ValidateAndBuildNrCellIdKey builds key according to the specified format returns the resulting string
+ */
+func ValidateAndBuildNrCellIdKey(cellId string) (string, IRNibError) {
+ if cellId == "" {
+ e := errors.New("#utils.ValidateAndBuildNrCellIdKey - an empty cell id received")
+ return "", NewValidationError(e)
+ }
+ return fmt.Sprintf("NRCELL:%s", cellId), nil
+}
+/*
+ValidateAndBuildNodeBNameKey builds key according to the specified format returns the resulting string
+ */
+func ValidateAndBuildNodeBNameKey(inventoryName string) (string, IRNibError) {
+ if inventoryName == "" {
+ e := errors.New("#utils.ValidateAndBuildNodeBNameKey - an empty inventory name received")
+ return "", NewValidationError(e)
+ }
+ return fmt.Sprintf("RAN:%s", inventoryName), nil
+}
+/*
+ValidateAndBuildNodeBIdKey builds key according to the specified format returns the resulting string
+ */
+func ValidateAndBuildNodeBIdKey(nodeType string, plmnId string, nbId string) (string, IRNibError) {
+ if nodeType == "" {
+ e := errors.New("#utils.ValidateAndBuildNodeBIdKey - an empty node type received")
+ return "", NewValidationError(e)
+ }
+ if plmnId == "" {
+ e := errors.New("#utils.ValidateAndBuildNodeBIdKey - an empty plmnId received")
+ return "", NewValidationError(e)
+ }
+ if nbId == "" {
+ e := errors.New("#utils.ValidateAndBuildNodeBIdKey - an empty nbId received")
+ return "", NewValidationError(e)
+ }
+ return fmt.Sprintf("%s:%s:%s", nodeType, plmnId, nbId), nil
+}
+/*
+ValidateAndBuildCellNamePciKey builds key according to the specified format returns the resulting string
+ */
+func ValidateAndBuildCellNamePciKey(inventoryName string, pci uint32) (string, IRNibError) {
+ if inventoryName == "" {
+ e := errors.New("#utils.ValidateAndBuildCellNamePciKey - an empty inventory name received")
+ return "", NewValidationError(e)
+ }
+ return fmt.Sprintf("PCI:%s:%02x", inventoryName, pci), nil
+}
\ No newline at end of file
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package common
+
+import (
+ "github.com/stretchr/testify/assert"
+ "testing"
+)
+
+func TestValidateAndBuildCellKeySuccess(t *testing.T) {
+ cellId := "aaaa"
+ prefix := "CELL"
+ delimiter := ":"
+ key, err := ValidateAndBuildCellIdKey(cellId)
+ if err != nil{
+ t.Errorf("#utils_test.TestValidateAndBuildCellKey - failed to validate key parameter")
+ }
+ assert.Contains(t, key, cellId)
+ assert.Contains(t, key, delimiter)
+ assert.Contains(t, key, prefix)
+}
+
+func TestValidateAndBuildNodeBNameKeySuccess(t *testing.T) {
+ name := "name"
+ prefix := "RAN"
+ delimiter := ":"
+ key, err := ValidateAndBuildNodeBNameKey(name)
+ if err != nil{
+ t.Errorf("#utils_test.TestValidateAndBuildNodeBNameKey - failed to validate key parameter")
+ }
+ assert.Contains(t, key, name)
+ assert.Contains(t, key, delimiter)
+ assert.Contains(t, key, prefix)
+}
+
+func TestValidateAndBuildNodeBIdKeySuccess(t *testing.T) {
+ nodeType := "ENB"
+ plmnId := "bbbb"
+ nbId := "cccc"
+ delimiter := ":"
+ key, err := ValidateAndBuildNodeBIdKey(nodeType, plmnId, nbId)
+ if err != nil{
+ t.Errorf("#utils_test.TestValidateAndBuildNodeBIdKey - failed to validate key parameter")
+ }
+ assert.Contains(t, key, nodeType)
+ assert.Contains(t, key, plmnId)
+ assert.Contains(t, key, nbId)
+ assert.Contains(t, key, delimiter)
+}
+
+func TestValidateAndBuildCellNamePciKeyNameValidationFailure(t *testing.T){
+ pci := 9999
+ _, err := ValidateAndBuildCellNamePciKey("", uint32(pci))
+ assert.NotNil(t, err)
+ assert.Equal(t, VALIDATION_ERROR, err.GetCode())
+ assert.Equal(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildCellNamePciKey - an empty inventory name received", err.Error())
+}
+
+func TestValidateAndBuildCellKeyCellidValidationFailure(t *testing.T) {
+ _, err := ValidateAndBuildCellIdKey("")
+ assert.NotNil(t, err)
+ assert.Equal(t, VALIDATION_ERROR, err.GetCode())
+ assert.Equal(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildCellIdKey - an empty cell id received", err.Error())
+}
+
+func TestValidateAndBuildNodeBNameKeyNameValidationFailure(t *testing.T) {
+ _, err := ValidateAndBuildNodeBNameKey("")
+ assert.NotNil(t, err)
+ assert.Equal(t, VALIDATION_ERROR, err.GetCode())
+ assert.Equal(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNodeBNameKey - an empty inventory name received", err.Error())
+}
+
+func TestValidateAndBuildNodeBIdKeyNodeTypeValidationFailure(t *testing.T) {
+ plmnId := "dddd"
+ nbId := "eeee"
+ _, err := ValidateAndBuildNodeBIdKey("", plmnId, nbId)
+ assert.NotNil(t, err)
+ assert.Equal(t, VALIDATION_ERROR, err.GetCode())
+ assert.Equal(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNodeBIdKey - an empty node type received", err.Error())
+}
+
+func TestValidateAndBuildNodeBIdKeyPlmnIdValidationFailure(t *testing.T) {
+ nodeType := "ffff"
+ nbId := "aaaa"
+ _, err := ValidateAndBuildNodeBIdKey(nodeType, "", nbId)
+ assert.NotNil(t, err)
+ assert.Equal(t, VALIDATION_ERROR, err.GetCode())
+ assert.Equal(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNodeBIdKey - an empty plmnId received", err.Error())
+}
+
+func TestValidateAndBuildNodeBIdKeyNbIdValidationFailure(t *testing.T) {
+ nodeType := "bbbb"
+ plmnId := "cccc"
+ _, err := ValidateAndBuildNodeBIdKey(nodeType, plmnId, "")
+ assert.NotNil(t, err)
+ assert.Equal(t, VALIDATION_ERROR, err.GetCode())
+ assert.Equal(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNodeBIdKey - an empty nbId received", err.Error())
+}
+
+func TestValidateAndBuildCellNamePciKeySuccess(t *testing.T){
+ name := "name"
+ prefix := "PCI"
+ pci := 9999
+ delimiter := ":"
+ key, err := ValidateAndBuildCellNamePciKey(name, uint32(pci))
+ if err != nil{
+ t.Errorf("#utils_test.TestValidateAndBuildCellNamePciKey - failed to validate key parameter")
+ }
+ assert.Contains(t, key, name)
+ assert.Contains(t, key, delimiter)
+ assert.Contains(t, key, prefix)
+ assert.Contains(t, key, "270f")
+}
\ No newline at end of file
--- /dev/null
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cell.proto
+
+package entities
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type Cell_Type int32
+
+const (
+ Cell_UNKNOWN_CELL Cell_Type = 0
+ Cell_LTE_CELL Cell_Type = 1
+ Cell_NR_CELL Cell_Type = 2
+)
+
+var Cell_Type_name = map[int32]string{
+ 0: "UNKNOWN_CELL",
+ 1: "LTE_CELL",
+ 2: "NR_CELL",
+}
+
+var Cell_Type_value = map[string]int32{
+ "UNKNOWN_CELL": 0,
+ "LTE_CELL": 1,
+ "NR_CELL": 2,
+}
+
+func (x Cell_Type) String() string {
+ return proto.EnumName(Cell_Type_name, int32(x))
+}
+
+func (Cell_Type) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_d2698cf62ebc0420, []int{0, 0}
+}
+
+type Cell struct {
+ Type Cell_Type `protobuf:"varint,1,opt,name=type,proto3,enum=entities.Cell_Type" json:"type,omitempty"`
+ // Types that are valid to be assigned to Cell:
+ // *Cell_ServedCellInfo
+ // *Cell_ServedNrCell
+ Cell isCell_Cell `protobuf_oneof:"cell"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Cell) Reset() { *m = Cell{} }
+func (m *Cell) String() string { return proto.CompactTextString(m) }
+func (*Cell) ProtoMessage() {}
+func (*Cell) Descriptor() ([]byte, []int) {
+ return fileDescriptor_d2698cf62ebc0420, []int{0}
+}
+
+func (m *Cell) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Cell.Unmarshal(m, b)
+}
+func (m *Cell) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Cell.Marshal(b, m, deterministic)
+}
+func (m *Cell) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Cell.Merge(m, src)
+}
+func (m *Cell) XXX_Size() int {
+ return xxx_messageInfo_Cell.Size(m)
+}
+func (m *Cell) XXX_DiscardUnknown() {
+ xxx_messageInfo_Cell.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cell proto.InternalMessageInfo
+
+func (m *Cell) GetType() Cell_Type {
+ if m != nil {
+ return m.Type
+ }
+ return Cell_UNKNOWN_CELL
+}
+
+type isCell_Cell interface {
+ isCell_Cell()
+}
+
+type Cell_ServedCellInfo struct {
+ ServedCellInfo *ServedCellInfo `protobuf:"bytes,2,opt,name=served_cell_info,json=servedCellInfo,proto3,oneof"`
+}
+
+type Cell_ServedNrCell struct {
+ ServedNrCell *ServedNRCell `protobuf:"bytes,3,opt,name=served_nr_cell,json=servedNrCell,proto3,oneof"`
+}
+
+func (*Cell_ServedCellInfo) isCell_Cell() {}
+
+func (*Cell_ServedNrCell) isCell_Cell() {}
+
+func (m *Cell) GetCell() isCell_Cell {
+ if m != nil {
+ return m.Cell
+ }
+ return nil
+}
+
+func (m *Cell) GetServedCellInfo() *ServedCellInfo {
+ if x, ok := m.GetCell().(*Cell_ServedCellInfo); ok {
+ return x.ServedCellInfo
+ }
+ return nil
+}
+
+func (m *Cell) GetServedNrCell() *ServedNRCell {
+ if x, ok := m.GetCell().(*Cell_ServedNrCell); ok {
+ return x.ServedNrCell
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Cell) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*Cell_ServedCellInfo)(nil),
+ (*Cell_ServedNrCell)(nil),
+ }
+}
+
+func init() {
+ proto.RegisterEnum("entities.Cell_Type", Cell_Type_name, Cell_Type_value)
+ proto.RegisterType((*Cell)(nil), "entities.Cell")
+}
+
+func init() { proto.RegisterFile("cell.proto", fileDescriptor_d2698cf62ebc0420) }
+
+var fileDescriptor_d2698cf62ebc0420 = []byte{
+ // 226 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4a, 0x4e, 0xcd, 0xc9,
+ 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x48, 0xcd, 0x2b, 0xc9, 0x2c, 0xc9, 0x4c, 0x2d,
+ 0x96, 0xe2, 0x4c, 0xcf, 0x4b, 0x82, 0x08, 0x4a, 0x71, 0xa6, 0xc2, 0x98, 0x4a, 0x9f, 0x18, 0xb9,
+ 0x58, 0x9c, 0x53, 0x73, 0x72, 0x84, 0xd4, 0xb9, 0x58, 0x4a, 0x2a, 0x0b, 0x52, 0x25, 0x18, 0x15,
+ 0x18, 0x35, 0xf8, 0x8c, 0x84, 0xf5, 0x60, 0xfa, 0xf4, 0x40, 0xb2, 0x7a, 0x21, 0x95, 0x05, 0xa9,
+ 0x41, 0x60, 0x05, 0x42, 0x2e, 0x5c, 0x02, 0xc5, 0xa9, 0x45, 0x65, 0xa9, 0x29, 0xf1, 0x20, 0x6b,
+ 0xe2, 0x33, 0xf3, 0xd2, 0xf2, 0x25, 0x98, 0x14, 0x18, 0x35, 0xb8, 0x8d, 0x24, 0x10, 0x9a, 0x82,
+ 0xc1, 0x2a, 0x40, 0x5a, 0x3d, 0xf3, 0xd2, 0xf2, 0x3d, 0x18, 0x82, 0xf8, 0x8a, 0x51, 0x44, 0x84,
+ 0xec, 0xb8, 0xa0, 0x22, 0xf1, 0x79, 0x45, 0x60, 0x83, 0x24, 0x98, 0xc1, 0x66, 0x88, 0xa1, 0x9b,
+ 0xe1, 0x17, 0x04, 0xd2, 0xe3, 0xc1, 0x10, 0xc4, 0x03, 0x51, 0xef, 0x57, 0x04, 0xe2, 0x2b, 0x19,
+ 0x73, 0xb1, 0x80, 0xdc, 0x24, 0x24, 0xc0, 0xc5, 0x13, 0xea, 0xe7, 0xed, 0xe7, 0x1f, 0xee, 0x17,
+ 0xef, 0xec, 0xea, 0xe3, 0x23, 0xc0, 0x20, 0xc4, 0xc3, 0xc5, 0xe1, 0x13, 0xe2, 0x0a, 0xe1, 0x31,
+ 0x0a, 0x71, 0x73, 0xb1, 0xfb, 0x05, 0x41, 0x38, 0x4c, 0x4e, 0x6c, 0x5c, 0x2c, 0x20, 0xab, 0x92,
+ 0xd8, 0xc0, 0x7e, 0x37, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x50, 0xb1, 0xc7, 0x12, 0x29, 0x01,
+ 0x00, 0x00,
+}
--- /dev/null
+syntax = "proto3";
+package entities;
+import "gnb.proto";
+import "enb.proto";
+
+message Cell{
+ enum Type{
+ UNKNOWN_CELL = 0;
+ LTE_CELL = 1;
+ NR_CELL = 2;
+ }
+ Type type = 1;
+ oneof cell{
+ ServedCellInfo served_cell_info = 2;
+ ServedNRCell served_nr_cell = 3;
+ }
+}
\ No newline at end of file
--- /dev/null
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: cells.proto
+
+package entities
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type Cells struct {
+ Type Cell_Type `protobuf:"varint,1,opt,name=type,proto3,enum=entities.Cell_Type" json:"type,omitempty"`
+ // Types that are valid to be assigned to List:
+ // *Cells_ServedCellInfos
+ // *Cells_ServedNrCells
+ List isCells_List `protobuf_oneof:"list"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Cells) Reset() { *m = Cells{} }
+func (m *Cells) String() string { return proto.CompactTextString(m) }
+func (*Cells) ProtoMessage() {}
+func (*Cells) Descriptor() ([]byte, []int) {
+ return fileDescriptor_842e821272d22ff7, []int{0}
+}
+
+func (m *Cells) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Cells.Unmarshal(m, b)
+}
+func (m *Cells) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Cells.Marshal(b, m, deterministic)
+}
+func (m *Cells) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Cells.Merge(m, src)
+}
+func (m *Cells) XXX_Size() int {
+ return xxx_messageInfo_Cells.Size(m)
+}
+func (m *Cells) XXX_DiscardUnknown() {
+ xxx_messageInfo_Cells.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Cells proto.InternalMessageInfo
+
+func (m *Cells) GetType() Cell_Type {
+ if m != nil {
+ return m.Type
+ }
+ return Cell_UNKNOWN_CELL
+}
+
+type isCells_List interface {
+ isCells_List()
+}
+
+type Cells_ServedCellInfos struct {
+ ServedCellInfos *ServedCellInfoList `protobuf:"bytes,2,opt,name=served_cell_infos,json=servedCellInfos,proto3,oneof"`
+}
+
+type Cells_ServedNrCells struct {
+ ServedNrCells *ServedNRCellList `protobuf:"bytes,3,opt,name=served_nr_cells,json=servedNrCells,proto3,oneof"`
+}
+
+func (*Cells_ServedCellInfos) isCells_List() {}
+
+func (*Cells_ServedNrCells) isCells_List() {}
+
+func (m *Cells) GetList() isCells_List {
+ if m != nil {
+ return m.List
+ }
+ return nil
+}
+
+func (m *Cells) GetServedCellInfos() *ServedCellInfoList {
+ if x, ok := m.GetList().(*Cells_ServedCellInfos); ok {
+ return x.ServedCellInfos
+ }
+ return nil
+}
+
+func (m *Cells) GetServedNrCells() *ServedNRCellList {
+ if x, ok := m.GetList().(*Cells_ServedNrCells); ok {
+ return x.ServedNrCells
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*Cells) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*Cells_ServedCellInfos)(nil),
+ (*Cells_ServedNrCells)(nil),
+ }
+}
+
+type ServedCellInfoList struct {
+ ServedCells []*ServedCellInfo `protobuf:"bytes,1,rep,name=served_cells,json=servedCells,proto3" json:"served_cells,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServedCellInfoList) Reset() { *m = ServedCellInfoList{} }
+func (m *ServedCellInfoList) String() string { return proto.CompactTextString(m) }
+func (*ServedCellInfoList) ProtoMessage() {}
+func (*ServedCellInfoList) Descriptor() ([]byte, []int) {
+ return fileDescriptor_842e821272d22ff7, []int{1}
+}
+
+func (m *ServedCellInfoList) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServedCellInfoList.Unmarshal(m, b)
+}
+func (m *ServedCellInfoList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServedCellInfoList.Marshal(b, m, deterministic)
+}
+func (m *ServedCellInfoList) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServedCellInfoList.Merge(m, src)
+}
+func (m *ServedCellInfoList) XXX_Size() int {
+ return xxx_messageInfo_ServedCellInfoList.Size(m)
+}
+func (m *ServedCellInfoList) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServedCellInfoList.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServedCellInfoList proto.InternalMessageInfo
+
+func (m *ServedCellInfoList) GetServedCells() []*ServedCellInfo {
+ if m != nil {
+ return m.ServedCells
+ }
+ return nil
+}
+
+type ServedNRCellList struct {
+ ServedCells []*ServedNRCell `protobuf:"bytes,1,rep,name=served_cells,json=servedCells,proto3" json:"served_cells,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServedNRCellList) Reset() { *m = ServedNRCellList{} }
+func (m *ServedNRCellList) String() string { return proto.CompactTextString(m) }
+func (*ServedNRCellList) ProtoMessage() {}
+func (*ServedNRCellList) Descriptor() ([]byte, []int) {
+ return fileDescriptor_842e821272d22ff7, []int{2}
+}
+
+func (m *ServedNRCellList) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServedNRCellList.Unmarshal(m, b)
+}
+func (m *ServedNRCellList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServedNRCellList.Marshal(b, m, deterministic)
+}
+func (m *ServedNRCellList) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServedNRCellList.Merge(m, src)
+}
+func (m *ServedNRCellList) XXX_Size() int {
+ return xxx_messageInfo_ServedNRCellList.Size(m)
+}
+func (m *ServedNRCellList) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServedNRCellList.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServedNRCellList proto.InternalMessageInfo
+
+func (m *ServedNRCellList) GetServedCells() []*ServedNRCell {
+ if m != nil {
+ return m.ServedCells
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*Cells)(nil), "entities.Cells")
+ proto.RegisterType((*ServedCellInfoList)(nil), "entities.ServedCellInfoList")
+ proto.RegisterType((*ServedNRCellList)(nil), "entities.ServedNRCellList")
+}
+
+func init() { proto.RegisterFile("cells.proto", fileDescriptor_842e821272d22ff7) }
+
+var fileDescriptor_842e821272d22ff7 = []byte{
+ // 241 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x4e, 0x4e, 0xcd, 0xc9,
+ 0x29, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x48, 0xcd, 0x2b, 0xc9, 0x2c, 0xc9, 0x4c,
+ 0x2d, 0x96, 0xe2, 0x02, 0x09, 0x43, 0x44, 0xa5, 0x38, 0xd3, 0xf3, 0x92, 0x60, 0xcc, 0x54, 0x18,
+ 0x53, 0xe9, 0x14, 0x23, 0x17, 0xab, 0x33, 0x48, 0xaf, 0x90, 0x3a, 0x17, 0x4b, 0x49, 0x65, 0x41,
+ 0xaa, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x9f, 0x91, 0xb0, 0x1e, 0xcc, 0x10, 0x3d, 0x90, 0xb4, 0x5e,
+ 0x48, 0x65, 0x41, 0x6a, 0x10, 0x58, 0x81, 0x90, 0x17, 0x97, 0x60, 0x71, 0x6a, 0x51, 0x59, 0x6a,
+ 0x4a, 0x3c, 0xc8, 0xf4, 0xf8, 0xcc, 0xbc, 0xb4, 0xfc, 0x62, 0x09, 0x26, 0x05, 0x46, 0x0d, 0x6e,
+ 0x23, 0x19, 0x84, 0xae, 0x60, 0xb0, 0x12, 0x90, 0x5e, 0xcf, 0xbc, 0xb4, 0x7c, 0x9f, 0xcc, 0xe2,
+ 0x12, 0x0f, 0x86, 0x20, 0xfe, 0x62, 0x14, 0xd1, 0x62, 0x21, 0x17, 0x2e, 0xa8, 0x50, 0x7c, 0x5e,
+ 0x11, 0xd8, 0xb8, 0x62, 0x09, 0x66, 0xb0, 0x49, 0x52, 0xe8, 0x26, 0xf9, 0x05, 0x81, 0x74, 0x41,
+ 0xcd, 0xe1, 0x85, 0x68, 0xf2, 0x2b, 0x02, 0x3b, 0xdd, 0x89, 0x8d, 0x8b, 0x25, 0x27, 0xb3, 0xb8,
+ 0x44, 0x29, 0x90, 0x4b, 0x08, 0xd3, 0x5a, 0x21, 0x6b, 0x2e, 0x1e, 0x24, 0xf7, 0x16, 0x4b, 0x30,
+ 0x2a, 0x30, 0x6b, 0x70, 0x1b, 0x49, 0xe0, 0x72, 0x6a, 0x10, 0x37, 0xc2, 0x91, 0xc5, 0x4a, 0xbe,
+ 0x5c, 0x02, 0xe8, 0xf6, 0x0b, 0x59, 0x62, 0x35, 0x50, 0x0c, 0xbb, 0x8b, 0x51, 0x8c, 0x4b, 0x62,
+ 0x03, 0x87, 0xba, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0xde, 0x2b, 0x35, 0x7d, 0xb0, 0x01, 0x00,
+ 0x00,
+}
--- /dev/null
+syntax = "proto3";
+package entities;
+import "cell.proto";
+import "gnb.proto";
+import "enb.proto";
+
+message Cells{
+ Cell.Type type = 1;
+ oneof list{
+ ServedCellInfoList served_cell_infos = 2;
+ ServedNRCellList served_nr_cells = 3;
+ }
+}
+
+message ServedCellInfoList{
+ repeated ServedCellInfo served_cells = 1;
+}
+
+message ServedNRCellList{
+ repeated ServedNRCell served_cells = 1;
+}
\ No newline at end of file
--- /dev/null
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: enb.proto
+
+package entities
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type FreqBandIndicatorPriority int32
+
+const (
+ FreqBandIndicatorPriority_UNKNOWN_FREQ_BAND_INDICATOR_PRIORITY FreqBandIndicatorPriority = 0
+ FreqBandIndicatorPriority_NOT_BROADCASTED FreqBandIndicatorPriority = 1
+ FreqBandIndicatorPriority_BROADCASTED FreqBandIndicatorPriority = 2
+)
+
+var FreqBandIndicatorPriority_name = map[int32]string{
+ 0: "UNKNOWN_FREQ_BAND_INDICATOR_PRIORITY",
+ 1: "NOT_BROADCASTED",
+ 2: "BROADCASTED",
+}
+
+var FreqBandIndicatorPriority_value = map[string]int32{
+ "UNKNOWN_FREQ_BAND_INDICATOR_PRIORITY": 0,
+ "NOT_BROADCASTED": 1,
+ "BROADCASTED": 2,
+}
+
+func (x FreqBandIndicatorPriority) String() string {
+ return proto.EnumName(FreqBandIndicatorPriority_name, int32(x))
+}
+
+func (FreqBandIndicatorPriority) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{0}
+}
+
+type BandwidthReducedSI int32
+
+const (
+ BandwidthReducedSI_UNKNOWN_BANDWIDTH_REDUCED_SI BandwidthReducedSI = 0
+ BandwidthReducedSI_SCHEDULED BandwidthReducedSI = 1
+)
+
+var BandwidthReducedSI_name = map[int32]string{
+ 0: "UNKNOWN_BANDWIDTH_REDUCED_SI",
+ 1: "SCHEDULED",
+}
+
+var BandwidthReducedSI_value = map[string]int32{
+ "UNKNOWN_BANDWIDTH_REDUCED_SI": 0,
+ "SCHEDULED": 1,
+}
+
+func (x BandwidthReducedSI) String() string {
+ return proto.EnumName(BandwidthReducedSI_name, int32(x))
+}
+
+func (BandwidthReducedSI) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{1}
+}
+
+type SubframeAllocationType int32
+
+const (
+ SubframeAllocationType_UNKNOWN_SUBFRAME_ALLOCATION_TYPE SubframeAllocationType = 0
+ SubframeAllocationType_ONE_FRAME SubframeAllocationType = 1
+ SubframeAllocationType_FOUR_FRAME SubframeAllocationType = 2
+)
+
+var SubframeAllocationType_name = map[int32]string{
+ 0: "UNKNOWN_SUBFRAME_ALLOCATION_TYPE",
+ 1: "ONE_FRAME",
+ 2: "FOUR_FRAME",
+}
+
+var SubframeAllocationType_value = map[string]int32{
+ "UNKNOWN_SUBFRAME_ALLOCATION_TYPE": 0,
+ "ONE_FRAME": 1,
+ "FOUR_FRAME": 2,
+}
+
+func (x SubframeAllocationType) String() string {
+ return proto.EnumName(SubframeAllocationType_name, int32(x))
+}
+
+func (SubframeAllocationType) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{2}
+}
+
+type RadioframeAllocationPeriod int32
+
+const (
+ RadioframeAllocationPeriod_UNKNOWN_RADIOFRAME_ALLOCATION_PERIOD RadioframeAllocationPeriod = 0
+ RadioframeAllocationPeriod_N1 RadioframeAllocationPeriod = 1
+ RadioframeAllocationPeriod_N2 RadioframeAllocationPeriod = 2
+ RadioframeAllocationPeriod_N4 RadioframeAllocationPeriod = 3
+ RadioframeAllocationPeriod_N8 RadioframeAllocationPeriod = 4
+ RadioframeAllocationPeriod_N16 RadioframeAllocationPeriod = 5
+ RadioframeAllocationPeriod_N32 RadioframeAllocationPeriod = 6
+)
+
+var RadioframeAllocationPeriod_name = map[int32]string{
+ 0: "UNKNOWN_RADIOFRAME_ALLOCATION_PERIOD",
+ 1: "N1",
+ 2: "N2",
+ 3: "N4",
+ 4: "N8",
+ 5: "N16",
+ 6: "N32",
+}
+
+var RadioframeAllocationPeriod_value = map[string]int32{
+ "UNKNOWN_RADIOFRAME_ALLOCATION_PERIOD": 0,
+ "N1": 1,
+ "N2": 2,
+ "N4": 3,
+ "N8": 4,
+ "N16": 5,
+ "N32": 6,
+}
+
+func (x RadioframeAllocationPeriod) String() string {
+ return proto.EnumName(RadioframeAllocationPeriod_name, int32(x))
+}
+
+func (RadioframeAllocationPeriod) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{3}
+}
+
+type NumberOfAntennaPorts int32
+
+const (
+ NumberOfAntennaPorts_UNKNOWN_NUMBER_OF_ANTENNA_PORTS NumberOfAntennaPorts = 0
+ NumberOfAntennaPorts_AN1 NumberOfAntennaPorts = 1
+ NumberOfAntennaPorts_AN2 NumberOfAntennaPorts = 2
+ NumberOfAntennaPorts_AN4 NumberOfAntennaPorts = 3
+)
+
+var NumberOfAntennaPorts_name = map[int32]string{
+ 0: "UNKNOWN_NUMBER_OF_ANTENNA_PORTS",
+ 1: "AN1",
+ 2: "AN2",
+ 3: "AN4",
+}
+
+var NumberOfAntennaPorts_value = map[string]int32{
+ "UNKNOWN_NUMBER_OF_ANTENNA_PORTS": 0,
+ "AN1": 1,
+ "AN2": 2,
+ "AN4": 3,
+}
+
+func (x NumberOfAntennaPorts) String() string {
+ return proto.EnumName(NumberOfAntennaPorts_name, int32(x))
+}
+
+func (NumberOfAntennaPorts) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{4}
+}
+
+type EnbType int32
+
+const (
+ EnbType_UNKNOWN_ENB_TYPE EnbType = 0
+ EnbType_MACRO_ENB EnbType = 1
+ EnbType_HOME_ENB EnbType = 2
+ EnbType_SHORT_MACRO_ENB EnbType = 3
+ EnbType_LONG_MACRO_ENB EnbType = 4
+)
+
+var EnbType_name = map[int32]string{
+ 0: "UNKNOWN_ENB_TYPE",
+ 1: "MACRO_ENB",
+ 2: "HOME_ENB",
+ 3: "SHORT_MACRO_ENB",
+ 4: "LONG_MACRO_ENB",
+}
+
+var EnbType_value = map[string]int32{
+ "UNKNOWN_ENB_TYPE": 0,
+ "MACRO_ENB": 1,
+ "HOME_ENB": 2,
+ "SHORT_MACRO_ENB": 3,
+ "LONG_MACRO_ENB": 4,
+}
+
+func (x EnbType) String() string {
+ return proto.EnumName(EnbType_name, int32(x))
+}
+
+func (EnbType) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{5}
+}
+
+type SubframeAssignment int32
+
+const (
+ SubframeAssignment_UNKNOWN_SUBFRAME_ASSIGNMENT SubframeAssignment = 0
+ SubframeAssignment_SA0 SubframeAssignment = 1
+ SubframeAssignment_SA1 SubframeAssignment = 2
+ SubframeAssignment_SA2 SubframeAssignment = 3
+ SubframeAssignment_SA3 SubframeAssignment = 4
+ SubframeAssignment_SA4 SubframeAssignment = 5
+ SubframeAssignment_SA5 SubframeAssignment = 6
+ SubframeAssignment_SA6 SubframeAssignment = 7
+)
+
+var SubframeAssignment_name = map[int32]string{
+ 0: "UNKNOWN_SUBFRAME_ASSIGNMENT",
+ 1: "SA0",
+ 2: "SA1",
+ 3: "SA2",
+ 4: "SA3",
+ 5: "SA4",
+ 6: "SA5",
+ 7: "SA6",
+}
+
+var SubframeAssignment_value = map[string]int32{
+ "UNKNOWN_SUBFRAME_ASSIGNMENT": 0,
+ "SA0": 1,
+ "SA1": 2,
+ "SA2": 3,
+ "SA3": 4,
+ "SA4": 5,
+ "SA5": 6,
+ "SA6": 7,
+}
+
+func (x SubframeAssignment) String() string {
+ return proto.EnumName(SubframeAssignment_name, int32(x))
+}
+
+func (SubframeAssignment) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{6}
+}
+
+type CyclicPrefix int32
+
+const (
+ CyclicPrefix_UNKNOWN_CYCLIC_PREFIX CyclicPrefix = 0
+ CyclicPrefix_NORMAL CyclicPrefix = 1
+ CyclicPrefix_EXTENDED CyclicPrefix = 2
+)
+
+var CyclicPrefix_name = map[int32]string{
+ 0: "UNKNOWN_CYCLIC_PREFIX",
+ 1: "NORMAL",
+ 2: "EXTENDED",
+}
+
+var CyclicPrefix_value = map[string]int32{
+ "UNKNOWN_CYCLIC_PREFIX": 0,
+ "NORMAL": 1,
+ "EXTENDED": 2,
+}
+
+func (x CyclicPrefix) String() string {
+ return proto.EnumName(CyclicPrefix_name, int32(x))
+}
+
+func (CyclicPrefix) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{7}
+}
+
+type TransmissionBandwidth int32
+
+const (
+ TransmissionBandwidth_UNKNOWN_TRANSMISSION_BANDWIDTH TransmissionBandwidth = 0
+ TransmissionBandwidth_BW6 TransmissionBandwidth = 1
+ TransmissionBandwidth_BW15 TransmissionBandwidth = 2
+ TransmissionBandwidth_BW25 TransmissionBandwidth = 3
+ TransmissionBandwidth_BW50 TransmissionBandwidth = 4
+ TransmissionBandwidth_BW75 TransmissionBandwidth = 5
+ TransmissionBandwidth_BW100 TransmissionBandwidth = 6
+ TransmissionBandwidth_BW1 TransmissionBandwidth = 7
+)
+
+var TransmissionBandwidth_name = map[int32]string{
+ 0: "UNKNOWN_TRANSMISSION_BANDWIDTH",
+ 1: "BW6",
+ 2: "BW15",
+ 3: "BW25",
+ 4: "BW50",
+ 5: "BW75",
+ 6: "BW100",
+ 7: "BW1",
+}
+
+var TransmissionBandwidth_value = map[string]int32{
+ "UNKNOWN_TRANSMISSION_BANDWIDTH": 0,
+ "BW6": 1,
+ "BW15": 2,
+ "BW25": 3,
+ "BW50": 4,
+ "BW75": 5,
+ "BW100": 6,
+ "BW1": 7,
+}
+
+func (x TransmissionBandwidth) String() string {
+ return proto.EnumName(TransmissionBandwidth_name, int32(x))
+}
+
+func (TransmissionBandwidth) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{8}
+}
+
+type Eutra_Mode int32
+
+const (
+ Eutra_UNKNOWN Eutra_Mode = 0
+ Eutra_FDD Eutra_Mode = 1
+ Eutra_TDD Eutra_Mode = 2
+)
+
+var Eutra_Mode_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "FDD",
+ 2: "TDD",
+}
+
+var Eutra_Mode_value = map[string]int32{
+ "UNKNOWN": 0,
+ "FDD": 1,
+ "TDD": 2,
+}
+
+func (x Eutra_Mode) String() string {
+ return proto.EnumName(Eutra_Mode_name, int32(x))
+}
+
+func (Eutra_Mode) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{3, 0}
+}
+
+type SpecialSubframe_Patterns int32
+
+const (
+ SpecialSubframe_UNKNOWN SpecialSubframe_Patterns = 0
+ SpecialSubframe_SSP0 SpecialSubframe_Patterns = 1
+ SpecialSubframe_SSP1 SpecialSubframe_Patterns = 2
+ SpecialSubframe_SSP2 SpecialSubframe_Patterns = 3
+ SpecialSubframe_SSP3 SpecialSubframe_Patterns = 4
+ SpecialSubframe_SSP4 SpecialSubframe_Patterns = 5
+ SpecialSubframe_SSP5 SpecialSubframe_Patterns = 6
+ SpecialSubframe_SSP6 SpecialSubframe_Patterns = 7
+ SpecialSubframe_SSP7 SpecialSubframe_Patterns = 8
+ SpecialSubframe_SSP8 SpecialSubframe_Patterns = 9
+)
+
+var SpecialSubframe_Patterns_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "SSP0",
+ 2: "SSP1",
+ 3: "SSP2",
+ 4: "SSP3",
+ 5: "SSP4",
+ 6: "SSP5",
+ 7: "SSP6",
+ 8: "SSP7",
+ 9: "SSP8",
+}
+
+var SpecialSubframe_Patterns_value = map[string]int32{
+ "UNKNOWN": 0,
+ "SSP0": 1,
+ "SSP1": 2,
+ "SSP2": 3,
+ "SSP3": 4,
+ "SSP4": 5,
+ "SSP5": 6,
+ "SSP6": 7,
+ "SSP7": 8,
+ "SSP8": 9,
+}
+
+func (x SpecialSubframe_Patterns) String() string {
+ return proto.EnumName(SpecialSubframe_Patterns_name, int32(x))
+}
+
+func (SpecialSubframe_Patterns) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{12, 0}
+}
+
+type AdditionalSpecialSubframe_Patterns int32
+
+const (
+ AdditionalSpecialSubframe_UNKNOWN AdditionalSpecialSubframe_Patterns = 0
+ AdditionalSpecialSubframe_SSP0 AdditionalSpecialSubframe_Patterns = 1
+ AdditionalSpecialSubframe_SSP1 AdditionalSpecialSubframe_Patterns = 2
+ AdditionalSpecialSubframe_SSP2 AdditionalSpecialSubframe_Patterns = 3
+ AdditionalSpecialSubframe_SSP3 AdditionalSpecialSubframe_Patterns = 4
+ AdditionalSpecialSubframe_SSP4 AdditionalSpecialSubframe_Patterns = 5
+ AdditionalSpecialSubframe_SSP5 AdditionalSpecialSubframe_Patterns = 6
+ AdditionalSpecialSubframe_SSP6 AdditionalSpecialSubframe_Patterns = 7
+ AdditionalSpecialSubframe_SSP7 AdditionalSpecialSubframe_Patterns = 8
+ AdditionalSpecialSubframe_SSP8 AdditionalSpecialSubframe_Patterns = 9
+ AdditionalSpecialSubframe_SSP9 AdditionalSpecialSubframe_Patterns = 10
+)
+
+var AdditionalSpecialSubframe_Patterns_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "SSP0",
+ 2: "SSP1",
+ 3: "SSP2",
+ 4: "SSP3",
+ 5: "SSP4",
+ 6: "SSP5",
+ 7: "SSP6",
+ 8: "SSP7",
+ 9: "SSP8",
+ 10: "SSP9",
+}
+
+var AdditionalSpecialSubframe_Patterns_value = map[string]int32{
+ "UNKNOWN": 0,
+ "SSP0": 1,
+ "SSP1": 2,
+ "SSP2": 3,
+ "SSP3": 4,
+ "SSP4": 5,
+ "SSP5": 6,
+ "SSP6": 7,
+ "SSP7": 8,
+ "SSP8": 9,
+ "SSP9": 10,
+}
+
+func (x AdditionalSpecialSubframe_Patterns) String() string {
+ return proto.EnumName(AdditionalSpecialSubframe_Patterns_name, int32(x))
+}
+
+func (AdditionalSpecialSubframe_Patterns) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{13, 0}
+}
+
+type AdditionalSpecialSubframePatterns_Extension int32
+
+const (
+ AdditionalSpecialSubframePatterns_UNKNOWN AdditionalSpecialSubframePatterns_Extension = 0
+ AdditionalSpecialSubframePatterns_SSP10 AdditionalSpecialSubframePatterns_Extension = 1
+)
+
+var AdditionalSpecialSubframePatterns_Extension_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "SSP10",
+}
+
+var AdditionalSpecialSubframePatterns_Extension_value = map[string]int32{
+ "UNKNOWN": 0,
+ "SSP10": 1,
+}
+
+func (x AdditionalSpecialSubframePatterns_Extension) String() string {
+ return proto.EnumName(AdditionalSpecialSubframePatterns_Extension_name, int32(x))
+}
+
+func (AdditionalSpecialSubframePatterns_Extension) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{14, 0}
+}
+
+type Enb struct {
+ EnbType EnbType `protobuf:"varint,1,opt,name=enb_type,json=enbType,proto3,enum=entities.EnbType" json:"enb_type,omitempty"`
+ ServedCells []*ServedCellInfo `protobuf:"bytes,2,rep,name=served_cells,json=servedCells,proto3" json:"served_cells,omitempty"`
+ GuGroupIds []string `protobuf:"bytes,3,rep,name=gu_group_ids,json=guGroupIds,proto3" json:"gu_group_ids,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Enb) Reset() { *m = Enb{} }
+func (m *Enb) String() string { return proto.CompactTextString(m) }
+func (*Enb) ProtoMessage() {}
+func (*Enb) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{0}
+}
+
+func (m *Enb) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Enb.Unmarshal(m, b)
+}
+func (m *Enb) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Enb.Marshal(b, m, deterministic)
+}
+func (m *Enb) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Enb.Merge(m, src)
+}
+func (m *Enb) XXX_Size() int {
+ return xxx_messageInfo_Enb.Size(m)
+}
+func (m *Enb) XXX_DiscardUnknown() {
+ xxx_messageInfo_Enb.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Enb proto.InternalMessageInfo
+
+func (m *Enb) GetEnbType() EnbType {
+ if m != nil {
+ return m.EnbType
+ }
+ return EnbType_UNKNOWN_ENB_TYPE
+}
+
+func (m *Enb) GetServedCells() []*ServedCellInfo {
+ if m != nil {
+ return m.ServedCells
+ }
+ return nil
+}
+
+func (m *Enb) GetGuGroupIds() []string {
+ if m != nil {
+ return m.GuGroupIds
+ }
+ return nil
+}
+
+type ServedCellInfo struct {
+ Pci uint32 `protobuf:"varint,1,opt,name=pci,proto3" json:"pci,omitempty"`
+ CellId string `protobuf:"bytes,2,opt,name=cell_id,json=cellId,proto3" json:"cell_id,omitempty"`
+ Tac string `protobuf:"bytes,3,opt,name=tac,proto3" json:"tac,omitempty"`
+ BroadcastPlmns []string `protobuf:"bytes,4,rep,name=broadcast_plmns,json=broadcastPlmns,proto3" json:"broadcast_plmns,omitempty"`
+ ChoiceEutraMode *ChoiceEUTRAMode `protobuf:"bytes,5,opt,name=choice_eutra_mode,json=choiceEutraMode,proto3" json:"choice_eutra_mode,omitempty"`
+ EutraMode Eutra_Mode `protobuf:"varint,6,opt,name=eutra_mode,json=eutraMode,proto3,enum=entities.Eutra_Mode" json:"eutra_mode,omitempty"`
+ NumberOfAntennaPorts NumberOfAntennaPorts `protobuf:"varint,7,opt,name=number_of_antenna_ports,json=numberOfAntennaPorts,proto3,enum=entities.NumberOfAntennaPorts" json:"number_of_antenna_ports,omitempty"`
+ PrachConfiguration *PrachConfiguration `protobuf:"bytes,8,opt,name=prach_configuration,json=prachConfiguration,proto3" json:"prach_configuration,omitempty"`
+ MbsfnSubframeInfos []*MbsfnSubframe `protobuf:"bytes,9,rep,name=mbsfn_subframe_infos,json=mbsfnSubframeInfos,proto3" json:"mbsfn_subframe_infos,omitempty"`
+ CsgId string `protobuf:"bytes,10,opt,name=csg_id,json=csgId,proto3" json:"csg_id,omitempty"`
+ MbmsServiceAreaIdentities []string `protobuf:"bytes,11,rep,name=mbms_service_area_identities,json=mbmsServiceAreaIdentities,proto3" json:"mbms_service_area_identities,omitempty"`
+ MultibandInfos []uint32 `protobuf:"varint,12,rep,packed,name=multiband_infos,json=multibandInfos,proto3" json:"multiband_infos,omitempty"`
+ FreqBandIndicatorPriority FreqBandIndicatorPriority `protobuf:"varint,13,opt,name=freq_band_indicator_priority,json=freqBandIndicatorPriority,proto3,enum=entities.FreqBandIndicatorPriority" json:"freq_band_indicator_priority,omitempty"`
+ BandwidthReducedSi BandwidthReducedSI `protobuf:"varint,14,opt,name=bandwidth_reduced_si,json=bandwidthReducedSi,proto3,enum=entities.BandwidthReducedSI" json:"bandwidth_reduced_si,omitempty"`
+ NeighbourInfos []*NeighbourInformation `protobuf:"bytes,15,rep,name=neighbour_infos,json=neighbourInfos,proto3" json:"neighbour_infos,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServedCellInfo) Reset() { *m = ServedCellInfo{} }
+func (m *ServedCellInfo) String() string { return proto.CompactTextString(m) }
+func (*ServedCellInfo) ProtoMessage() {}
+func (*ServedCellInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{1}
+}
+
+func (m *ServedCellInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServedCellInfo.Unmarshal(m, b)
+}
+func (m *ServedCellInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServedCellInfo.Marshal(b, m, deterministic)
+}
+func (m *ServedCellInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServedCellInfo.Merge(m, src)
+}
+func (m *ServedCellInfo) XXX_Size() int {
+ return xxx_messageInfo_ServedCellInfo.Size(m)
+}
+func (m *ServedCellInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServedCellInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServedCellInfo proto.InternalMessageInfo
+
+func (m *ServedCellInfo) GetPci() uint32 {
+ if m != nil {
+ return m.Pci
+ }
+ return 0
+}
+
+func (m *ServedCellInfo) GetCellId() string {
+ if m != nil {
+ return m.CellId
+ }
+ return ""
+}
+
+func (m *ServedCellInfo) GetTac() string {
+ if m != nil {
+ return m.Tac
+ }
+ return ""
+}
+
+func (m *ServedCellInfo) GetBroadcastPlmns() []string {
+ if m != nil {
+ return m.BroadcastPlmns
+ }
+ return nil
+}
+
+func (m *ServedCellInfo) GetChoiceEutraMode() *ChoiceEUTRAMode {
+ if m != nil {
+ return m.ChoiceEutraMode
+ }
+ return nil
+}
+
+func (m *ServedCellInfo) GetEutraMode() Eutra_Mode {
+ if m != nil {
+ return m.EutraMode
+ }
+ return Eutra_UNKNOWN
+}
+
+func (m *ServedCellInfo) GetNumberOfAntennaPorts() NumberOfAntennaPorts {
+ if m != nil {
+ return m.NumberOfAntennaPorts
+ }
+ return NumberOfAntennaPorts_UNKNOWN_NUMBER_OF_ANTENNA_PORTS
+}
+
+func (m *ServedCellInfo) GetPrachConfiguration() *PrachConfiguration {
+ if m != nil {
+ return m.PrachConfiguration
+ }
+ return nil
+}
+
+func (m *ServedCellInfo) GetMbsfnSubframeInfos() []*MbsfnSubframe {
+ if m != nil {
+ return m.MbsfnSubframeInfos
+ }
+ return nil
+}
+
+func (m *ServedCellInfo) GetCsgId() string {
+ if m != nil {
+ return m.CsgId
+ }
+ return ""
+}
+
+func (m *ServedCellInfo) GetMbmsServiceAreaIdentities() []string {
+ if m != nil {
+ return m.MbmsServiceAreaIdentities
+ }
+ return nil
+}
+
+func (m *ServedCellInfo) GetMultibandInfos() []uint32 {
+ if m != nil {
+ return m.MultibandInfos
+ }
+ return nil
+}
+
+func (m *ServedCellInfo) GetFreqBandIndicatorPriority() FreqBandIndicatorPriority {
+ if m != nil {
+ return m.FreqBandIndicatorPriority
+ }
+ return FreqBandIndicatorPriority_UNKNOWN_FREQ_BAND_INDICATOR_PRIORITY
+}
+
+func (m *ServedCellInfo) GetBandwidthReducedSi() BandwidthReducedSI {
+ if m != nil {
+ return m.BandwidthReducedSi
+ }
+ return BandwidthReducedSI_UNKNOWN_BANDWIDTH_REDUCED_SI
+}
+
+func (m *ServedCellInfo) GetNeighbourInfos() []*NeighbourInformation {
+ if m != nil {
+ return m.NeighbourInfos
+ }
+ return nil
+}
+
+type ChoiceEUTRAMode struct {
+ Fdd *FddInfo `protobuf:"bytes,1,opt,name=fdd,proto3" json:"fdd,omitempty"`
+ Tdd *TddInfo `protobuf:"bytes,2,opt,name=tdd,proto3" json:"tdd,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ChoiceEUTRAMode) Reset() { *m = ChoiceEUTRAMode{} }
+func (m *ChoiceEUTRAMode) String() string { return proto.CompactTextString(m) }
+func (*ChoiceEUTRAMode) ProtoMessage() {}
+func (*ChoiceEUTRAMode) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{2}
+}
+
+func (m *ChoiceEUTRAMode) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ChoiceEUTRAMode.Unmarshal(m, b)
+}
+func (m *ChoiceEUTRAMode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ChoiceEUTRAMode.Marshal(b, m, deterministic)
+}
+func (m *ChoiceEUTRAMode) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ChoiceEUTRAMode.Merge(m, src)
+}
+func (m *ChoiceEUTRAMode) XXX_Size() int {
+ return xxx_messageInfo_ChoiceEUTRAMode.Size(m)
+}
+func (m *ChoiceEUTRAMode) XXX_DiscardUnknown() {
+ xxx_messageInfo_ChoiceEUTRAMode.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ChoiceEUTRAMode proto.InternalMessageInfo
+
+func (m *ChoiceEUTRAMode) GetFdd() *FddInfo {
+ if m != nil {
+ return m.Fdd
+ }
+ return nil
+}
+
+func (m *ChoiceEUTRAMode) GetTdd() *TddInfo {
+ if m != nil {
+ return m.Tdd
+ }
+ return nil
+}
+
+type Eutra struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Eutra) Reset() { *m = Eutra{} }
+func (m *Eutra) String() string { return proto.CompactTextString(m) }
+func (*Eutra) ProtoMessage() {}
+func (*Eutra) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{3}
+}
+
+func (m *Eutra) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Eutra.Unmarshal(m, b)
+}
+func (m *Eutra) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Eutra.Marshal(b, m, deterministic)
+}
+func (m *Eutra) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Eutra.Merge(m, src)
+}
+func (m *Eutra) XXX_Size() int {
+ return xxx_messageInfo_Eutra.Size(m)
+}
+func (m *Eutra) XXX_DiscardUnknown() {
+ xxx_messageInfo_Eutra.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Eutra proto.InternalMessageInfo
+
+type NeighbourInformation struct {
+ Ecgi string `protobuf:"bytes,1,opt,name=ecgi,proto3" json:"ecgi,omitempty"`
+ Pci uint32 `protobuf:"varint,2,opt,name=pci,proto3" json:"pci,omitempty"`
+ EarFcn uint32 `protobuf:"varint,3,opt,name=ear_fcn,json=earFcn,proto3" json:"ear_fcn,omitempty"`
+ Tac string `protobuf:"bytes,4,opt,name=tac,proto3" json:"tac,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NeighbourInformation) Reset() { *m = NeighbourInformation{} }
+func (m *NeighbourInformation) String() string { return proto.CompactTextString(m) }
+func (*NeighbourInformation) ProtoMessage() {}
+func (*NeighbourInformation) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{4}
+}
+
+func (m *NeighbourInformation) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NeighbourInformation.Unmarshal(m, b)
+}
+func (m *NeighbourInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NeighbourInformation.Marshal(b, m, deterministic)
+}
+func (m *NeighbourInformation) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NeighbourInformation.Merge(m, src)
+}
+func (m *NeighbourInformation) XXX_Size() int {
+ return xxx_messageInfo_NeighbourInformation.Size(m)
+}
+func (m *NeighbourInformation) XXX_DiscardUnknown() {
+ xxx_messageInfo_NeighbourInformation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NeighbourInformation proto.InternalMessageInfo
+
+func (m *NeighbourInformation) GetEcgi() string {
+ if m != nil {
+ return m.Ecgi
+ }
+ return ""
+}
+
+func (m *NeighbourInformation) GetPci() uint32 {
+ if m != nil {
+ return m.Pci
+ }
+ return 0
+}
+
+func (m *NeighbourInformation) GetEarFcn() uint32 {
+ if m != nil {
+ return m.EarFcn
+ }
+ return 0
+}
+
+func (m *NeighbourInformation) GetTac() string {
+ if m != nil {
+ return m.Tac
+ }
+ return ""
+}
+
+type MbsfnSubframe struct {
+ RadioframeAllocationPeriod RadioframeAllocationPeriod `protobuf:"varint,1,opt,name=radioframe_allocation_period,json=radioframeAllocationPeriod,proto3,enum=entities.RadioframeAllocationPeriod" json:"radioframe_allocation_period,omitempty"`
+ RadioframeAllocationOffset uint32 `protobuf:"varint,2,opt,name=radioframe_allocation_offset,json=radioframeAllocationOffset,proto3" json:"radioframe_allocation_offset,omitempty"`
+ SubframeAllocation string `protobuf:"bytes,3,opt,name=subframe_allocation,json=subframeAllocation,proto3" json:"subframe_allocation,omitempty"`
+ SubframeAllocationType SubframeAllocationType `protobuf:"varint,4,opt,name=subframe_allocation_type,json=subframeAllocationType,proto3,enum=entities.SubframeAllocationType" json:"subframe_allocation_type,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *MbsfnSubframe) Reset() { *m = MbsfnSubframe{} }
+func (m *MbsfnSubframe) String() string { return proto.CompactTextString(m) }
+func (*MbsfnSubframe) ProtoMessage() {}
+func (*MbsfnSubframe) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{5}
+}
+
+func (m *MbsfnSubframe) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_MbsfnSubframe.Unmarshal(m, b)
+}
+func (m *MbsfnSubframe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_MbsfnSubframe.Marshal(b, m, deterministic)
+}
+func (m *MbsfnSubframe) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MbsfnSubframe.Merge(m, src)
+}
+func (m *MbsfnSubframe) XXX_Size() int {
+ return xxx_messageInfo_MbsfnSubframe.Size(m)
+}
+func (m *MbsfnSubframe) XXX_DiscardUnknown() {
+ xxx_messageInfo_MbsfnSubframe.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MbsfnSubframe proto.InternalMessageInfo
+
+func (m *MbsfnSubframe) GetRadioframeAllocationPeriod() RadioframeAllocationPeriod {
+ if m != nil {
+ return m.RadioframeAllocationPeriod
+ }
+ return RadioframeAllocationPeriod_UNKNOWN_RADIOFRAME_ALLOCATION_PERIOD
+}
+
+func (m *MbsfnSubframe) GetRadioframeAllocationOffset() uint32 {
+ if m != nil {
+ return m.RadioframeAllocationOffset
+ }
+ return 0
+}
+
+func (m *MbsfnSubframe) GetSubframeAllocation() string {
+ if m != nil {
+ return m.SubframeAllocation
+ }
+ return ""
+}
+
+func (m *MbsfnSubframe) GetSubframeAllocationType() SubframeAllocationType {
+ if m != nil {
+ return m.SubframeAllocationType
+ }
+ return SubframeAllocationType_UNKNOWN_SUBFRAME_ALLOCATION_TYPE
+}
+
+type PrachConfiguration struct {
+ RootSequenceIndex uint32 `protobuf:"varint,1,opt,name=root_sequence_index,json=rootSequenceIndex,proto3" json:"root_sequence_index,omitempty"`
+ ZeroCorrelationZoneConfiguration uint32 `protobuf:"varint,2,opt,name=zero_correlation_zone_configuration,json=zeroCorrelationZoneConfiguration,proto3" json:"zero_correlation_zone_configuration,omitempty"`
+ HighSpeedFlag bool `protobuf:"varint,3,opt,name=high_speed_flag,json=highSpeedFlag,proto3" json:"high_speed_flag,omitempty"`
+ PrachFrequencyOffset uint32 `protobuf:"varint,4,opt,name=prach_frequency_offset,json=prachFrequencyOffset,proto3" json:"prach_frequency_offset,omitempty"`
+ PrachConfigurationIndex uint32 `protobuf:"varint,5,opt,name=prach_configuration_index,json=prachConfigurationIndex,proto3" json:"prach_configuration_index,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *PrachConfiguration) Reset() { *m = PrachConfiguration{} }
+func (m *PrachConfiguration) String() string { return proto.CompactTextString(m) }
+func (*PrachConfiguration) ProtoMessage() {}
+func (*PrachConfiguration) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{6}
+}
+
+func (m *PrachConfiguration) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_PrachConfiguration.Unmarshal(m, b)
+}
+func (m *PrachConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_PrachConfiguration.Marshal(b, m, deterministic)
+}
+func (m *PrachConfiguration) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_PrachConfiguration.Merge(m, src)
+}
+func (m *PrachConfiguration) XXX_Size() int {
+ return xxx_messageInfo_PrachConfiguration.Size(m)
+}
+func (m *PrachConfiguration) XXX_DiscardUnknown() {
+ xxx_messageInfo_PrachConfiguration.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PrachConfiguration proto.InternalMessageInfo
+
+func (m *PrachConfiguration) GetRootSequenceIndex() uint32 {
+ if m != nil {
+ return m.RootSequenceIndex
+ }
+ return 0
+}
+
+func (m *PrachConfiguration) GetZeroCorrelationZoneConfiguration() uint32 {
+ if m != nil {
+ return m.ZeroCorrelationZoneConfiguration
+ }
+ return 0
+}
+
+func (m *PrachConfiguration) GetHighSpeedFlag() bool {
+ if m != nil {
+ return m.HighSpeedFlag
+ }
+ return false
+}
+
+func (m *PrachConfiguration) GetPrachFrequencyOffset() uint32 {
+ if m != nil {
+ return m.PrachFrequencyOffset
+ }
+ return 0
+}
+
+func (m *PrachConfiguration) GetPrachConfigurationIndex() uint32 {
+ if m != nil {
+ return m.PrachConfigurationIndex
+ }
+ return 0
+}
+
+type TddInfo struct {
+ EarFcn uint32 `protobuf:"varint,1,opt,name=ear_fcn,json=earFcn,proto3" json:"ear_fcn,omitempty"`
+ TransmissionBandwidth TransmissionBandwidth `protobuf:"varint,2,opt,name=transmission_bandwidth,json=transmissionBandwidth,proto3,enum=entities.TransmissionBandwidth" json:"transmission_bandwidth,omitempty"`
+ SubframeAssignment SubframeAssignment `protobuf:"varint,3,opt,name=subframe_assignment,json=subframeAssignment,proto3,enum=entities.SubframeAssignment" json:"subframe_assignment,omitempty"`
+ SpecialSubframeInfo *SpecialSubframeInfo `protobuf:"bytes,4,opt,name=special_subframe_info,json=specialSubframeInfo,proto3" json:"special_subframe_info,omitempty"`
+ AdditionalSpecialSubframeInfo *AdditionalSpecialSubframeInfo `protobuf:"bytes,5,opt,name=additional_special_subframe_info,json=additionalSpecialSubframeInfo,proto3" json:"additional_special_subframe_info,omitempty"`
+ AdditionalSpecialSubframeExtensionInfo *AdditionalSpecialSubframeExtensionInfo `protobuf:"bytes,6,opt,name=additional_special_subframe_extension_info,json=additionalSpecialSubframeExtensionInfo,proto3" json:"additional_special_subframe_extension_info,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *TddInfo) Reset() { *m = TddInfo{} }
+func (m *TddInfo) String() string { return proto.CompactTextString(m) }
+func (*TddInfo) ProtoMessage() {}
+func (*TddInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{7}
+}
+
+func (m *TddInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_TddInfo.Unmarshal(m, b)
+}
+func (m *TddInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_TddInfo.Marshal(b, m, deterministic)
+}
+func (m *TddInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TddInfo.Merge(m, src)
+}
+func (m *TddInfo) XXX_Size() int {
+ return xxx_messageInfo_TddInfo.Size(m)
+}
+func (m *TddInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_TddInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TddInfo proto.InternalMessageInfo
+
+func (m *TddInfo) GetEarFcn() uint32 {
+ if m != nil {
+ return m.EarFcn
+ }
+ return 0
+}
+
+func (m *TddInfo) GetTransmissionBandwidth() TransmissionBandwidth {
+ if m != nil {
+ return m.TransmissionBandwidth
+ }
+ return TransmissionBandwidth_UNKNOWN_TRANSMISSION_BANDWIDTH
+}
+
+func (m *TddInfo) GetSubframeAssignment() SubframeAssignment {
+ if m != nil {
+ return m.SubframeAssignment
+ }
+ return SubframeAssignment_UNKNOWN_SUBFRAME_ASSIGNMENT
+}
+
+func (m *TddInfo) GetSpecialSubframeInfo() *SpecialSubframeInfo {
+ if m != nil {
+ return m.SpecialSubframeInfo
+ }
+ return nil
+}
+
+func (m *TddInfo) GetAdditionalSpecialSubframeInfo() *AdditionalSpecialSubframeInfo {
+ if m != nil {
+ return m.AdditionalSpecialSubframeInfo
+ }
+ return nil
+}
+
+func (m *TddInfo) GetAdditionalSpecialSubframeExtensionInfo() *AdditionalSpecialSubframeExtensionInfo {
+ if m != nil {
+ return m.AdditionalSpecialSubframeExtensionInfo
+ }
+ return nil
+}
+
+type AdditionalSpecialSubframeExtensionInfo struct {
+ AdditionalSpecialSubframePatternsExtension AdditionalSpecialSubframePatterns_Extension `protobuf:"varint,1,opt,name=additional_special_subframe_patterns_extension,json=additionalSpecialSubframePatternsExtension,proto3,enum=entities.AdditionalSpecialSubframePatterns_Extension" json:"additional_special_subframe_patterns_extension,omitempty"`
+ CyclicPrefixDl CyclicPrefix `protobuf:"varint,2,opt,name=cyclic_prefix_dl,json=cyclicPrefixDl,proto3,enum=entities.CyclicPrefix" json:"cyclic_prefix_dl,omitempty"`
+ CyclicPrefixUl CyclicPrefix `protobuf:"varint,3,opt,name=cyclic_prefix_ul,json=cyclicPrefixUl,proto3,enum=entities.CyclicPrefix" json:"cyclic_prefix_ul,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *AdditionalSpecialSubframeExtensionInfo) Reset() {
+ *m = AdditionalSpecialSubframeExtensionInfo{}
+}
+func (m *AdditionalSpecialSubframeExtensionInfo) String() string { return proto.CompactTextString(m) }
+func (*AdditionalSpecialSubframeExtensionInfo) ProtoMessage() {}
+func (*AdditionalSpecialSubframeExtensionInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{8}
+}
+
+func (m *AdditionalSpecialSubframeExtensionInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_AdditionalSpecialSubframeExtensionInfo.Unmarshal(m, b)
+}
+func (m *AdditionalSpecialSubframeExtensionInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_AdditionalSpecialSubframeExtensionInfo.Marshal(b, m, deterministic)
+}
+func (m *AdditionalSpecialSubframeExtensionInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AdditionalSpecialSubframeExtensionInfo.Merge(m, src)
+}
+func (m *AdditionalSpecialSubframeExtensionInfo) XXX_Size() int {
+ return xxx_messageInfo_AdditionalSpecialSubframeExtensionInfo.Size(m)
+}
+func (m *AdditionalSpecialSubframeExtensionInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_AdditionalSpecialSubframeExtensionInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AdditionalSpecialSubframeExtensionInfo proto.InternalMessageInfo
+
+func (m *AdditionalSpecialSubframeExtensionInfo) GetAdditionalSpecialSubframePatternsExtension() AdditionalSpecialSubframePatterns_Extension {
+ if m != nil {
+ return m.AdditionalSpecialSubframePatternsExtension
+ }
+ return AdditionalSpecialSubframePatterns_UNKNOWN
+}
+
+func (m *AdditionalSpecialSubframeExtensionInfo) GetCyclicPrefixDl() CyclicPrefix {
+ if m != nil {
+ return m.CyclicPrefixDl
+ }
+ return CyclicPrefix_UNKNOWN_CYCLIC_PREFIX
+}
+
+func (m *AdditionalSpecialSubframeExtensionInfo) GetCyclicPrefixUl() CyclicPrefix {
+ if m != nil {
+ return m.CyclicPrefixUl
+ }
+ return CyclicPrefix_UNKNOWN_CYCLIC_PREFIX
+}
+
+type AdditionalSpecialSubframeInfo struct {
+ AdditionalSpecialSubframePatterns AdditionalSpecialSubframe_Patterns `protobuf:"varint,1,opt,name=additional_special_subframe_patterns,json=additionalSpecialSubframePatterns,proto3,enum=entities.AdditionalSpecialSubframe_Patterns" json:"additional_special_subframe_patterns,omitempty"`
+ CyclicPrefixDl CyclicPrefix `protobuf:"varint,2,opt,name=cyclic_prefix_dl,json=cyclicPrefixDl,proto3,enum=entities.CyclicPrefix" json:"cyclic_prefix_dl,omitempty"`
+ CyclicPrefixUl CyclicPrefix `protobuf:"varint,3,opt,name=cyclic_prefix_ul,json=cyclicPrefixUl,proto3,enum=entities.CyclicPrefix" json:"cyclic_prefix_ul,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *AdditionalSpecialSubframeInfo) Reset() { *m = AdditionalSpecialSubframeInfo{} }
+func (m *AdditionalSpecialSubframeInfo) String() string { return proto.CompactTextString(m) }
+func (*AdditionalSpecialSubframeInfo) ProtoMessage() {}
+func (*AdditionalSpecialSubframeInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{9}
+}
+
+func (m *AdditionalSpecialSubframeInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_AdditionalSpecialSubframeInfo.Unmarshal(m, b)
+}
+func (m *AdditionalSpecialSubframeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_AdditionalSpecialSubframeInfo.Marshal(b, m, deterministic)
+}
+func (m *AdditionalSpecialSubframeInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AdditionalSpecialSubframeInfo.Merge(m, src)
+}
+func (m *AdditionalSpecialSubframeInfo) XXX_Size() int {
+ return xxx_messageInfo_AdditionalSpecialSubframeInfo.Size(m)
+}
+func (m *AdditionalSpecialSubframeInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_AdditionalSpecialSubframeInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AdditionalSpecialSubframeInfo proto.InternalMessageInfo
+
+func (m *AdditionalSpecialSubframeInfo) GetAdditionalSpecialSubframePatterns() AdditionalSpecialSubframe_Patterns {
+ if m != nil {
+ return m.AdditionalSpecialSubframePatterns
+ }
+ return AdditionalSpecialSubframe_UNKNOWN
+}
+
+func (m *AdditionalSpecialSubframeInfo) GetCyclicPrefixDl() CyclicPrefix {
+ if m != nil {
+ return m.CyclicPrefixDl
+ }
+ return CyclicPrefix_UNKNOWN_CYCLIC_PREFIX
+}
+
+func (m *AdditionalSpecialSubframeInfo) GetCyclicPrefixUl() CyclicPrefix {
+ if m != nil {
+ return m.CyclicPrefixUl
+ }
+ return CyclicPrefix_UNKNOWN_CYCLIC_PREFIX
+}
+
+type FddInfo struct {
+ UlearFcn uint32 `protobuf:"varint,1,opt,name=ulear_fcn,json=ulearFcn,proto3" json:"ulear_fcn,omitempty"`
+ DlearFcn uint32 `protobuf:"varint,2,opt,name=dlear_fcn,json=dlearFcn,proto3" json:"dlear_fcn,omitempty"`
+ UlTransmissionBandwidth TransmissionBandwidth `protobuf:"varint,3,opt,name=ul_transmission_bandwidth,json=ulTransmissionBandwidth,proto3,enum=entities.TransmissionBandwidth" json:"ul_transmission_bandwidth,omitempty"`
+ DlTransmissionBandwidth TransmissionBandwidth `protobuf:"varint,4,opt,name=dl_transmission_bandwidth,json=dlTransmissionBandwidth,proto3,enum=entities.TransmissionBandwidth" json:"dl_transmission_bandwidth,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FddInfo) Reset() { *m = FddInfo{} }
+func (m *FddInfo) String() string { return proto.CompactTextString(m) }
+func (*FddInfo) ProtoMessage() {}
+func (*FddInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{10}
+}
+
+func (m *FddInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FddInfo.Unmarshal(m, b)
+}
+func (m *FddInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FddInfo.Marshal(b, m, deterministic)
+}
+func (m *FddInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FddInfo.Merge(m, src)
+}
+func (m *FddInfo) XXX_Size() int {
+ return xxx_messageInfo_FddInfo.Size(m)
+}
+func (m *FddInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_FddInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FddInfo proto.InternalMessageInfo
+
+func (m *FddInfo) GetUlearFcn() uint32 {
+ if m != nil {
+ return m.UlearFcn
+ }
+ return 0
+}
+
+func (m *FddInfo) GetDlearFcn() uint32 {
+ if m != nil {
+ return m.DlearFcn
+ }
+ return 0
+}
+
+func (m *FddInfo) GetUlTransmissionBandwidth() TransmissionBandwidth {
+ if m != nil {
+ return m.UlTransmissionBandwidth
+ }
+ return TransmissionBandwidth_UNKNOWN_TRANSMISSION_BANDWIDTH
+}
+
+func (m *FddInfo) GetDlTransmissionBandwidth() TransmissionBandwidth {
+ if m != nil {
+ return m.DlTransmissionBandwidth
+ }
+ return TransmissionBandwidth_UNKNOWN_TRANSMISSION_BANDWIDTH
+}
+
+type SpecialSubframeInfo struct {
+ SpecialSubframePatterns SpecialSubframe_Patterns `protobuf:"varint,1,opt,name=special_subframe_patterns,json=specialSubframePatterns,proto3,enum=entities.SpecialSubframe_Patterns" json:"special_subframe_patterns,omitempty"`
+ CyclicPrefixDl CyclicPrefix `protobuf:"varint,2,opt,name=cyclic_prefix_dl,json=cyclicPrefixDl,proto3,enum=entities.CyclicPrefix" json:"cyclic_prefix_dl,omitempty"`
+ CyclicPrefixUl CyclicPrefix `protobuf:"varint,3,opt,name=cyclic_prefix_ul,json=cyclicPrefixUl,proto3,enum=entities.CyclicPrefix" json:"cyclic_prefix_ul,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SpecialSubframeInfo) Reset() { *m = SpecialSubframeInfo{} }
+func (m *SpecialSubframeInfo) String() string { return proto.CompactTextString(m) }
+func (*SpecialSubframeInfo) ProtoMessage() {}
+func (*SpecialSubframeInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{11}
+}
+
+func (m *SpecialSubframeInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SpecialSubframeInfo.Unmarshal(m, b)
+}
+func (m *SpecialSubframeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SpecialSubframeInfo.Marshal(b, m, deterministic)
+}
+func (m *SpecialSubframeInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SpecialSubframeInfo.Merge(m, src)
+}
+func (m *SpecialSubframeInfo) XXX_Size() int {
+ return xxx_messageInfo_SpecialSubframeInfo.Size(m)
+}
+func (m *SpecialSubframeInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_SpecialSubframeInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SpecialSubframeInfo proto.InternalMessageInfo
+
+func (m *SpecialSubframeInfo) GetSpecialSubframePatterns() SpecialSubframe_Patterns {
+ if m != nil {
+ return m.SpecialSubframePatterns
+ }
+ return SpecialSubframe_UNKNOWN
+}
+
+func (m *SpecialSubframeInfo) GetCyclicPrefixDl() CyclicPrefix {
+ if m != nil {
+ return m.CyclicPrefixDl
+ }
+ return CyclicPrefix_UNKNOWN_CYCLIC_PREFIX
+}
+
+func (m *SpecialSubframeInfo) GetCyclicPrefixUl() CyclicPrefix {
+ if m != nil {
+ return m.CyclicPrefixUl
+ }
+ return CyclicPrefix_UNKNOWN_CYCLIC_PREFIX
+}
+
+type SpecialSubframe struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SpecialSubframe) Reset() { *m = SpecialSubframe{} }
+func (m *SpecialSubframe) String() string { return proto.CompactTextString(m) }
+func (*SpecialSubframe) ProtoMessage() {}
+func (*SpecialSubframe) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{12}
+}
+
+func (m *SpecialSubframe) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SpecialSubframe.Unmarshal(m, b)
+}
+func (m *SpecialSubframe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SpecialSubframe.Marshal(b, m, deterministic)
+}
+func (m *SpecialSubframe) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SpecialSubframe.Merge(m, src)
+}
+func (m *SpecialSubframe) XXX_Size() int {
+ return xxx_messageInfo_SpecialSubframe.Size(m)
+}
+func (m *SpecialSubframe) XXX_DiscardUnknown() {
+ xxx_messageInfo_SpecialSubframe.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SpecialSubframe proto.InternalMessageInfo
+
+type AdditionalSpecialSubframe struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *AdditionalSpecialSubframe) Reset() { *m = AdditionalSpecialSubframe{} }
+func (m *AdditionalSpecialSubframe) String() string { return proto.CompactTextString(m) }
+func (*AdditionalSpecialSubframe) ProtoMessage() {}
+func (*AdditionalSpecialSubframe) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{13}
+}
+
+func (m *AdditionalSpecialSubframe) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_AdditionalSpecialSubframe.Unmarshal(m, b)
+}
+func (m *AdditionalSpecialSubframe) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_AdditionalSpecialSubframe.Marshal(b, m, deterministic)
+}
+func (m *AdditionalSpecialSubframe) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AdditionalSpecialSubframe.Merge(m, src)
+}
+func (m *AdditionalSpecialSubframe) XXX_Size() int {
+ return xxx_messageInfo_AdditionalSpecialSubframe.Size(m)
+}
+func (m *AdditionalSpecialSubframe) XXX_DiscardUnknown() {
+ xxx_messageInfo_AdditionalSpecialSubframe.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AdditionalSpecialSubframe proto.InternalMessageInfo
+
+type AdditionalSpecialSubframePatterns struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *AdditionalSpecialSubframePatterns) Reset() { *m = AdditionalSpecialSubframePatterns{} }
+func (m *AdditionalSpecialSubframePatterns) String() string { return proto.CompactTextString(m) }
+func (*AdditionalSpecialSubframePatterns) ProtoMessage() {}
+func (*AdditionalSpecialSubframePatterns) Descriptor() ([]byte, []int) {
+ return fileDescriptor_4640cfb595a9e9c8, []int{14}
+}
+
+func (m *AdditionalSpecialSubframePatterns) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_AdditionalSpecialSubframePatterns.Unmarshal(m, b)
+}
+func (m *AdditionalSpecialSubframePatterns) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_AdditionalSpecialSubframePatterns.Marshal(b, m, deterministic)
+}
+func (m *AdditionalSpecialSubframePatterns) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AdditionalSpecialSubframePatterns.Merge(m, src)
+}
+func (m *AdditionalSpecialSubframePatterns) XXX_Size() int {
+ return xxx_messageInfo_AdditionalSpecialSubframePatterns.Size(m)
+}
+func (m *AdditionalSpecialSubframePatterns) XXX_DiscardUnknown() {
+ xxx_messageInfo_AdditionalSpecialSubframePatterns.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AdditionalSpecialSubframePatterns proto.InternalMessageInfo
+
+func init() {
+ proto.RegisterEnum("entities.FreqBandIndicatorPriority", FreqBandIndicatorPriority_name, FreqBandIndicatorPriority_value)
+ proto.RegisterEnum("entities.BandwidthReducedSI", BandwidthReducedSI_name, BandwidthReducedSI_value)
+ proto.RegisterEnum("entities.SubframeAllocationType", SubframeAllocationType_name, SubframeAllocationType_value)
+ proto.RegisterEnum("entities.RadioframeAllocationPeriod", RadioframeAllocationPeriod_name, RadioframeAllocationPeriod_value)
+ proto.RegisterEnum("entities.NumberOfAntennaPorts", NumberOfAntennaPorts_name, NumberOfAntennaPorts_value)
+ proto.RegisterEnum("entities.EnbType", EnbType_name, EnbType_value)
+ proto.RegisterEnum("entities.SubframeAssignment", SubframeAssignment_name, SubframeAssignment_value)
+ proto.RegisterEnum("entities.CyclicPrefix", CyclicPrefix_name, CyclicPrefix_value)
+ proto.RegisterEnum("entities.TransmissionBandwidth", TransmissionBandwidth_name, TransmissionBandwidth_value)
+ proto.RegisterEnum("entities.Eutra_Mode", Eutra_Mode_name, Eutra_Mode_value)
+ proto.RegisterEnum("entities.SpecialSubframe_Patterns", SpecialSubframe_Patterns_name, SpecialSubframe_Patterns_value)
+ proto.RegisterEnum("entities.AdditionalSpecialSubframe_Patterns", AdditionalSpecialSubframe_Patterns_name, AdditionalSpecialSubframe_Patterns_value)
+ proto.RegisterEnum("entities.AdditionalSpecialSubframePatterns_Extension", AdditionalSpecialSubframePatterns_Extension_name, AdditionalSpecialSubframePatterns_Extension_value)
+ proto.RegisterType((*Enb)(nil), "entities.Enb")
+ proto.RegisterType((*ServedCellInfo)(nil), "entities.ServedCellInfo")
+ proto.RegisterType((*ChoiceEUTRAMode)(nil), "entities.ChoiceEUTRAMode")
+ proto.RegisterType((*Eutra)(nil), "entities.Eutra")
+ proto.RegisterType((*NeighbourInformation)(nil), "entities.NeighbourInformation")
+ proto.RegisterType((*MbsfnSubframe)(nil), "entities.MbsfnSubframe")
+ proto.RegisterType((*PrachConfiguration)(nil), "entities.PrachConfiguration")
+ proto.RegisterType((*TddInfo)(nil), "entities.TddInfo")
+ proto.RegisterType((*AdditionalSpecialSubframeExtensionInfo)(nil), "entities.AdditionalSpecialSubframeExtensionInfo")
+ proto.RegisterType((*AdditionalSpecialSubframeInfo)(nil), "entities.AdditionalSpecialSubframeInfo")
+ proto.RegisterType((*FddInfo)(nil), "entities.FddInfo")
+ proto.RegisterType((*SpecialSubframeInfo)(nil), "entities.SpecialSubframeInfo")
+ proto.RegisterType((*SpecialSubframe)(nil), "entities.SpecialSubframe")
+ proto.RegisterType((*AdditionalSpecialSubframe)(nil), "entities.AdditionalSpecialSubframe")
+ proto.RegisterType((*AdditionalSpecialSubframePatterns)(nil), "entities.AdditionalSpecialSubframePatterns")
+}
+
+func init() { proto.RegisterFile("enb.proto", fileDescriptor_4640cfb595a9e9c8) }
+
+var fileDescriptor_4640cfb595a9e9c8 = []byte{
+ // 1869 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4b, 0x73, 0xdb, 0xc8,
+ 0x11, 0x36, 0x1f, 0xe2, 0xa3, 0x65, 0x51, 0xf0, 0x48, 0x96, 0xa8, 0xb5, 0xbc, 0xe6, 0x52, 0x8e,
+ 0x57, 0xc5, 0xda, 0x52, 0x24, 0x4a, 0xf2, 0x6e, 0x92, 0x43, 0x16, 0x24, 0x41, 0x0b, 0x15, 0x11,
+ 0xe0, 0x0e, 0xa8, 0xd5, 0x7a, 0xb7, 0x92, 0x29, 0x10, 0x18, 0x52, 0xa8, 0x80, 0x00, 0x0d, 0x80,
+ 0x89, 0xb5, 0xa9, 0x54, 0xe5, 0x90, 0x63, 0x4e, 0x39, 0x25, 0x87, 0x5c, 0x72, 0xcf, 0xdf, 0x48,
+ 0xe5, 0x7f, 0xe4, 0x57, 0xe4, 0x90, 0xaa, 0xd4, 0x0c, 0x1e, 0x04, 0x4d, 0xca, 0xd6, 0x29, 0xb5,
+ 0x27, 0x35, 0xba, 0xbf, 0x7e, 0x4c, 0x4f, 0xf7, 0x47, 0x40, 0x50, 0xa6, 0xce, 0xf0, 0x68, 0xea,
+ 0xb9, 0x81, 0x8b, 0x4a, 0xd4, 0x09, 0xac, 0xc0, 0xa2, 0x7e, 0xfd, 0xcf, 0x19, 0xc8, 0x49, 0xce,
+ 0x10, 0x7d, 0x06, 0x25, 0xea, 0x0c, 0x49, 0x70, 0x3b, 0xa5, 0xd5, 0x4c, 0x2d, 0x73, 0x58, 0x69,
+ 0x3e, 0x3a, 0x8a, 0x41, 0x47, 0x92, 0x33, 0x1c, 0xdc, 0x4e, 0x29, 0x2e, 0xd2, 0x50, 0x40, 0x3f,
+ 0x83, 0x87, 0x3e, 0xf5, 0x7e, 0x43, 0x4d, 0x62, 0x50, 0xdb, 0xf6, 0xab, 0xd9, 0x5a, 0xee, 0x70,
+ 0xbd, 0x59, 0x9d, 0x7b, 0x68, 0xdc, 0xda, 0xa6, 0xb6, 0x2d, 0x3b, 0x23, 0x17, 0xaf, 0xfb, 0xc9,
+ 0xb3, 0x8f, 0x6a, 0xf0, 0x70, 0x3c, 0x23, 0x63, 0xcf, 0x9d, 0x4d, 0x89, 0x65, 0xfa, 0xd5, 0x5c,
+ 0x2d, 0x77, 0x58, 0xc6, 0x30, 0x9e, 0xbd, 0x62, 0x2a, 0xd9, 0xf4, 0xeb, 0xff, 0x2e, 0x40, 0x65,
+ 0x31, 0x02, 0x12, 0x20, 0x37, 0x35, 0x2c, 0x5e, 0xda, 0x06, 0x66, 0x22, 0xda, 0x85, 0x22, 0x4b,
+ 0x4e, 0x2c, 0xb3, 0x9a, 0xad, 0x65, 0x0e, 0xcb, 0xb8, 0xc0, 0x1e, 0x65, 0x93, 0x41, 0x03, 0xdd,
+ 0xa8, 0xe6, 0xb8, 0x92, 0x89, 0xe8, 0x53, 0xd8, 0x1c, 0x7a, 0xae, 0x6e, 0x1a, 0xba, 0x1f, 0x90,
+ 0xa9, 0x3d, 0x71, 0xfc, 0x6a, 0x9e, 0x27, 0xad, 0x24, 0xea, 0x3e, 0xd3, 0x22, 0x09, 0x1e, 0x19,
+ 0x37, 0xae, 0x65, 0x50, 0x42, 0x67, 0x81, 0xa7, 0x93, 0x89, 0x6b, 0xd2, 0xea, 0x5a, 0x2d, 0x73,
+ 0xb8, 0xde, 0xdc, 0x9b, 0x1f, 0xae, 0xcd, 0x21, 0xd2, 0xd5, 0x00, 0x8b, 0x3d, 0xd7, 0xa4, 0x78,
+ 0x33, 0xf4, 0x91, 0x98, 0x0b, 0x53, 0xa0, 0x53, 0x80, 0x94, 0x7f, 0x81, 0xb7, 0x73, 0x3b, 0xd5,
+ 0x4e, 0x66, 0x3b, 0xe2, 0xae, 0x65, 0x9a, 0x38, 0x5d, 0xc1, 0xae, 0x33, 0x9b, 0x0c, 0xa9, 0x47,
+ 0xdc, 0x11, 0xd1, 0x9d, 0x80, 0x3a, 0x8e, 0x4e, 0xa6, 0xae, 0x17, 0xf8, 0xd5, 0x22, 0x8f, 0xf0,
+ 0xf1, 0x3c, 0x82, 0xc2, 0x81, 0xea, 0x48, 0x0c, 0x61, 0x7d, 0x86, 0xc2, 0xdb, 0xce, 0x0a, 0x2d,
+ 0xea, 0xc1, 0xd6, 0xd4, 0xd3, 0x8d, 0x1b, 0x62, 0xb8, 0xce, 0xc8, 0x1a, 0xcf, 0x3c, 0x3d, 0xb0,
+ 0x5c, 0xa7, 0x5a, 0xe2, 0x87, 0xda, 0x9f, 0x87, 0xec, 0x33, 0x50, 0x3b, 0x8d, 0xc1, 0x68, 0xba,
+ 0xa4, 0x43, 0x32, 0x6c, 0x4f, 0x86, 0xfe, 0xc8, 0x21, 0xfe, 0x6c, 0x38, 0xf2, 0xf4, 0x09, 0x25,
+ 0x96, 0x33, 0x72, 0xfd, 0x6a, 0x99, 0x4f, 0xc0, 0xee, 0x3c, 0x5e, 0x8f, 0xa1, 0xb4, 0x08, 0x84,
+ 0xd1, 0x24, 0xfd, 0xc8, 0x6e, 0xd4, 0x47, 0x8f, 0xa1, 0x60, 0xf8, 0x63, 0x76, 0x7f, 0xc0, 0xaf,
+ 0x6a, 0xcd, 0xf0, 0xc7, 0xb2, 0x89, 0x7e, 0x0e, 0xfb, 0x93, 0xe1, 0xc4, 0x27, 0x6c, 0x64, 0xd8,
+ 0x4d, 0xe8, 0x1e, 0xd5, 0x89, 0x65, 0xc6, 0x81, 0xab, 0xeb, 0xfc, 0xe6, 0xf6, 0x18, 0x46, 0x0b,
+ 0x21, 0xa2, 0x47, 0x75, 0x39, 0x01, 0xb0, 0xdb, 0x9e, 0xcc, 0xec, 0xc0, 0x1a, 0xea, 0x8e, 0x19,
+ 0x55, 0xf7, 0xb0, 0x96, 0x3b, 0xdc, 0xc0, 0x95, 0x44, 0x1d, 0x16, 0x60, 0xc2, 0xfe, 0xc8, 0xa3,
+ 0x6f, 0x48, 0x04, 0x34, 0x2d, 0x43, 0x0f, 0x5c, 0x8f, 0x4c, 0x3d, 0xcb, 0xf5, 0xac, 0xe0, 0xb6,
+ 0xba, 0xc1, 0xdb, 0x7e, 0x30, 0x3f, 0x53, 0xd7, 0xa3, 0x6f, 0x5a, 0xdc, 0x3d, 0xc2, 0xf6, 0x23,
+ 0x28, 0xde, 0x1b, 0xdd, 0x65, 0x42, 0x0a, 0x6c, 0xb3, 0x04, 0xbf, 0xb5, 0xcc, 0xe0, 0x86, 0x78,
+ 0xd4, 0x9c, 0x19, 0xd4, 0x24, 0xbe, 0x55, 0xad, 0xf0, 0xe8, 0xa9, 0x1b, 0x68, 0xc5, 0x28, 0x1c,
+ 0x82, 0x34, 0x19, 0xa3, 0xe1, 0xbb, 0x3a, 0x0b, 0xbd, 0x82, 0x4d, 0x87, 0x5a, 0xe3, 0x9b, 0xa1,
+ 0x3b, 0xf3, 0xa2, 0xe3, 0x6d, 0xf2, 0xe6, 0xa7, 0xe7, 0x23, 0x06, 0xb0, 0x83, 0x7a, 0x93, 0xf0,
+ 0x3a, 0x2b, 0x4e, 0x5a, 0xeb, 0xd7, 0xbf, 0x83, 0xcd, 0x77, 0x26, 0x19, 0x1d, 0x40, 0x6e, 0x64,
+ 0x9a, 0x7c, 0xcb, 0xd6, 0xd3, 0x04, 0xd0, 0x35, 0x79, 0xcb, 0x30, 0xb3, 0x32, 0x50, 0x60, 0x86,
+ 0x4b, 0xb7, 0x00, 0x1a, 0xc4, 0xa0, 0xc0, 0x34, 0xeb, 0x47, 0xb0, 0xc6, 0xc7, 0xbc, 0xfe, 0x23,
+ 0xc8, 0xf3, 0xd0, 0xeb, 0x50, 0xbc, 0x52, 0x7e, 0xa1, 0xa8, 0xd7, 0x8a, 0xf0, 0x00, 0x15, 0x21,
+ 0xd7, 0xed, 0x74, 0x84, 0x0c, 0x13, 0x06, 0x9d, 0x8e, 0x90, 0xad, 0x8f, 0x61, 0x7b, 0x55, 0xd1,
+ 0x08, 0x41, 0x9e, 0x1a, 0xe3, 0x70, 0xf1, 0xcb, 0x98, 0xcb, 0x31, 0x17, 0x64, 0x17, 0xb8, 0x80,
+ 0xea, 0x1e, 0x19, 0x19, 0x0e, 0x5f, 0xfb, 0x0d, 0x5c, 0xa0, 0xba, 0xd7, 0x35, 0x9c, 0x98, 0x0b,
+ 0xf2, 0x09, 0x17, 0xd4, 0xff, 0x99, 0x85, 0x8d, 0x85, 0xd9, 0x44, 0x23, 0xd8, 0xf7, 0x74, 0xd3,
+ 0x72, 0xc3, 0x71, 0xd6, 0x6d, 0xdb, 0x35, 0x78, 0x6e, 0x32, 0xa5, 0x9e, 0xe5, 0x9a, 0x11, 0x1d,
+ 0x3e, 0x9f, 0x1f, 0x14, 0x27, 0x68, 0x31, 0x01, 0xf7, 0x39, 0x16, 0x7f, 0xe4, 0xdd, 0x69, 0x43,
+ 0x5f, 0xde, 0x95, 0xc7, 0x1d, 0x8d, 0x7c, 0x1a, 0x44, 0xe7, 0x59, 0x19, 0x41, 0xe5, 0x08, 0xf4,
+ 0x63, 0xd8, 0x4a, 0xd6, 0x6e, 0xee, 0x1f, 0x31, 0x1d, 0x8a, 0x4d, 0x73, 0x37, 0xf4, 0x2d, 0x54,
+ 0x57, 0x38, 0x84, 0x2c, 0x9f, 0xe7, 0xc7, 0xaa, 0xa5, 0x38, 0x7b, 0xc9, 0x9f, 0x93, 0xfe, 0x8e,
+ 0xbf, 0x52, 0x5f, 0xff, 0x47, 0x16, 0xd0, 0x32, 0x69, 0xa0, 0x23, 0xd8, 0xf2, 0x5c, 0x37, 0x20,
+ 0x3e, 0x7d, 0x33, 0xa3, 0x8e, 0xc1, 0xf8, 0xc1, 0xa4, 0x6f, 0x23, 0xe2, 0x7e, 0xc4, 0x4c, 0x5a,
+ 0x64, 0x91, 0x99, 0x01, 0xf5, 0xe0, 0xe0, 0x7b, 0xea, 0xb9, 0xc4, 0x70, 0x3d, 0x8f, 0xda, 0x61,
+ 0x7d, 0xdf, 0xbb, 0x0e, 0x7d, 0x87, 0xaf, 0xc2, 0xe6, 0xd4, 0x18, 0xb4, 0x3d, 0x47, 0x7e, 0xeb,
+ 0x3a, 0x74, 0x31, 0xfd, 0x0b, 0xd8, 0xbc, 0xb1, 0xc6, 0x37, 0xc4, 0x9f, 0x52, 0x6a, 0x92, 0x91,
+ 0xad, 0x8f, 0x79, 0x7b, 0x4a, 0x78, 0x83, 0xa9, 0x35, 0xa6, 0xed, 0xda, 0xfa, 0x18, 0x9d, 0xc1,
+ 0x4e, 0x48, 0x8b, 0x6c, 0x71, 0x59, 0x39, 0xb7, 0xf1, 0x35, 0xe4, 0x79, 0xa6, 0x6d, 0x6e, 0xed,
+ 0xc6, 0xc6, 0xe8, 0x02, 0x7e, 0x0a, 0x7b, 0x2b, 0xc8, 0x34, 0x3a, 0xe2, 0x1a, 0x77, 0xdc, 0x5d,
+ 0x26, 0x4d, 0x7e, 0xd0, 0xfa, 0xdf, 0xf2, 0x50, 0x8c, 0x56, 0x24, 0x3d, 0xaf, 0x99, 0x85, 0x79,
+ 0xfd, 0x1a, 0x76, 0x02, 0x4f, 0x77, 0xfc, 0x89, 0xe5, 0xfb, 0x2c, 0x72, 0xb2, 0xff, 0xbc, 0x01,
+ 0x95, 0xe6, 0xb3, 0xd4, 0xba, 0xa5, 0x70, 0x73, 0xea, 0x78, 0x1c, 0xac, 0x52, 0xb3, 0x5f, 0x81,
+ 0xf9, 0x20, 0xf8, 0xbe, 0x35, 0x76, 0x26, 0xd4, 0x09, 0x78, 0x6b, 0x16, 0x38, 0x28, 0x99, 0x81,
+ 0x04, 0x93, 0x9a, 0xab, 0x44, 0x87, 0xbe, 0x82, 0xc7, 0xfe, 0x94, 0x1a, 0x96, 0x6e, 0x2f, 0xfe,
+ 0x0e, 0xf0, 0xe6, 0xad, 0x37, 0x9f, 0xa6, 0x02, 0x86, 0xb0, 0x34, 0xf3, 0xe3, 0x2d, 0x7f, 0x59,
+ 0x89, 0xa6, 0x50, 0xd3, 0x4d, 0xd3, 0x62, 0xfd, 0x62, 0x51, 0x57, 0x46, 0x0f, 0x7f, 0x89, 0x3f,
+ 0x9d, 0x47, 0x17, 0x13, 0x8f, 0x55, 0x79, 0x9e, 0xea, 0xef, 0x33, 0xa3, 0x3f, 0x65, 0xa0, 0xf1,
+ 0xbe, 0x94, 0xf4, 0x6d, 0x40, 0x1d, 0x3f, 0xbc, 0xdf, 0x91, 0xcb, 0x7f, 0xc6, 0xd7, 0x9b, 0xc7,
+ 0xf7, 0x48, 0x2e, 0xc5, 0x8e, 0xbc, 0x8a, 0x17, 0xfa, 0xbd, 0x70, 0xf5, 0x7f, 0x65, 0xe1, 0xc5,
+ 0xfd, 0x42, 0xa2, 0xbf, 0x66, 0xe0, 0xe8, 0x7d, 0x95, 0x4f, 0xf5, 0x20, 0xa0, 0x9e, 0xe3, 0xcf,
+ 0x8f, 0x10, 0x91, 0xd8, 0xf9, 0x3d, 0xaa, 0xef, 0x47, 0xce, 0x47, 0x49, 0x4e, 0xdc, 0xd0, 0x3f,
+ 0x04, 0x4e, 0xb0, 0xe8, 0x4b, 0x10, 0x8c, 0x5b, 0xc3, 0xb6, 0x0c, 0x32, 0xf5, 0xe8, 0xc8, 0x7a,
+ 0x4b, 0x4c, 0x3b, 0x9a, 0xdd, 0x9d, 0xd4, 0x1b, 0x14, 0x47, 0xf4, 0x39, 0x00, 0x57, 0x8c, 0xd4,
+ 0x53, 0xc7, 0x5e, 0x8e, 0x30, 0xb3, 0xa3, 0x41, 0xbd, 0x57, 0x84, 0x2b, 0xbb, 0xfe, 0xf7, 0x2c,
+ 0x3c, 0x7d, 0xef, 0x68, 0xa0, 0xdf, 0xc3, 0xf3, 0xfb, 0x34, 0x30, 0x6a, 0xdb, 0x67, 0xf7, 0x68,
+ 0xdb, 0x51, 0xdc, 0x0a, 0xfc, 0xc9, 0x07, 0xbb, 0xf5, 0x83, 0x68, 0xd2, 0x7f, 0x33, 0x50, 0x8c,
+ 0x7e, 0xd7, 0xd1, 0x13, 0x28, 0xcf, 0xec, 0x45, 0x46, 0x2a, 0x71, 0x05, 0xe3, 0xa4, 0x27, 0x50,
+ 0x36, 0x13, 0x63, 0xc8, 0xc3, 0x25, 0x33, 0x36, 0x7e, 0x07, 0x7b, 0x33, 0x9b, 0xdc, 0xc1, 0x59,
+ 0xb9, 0xfb, 0x71, 0xd6, 0xee, 0xcc, 0x5e, 0x69, 0x60, 0xc1, 0xcd, 0x3b, 0x83, 0xe7, 0xef, 0x19,
+ 0xdc, 0x5c, 0x1d, 0xbc, 0xfe, 0x9f, 0x0c, 0x6c, 0xad, 0x1a, 0x8d, 0x5f, 0xc1, 0xde, 0x87, 0xe6,
+ 0xa1, 0x7e, 0x27, 0xbf, 0xcd, 0xa7, 0x60, 0xd7, 0xff, 0x01, 0xdf, 0xfd, 0x1f, 0x33, 0xb0, 0xf9,
+ 0x4e, 0xe5, 0xf5, 0x37, 0x50, 0x4a, 0x6a, 0x5c, 0x78, 0x59, 0x2b, 0x41, 0x5e, 0xd3, 0xfa, 0xc7,
+ 0x42, 0x26, 0x92, 0x4e, 0x84, 0x6c, 0x24, 0x35, 0x85, 0x5c, 0x24, 0x9d, 0x0a, 0xf9, 0x48, 0x3a,
+ 0x13, 0xd6, 0x22, 0xe9, 0x5c, 0x28, 0x44, 0xd2, 0x4b, 0xa1, 0x18, 0x49, 0x9f, 0x0b, 0xa5, 0x48,
+ 0xfa, 0x42, 0x28, 0xd7, 0xff, 0x92, 0x81, 0xbd, 0x3b, 0x17, 0xaa, 0xfe, 0xbb, 0xff, 0x7b, 0x41,
+ 0x91, 0xf4, 0x13, 0x01, 0xea, 0x17, 0xf0, 0xc9, 0x07, 0x19, 0xb2, 0x7e, 0x00, 0xe5, 0x39, 0xf1,
+ 0x2d, 0x94, 0x58, 0x86, 0x35, 0x56, 0xd8, 0xb1, 0x90, 0x69, 0xfc, 0x1a, 0xf6, 0xee, 0xfc, 0x6e,
+ 0x40, 0x87, 0xf0, 0x3c, 0x72, 0x22, 0x5d, 0x2c, 0x7d, 0x45, 0x5a, 0xa2, 0xd2, 0x21, 0xb2, 0xd2,
+ 0x91, 0xdb, 0xe2, 0x40, 0xc5, 0xa4, 0x8f, 0x65, 0x15, 0xcb, 0x83, 0xd7, 0xc2, 0x03, 0xb4, 0x05,
+ 0x9b, 0x8a, 0x3a, 0x20, 0x2d, 0xac, 0x8a, 0x9d, 0xb6, 0xa8, 0x0d, 0x24, 0xf6, 0xfa, 0xbc, 0x09,
+ 0xeb, 0x69, 0x45, 0xb6, 0x21, 0x01, 0x5a, 0xfe, 0x8c, 0x40, 0x35, 0xd8, 0x8f, 0xb3, 0xb0, 0x04,
+ 0xd7, 0x72, 0x67, 0x70, 0x41, 0xb0, 0xd4, 0xb9, 0x6a, 0x4b, 0x1d, 0xa2, 0xc9, 0xc2, 0x03, 0xb4,
+ 0x01, 0x65, 0xad, 0x7d, 0x21, 0x75, 0xae, 0x2e, 0x59, 0xdc, 0xc6, 0x2f, 0x61, 0x67, 0xf5, 0xdb,
+ 0x20, 0x7a, 0x0e, 0xb5, 0x38, 0x94, 0x76, 0xd5, 0xea, 0x62, 0xb1, 0x27, 0x11, 0xf1, 0xf2, 0x52,
+ 0x6d, 0x8b, 0x03, 0x59, 0x55, 0xc8, 0xe0, 0x75, 0x5f, 0x0a, 0xc3, 0xa9, 0x8a, 0x44, 0xb8, 0x59,
+ 0xc8, 0xa0, 0x0a, 0x40, 0x57, 0xbd, 0xc2, 0xd1, 0x73, 0xb6, 0xf1, 0x16, 0x3e, 0xba, 0xfb, 0x1d,
+ 0x3a, 0xdd, 0x13, 0x2c, 0x76, 0x64, 0x75, 0x29, 0x49, 0x5f, 0xc2, 0xb2, 0xda, 0x11, 0x1e, 0xa0,
+ 0x02, 0x64, 0x95, 0x13, 0x21, 0xc3, 0xff, 0x36, 0x85, 0x2c, 0xff, 0x7b, 0x26, 0xe4, 0xf8, 0xdf,
+ 0x2f, 0x84, 0x3c, 0xfb, 0xba, 0x50, 0x4e, 0x5e, 0x0a, 0x6b, 0x5c, 0x38, 0x6d, 0x0a, 0x85, 0xc6,
+ 0xd7, 0xb0, 0xbd, 0xea, 0xdb, 0x19, 0x1d, 0xc0, 0xb3, 0x38, 0xa7, 0x72, 0xd5, 0x6b, 0x49, 0x98,
+ 0xa8, 0x5d, 0x22, 0x2a, 0x03, 0x49, 0x51, 0x44, 0xd2, 0x57, 0xf1, 0x40, 0x0b, 0xbf, 0x5a, 0x44,
+ 0x9e, 0x8f, 0x0b, 0x2c, 0x21, 0x17, 0xce, 0x84, 0x5c, 0x83, 0x42, 0x31, 0xfa, 0x27, 0x09, 0xda,
+ 0x06, 0x21, 0x0e, 0x25, 0x29, 0xad, 0x54, 0x47, 0x7a, 0x62, 0x1b, 0xab, 0x4c, 0x27, 0x64, 0xd0,
+ 0x43, 0x28, 0x5d, 0xa8, 0x3d, 0x89, 0x3f, 0x65, 0xd9, 0xdd, 0x6a, 0x17, 0x2a, 0x1e, 0x90, 0x39,
+ 0x24, 0x87, 0x10, 0x54, 0x2e, 0x55, 0xe5, 0x55, 0x4a, 0x97, 0x6f, 0x04, 0x80, 0x96, 0xdf, 0xd0,
+ 0xd0, 0x33, 0x78, 0xb2, 0x7c, 0x27, 0x9a, 0x26, 0xbf, 0x52, 0x7a, 0x92, 0x32, 0x08, 0x0b, 0xd7,
+ 0xc4, 0xe3, 0xb0, 0x70, 0x4d, 0x3c, 0x09, 0x0b, 0xd7, 0x44, 0xb6, 0x2d, 0x5c, 0x38, 0x0d, 0x7b,
+ 0xa5, 0x89, 0x67, 0x61, 0xaf, 0x34, 0x91, 0xad, 0x0a, 0x17, 0x5e, 0x0a, 0xc5, 0x46, 0x1b, 0x1e,
+ 0xa6, 0xd9, 0x04, 0xed, 0xc1, 0xe3, 0x38, 0x5f, 0xfb, 0x75, 0xfb, 0x52, 0x6e, 0x93, 0x3e, 0x96,
+ 0xba, 0xf2, 0x37, 0xc2, 0x03, 0x04, 0x50, 0x50, 0x54, 0xdc, 0x13, 0x2f, 0xc3, 0x33, 0x4a, 0xdf,
+ 0x0c, 0x24, 0xa5, 0xc3, 0x27, 0xf3, 0x0f, 0x19, 0x78, 0xbc, 0x9a, 0xe5, 0xeb, 0xf0, 0x71, 0x1c,
+ 0x6e, 0x80, 0x45, 0x45, 0xeb, 0xc9, 0x9a, 0xc6, 0xae, 0x39, 0x19, 0xd5, 0xf0, 0x04, 0xad, 0xeb,
+ 0x97, 0xe1, 0xc6, 0xb7, 0xae, 0x4f, 0xce, 0xc3, 0x8d, 0x6f, 0x5d, 0x37, 0xcf, 0xc3, 0x8d, 0x6f,
+ 0x5d, 0x9f, 0x1f, 0x87, 0x1b, 0xdf, 0xba, 0xfe, 0xfc, 0x5c, 0x58, 0x63, 0x0b, 0xd8, 0xba, 0x3e,
+ 0x39, 0x3e, 0x0e, 0xcf, 0xd1, 0xba, 0x3e, 0x11, 0x8a, 0xc3, 0x02, 0xff, 0xe7, 0xd7, 0xe9, 0xff,
+ 0x02, 0x00, 0x00, 0xff, 0xff, 0x10, 0x6b, 0x1a, 0x98, 0x09, 0x13, 0x00, 0x00,
+}
--- /dev/null
+syntax = "proto3";
+package entities;
+
+message Enb{
+ EnbType enb_type = 1;
+ repeated ServedCellInfo served_cells = 2;
+ repeated string gu_group_ids = 3;
+}
+
+message ServedCellInfo{
+ uint32 pci = 1;
+ string cell_id = 2;
+ string tac = 3;
+ repeated string broadcast_plmns = 4;
+ ChoiceEUTRAMode choice_eutra_mode = 5;
+ Eutra.Mode eutra_mode = 6;
+ NumberOfAntennaPorts number_of_antenna_ports = 7;
+ PrachConfiguration prach_configuration = 8;
+ repeated MbsfnSubframe mbsfn_subframe_infos = 9;
+ string csg_id = 10;
+ repeated string mbms_service_area_identities = 11;
+ repeated uint32 multiband_infos = 12;
+ FreqBandIndicatorPriority freq_band_indicator_priority = 13;
+ BandwidthReducedSI bandwidth_reduced_si = 14;
+ repeated NeighbourInformation neighbour_infos = 15;
+}
+
+message ChoiceEUTRAMode{
+ FddInfo fdd = 1;
+ TddInfo tdd = 2;
+}
+
+message Eutra{
+ enum Mode{
+ UNKNOWN = 0;
+ FDD = 1;
+ TDD = 2;
+ }
+}
+
+message NeighbourInformation{
+ string ecgi = 1;
+ uint32 pci = 2;
+ uint32 ear_fcn = 3;
+ string tac = 4;
+}
+
+enum FreqBandIndicatorPriority{
+ UNKNOWN_FREQ_BAND_INDICATOR_PRIORITY = 0;
+ NOT_BROADCASTED = 1;
+ BROADCASTED = 2;
+}
+
+enum BandwidthReducedSI{
+ UNKNOWN_BANDWIDTH_REDUCED_SI = 0;
+ SCHEDULED = 1;
+}
+
+message MbsfnSubframe{
+ RadioframeAllocationPeriod radioframe_allocation_period = 1;
+ uint32 radioframe_allocation_offset = 2;
+ string subframe_allocation = 3;
+ SubframeAllocationType subframe_allocation_type = 4;
+}
+
+enum SubframeAllocationType{
+ UNKNOWN_SUBFRAME_ALLOCATION_TYPE = 0;
+ ONE_FRAME = 1;
+ FOUR_FRAME = 2;
+}
+
+enum RadioframeAllocationPeriod{
+ UNKNOWN_RADIOFRAME_ALLOCATION_PERIOD = 0;
+ N1 = 1;
+ N2 = 2;
+ N4 = 3;
+ N8 = 4;
+ N16 = 5;
+ N32 = 6;
+}
+message PrachConfiguration{
+ uint32 root_sequence_index = 1;
+ uint32 zero_correlation_zone_configuration = 2;
+ bool high_speed_flag = 3;
+ uint32 prach_frequency_offset = 4;
+ uint32 prach_configuration_index = 5;
+}
+
+enum NumberOfAntennaPorts{
+ UNKNOWN_NUMBER_OF_ANTENNA_PORTS = 0;
+ AN1 = 1;
+ AN2 = 2;
+ AN4 = 3;
+}
+
+message TddInfo{
+ uint32 ear_fcn = 1;
+ TransmissionBandwidth transmission_bandwidth = 2;
+ SubframeAssignment subframe_assignment = 3;
+ SpecialSubframeInfo special_subframe_info = 4;
+ AdditionalSpecialSubframeInfo additional_special_subframe_info = 5;
+ AdditionalSpecialSubframeExtensionInfo additional_special_subframe_extension_info = 6;
+}
+
+message AdditionalSpecialSubframeExtensionInfo{
+ AdditionalSpecialSubframePatterns.Extension additional_special_subframe_patterns_extension = 1;
+ CyclicPrefix cyclic_prefix_dl = 2;
+ CyclicPrefix cyclic_prefix_ul = 3;
+}
+
+message AdditionalSpecialSubframeInfo{
+ AdditionalSpecialSubframe.Patterns additional_special_subframe_patterns = 1;
+ CyclicPrefix cyclic_prefix_dl = 2;
+ CyclicPrefix cyclic_prefix_ul = 3;
+}
+
+message FddInfo{
+ uint32 ulear_fcn = 1;
+ uint32 dlear_fcn = 2;
+ TransmissionBandwidth ul_transmission_bandwidth = 3;
+ TransmissionBandwidth dl_transmission_bandwidth = 4;
+}
+
+message SpecialSubframeInfo{
+ SpecialSubframe.Patterns special_subframe_patterns = 1;
+ CyclicPrefix cyclic_prefix_dl = 2;
+ CyclicPrefix cyclic_prefix_ul = 3;
+}
+
+enum EnbType{
+ UNKNOWN_ENB_TYPE = 0;
+ MACRO_ENB = 1;
+ HOME_ENB = 2;
+ SHORT_MACRO_ENB = 3;
+ LONG_MACRO_ENB = 4;
+}
+
+enum SubframeAssignment{
+ UNKNOWN_SUBFRAME_ASSIGNMENT = 0;
+ SA0 = 1;
+ SA1 = 2;
+ SA2 = 3;
+ SA3 = 4;
+ SA4 = 5;
+ SA5 = 6;
+ SA6 = 7;
+}
+
+enum CyclicPrefix{
+ UNKNOWN_CYCLIC_PREFIX = 0;
+ NORMAL = 1;
+ EXTENDED = 2;
+}
+
+message SpecialSubframe{
+enum Patterns{
+ UNKNOWN = 0;
+ SSP0 = 1;
+ SSP1 = 2;
+ SSP2 = 3;
+ SSP3 = 4;
+ SSP4 = 5;
+ SSP5 = 6;
+ SSP6 = 7;
+ SSP7 = 8;
+ SSP8 = 9;
+}
+}
+
+message AdditionalSpecialSubframe{
+ enum Patterns{
+ UNKNOWN = 0;
+ SSP0 = 1;
+ SSP1 = 2;
+ SSP2 = 3;
+ SSP3 = 4;
+ SSP4 = 5;
+ SSP5 = 6;
+ SSP6 = 7;
+ SSP7 = 8;
+ SSP8 = 9;
+ SSP9 = 10;
+ }
+}
+
+message AdditionalSpecialSubframePatterns{
+ enum Extension{
+ UNKNOWN = 0;
+ SSP10 = 1;
+ }
+}
+
+enum TransmissionBandwidth{
+ UNKNOWN_TRANSMISSION_BANDWIDTH = 0;
+ BW6 = 1;
+ BW15 = 2;
+ BW25 = 3;
+ BW50 = 4;
+ BW75 = 5;
+ BW100 = 6;
+ BW1 = 7;
+}
+
--- /dev/null
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: gnb.proto
+
+package entities
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type Nrscs int32
+
+const (
+ Nrscs_UNKNOWN_NRSCS Nrscs = 0
+ Nrscs_SCS15 Nrscs = 1
+ Nrscs_SCS30 Nrscs = 2
+ Nrscs_SCS60 Nrscs = 3
+ Nrscs_SCS120 Nrscs = 4
+)
+
+var Nrscs_name = map[int32]string{
+ 0: "UNKNOWN_NRSCS",
+ 1: "SCS15",
+ 2: "SCS30",
+ 3: "SCS60",
+ 4: "SCS120",
+}
+
+var Nrscs_value = map[string]int32{
+ "UNKNOWN_NRSCS": 0,
+ "SCS15": 1,
+ "SCS30": 2,
+ "SCS60": 3,
+ "SCS120": 4,
+}
+
+func (x Nrscs) String() string {
+ return proto.EnumName(Nrscs_name, int32(x))
+}
+
+func (Nrscs) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{0}
+}
+
+type Ncnrb int32
+
+const (
+ Ncnrb_UNKNOWN_NCNRB Ncnrb = 0
+ Ncnrb_NRB11 Ncnrb = 1
+ Ncnrb_NRB18 Ncnrb = 2
+ Ncnrb_NRB24 Ncnrb = 3
+ Ncnrb_NRB25 Ncnrb = 4
+ Ncnrb_NRB31 Ncnrb = 5
+ Ncnrb_NRB32 Ncnrb = 6
+ Ncnrb_NRB38 Ncnrb = 7
+ Ncnrb_NRB51 Ncnrb = 8
+ Ncnrb_NRB52 Ncnrb = 9
+ Ncnrb_NRB65 Ncnrb = 10
+ Ncnrb_NRB66 Ncnrb = 11
+ Ncnrb_NRB78 Ncnrb = 12
+ Ncnrb_NRB79 Ncnrb = 13
+ Ncnrb_NRB93 Ncnrb = 14
+ Ncnrb_NRB106 Ncnrb = 15
+ Ncnrb_NRB107 Ncnrb = 16
+ Ncnrb_NRB121 Ncnrb = 17
+ Ncnrb_NRB132 Ncnrb = 18
+ Ncnrb_NRB133 Ncnrb = 19
+ Ncnrb_NRB135 Ncnrb = 20
+ Ncnrb_NRB160 Ncnrb = 21
+ Ncnrb_NRB162 Ncnrb = 22
+ Ncnrb_NRB189 Ncnrb = 23
+ Ncnrb_NRB216 Ncnrb = 24
+ Ncnrb_NRB217 Ncnrb = 25
+ Ncnrb_NRB245 Ncnrb = 26
+ Ncnrb_NRB264 Ncnrb = 27
+ Ncnrb_NRB270 Ncnrb = 28
+ Ncnrb_NRB273 Ncnrb = 29
+)
+
+var Ncnrb_name = map[int32]string{
+ 0: "UNKNOWN_NCNRB",
+ 1: "NRB11",
+ 2: "NRB18",
+ 3: "NRB24",
+ 4: "NRB25",
+ 5: "NRB31",
+ 6: "NRB32",
+ 7: "NRB38",
+ 8: "NRB51",
+ 9: "NRB52",
+ 10: "NRB65",
+ 11: "NRB66",
+ 12: "NRB78",
+ 13: "NRB79",
+ 14: "NRB93",
+ 15: "NRB106",
+ 16: "NRB107",
+ 17: "NRB121",
+ 18: "NRB132",
+ 19: "NRB133",
+ 20: "NRB135",
+ 21: "NRB160",
+ 22: "NRB162",
+ 23: "NRB189",
+ 24: "NRB216",
+ 25: "NRB217",
+ 26: "NRB245",
+ 27: "NRB264",
+ 28: "NRB270",
+ 29: "NRB273",
+}
+
+var Ncnrb_value = map[string]int32{
+ "UNKNOWN_NCNRB": 0,
+ "NRB11": 1,
+ "NRB18": 2,
+ "NRB24": 3,
+ "NRB25": 4,
+ "NRB31": 5,
+ "NRB32": 6,
+ "NRB38": 7,
+ "NRB51": 8,
+ "NRB52": 9,
+ "NRB65": 10,
+ "NRB66": 11,
+ "NRB78": 12,
+ "NRB79": 13,
+ "NRB93": 14,
+ "NRB106": 15,
+ "NRB107": 16,
+ "NRB121": 17,
+ "NRB132": 18,
+ "NRB133": 19,
+ "NRB135": 20,
+ "NRB160": 21,
+ "NRB162": 22,
+ "NRB189": 23,
+ "NRB216": 24,
+ "NRB217": 25,
+ "NRB245": 26,
+ "NRB264": 27,
+ "NRB270": 28,
+ "NRB273": 29,
+}
+
+func (x Ncnrb) String() string {
+ return proto.EnumName(Ncnrb_name, int32(x))
+}
+
+func (Ncnrb) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{1}
+}
+
+type Nr_Mode int32
+
+const (
+ Nr_UNKNOWN Nr_Mode = 0
+ Nr_FDD Nr_Mode = 1
+ Nr_TDD Nr_Mode = 2
+)
+
+var Nr_Mode_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "FDD",
+ 2: "TDD",
+}
+
+var Nr_Mode_value = map[string]int32{
+ "UNKNOWN": 0,
+ "FDD": 1,
+ "TDD": 2,
+}
+
+func (x Nr_Mode) String() string {
+ return proto.EnumName(Nr_Mode_name, int32(x))
+}
+
+func (Nr_Mode) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{3, 0}
+}
+
+type Gnb struct {
+ ServedNrCells []*ServedNRCell `protobuf:"bytes,1,rep,name=served_nr_cells,json=servedNrCells,proto3" json:"served_nr_cells,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Gnb) Reset() { *m = Gnb{} }
+func (m *Gnb) String() string { return proto.CompactTextString(m) }
+func (*Gnb) ProtoMessage() {}
+func (*Gnb) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{0}
+}
+
+func (m *Gnb) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Gnb.Unmarshal(m, b)
+}
+func (m *Gnb) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Gnb.Marshal(b, m, deterministic)
+}
+func (m *Gnb) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Gnb.Merge(m, src)
+}
+func (m *Gnb) XXX_Size() int {
+ return xxx_messageInfo_Gnb.Size(m)
+}
+func (m *Gnb) XXX_DiscardUnknown() {
+ xxx_messageInfo_Gnb.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Gnb proto.InternalMessageInfo
+
+func (m *Gnb) GetServedNrCells() []*ServedNRCell {
+ if m != nil {
+ return m.ServedNrCells
+ }
+ return nil
+}
+
+type ServedNRCell struct {
+ ServedNrCellInformation *ServedNRCellInformation `protobuf:"bytes,1,opt,name=served_nr_cell_information,json=servedNrCellInformation,proto3" json:"served_nr_cell_information,omitempty"`
+ NrNeighbourInfos []*NrNeighbourInformation `protobuf:"bytes,2,rep,name=nr_neighbour_infos,json=nrNeighbourInfos,proto3" json:"nr_neighbour_infos,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServedNRCell) Reset() { *m = ServedNRCell{} }
+func (m *ServedNRCell) String() string { return proto.CompactTextString(m) }
+func (*ServedNRCell) ProtoMessage() {}
+func (*ServedNRCell) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{1}
+}
+
+func (m *ServedNRCell) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServedNRCell.Unmarshal(m, b)
+}
+func (m *ServedNRCell) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServedNRCell.Marshal(b, m, deterministic)
+}
+func (m *ServedNRCell) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServedNRCell.Merge(m, src)
+}
+func (m *ServedNRCell) XXX_Size() int {
+ return xxx_messageInfo_ServedNRCell.Size(m)
+}
+func (m *ServedNRCell) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServedNRCell.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServedNRCell proto.InternalMessageInfo
+
+func (m *ServedNRCell) GetServedNrCellInformation() *ServedNRCellInformation {
+ if m != nil {
+ return m.ServedNrCellInformation
+ }
+ return nil
+}
+
+func (m *ServedNRCell) GetNrNeighbourInfos() []*NrNeighbourInformation {
+ if m != nil {
+ return m.NrNeighbourInfos
+ }
+ return nil
+}
+
+type ServedNRCellInformation struct {
+ NrPci uint32 `protobuf:"varint,1,opt,name=nr_pci,json=nrPci,proto3" json:"nr_pci,omitempty"`
+ CellId string `protobuf:"bytes,2,opt,name=cell_id,json=cellId,proto3" json:"cell_id,omitempty"`
+ Stac5G string `protobuf:"bytes,3,opt,name=stac5g,proto3" json:"stac5g,omitempty"`
+ ConfiguredStac string `protobuf:"bytes,4,opt,name=configured_stac,json=configuredStac,proto3" json:"configured_stac,omitempty"`
+ ServedPlmns []string `protobuf:"bytes,5,rep,name=served_plmns,json=servedPlmns,proto3" json:"served_plmns,omitempty"`
+ NrMode Nr_Mode `protobuf:"varint,6,opt,name=nr_mode,json=nrMode,proto3,enum=entities.Nr_Mode" json:"nr_mode,omitempty"`
+ ChoiceNrMode *ServedNRCellInformation_ChoiceNRMode `protobuf:"bytes,7,opt,name=choice_nr_mode,json=choiceNrMode,proto3" json:"choice_nr_mode,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServedNRCellInformation) Reset() { *m = ServedNRCellInformation{} }
+func (m *ServedNRCellInformation) String() string { return proto.CompactTextString(m) }
+func (*ServedNRCellInformation) ProtoMessage() {}
+func (*ServedNRCellInformation) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{2}
+}
+
+func (m *ServedNRCellInformation) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServedNRCellInformation.Unmarshal(m, b)
+}
+func (m *ServedNRCellInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServedNRCellInformation.Marshal(b, m, deterministic)
+}
+func (m *ServedNRCellInformation) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServedNRCellInformation.Merge(m, src)
+}
+func (m *ServedNRCellInformation) XXX_Size() int {
+ return xxx_messageInfo_ServedNRCellInformation.Size(m)
+}
+func (m *ServedNRCellInformation) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServedNRCellInformation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServedNRCellInformation proto.InternalMessageInfo
+
+func (m *ServedNRCellInformation) GetNrPci() uint32 {
+ if m != nil {
+ return m.NrPci
+ }
+ return 0
+}
+
+func (m *ServedNRCellInformation) GetCellId() string {
+ if m != nil {
+ return m.CellId
+ }
+ return ""
+}
+
+func (m *ServedNRCellInformation) GetStac5G() string {
+ if m != nil {
+ return m.Stac5G
+ }
+ return ""
+}
+
+func (m *ServedNRCellInformation) GetConfiguredStac() string {
+ if m != nil {
+ return m.ConfiguredStac
+ }
+ return ""
+}
+
+func (m *ServedNRCellInformation) GetServedPlmns() []string {
+ if m != nil {
+ return m.ServedPlmns
+ }
+ return nil
+}
+
+func (m *ServedNRCellInformation) GetNrMode() Nr_Mode {
+ if m != nil {
+ return m.NrMode
+ }
+ return Nr_UNKNOWN
+}
+
+func (m *ServedNRCellInformation) GetChoiceNrMode() *ServedNRCellInformation_ChoiceNRMode {
+ if m != nil {
+ return m.ChoiceNrMode
+ }
+ return nil
+}
+
+type ServedNRCellInformation_ChoiceNRMode struct {
+ Fdd *ServedNRCellInformation_ChoiceNRMode_FddInfo `protobuf:"bytes,1,opt,name=fdd,proto3" json:"fdd,omitempty"`
+ Tdd *ServedNRCellInformation_ChoiceNRMode_TddInfo `protobuf:"bytes,2,opt,name=tdd,proto3" json:"tdd,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode) Reset() { *m = ServedNRCellInformation_ChoiceNRMode{} }
+func (m *ServedNRCellInformation_ChoiceNRMode) String() string { return proto.CompactTextString(m) }
+func (*ServedNRCellInformation_ChoiceNRMode) ProtoMessage() {}
+func (*ServedNRCellInformation_ChoiceNRMode) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{2, 0}
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode.Unmarshal(m, b)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode.Marshal(b, m, deterministic)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode.Merge(m, src)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode) XXX_Size() int {
+ return xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode.Size(m)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode proto.InternalMessageInfo
+
+func (m *ServedNRCellInformation_ChoiceNRMode) GetFdd() *ServedNRCellInformation_ChoiceNRMode_FddInfo {
+ if m != nil {
+ return m.Fdd
+ }
+ return nil
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode) GetTdd() *ServedNRCellInformation_ChoiceNRMode_TddInfo {
+ if m != nil {
+ return m.Tdd
+ }
+ return nil
+}
+
+type ServedNRCellInformation_ChoiceNRMode_FddInfo struct {
+ UlFreqInfo *NrFrequencyInfo `protobuf:"bytes,1,opt,name=ul_freq_info,json=ulFreqInfo,proto3" json:"ul_freq_info,omitempty"`
+ DlFreqInfo *NrFrequencyInfo `protobuf:"bytes,2,opt,name=dl_freq_info,json=dlFreqInfo,proto3" json:"dl_freq_info,omitempty"`
+ UlTransmissionBandwidth *NrTransmissionBandwidth `protobuf:"bytes,3,opt,name=ul_transmission_bandwidth,json=ulTransmissionBandwidth,proto3" json:"ul_transmission_bandwidth,omitempty"`
+ DlTransmissionBandwidth *NrTransmissionBandwidth `protobuf:"bytes,4,opt,name=dl_transmission_bandwidth,json=dlTransmissionBandwidth,proto3" json:"dl_transmission_bandwidth,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) Reset() {
+ *m = ServedNRCellInformation_ChoiceNRMode_FddInfo{}
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) String() string {
+ return proto.CompactTextString(m)
+}
+func (*ServedNRCellInformation_ChoiceNRMode_FddInfo) ProtoMessage() {}
+func (*ServedNRCellInformation_ChoiceNRMode_FddInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{2, 0, 0}
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_FddInfo.Unmarshal(m, b)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_FddInfo.Marshal(b, m, deterministic)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_FddInfo.Merge(m, src)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) XXX_Size() int {
+ return xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_FddInfo.Size(m)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_FddInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_FddInfo proto.InternalMessageInfo
+
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) GetUlFreqInfo() *NrFrequencyInfo {
+ if m != nil {
+ return m.UlFreqInfo
+ }
+ return nil
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) GetDlFreqInfo() *NrFrequencyInfo {
+ if m != nil {
+ return m.DlFreqInfo
+ }
+ return nil
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) GetUlTransmissionBandwidth() *NrTransmissionBandwidth {
+ if m != nil {
+ return m.UlTransmissionBandwidth
+ }
+ return nil
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode_FddInfo) GetDlTransmissionBandwidth() *NrTransmissionBandwidth {
+ if m != nil {
+ return m.DlTransmissionBandwidth
+ }
+ return nil
+}
+
+type ServedNRCellInformation_ChoiceNRMode_TddInfo struct {
+ NrFreqInfo *NrFrequencyInfo `protobuf:"bytes,1,opt,name=nr_freq_info,json=nrFreqInfo,proto3" json:"nr_freq_info,omitempty"`
+ TransmissionBandwidth *NrTransmissionBandwidth `protobuf:"bytes,2,opt,name=transmission_bandwidth,json=transmissionBandwidth,proto3" json:"transmission_bandwidth,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode_TddInfo) Reset() {
+ *m = ServedNRCellInformation_ChoiceNRMode_TddInfo{}
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_TddInfo) String() string {
+ return proto.CompactTextString(m)
+}
+func (*ServedNRCellInformation_ChoiceNRMode_TddInfo) ProtoMessage() {}
+func (*ServedNRCellInformation_ChoiceNRMode_TddInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{2, 0, 1}
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode_TddInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_TddInfo.Unmarshal(m, b)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_TddInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_TddInfo.Marshal(b, m, deterministic)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_TddInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_TddInfo.Merge(m, src)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_TddInfo) XXX_Size() int {
+ return xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_TddInfo.Size(m)
+}
+func (m *ServedNRCellInformation_ChoiceNRMode_TddInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_TddInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServedNRCellInformation_ChoiceNRMode_TddInfo proto.InternalMessageInfo
+
+func (m *ServedNRCellInformation_ChoiceNRMode_TddInfo) GetNrFreqInfo() *NrFrequencyInfo {
+ if m != nil {
+ return m.NrFreqInfo
+ }
+ return nil
+}
+
+func (m *ServedNRCellInformation_ChoiceNRMode_TddInfo) GetTransmissionBandwidth() *NrTransmissionBandwidth {
+ if m != nil {
+ return m.TransmissionBandwidth
+ }
+ return nil
+}
+
+type Nr struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Nr) Reset() { *m = Nr{} }
+func (m *Nr) String() string { return proto.CompactTextString(m) }
+func (*Nr) ProtoMessage() {}
+func (*Nr) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{3}
+}
+
+func (m *Nr) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Nr.Unmarshal(m, b)
+}
+func (m *Nr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Nr.Marshal(b, m, deterministic)
+}
+func (m *Nr) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Nr.Merge(m, src)
+}
+func (m *Nr) XXX_Size() int {
+ return xxx_messageInfo_Nr.Size(m)
+}
+func (m *Nr) XXX_DiscardUnknown() {
+ xxx_messageInfo_Nr.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Nr proto.InternalMessageInfo
+
+type NrFrequencyInfo struct {
+ NrArFcn uint64 `protobuf:"varint,1,opt,name=nr_ar_fcn,json=nrArFcn,proto3" json:"nr_ar_fcn,omitempty"`
+ SulInformation *NrFrequencyInfo_SulInformation `protobuf:"bytes,3,opt,name=sulInformation,proto3" json:"sulInformation,omitempty"`
+ FrequencyBands []*FrequencyBandItem `protobuf:"bytes,4,rep,name=frequency_bands,json=frequencyBands,proto3" json:"frequency_bands,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NrFrequencyInfo) Reset() { *m = NrFrequencyInfo{} }
+func (m *NrFrequencyInfo) String() string { return proto.CompactTextString(m) }
+func (*NrFrequencyInfo) ProtoMessage() {}
+func (*NrFrequencyInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{4}
+}
+
+func (m *NrFrequencyInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NrFrequencyInfo.Unmarshal(m, b)
+}
+func (m *NrFrequencyInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NrFrequencyInfo.Marshal(b, m, deterministic)
+}
+func (m *NrFrequencyInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NrFrequencyInfo.Merge(m, src)
+}
+func (m *NrFrequencyInfo) XXX_Size() int {
+ return xxx_messageInfo_NrFrequencyInfo.Size(m)
+}
+func (m *NrFrequencyInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_NrFrequencyInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NrFrequencyInfo proto.InternalMessageInfo
+
+func (m *NrFrequencyInfo) GetNrArFcn() uint64 {
+ if m != nil {
+ return m.NrArFcn
+ }
+ return 0
+}
+
+func (m *NrFrequencyInfo) GetSulInformation() *NrFrequencyInfo_SulInformation {
+ if m != nil {
+ return m.SulInformation
+ }
+ return nil
+}
+
+func (m *NrFrequencyInfo) GetFrequencyBands() []*FrequencyBandItem {
+ if m != nil {
+ return m.FrequencyBands
+ }
+ return nil
+}
+
+type NrFrequencyInfo_SulInformation struct {
+ SulArFcn uint64 `protobuf:"varint,1,opt,name=sul_ar_fcn,json=sulArFcn,proto3" json:"sul_ar_fcn,omitempty"`
+ SulTransmissionBandwidth *NrTransmissionBandwidth `protobuf:"bytes,2,opt,name=sul_transmission_bandwidth,json=sulTransmissionBandwidth,proto3" json:"sul_transmission_bandwidth,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NrFrequencyInfo_SulInformation) Reset() { *m = NrFrequencyInfo_SulInformation{} }
+func (m *NrFrequencyInfo_SulInformation) String() string { return proto.CompactTextString(m) }
+func (*NrFrequencyInfo_SulInformation) ProtoMessage() {}
+func (*NrFrequencyInfo_SulInformation) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{4, 0}
+}
+
+func (m *NrFrequencyInfo_SulInformation) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NrFrequencyInfo_SulInformation.Unmarshal(m, b)
+}
+func (m *NrFrequencyInfo_SulInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NrFrequencyInfo_SulInformation.Marshal(b, m, deterministic)
+}
+func (m *NrFrequencyInfo_SulInformation) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NrFrequencyInfo_SulInformation.Merge(m, src)
+}
+func (m *NrFrequencyInfo_SulInformation) XXX_Size() int {
+ return xxx_messageInfo_NrFrequencyInfo_SulInformation.Size(m)
+}
+func (m *NrFrequencyInfo_SulInformation) XXX_DiscardUnknown() {
+ xxx_messageInfo_NrFrequencyInfo_SulInformation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NrFrequencyInfo_SulInformation proto.InternalMessageInfo
+
+func (m *NrFrequencyInfo_SulInformation) GetSulArFcn() uint64 {
+ if m != nil {
+ return m.SulArFcn
+ }
+ return 0
+}
+
+func (m *NrFrequencyInfo_SulInformation) GetSulTransmissionBandwidth() *NrTransmissionBandwidth {
+ if m != nil {
+ return m.SulTransmissionBandwidth
+ }
+ return nil
+}
+
+type FrequencyBandItem struct {
+ NrFrequencyBand uint32 `protobuf:"varint,1,opt,name=nr_frequency_band,json=nrFrequencyBand,proto3" json:"nr_frequency_band,omitempty"`
+ SupportedSulBands []uint32 `protobuf:"varint,2,rep,packed,name=supported_sul_bands,json=supportedSulBands,proto3" json:"supported_sul_bands,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FrequencyBandItem) Reset() { *m = FrequencyBandItem{} }
+func (m *FrequencyBandItem) String() string { return proto.CompactTextString(m) }
+func (*FrequencyBandItem) ProtoMessage() {}
+func (*FrequencyBandItem) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{5}
+}
+
+func (m *FrequencyBandItem) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FrequencyBandItem.Unmarshal(m, b)
+}
+func (m *FrequencyBandItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FrequencyBandItem.Marshal(b, m, deterministic)
+}
+func (m *FrequencyBandItem) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FrequencyBandItem.Merge(m, src)
+}
+func (m *FrequencyBandItem) XXX_Size() int {
+ return xxx_messageInfo_FrequencyBandItem.Size(m)
+}
+func (m *FrequencyBandItem) XXX_DiscardUnknown() {
+ xxx_messageInfo_FrequencyBandItem.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FrequencyBandItem proto.InternalMessageInfo
+
+func (m *FrequencyBandItem) GetNrFrequencyBand() uint32 {
+ if m != nil {
+ return m.NrFrequencyBand
+ }
+ return 0
+}
+
+func (m *FrequencyBandItem) GetSupportedSulBands() []uint32 {
+ if m != nil {
+ return m.SupportedSulBands
+ }
+ return nil
+}
+
+type NrTransmissionBandwidth struct {
+ Nrscs Nrscs `protobuf:"varint,1,opt,name=nrscs,proto3,enum=entities.Nrscs" json:"nrscs,omitempty"`
+ Ncnrb Ncnrb `protobuf:"varint,2,opt,name=ncnrb,proto3,enum=entities.Ncnrb" json:"ncnrb,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NrTransmissionBandwidth) Reset() { *m = NrTransmissionBandwidth{} }
+func (m *NrTransmissionBandwidth) String() string { return proto.CompactTextString(m) }
+func (*NrTransmissionBandwidth) ProtoMessage() {}
+func (*NrTransmissionBandwidth) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{6}
+}
+
+func (m *NrTransmissionBandwidth) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NrTransmissionBandwidth.Unmarshal(m, b)
+}
+func (m *NrTransmissionBandwidth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NrTransmissionBandwidth.Marshal(b, m, deterministic)
+}
+func (m *NrTransmissionBandwidth) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NrTransmissionBandwidth.Merge(m, src)
+}
+func (m *NrTransmissionBandwidth) XXX_Size() int {
+ return xxx_messageInfo_NrTransmissionBandwidth.Size(m)
+}
+func (m *NrTransmissionBandwidth) XXX_DiscardUnknown() {
+ xxx_messageInfo_NrTransmissionBandwidth.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NrTransmissionBandwidth proto.InternalMessageInfo
+
+func (m *NrTransmissionBandwidth) GetNrscs() Nrscs {
+ if m != nil {
+ return m.Nrscs
+ }
+ return Nrscs_UNKNOWN_NRSCS
+}
+
+func (m *NrTransmissionBandwidth) GetNcnrb() Ncnrb {
+ if m != nil {
+ return m.Ncnrb
+ }
+ return Ncnrb_UNKNOWN_NCNRB
+}
+
+type NrNeighbourInformation struct {
+ NrPci uint32 `protobuf:"varint,1,opt,name=nr_pci,json=nrPci,proto3" json:"nr_pci,omitempty"`
+ NrCgi string `protobuf:"bytes,2,opt,name=nr_cgi,json=nrCgi,proto3" json:"nr_cgi,omitempty"`
+ NrMode Nr_Mode `protobuf:"varint,3,opt,name=nr_mode,json=nrMode,proto3,enum=entities.Nr_Mode" json:"nr_mode,omitempty"`
+ ChoiceNrMode *NrNeighbourInformation_ChoiceNRMode `protobuf:"bytes,4,opt,name=choice_nr_mode,json=choiceNrMode,proto3" json:"choice_nr_mode,omitempty"`
+ Stac5G string `protobuf:"bytes,5,opt,name=stac5g,proto3" json:"stac5g,omitempty"`
+ ConfiguredStac string `protobuf:"bytes,6,opt,name=configured_stac,json=configuredStac,proto3" json:"configured_stac,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NrNeighbourInformation) Reset() { *m = NrNeighbourInformation{} }
+func (m *NrNeighbourInformation) String() string { return proto.CompactTextString(m) }
+func (*NrNeighbourInformation) ProtoMessage() {}
+func (*NrNeighbourInformation) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{7}
+}
+
+func (m *NrNeighbourInformation) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NrNeighbourInformation.Unmarshal(m, b)
+}
+func (m *NrNeighbourInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NrNeighbourInformation.Marshal(b, m, deterministic)
+}
+func (m *NrNeighbourInformation) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NrNeighbourInformation.Merge(m, src)
+}
+func (m *NrNeighbourInformation) XXX_Size() int {
+ return xxx_messageInfo_NrNeighbourInformation.Size(m)
+}
+func (m *NrNeighbourInformation) XXX_DiscardUnknown() {
+ xxx_messageInfo_NrNeighbourInformation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NrNeighbourInformation proto.InternalMessageInfo
+
+func (m *NrNeighbourInformation) GetNrPci() uint32 {
+ if m != nil {
+ return m.NrPci
+ }
+ return 0
+}
+
+func (m *NrNeighbourInformation) GetNrCgi() string {
+ if m != nil {
+ return m.NrCgi
+ }
+ return ""
+}
+
+func (m *NrNeighbourInformation) GetNrMode() Nr_Mode {
+ if m != nil {
+ return m.NrMode
+ }
+ return Nr_UNKNOWN
+}
+
+func (m *NrNeighbourInformation) GetChoiceNrMode() *NrNeighbourInformation_ChoiceNRMode {
+ if m != nil {
+ return m.ChoiceNrMode
+ }
+ return nil
+}
+
+func (m *NrNeighbourInformation) GetStac5G() string {
+ if m != nil {
+ return m.Stac5G
+ }
+ return ""
+}
+
+func (m *NrNeighbourInformation) GetConfiguredStac() string {
+ if m != nil {
+ return m.ConfiguredStac
+ }
+ return ""
+}
+
+type NrNeighbourInformation_ChoiceNRMode struct {
+ Fdd *NrNeighbourInformation_ChoiceNRMode_FddInfo `protobuf:"bytes,1,opt,name=fdd,proto3" json:"fdd,omitempty"`
+ Tdd *NrNeighbourInformation_ChoiceNRMode_TddInfo `protobuf:"bytes,2,opt,name=tdd,proto3" json:"tdd,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NrNeighbourInformation_ChoiceNRMode) Reset() { *m = NrNeighbourInformation_ChoiceNRMode{} }
+func (m *NrNeighbourInformation_ChoiceNRMode) String() string { return proto.CompactTextString(m) }
+func (*NrNeighbourInformation_ChoiceNRMode) ProtoMessage() {}
+func (*NrNeighbourInformation_ChoiceNRMode) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{7, 0}
+}
+
+func (m *NrNeighbourInformation_ChoiceNRMode) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode.Unmarshal(m, b)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode.Marshal(b, m, deterministic)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode.Merge(m, src)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode) XXX_Size() int {
+ return xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode.Size(m)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode) XXX_DiscardUnknown() {
+ xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode proto.InternalMessageInfo
+
+func (m *NrNeighbourInformation_ChoiceNRMode) GetFdd() *NrNeighbourInformation_ChoiceNRMode_FddInfo {
+ if m != nil {
+ return m.Fdd
+ }
+ return nil
+}
+
+func (m *NrNeighbourInformation_ChoiceNRMode) GetTdd() *NrNeighbourInformation_ChoiceNRMode_TddInfo {
+ if m != nil {
+ return m.Tdd
+ }
+ return nil
+}
+
+type NrNeighbourInformation_ChoiceNRMode_FddInfo struct {
+ UlarFcnFreqInfo *NrFrequencyInfo `protobuf:"bytes,1,opt,name=ular_fcn_freq_info,json=ularFcnFreqInfo,proto3" json:"ular_fcn_freq_info,omitempty"`
+ DlarFcnFreqInfo *NrFrequencyInfo `protobuf:"bytes,2,opt,name=dlar_fcn_freq_info,json=dlarFcnFreqInfo,proto3" json:"dlar_fcn_freq_info,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NrNeighbourInformation_ChoiceNRMode_FddInfo) Reset() {
+ *m = NrNeighbourInformation_ChoiceNRMode_FddInfo{}
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_FddInfo) String() string {
+ return proto.CompactTextString(m)
+}
+func (*NrNeighbourInformation_ChoiceNRMode_FddInfo) ProtoMessage() {}
+func (*NrNeighbourInformation_ChoiceNRMode_FddInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{7, 0, 0}
+}
+
+func (m *NrNeighbourInformation_ChoiceNRMode_FddInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_FddInfo.Unmarshal(m, b)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_FddInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_FddInfo.Marshal(b, m, deterministic)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_FddInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_FddInfo.Merge(m, src)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_FddInfo) XXX_Size() int {
+ return xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_FddInfo.Size(m)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_FddInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_FddInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_FddInfo proto.InternalMessageInfo
+
+func (m *NrNeighbourInformation_ChoiceNRMode_FddInfo) GetUlarFcnFreqInfo() *NrFrequencyInfo {
+ if m != nil {
+ return m.UlarFcnFreqInfo
+ }
+ return nil
+}
+
+func (m *NrNeighbourInformation_ChoiceNRMode_FddInfo) GetDlarFcnFreqInfo() *NrFrequencyInfo {
+ if m != nil {
+ return m.DlarFcnFreqInfo
+ }
+ return nil
+}
+
+type NrNeighbourInformation_ChoiceNRMode_TddInfo struct {
+ ArFcnNrFreqInfo *NrFrequencyInfo `protobuf:"bytes,1,opt,name=ar_fcn_nr_freq_info,json=arFcnNrFreqInfo,proto3" json:"ar_fcn_nr_freq_info,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NrNeighbourInformation_ChoiceNRMode_TddInfo) Reset() {
+ *m = NrNeighbourInformation_ChoiceNRMode_TddInfo{}
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_TddInfo) String() string {
+ return proto.CompactTextString(m)
+}
+func (*NrNeighbourInformation_ChoiceNRMode_TddInfo) ProtoMessage() {}
+func (*NrNeighbourInformation_ChoiceNRMode_TddInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_22d18f428b8f19f0, []int{7, 0, 1}
+}
+
+func (m *NrNeighbourInformation_ChoiceNRMode_TddInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_TddInfo.Unmarshal(m, b)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_TddInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_TddInfo.Marshal(b, m, deterministic)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_TddInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_TddInfo.Merge(m, src)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_TddInfo) XXX_Size() int {
+ return xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_TddInfo.Size(m)
+}
+func (m *NrNeighbourInformation_ChoiceNRMode_TddInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_TddInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NrNeighbourInformation_ChoiceNRMode_TddInfo proto.InternalMessageInfo
+
+func (m *NrNeighbourInformation_ChoiceNRMode_TddInfo) GetArFcnNrFreqInfo() *NrFrequencyInfo {
+ if m != nil {
+ return m.ArFcnNrFreqInfo
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterEnum("entities.Nrscs", Nrscs_name, Nrscs_value)
+ proto.RegisterEnum("entities.Ncnrb", Ncnrb_name, Ncnrb_value)
+ proto.RegisterEnum("entities.Nr_Mode", Nr_Mode_name, Nr_Mode_value)
+ proto.RegisterType((*Gnb)(nil), "entities.Gnb")
+ proto.RegisterType((*ServedNRCell)(nil), "entities.ServedNRCell")
+ proto.RegisterType((*ServedNRCellInformation)(nil), "entities.ServedNRCellInformation")
+ proto.RegisterType((*ServedNRCellInformation_ChoiceNRMode)(nil), "entities.ServedNRCellInformation.ChoiceNRMode")
+ proto.RegisterType((*ServedNRCellInformation_ChoiceNRMode_FddInfo)(nil), "entities.ServedNRCellInformation.ChoiceNRMode.FddInfo")
+ proto.RegisterType((*ServedNRCellInformation_ChoiceNRMode_TddInfo)(nil), "entities.ServedNRCellInformation.ChoiceNRMode.TddInfo")
+ proto.RegisterType((*Nr)(nil), "entities.Nr")
+ proto.RegisterType((*NrFrequencyInfo)(nil), "entities.NrFrequencyInfo")
+ proto.RegisterType((*NrFrequencyInfo_SulInformation)(nil), "entities.NrFrequencyInfo.SulInformation")
+ proto.RegisterType((*FrequencyBandItem)(nil), "entities.FrequencyBandItem")
+ proto.RegisterType((*NrTransmissionBandwidth)(nil), "entities.NrTransmissionBandwidth")
+ proto.RegisterType((*NrNeighbourInformation)(nil), "entities.NrNeighbourInformation")
+ proto.RegisterType((*NrNeighbourInformation_ChoiceNRMode)(nil), "entities.NrNeighbourInformation.ChoiceNRMode")
+ proto.RegisterType((*NrNeighbourInformation_ChoiceNRMode_FddInfo)(nil), "entities.NrNeighbourInformation.ChoiceNRMode.FddInfo")
+ proto.RegisterType((*NrNeighbourInformation_ChoiceNRMode_TddInfo)(nil), "entities.NrNeighbourInformation.ChoiceNRMode.TddInfo")
+}
+
+func init() { proto.RegisterFile("gnb.proto", fileDescriptor_22d18f428b8f19f0) }
+
+var fileDescriptor_22d18f428b8f19f0 = []byte{
+ // 1071 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x56, 0xdd, 0x6e, 0xe3, 0x44,
+ 0x14, 0x5e, 0x27, 0x71, 0xb2, 0x39, 0x4d, 0x93, 0xc9, 0x2c, 0xdb, 0xb8, 0xd9, 0x45, 0xca, 0x46,
+ 0x5a, 0x11, 0x15, 0x11, 0x25, 0x4e, 0x93, 0xb6, 0x42, 0x42, 0xa2, 0x29, 0x29, 0x15, 0xc2, 0x54,
+ 0x4e, 0x11, 0xdc, 0x80, 0x95, 0x78, 0x9c, 0xd4, 0x92, 0x3b, 0xee, 0xce, 0xd8, 0x20, 0x1e, 0x81,
+ 0x2b, 0xb8, 0x45, 0xdc, 0xf0, 0x1e, 0x48, 0x48, 0x3c, 0x05, 0xaf, 0xc0, 0x63, 0x20, 0x8f, 0x7f,
+ 0x62, 0xb7, 0x09, 0x69, 0xae, 0xfa, 0xe5, 0xfc, 0x7c, 0x3e, 0xe7, 0xf8, 0xf8, 0x3b, 0x85, 0xf2,
+ 0x92, 0xce, 0xbb, 0xf7, 0xcc, 0xf5, 0x5c, 0xfc, 0xdc, 0xa2, 0x9e, 0xed, 0xd9, 0x16, 0x6f, 0x7f,
+ 0x06, 0xf9, 0x4b, 0x3a, 0xc7, 0x9f, 0x40, 0x8d, 0x5b, 0xec, 0x07, 0x8b, 0x18, 0x94, 0x19, 0xa6,
+ 0xe5, 0x38, 0x5c, 0x91, 0x5a, 0xf9, 0xce, 0x9e, 0x7a, 0xd0, 0x8d, 0x43, 0xbb, 0x53, 0x11, 0xa0,
+ 0xe9, 0x63, 0xcb, 0x71, 0xf4, 0xfd, 0x30, 0x5c, 0x63, 0xc1, 0x2f, 0xde, 0xfe, 0x4b, 0x82, 0x4a,
+ 0xda, 0x8f, 0xbf, 0x87, 0x66, 0x96, 0xd0, 0xb0, 0xe9, 0xc2, 0x65, 0x77, 0x33, 0xcf, 0x76, 0xa9,
+ 0x22, 0xb5, 0xa4, 0xce, 0x9e, 0xfa, 0x66, 0x3d, 0xf7, 0xd5, 0x2a, 0x50, 0x6f, 0xa4, 0x1f, 0x93,
+ 0x72, 0x60, 0x0d, 0x30, 0x65, 0x06, 0xb5, 0xec, 0xe5, 0xed, 0xdc, 0xf5, 0x99, 0x60, 0xe7, 0x4a,
+ 0x4e, 0xd4, 0xdc, 0x5a, 0xf1, 0x6a, 0x4c, 0x8b, 0x43, 0xd2, 0xb4, 0x88, 0x66, 0xed, 0xbc, 0xfd,
+ 0x67, 0x09, 0x1a, 0x1b, 0x8a, 0xc0, 0x2f, 0xa1, 0x48, 0x99, 0x71, 0x6f, 0xda, 0xa2, 0xee, 0x7d,
+ 0x5d, 0xa6, 0xec, 0xda, 0xb4, 0x71, 0x03, 0x4a, 0x61, 0x63, 0x44, 0xc9, 0xb5, 0xa4, 0x4e, 0x59,
+ 0x2f, 0x06, 0x3f, 0xaf, 0x08, 0x3e, 0x80, 0x22, 0xf7, 0x66, 0xe6, 0x70, 0xa9, 0xe4, 0x43, 0x7b,
+ 0xf8, 0x0b, 0x7f, 0x00, 0x35, 0xd3, 0xa5, 0x0b, 0x7b, 0xe9, 0x33, 0x8b, 0x18, 0x81, 0x51, 0x29,
+ 0x88, 0x80, 0xea, 0xca, 0x3c, 0xf5, 0x66, 0x26, 0x7e, 0x03, 0x95, 0x68, 0x78, 0xf7, 0xce, 0x1d,
+ 0xe5, 0x8a, 0xdc, 0xca, 0x77, 0xca, 0xfa, 0x5e, 0x68, 0xbb, 0x0e, 0x4c, 0xf8, 0x08, 0x4a, 0x94,
+ 0x19, 0x77, 0x2e, 0xb1, 0x94, 0x62, 0x4b, 0xea, 0x54, 0xd5, 0x7a, 0xba, 0xe9, 0xee, 0x97, 0x2e,
+ 0xb1, 0xf4, 0x22, 0x65, 0xc1, 0x5f, 0x7c, 0x03, 0x55, 0xf3, 0xd6, 0xb5, 0x4d, 0xcb, 0x88, 0x53,
+ 0x4a, 0x62, 0xfe, 0xdd, 0xad, 0xf3, 0xef, 0x8e, 0x45, 0x9e, 0xa6, 0x0b, 0xbe, 0x4a, 0xc8, 0xa2,
+ 0x09, 0xd6, 0xe6, 0xcf, 0x32, 0x54, 0xd2, 0x6e, 0xfc, 0x39, 0xe4, 0x17, 0x84, 0x44, 0xef, 0x76,
+ 0xb4, 0x1b, 0x77, 0x77, 0x42, 0x48, 0xe0, 0xd3, 0x03, 0x8a, 0x80, 0xc9, 0x23, 0xe1, 0x54, 0x77,
+ 0x67, 0xba, 0x89, 0x99, 0x3c, 0x42, 0x9a, 0x7f, 0xe7, 0xa0, 0x14, 0x51, 0xe3, 0x8f, 0xa1, 0xe2,
+ 0x3b, 0xc6, 0x82, 0x59, 0xef, 0xc4, 0xb6, 0x44, 0x85, 0x1e, 0xa6, 0xe7, 0x36, 0x61, 0xd6, 0x3b,
+ 0xdf, 0xa2, 0xe6, 0x4f, 0x82, 0x01, 0x7c, 0x27, 0x30, 0xc4, 0xc9, 0x24, 0x9d, 0x9c, 0xdb, 0x9a,
+ 0x4c, 0x56, 0xc9, 0xdf, 0xc1, 0xa1, 0xef, 0x18, 0x1e, 0x9b, 0x51, 0x7e, 0x67, 0x73, 0x6e, 0xbb,
+ 0xd4, 0x98, 0xcf, 0x28, 0xf9, 0xd1, 0x26, 0xde, 0xad, 0xd8, 0x91, 0xcc, 0xb7, 0xa0, 0xb1, 0x9b,
+ 0x54, 0xe4, 0x79, 0x1c, 0xa8, 0x37, 0x7c, 0x67, 0xad, 0x23, 0xa0, 0x27, 0x1b, 0xe9, 0x0b, 0x4f,
+ 0xa6, 0x27, 0xeb, 0xe9, 0x9b, 0x7f, 0x48, 0x50, 0xba, 0x59, 0xcd, 0x90, 0xb2, 0x9d, 0x66, 0x48,
+ 0x59, 0x32, 0x86, 0x6f, 0xe1, 0x60, 0x43, 0x91, 0xb9, 0xa7, 0x16, 0xf9, 0xd2, 0x5b, 0x67, 0x6e,
+ 0x7f, 0x08, 0x39, 0x8d, 0xb5, 0xdf, 0x42, 0x41, 0x2c, 0xe2, 0x1e, 0x94, 0xbe, 0xd6, 0xbe, 0xd0,
+ 0xbe, 0xfa, 0x46, 0x43, 0xcf, 0x70, 0x09, 0xf2, 0x93, 0x8b, 0x0b, 0x24, 0x05, 0xe0, 0xe6, 0xe2,
+ 0x02, 0xe5, 0xda, 0xff, 0xe4, 0xa0, 0xf6, 0xa0, 0x4c, 0xdc, 0x84, 0x32, 0x65, 0xc6, 0x8c, 0x19,
+ 0x0b, 0x33, 0x54, 0xa7, 0x82, 0x5e, 0xa2, 0xec, 0x53, 0x36, 0x31, 0x29, 0xbe, 0x86, 0x2a, 0xf7,
+ 0xd3, 0xfb, 0x16, 0xbd, 0xb2, 0xce, 0xc6, 0xae, 0xbb, 0xd3, 0x4c, 0xbc, 0xfe, 0x20, 0x1f, 0x5f,
+ 0x40, 0x6d, 0x11, 0xc7, 0x8b, 0x29, 0x70, 0xa5, 0x20, 0x94, 0xeb, 0xd5, 0x8a, 0x32, 0x21, 0x0c,
+ 0xba, 0xbc, 0xf2, 0xac, 0x3b, 0xbd, 0xba, 0x48, 0x9b, 0x78, 0xf3, 0x17, 0x09, 0xaa, 0xd9, 0x07,
+ 0xe1, 0xd7, 0x00, 0xdc, 0x77, 0xb2, 0x7d, 0x3c, 0xe7, 0xbe, 0x13, 0x36, 0x62, 0x40, 0x93, 0x6f,
+ 0xde, 0xc3, 0x27, 0xbf, 0x03, 0x85, 0x6f, 0x58, 0xc4, 0xb6, 0x0b, 0xf5, 0x47, 0x65, 0xe3, 0x23,
+ 0xa8, 0x47, 0x2b, 0xb3, 0xea, 0x37, 0x12, 0xd2, 0x1a, 0x65, 0x99, 0x78, 0xdc, 0x85, 0x17, 0xdc,
+ 0xbf, 0xbf, 0x77, 0x99, 0x17, 0x08, 0xa4, 0xef, 0x44, 0xc3, 0x09, 0x64, 0x7d, 0x5f, 0xaf, 0x27,
+ 0xae, 0xa9, 0xef, 0x88, 0x11, 0xb4, 0x97, 0xd0, 0xd8, 0x50, 0x25, 0x7e, 0x0b, 0x32, 0x65, 0xdc,
+ 0xe4, 0xe2, 0x51, 0x55, 0xb5, 0x96, 0xee, 0x8b, 0x9b, 0x5c, 0x0f, 0xbd, 0x22, 0xcc, 0xa4, 0x6c,
+ 0x2e, 0xda, 0xcf, 0x86, 0x05, 0x66, 0x3d, 0xf4, 0xb6, 0x7f, 0x97, 0xe1, 0x60, 0xfd, 0x2d, 0xd9,
+ 0x74, 0x1d, 0x42, 0xb3, 0xb9, 0xb4, 0xa3, 0xe3, 0x20, 0x53, 0x36, 0x5e, 0xda, 0x69, 0xdd, 0xce,
+ 0x6f, 0xd3, 0xed, 0xe9, 0x23, 0xdd, 0x0e, 0x3f, 0xe6, 0x8f, 0xb6, 0xdd, 0xb7, 0xff, 0x91, 0xed,
+ 0xd4, 0x71, 0x92, 0xb7, 0x1d, 0xa7, 0xe2, 0xba, 0xe3, 0xd4, 0xfc, 0x35, 0xff, 0x40, 0xf7, 0x2f,
+ 0xd3, 0xba, 0x3f, 0xdc, 0xa9, 0xb6, 0xac, 0xec, 0x5f, 0xa6, 0x65, 0x7f, 0x47, 0xa2, 0x8c, 0xea,
+ 0xff, 0x26, 0xad, 0x54, 0x7f, 0x02, 0xd8, 0x77, 0xc2, 0x0f, 0x62, 0x17, 0xdd, 0xaa, 0x05, 0x49,
+ 0x13, 0x93, 0x26, 0xe2, 0x35, 0x01, 0x4c, 0x1e, 0xf3, 0x6c, 0x3d, 0x03, 0x35, 0x92, 0xe5, 0x69,
+ 0xea, 0x2b, 0x31, 0xbd, 0x84, 0x17, 0x11, 0xe1, 0x6e, 0x9a, 0x5a, 0x13, 0x8c, 0x5a, 0x22, 0xac,
+ 0x47, 0x97, 0x20, 0x8b, 0xa5, 0xc6, 0x75, 0xd8, 0x8f, 0x94, 0xcf, 0xd0, 0xf4, 0xe9, 0x78, 0x8a,
+ 0x9e, 0xe1, 0x32, 0xc8, 0xd3, 0xf1, 0xb4, 0x3f, 0x44, 0x52, 0x04, 0x07, 0x3d, 0x94, 0x8b, 0xe0,
+ 0xa8, 0x87, 0xf2, 0x18, 0xa0, 0x18, 0x04, 0xa8, 0x3d, 0x54, 0x38, 0xfa, 0x37, 0x07, 0xb2, 0xd8,
+ 0xfb, 0x0c, 0xd3, 0x58, 0xd3, 0xcf, 0x43, 0x26, 0x4d, 0x3f, 0xef, 0xf7, 0x43, 0xa6, 0x00, 0x9e,
+ 0x86, 0x4c, 0x9a, 0x7e, 0xae, 0x1e, 0xa3, 0x7c, 0x0c, 0x87, 0xa8, 0x10, 0xc1, 0x41, 0x1f, 0xc9,
+ 0x31, 0x54, 0x51, 0x31, 0x86, 0xa7, 0xa8, 0x14, 0xc1, 0x61, 0x1f, 0x3d, 0x8f, 0xa1, 0x8a, 0xca,
+ 0x11, 0x1c, 0x0d, 0x11, 0xc4, 0x70, 0x84, 0xf6, 0x22, 0x78, 0x72, 0x8a, 0x2a, 0x31, 0x3c, 0x43,
+ 0xfb, 0x11, 0x3c, 0x1b, 0xa0, 0x6a, 0xd0, 0x42, 0x50, 0x4e, 0x6f, 0x84, 0x6a, 0x09, 0x3e, 0x41,
+ 0x28, 0xc6, 0x6a, 0x1f, 0xd5, 0x63, 0x3c, 0x50, 0x11, 0x4e, 0xf0, 0x00, 0xbd, 0x48, 0xf0, 0x10,
+ 0xbd, 0x17, 0xe3, 0x51, 0x0f, 0xbd, 0x4c, 0xb0, 0x8a, 0x0e, 0x62, 0x7c, 0x7a, 0x86, 0x1a, 0x11,
+ 0x56, 0xfb, 0x23, 0xa4, 0x24, 0xf8, 0x04, 0x1d, 0xc6, 0xf8, 0x78, 0x88, 0x9a, 0x31, 0x1e, 0x1d,
+ 0xa3, 0x57, 0x31, 0x3e, 0xe9, 0xa1, 0xd7, 0x09, 0x1e, 0xa0, 0xf7, 0xe7, 0x45, 0xf1, 0x9f, 0xf8,
+ 0xe0, 0xbf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6a, 0xdb, 0x0f, 0xb8, 0x96, 0x0b, 0x00, 0x00,
+}
--- /dev/null
+syntax = "proto3";
+package entities;
+
+message Gnb{
+ repeated ServedNRCell served_nr_cells = 1;
+}
+
+message ServedNRCell{
+ ServedNRCellInformation served_nr_cell_information = 1;
+ repeated NrNeighbourInformation nr_neighbour_infos = 2;
+}
+
+message ServedNRCellInformation{
+ uint32 nr_pci = 1;
+ string cell_id = 2;
+ string stac5g = 3;
+ string configured_stac = 4;
+ repeated string served_plmns= 5;
+ Nr.Mode nr_mode = 6;
+ message ChoiceNRMode{
+ message FddInfo{
+ NrFrequencyInfo ul_freq_info = 1;
+ NrFrequencyInfo dl_freq_info = 2;
+ NrTransmissionBandwidth ul_transmission_bandwidth = 3;
+ NrTransmissionBandwidth dl_transmission_bandwidth = 4;
+ }
+ message TddInfo{
+ NrFrequencyInfo nr_freq_info = 1;
+ NrTransmissionBandwidth transmission_bandwidth = 2;
+ }
+ FddInfo fdd = 1;
+ TddInfo tdd = 2;
+ }
+ ChoiceNRMode choice_nr_mode = 7;
+}
+
+message Nr{
+ enum Mode{
+ UNKNOWN = 0;
+ FDD = 1;
+ TDD = 2;
+ }
+}
+
+message NrFrequencyInfo{
+ uint64 nr_ar_fcn = 1;
+ message SulInformation{
+ uint64 sul_ar_fcn = 1;
+ NrTransmissionBandwidth sul_transmission_bandwidth = 2;
+ }
+ SulInformation sulInformation = 3;
+ repeated FrequencyBandItem frequency_bands = 4;
+}
+
+message FrequencyBandItem{
+ uint32 nr_frequency_band = 1;
+ repeated uint32 supported_sul_bands = 2;
+}
+
+message NrTransmissionBandwidth{
+ Nrscs nrscs = 1;
+ Ncnrb ncnrb= 2;
+}
+
+enum Nrscs {
+ UNKNOWN_NRSCS = 0;
+ SCS15 = 1;
+ SCS30 = 2;
+ SCS60 = 3;
+ SCS120 = 4;
+}
+
+enum Ncnrb{
+ UNKNOWN_NCNRB = 0;
+ NRB11 =1;
+ NRB18 =2;
+ NRB24 =3;
+ NRB25 =4;
+ NRB31 =5;
+ NRB32 =6;
+ NRB38 =7;
+ NRB51 =8;
+ NRB52 =9;
+ NRB65 =10;
+ NRB66 =11;
+ NRB78 =12;
+ NRB79 =13;
+ NRB93 =14;
+ NRB106 =15;
+ NRB107 =16;
+ NRB121 =17;
+ NRB132 =18;
+ NRB133 =19;
+ NRB135 =20;
+ NRB160 =21;
+ NRB162 =22;
+ NRB189 =23;
+ NRB216 =24;
+ NRB217 =25;
+ NRB245 =26;
+ NRB264 =27;
+ NRB270 =28;
+ NRB273 =29;
+}
+
+message NrNeighbourInformation{
+ uint32 nr_pci = 1;
+ string nr_cgi = 2;
+ Nr.Mode nr_mode = 3;
+ message ChoiceNRMode{
+ message FddInfo{
+ NrFrequencyInfo ular_fcn_freq_info = 1;
+ NrFrequencyInfo dlar_fcn_freq_info = 2;
+ }
+ message TddInfo{
+ NrFrequencyInfo ar_fcn_nr_freq_info = 1;
+ }
+ FddInfo fdd = 1;
+ TddInfo tdd = 2;
+ }
+ ChoiceNRMode choice_nr_mode = 4;
+ string stac5g = 5;
+ string configured_stac = 6;
+}
\ No newline at end of file
--- /dev/null
+module gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/entities
+
+go 1.12
+
+require github.com/golang/protobuf v1.3.1
--- /dev/null
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
--- /dev/null
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: nb_identity.proto
+
+package entities
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type NbIdentity struct {
+ InventoryName string `protobuf:"bytes,1,opt,name=inventory_name,json=inventoryName,proto3" json:"inventory_name,omitempty"`
+ GlobalNbId *GlobalNbId `protobuf:"bytes,2,opt,name=global_nb_id,json=globalNbId,proto3" json:"global_nb_id,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NbIdentity) Reset() { *m = NbIdentity{} }
+func (m *NbIdentity) String() string { return proto.CompactTextString(m) }
+func (*NbIdentity) ProtoMessage() {}
+func (*NbIdentity) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a07701eb9efb4b89, []int{0}
+}
+
+func (m *NbIdentity) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NbIdentity.Unmarshal(m, b)
+}
+func (m *NbIdentity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NbIdentity.Marshal(b, m, deterministic)
+}
+func (m *NbIdentity) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NbIdentity.Merge(m, src)
+}
+func (m *NbIdentity) XXX_Size() int {
+ return xxx_messageInfo_NbIdentity.Size(m)
+}
+func (m *NbIdentity) XXX_DiscardUnknown() {
+ xxx_messageInfo_NbIdentity.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NbIdentity proto.InternalMessageInfo
+
+func (m *NbIdentity) GetInventoryName() string {
+ if m != nil {
+ return m.InventoryName
+ }
+ return ""
+}
+
+func (m *NbIdentity) GetGlobalNbId() *GlobalNbId {
+ if m != nil {
+ return m.GlobalNbId
+ }
+ return nil
+}
+
+type GlobalNbId struct {
+ PlmnId string `protobuf:"bytes,1,opt,name=plmn_id,json=plmnId,proto3" json:"plmn_id,omitempty"`
+ NbId string `protobuf:"bytes,2,opt,name=nb_id,json=nbId,proto3" json:"nb_id,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *GlobalNbId) Reset() { *m = GlobalNbId{} }
+func (m *GlobalNbId) String() string { return proto.CompactTextString(m) }
+func (*GlobalNbId) ProtoMessage() {}
+func (*GlobalNbId) Descriptor() ([]byte, []int) {
+ return fileDescriptor_a07701eb9efb4b89, []int{1}
+}
+
+func (m *GlobalNbId) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_GlobalNbId.Unmarshal(m, b)
+}
+func (m *GlobalNbId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_GlobalNbId.Marshal(b, m, deterministic)
+}
+func (m *GlobalNbId) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GlobalNbId.Merge(m, src)
+}
+func (m *GlobalNbId) XXX_Size() int {
+ return xxx_messageInfo_GlobalNbId.Size(m)
+}
+func (m *GlobalNbId) XXX_DiscardUnknown() {
+ xxx_messageInfo_GlobalNbId.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GlobalNbId proto.InternalMessageInfo
+
+func (m *GlobalNbId) GetPlmnId() string {
+ if m != nil {
+ return m.PlmnId
+ }
+ return ""
+}
+
+func (m *GlobalNbId) GetNbId() string {
+ if m != nil {
+ return m.NbId
+ }
+ return ""
+}
+
+func init() {
+ proto.RegisterType((*NbIdentity)(nil), "entities.NbIdentity")
+ proto.RegisterType((*GlobalNbId)(nil), "entities.GlobalNbId")
+}
+
+func init() { proto.RegisterFile("nb_identity.proto", fileDescriptor_a07701eb9efb4b89) }
+
+var fileDescriptor_a07701eb9efb4b89 = []byte{
+ // 167 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcc, 0x4b, 0x8a, 0xcf,
+ 0x4c, 0x49, 0xcd, 0x2b, 0xc9, 0x2c, 0xa9, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x00,
+ 0xf3, 0x32, 0x53, 0x8b, 0x95, 0xb2, 0xb9, 0xb8, 0xfc, 0x92, 0x3c, 0xa1, 0xb2, 0x42, 0xaa, 0x5c,
+ 0x7c, 0x99, 0x79, 0x65, 0xa9, 0x79, 0x25, 0xf9, 0x45, 0x95, 0xf1, 0x79, 0x89, 0xb9, 0xa9, 0x12,
+ 0x8c, 0x0a, 0x8c, 0x1a, 0x9c, 0x41, 0xbc, 0x70, 0x51, 0xbf, 0xc4, 0xdc, 0x54, 0x21, 0x33, 0x2e,
+ 0x9e, 0xf4, 0x9c, 0xfc, 0xa4, 0xc4, 0x9c, 0x78, 0xb0, 0xd1, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xdc,
+ 0x46, 0x22, 0x7a, 0x30, 0x53, 0xf5, 0xdc, 0xc1, 0xb2, 0x20, 0x83, 0x83, 0xb8, 0xd2, 0xe1, 0x6c,
+ 0x25, 0x2b, 0x2e, 0x2e, 0x84, 0x8c, 0x90, 0x38, 0x17, 0x7b, 0x41, 0x4e, 0x6e, 0x1e, 0xc8, 0x00,
+ 0x88, 0x2d, 0x6c, 0x20, 0xae, 0x67, 0x8a, 0x90, 0x30, 0x17, 0x2b, 0xc2, 0x5c, 0xce, 0x20, 0x96,
+ 0xbc, 0x24, 0xcf, 0x94, 0x24, 0x36, 0xb0, 0xcb, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x3f,
+ 0x65, 0xd0, 0x4b, 0xce, 0x00, 0x00, 0x00,
+}
--- /dev/null
+syntax = "proto3";
+package entities;
+
+message NbIdentity{
+ string inventory_name = 1;
+ GlobalNbId global_nb_id = 2;
+}
+
+message GlobalNbId{
+ string plmn_id = 1;
+ string nb_id = 2;
+}
--- /dev/null
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: nodeb_info.proto
+
+package entities
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type ConnectionStatus int32
+
+const (
+ ConnectionStatus_UNKNOWN_CONNECTION_STATUS ConnectionStatus = 0
+ ConnectionStatus_CONNECTED ConnectionStatus = 1
+ ConnectionStatus_NOT_CONNECTED ConnectionStatus = 2
+ ConnectionStatus_CONNECTED_SETUP_FAILED ConnectionStatus = 3
+ ConnectionStatus_CONNECTING ConnectionStatus = 4
+)
+
+var ConnectionStatus_name = map[int32]string{
+ 0: "UNKNOWN_CONNECTION_STATUS",
+ 1: "CONNECTED",
+ 2: "NOT_CONNECTED",
+ 3: "CONNECTED_SETUP_FAILED",
+ 4: "CONNECTING",
+}
+
+var ConnectionStatus_value = map[string]int32{
+ "UNKNOWN_CONNECTION_STATUS": 0,
+ "CONNECTED": 1,
+ "NOT_CONNECTED": 2,
+ "CONNECTED_SETUP_FAILED": 3,
+ "CONNECTING": 4,
+}
+
+func (x ConnectionStatus) String() string {
+ return proto.EnumName(ConnectionStatus_name, int32(x))
+}
+
+func (ConnectionStatus) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_04b920976079e56c, []int{0}
+}
+
+type Node_Type int32
+
+const (
+ Node_UNKNOWN Node_Type = 0
+ Node_ENB Node_Type = 1
+ Node_GNB Node_Type = 2
+)
+
+var Node_Type_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "ENB",
+ 2: "GNB",
+}
+
+var Node_Type_value = map[string]int32{
+ "UNKNOWN": 0,
+ "ENB": 1,
+ "GNB": 2,
+}
+
+func (x Node_Type) String() string {
+ return proto.EnumName(Node_Type_name, int32(x))
+}
+
+func (Node_Type) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_04b920976079e56c, []int{1, 0}
+}
+
+type Failure_Type int32
+
+const (
+ Failure_UNKNOWN_TYPE Failure_Type = 0
+ Failure_X2_SETUP_FAILURE Failure_Type = 1
+ Failure_ENDC_X2_SETUP_FAILURE Failure_Type = 2
+)
+
+var Failure_Type_name = map[int32]string{
+ 0: "UNKNOWN_TYPE",
+ 1: "X2_SETUP_FAILURE",
+ 2: "ENDC_X2_SETUP_FAILURE",
+}
+
+var Failure_Type_value = map[string]int32{
+ "UNKNOWN_TYPE": 0,
+ "X2_SETUP_FAILURE": 1,
+ "ENDC_X2_SETUP_FAILURE": 2,
+}
+
+func (x Failure_Type) String() string {
+ return proto.EnumName(Failure_Type_name, int32(x))
+}
+
+func (Failure_Type) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_04b920976079e56c, []int{2, 0}
+}
+
+type NodebInfo struct {
+ RanName string `protobuf:"bytes,1,opt,name=ran_name,json=ranName,proto3" json:"ran_name,omitempty"`
+ Ip string `protobuf:"bytes,2,opt,name=ip,proto3" json:"ip,omitempty"`
+ Port uint32 `protobuf:"varint,3,opt,name=port,proto3" json:"port,omitempty"`
+ ConnectionStatus ConnectionStatus `protobuf:"varint,4,opt,name=connection_status,json=connectionStatus,proto3,enum=entities.ConnectionStatus" json:"connection_status,omitempty"`
+ GlobalNbId *GlobalNbId `protobuf:"bytes,5,opt,name=global_nb_id,json=globalNbId,proto3" json:"global_nb_id,omitempty"`
+ NodeType Node_Type `protobuf:"varint,6,opt,name=node_type,json=nodeType,proto3,enum=entities.Node_Type" json:"node_type,omitempty"`
+ // Types that are valid to be assigned to Configuration:
+ // *NodebInfo_Enb
+ // *NodebInfo_Gnb
+ Configuration isNodebInfo_Configuration `protobuf_oneof:"configuration"`
+ FailureType Failure_Type `protobuf:"varint,9,opt,name=failure_type,json=failureType,proto3,enum=entities.Failure_Type" json:"failure_type,omitempty"`
+ SetupFailure *SetupFailure `protobuf:"bytes,10,opt,name=setup_failure,json=setupFailure,proto3" json:"setup_failure,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *NodebInfo) Reset() { *m = NodebInfo{} }
+func (m *NodebInfo) String() string { return proto.CompactTextString(m) }
+func (*NodebInfo) ProtoMessage() {}
+func (*NodebInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_04b920976079e56c, []int{0}
+}
+
+func (m *NodebInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_NodebInfo.Unmarshal(m, b)
+}
+func (m *NodebInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_NodebInfo.Marshal(b, m, deterministic)
+}
+func (m *NodebInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_NodebInfo.Merge(m, src)
+}
+func (m *NodebInfo) XXX_Size() int {
+ return xxx_messageInfo_NodebInfo.Size(m)
+}
+func (m *NodebInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_NodebInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_NodebInfo proto.InternalMessageInfo
+
+func (m *NodebInfo) GetRanName() string {
+ if m != nil {
+ return m.RanName
+ }
+ return ""
+}
+
+func (m *NodebInfo) GetIp() string {
+ if m != nil {
+ return m.Ip
+ }
+ return ""
+}
+
+func (m *NodebInfo) GetPort() uint32 {
+ if m != nil {
+ return m.Port
+ }
+ return 0
+}
+
+func (m *NodebInfo) GetConnectionStatus() ConnectionStatus {
+ if m != nil {
+ return m.ConnectionStatus
+ }
+ return ConnectionStatus_UNKNOWN_CONNECTION_STATUS
+}
+
+func (m *NodebInfo) GetGlobalNbId() *GlobalNbId {
+ if m != nil {
+ return m.GlobalNbId
+ }
+ return nil
+}
+
+func (m *NodebInfo) GetNodeType() Node_Type {
+ if m != nil {
+ return m.NodeType
+ }
+ return Node_UNKNOWN
+}
+
+type isNodebInfo_Configuration interface {
+ isNodebInfo_Configuration()
+}
+
+type NodebInfo_Enb struct {
+ Enb *Enb `protobuf:"bytes,7,opt,name=enb,proto3,oneof"`
+}
+
+type NodebInfo_Gnb struct {
+ Gnb *Gnb `protobuf:"bytes,8,opt,name=gnb,proto3,oneof"`
+}
+
+func (*NodebInfo_Enb) isNodebInfo_Configuration() {}
+
+func (*NodebInfo_Gnb) isNodebInfo_Configuration() {}
+
+func (m *NodebInfo) GetConfiguration() isNodebInfo_Configuration {
+ if m != nil {
+ return m.Configuration
+ }
+ return nil
+}
+
+func (m *NodebInfo) GetEnb() *Enb {
+ if x, ok := m.GetConfiguration().(*NodebInfo_Enb); ok {
+ return x.Enb
+ }
+ return nil
+}
+
+func (m *NodebInfo) GetGnb() *Gnb {
+ if x, ok := m.GetConfiguration().(*NodebInfo_Gnb); ok {
+ return x.Gnb
+ }
+ return nil
+}
+
+func (m *NodebInfo) GetFailureType() Failure_Type {
+ if m != nil {
+ return m.FailureType
+ }
+ return Failure_UNKNOWN_TYPE
+}
+
+func (m *NodebInfo) GetSetupFailure() *SetupFailure {
+ if m != nil {
+ return m.SetupFailure
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*NodebInfo) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*NodebInfo_Enb)(nil),
+ (*NodebInfo_Gnb)(nil),
+ }
+}
+
+type Node struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Node) Reset() { *m = Node{} }
+func (m *Node) String() string { return proto.CompactTextString(m) }
+func (*Node) ProtoMessage() {}
+func (*Node) Descriptor() ([]byte, []int) {
+ return fileDescriptor_04b920976079e56c, []int{1}
+}
+
+func (m *Node) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Node.Unmarshal(m, b)
+}
+func (m *Node) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Node.Marshal(b, m, deterministic)
+}
+func (m *Node) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Node.Merge(m, src)
+}
+func (m *Node) XXX_Size() int {
+ return xxx_messageInfo_Node.Size(m)
+}
+func (m *Node) XXX_DiscardUnknown() {
+ xxx_messageInfo_Node.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Node proto.InternalMessageInfo
+
+type Failure struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Failure) Reset() { *m = Failure{} }
+func (m *Failure) String() string { return proto.CompactTextString(m) }
+func (*Failure) ProtoMessage() {}
+func (*Failure) Descriptor() ([]byte, []int) {
+ return fileDescriptor_04b920976079e56c, []int{2}
+}
+
+func (m *Failure) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Failure.Unmarshal(m, b)
+}
+func (m *Failure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Failure.Marshal(b, m, deterministic)
+}
+func (m *Failure) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Failure.Merge(m, src)
+}
+func (m *Failure) XXX_Size() int {
+ return xxx_messageInfo_Failure.Size(m)
+}
+func (m *Failure) XXX_DiscardUnknown() {
+ xxx_messageInfo_Failure.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Failure proto.InternalMessageInfo
+
+func init() {
+ proto.RegisterEnum("entities.ConnectionStatus", ConnectionStatus_name, ConnectionStatus_value)
+ proto.RegisterEnum("entities.Node_Type", Node_Type_name, Node_Type_value)
+ proto.RegisterEnum("entities.Failure_Type", Failure_Type_name, Failure_Type_value)
+ proto.RegisterType((*NodebInfo)(nil), "entities.NodebInfo")
+ proto.RegisterType((*Node)(nil), "entities.Node")
+ proto.RegisterType((*Failure)(nil), "entities.Failure")
+}
+
+func init() { proto.RegisterFile("nodeb_info.proto", fileDescriptor_04b920976079e56c) }
+
+var fileDescriptor_04b920976079e56c = []byte{
+ // 506 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x52, 0x51, 0x8b, 0xda, 0x4c,
+ 0x14, 0x35, 0xd1, 0x6f, 0x35, 0x57, 0xe3, 0x37, 0x4e, 0xb7, 0x4b, 0x14, 0x4a, 0xad, 0x50, 0x90,
+ 0x42, 0xa5, 0x58, 0x28, 0x94, 0x3e, 0xad, 0x9a, 0xb5, 0xd2, 0x32, 0x2e, 0x31, 0xd2, 0xf6, 0x69,
+ 0xc8, 0xe8, 0x18, 0x02, 0xee, 0x4c, 0x48, 0x22, 0xd4, 0xa7, 0xfe, 0xc1, 0xfe, 0xa8, 0x32, 0x93,
+ 0x68, 0xac, 0x7d, 0xbb, 0x73, 0xce, 0xb9, 0xe7, 0xdc, 0xb9, 0x33, 0x80, 0x84, 0xdc, 0x72, 0x46,
+ 0x23, 0xb1, 0x93, 0xa3, 0x38, 0x91, 0x99, 0xc4, 0x0d, 0x2e, 0xb2, 0x28, 0x8b, 0x78, 0xda, 0xb3,
+ 0x42, 0xc1, 0x72, 0xb0, 0x67, 0xf1, 0x73, 0xf9, 0xf2, 0xe7, 0x98, 0xa6, 0x3c, 0x3b, 0xc4, 0x74,
+ 0x17, 0x44, 0xfb, 0x43, 0xc2, 0x69, 0xc2, 0xd3, 0x58, 0x8a, 0x94, 0x17, 0x82, 0x8e, 0x60, 0x34,
+ 0xda, 0x6a, 0x97, 0x63, 0x0e, 0x0d, 0x7e, 0x57, 0xc1, 0x22, 0x2a, 0x68, 0x21, 0x76, 0x12, 0x77,
+ 0xa1, 0x91, 0x04, 0x82, 0x8a, 0xe0, 0x89, 0x3b, 0x46, 0xdf, 0x18, 0x5a, 0x5e, 0x3d, 0x09, 0x04,
+ 0x09, 0x9e, 0x38, 0x6e, 0x83, 0x19, 0xc5, 0x8e, 0xa9, 0x41, 0x33, 0x8a, 0x31, 0x86, 0x5a, 0x2c,
+ 0x93, 0xcc, 0xa9, 0xf6, 0x8d, 0xa1, 0xed, 0xe9, 0x1a, 0xcf, 0xa1, 0xb3, 0x91, 0x42, 0xf0, 0x4d,
+ 0x16, 0x49, 0x41, 0xd3, 0x2c, 0xc8, 0x0e, 0xa9, 0x53, 0xeb, 0x1b, 0xc3, 0xf6, 0xb8, 0x37, 0x3a,
+ 0x0d, 0x3f, 0x9a, 0x9e, 0x25, 0x2b, 0xad, 0xf0, 0xd0, 0xe6, 0x0a, 0xc1, 0x1f, 0xa0, 0x15, 0xee,
+ 0x25, 0x0b, 0xf6, 0x54, 0x4f, 0xec, 0xfc, 0xd7, 0x37, 0x86, 0xcd, 0xf1, 0x6d, 0xe9, 0x31, 0xd7,
+ 0x2c, 0x61, 0x8b, 0xad, 0x07, 0xe1, 0xb9, 0xc6, 0xef, 0xc0, 0x52, 0x5b, 0xa3, 0xd9, 0x31, 0xe6,
+ 0xce, 0x8d, 0x0e, 0x7e, 0x56, 0x36, 0xa9, 0x7b, 0x8e, 0xfc, 0x63, 0xcc, 0xbd, 0x86, 0x52, 0xa9,
+ 0x0a, 0xbf, 0x82, 0x2a, 0x17, 0xcc, 0xa9, 0xeb, 0x00, 0xbb, 0xd4, 0xba, 0x82, 0x7d, 0xae, 0x78,
+ 0x8a, 0x53, 0x92, 0x50, 0x30, 0xa7, 0x71, 0x2d, 0x99, 0xe7, 0x92, 0x50, 0x30, 0xfc, 0x11, 0x5a,
+ 0xa7, 0x95, 0xeb, 0x68, 0x4b, 0x47, 0xdf, 0x95, 0xda, 0x87, 0x9c, 0xcd, 0xd3, 0x9b, 0x85, 0x56,
+ 0x0f, 0xf0, 0x09, 0xec, 0xbf, 0xde, 0xcc, 0x01, 0x9d, 0x73, 0xd1, 0xbb, 0x52, 0x74, 0x61, 0xe0,
+ 0xb5, 0xd2, 0x8b, 0xd3, 0xe4, 0x7f, 0xb0, 0x37, 0x52, 0xec, 0xa2, 0xf0, 0x90, 0x04, 0x6a, 0x7d,
+ 0x83, 0xb7, 0x50, 0x53, 0xb7, 0x1c, 0xbc, 0x86, 0x9a, 0x76, 0x6f, 0x42, 0x7d, 0x4d, 0xbe, 0x90,
+ 0xe5, 0x37, 0x82, 0x2a, 0xb8, 0x0e, 0x55, 0x97, 0x4c, 0x90, 0xa1, 0x8a, 0x39, 0x99, 0x20, 0x73,
+ 0xe0, 0x43, 0xbd, 0xb0, 0x1a, 0x2c, 0x8a, 0x0e, 0x04, 0xad, 0xa2, 0x83, 0xfa, 0x3f, 0x1e, 0x5d,
+ 0x54, 0xc1, 0xb7, 0x80, 0xbe, 0x8f, 0xe9, 0xca, 0xf5, 0xd7, 0x8f, 0xf4, 0xe1, 0x7e, 0xf1, 0x75,
+ 0xed, 0xb9, 0xc8, 0xc0, 0x5d, 0x78, 0xee, 0x92, 0xd9, 0x94, 0xfe, 0x43, 0x99, 0x6f, 0x7e, 0x01,
+ 0xba, 0x7e, 0x63, 0xfc, 0x02, 0xba, 0x27, 0xdb, 0xe9, 0x92, 0x10, 0x77, 0xea, 0x2f, 0x96, 0x84,
+ 0xae, 0xfc, 0x7b, 0x7f, 0xbd, 0x42, 0x15, 0x6c, 0x83, 0x55, 0xc0, 0xee, 0x0c, 0x19, 0xb8, 0x03,
+ 0x36, 0x59, 0xfa, 0xb4, 0x84, 0x4c, 0xdc, 0x83, 0xbb, 0xf3, 0xf1, 0x22, 0xd1, 0x9d, 0xa1, 0x2a,
+ 0x6e, 0x03, 0x9c, 0x4c, 0xc9, 0x1c, 0xd5, 0xd8, 0x8d, 0xfe, 0xdb, 0xef, 0xff, 0x04, 0x00, 0x00,
+ 0xff, 0xff, 0x44, 0xa7, 0x9d, 0x8f, 0x43, 0x03, 0x00, 0x00,
+}
--- /dev/null
+syntax = "proto3";
+package entities;
+import "gnb.proto";
+import "enb.proto";
+import "x2_setup_failure_response.proto";
+import "nb_identity.proto";
+
+message NodebInfo{
+ string ran_name = 1;
+ string ip = 2;
+ uint32 port = 3;
+ ConnectionStatus connection_status = 4;
+ GlobalNbId global_nb_id = 5;
+ Node.Type node_type = 6;
+ oneof configuration{
+ Enb enb = 7;
+ Gnb gnb = 8;
+ }
+ Failure.Type failure_type = 9;
+ SetupFailure setup_failure = 10;
+}
+
+enum ConnectionStatus{
+ UNKNOWN_CONNECTION_STATUS = 0;
+ CONNECTED = 1;
+ NOT_CONNECTED = 2;
+ CONNECTED_SETUP_FAILED = 3;
+ CONNECTING = 4;
+}
+
+message Node{
+ enum Type{
+ UNKNOWN = 0;
+ ENB = 1;
+ GNB = 2;
+ }
+}
+
+message Failure{
+ enum Type{
+ UNKNOWN_TYPE = 0;
+ X2_SETUP_FAILURE = 1;
+ ENDC_X2_SETUP_FAILURE = 2;
+ }
+}
--- /dev/null
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: x2_setup_failure_response.proto
+
+package entities
+
+import (
+ fmt "fmt"
+ proto "github.com/golang/protobuf/proto"
+ math "math"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
+
+type TypeOfError int32
+
+const (
+ TypeOfError_UNKNOWN_ERROR TypeOfError = 0
+ TypeOfError_NOT_UNDERSTOOD TypeOfError = 1
+ TypeOfError_MISSING TypeOfError = 2
+)
+
+var TypeOfError_name = map[int32]string{
+ 0: "UNKNOWN_ERROR",
+ 1: "NOT_UNDERSTOOD",
+ 2: "MISSING",
+}
+
+var TypeOfError_value = map[string]int32{
+ "UNKNOWN_ERROR": 0,
+ "NOT_UNDERSTOOD": 1,
+ "MISSING": 2,
+}
+
+func (x TypeOfError) String() string {
+ return proto.EnumName(TypeOfError_name, int32(x))
+}
+
+func (TypeOfError) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{0}
+}
+
+type TimeToWait int32
+
+const (
+ TimeToWait_UNKNOWN_TIMEOUT TimeToWait = 0
+ TimeToWait_V1S TimeToWait = 1
+ TimeToWait_V2S TimeToWait = 2
+ TimeToWait_V5S TimeToWait = 3
+ TimeToWait_V10S TimeToWait = 4
+ TimeToWait_V20S TimeToWait = 5
+ TimeToWait_V60S TimeToWait = 6
+)
+
+var TimeToWait_name = map[int32]string{
+ 0: "UNKNOWN_TIMEOUT",
+ 1: "V1S",
+ 2: "V2S",
+ 3: "V5S",
+ 4: "V10S",
+ 5: "V20S",
+ 6: "V60S",
+}
+
+var TimeToWait_value = map[string]int32{
+ "UNKNOWN_TIMEOUT": 0,
+ "V1S": 1,
+ "V2S": 2,
+ "V5S": 3,
+ "V10S": 4,
+ "V20S": 5,
+ "V60S": 6,
+}
+
+func (x TimeToWait) String() string {
+ return proto.EnumName(TimeToWait_name, int32(x))
+}
+
+func (TimeToWait) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{1}
+}
+
+type TriggeringMessage int32
+
+const (
+ TriggeringMessage_UNKNOWN_MESSAGE TriggeringMessage = 0
+ TriggeringMessage_INITIATING_MESSAGE TriggeringMessage = 1
+ TriggeringMessage_SUCCESSFUL_OUTCOME TriggeringMessage = 2
+ TriggeringMessage_UNSUCCESSFUL_OUTCOME TriggeringMessage = 3
+)
+
+var TriggeringMessage_name = map[int32]string{
+ 0: "UNKNOWN_MESSAGE",
+ 1: "INITIATING_MESSAGE",
+ 2: "SUCCESSFUL_OUTCOME",
+ 3: "UNSUCCESSFUL_OUTCOME",
+}
+
+var TriggeringMessage_value = map[string]int32{
+ "UNKNOWN_MESSAGE": 0,
+ "INITIATING_MESSAGE": 1,
+ "SUCCESSFUL_OUTCOME": 2,
+ "UNSUCCESSFUL_OUTCOME": 3,
+}
+
+func (x TriggeringMessage) String() string {
+ return proto.EnumName(TriggeringMessage_name, int32(x))
+}
+
+func (TriggeringMessage) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{2}
+}
+
+type Criticality int32
+
+const (
+ Criticality_UNKNOWN_CRITICALITY Criticality = 0
+ Criticality_REJECT Criticality = 1
+ Criticality_IGNORE Criticality = 2
+ Criticality_NOTIFY Criticality = 3
+)
+
+var Criticality_name = map[int32]string{
+ 0: "UNKNOWN_CRITICALITY",
+ 1: "REJECT",
+ 2: "IGNORE",
+ 3: "NOTIFY",
+}
+
+var Criticality_value = map[string]int32{
+ "UNKNOWN_CRITICALITY": 0,
+ "REJECT": 1,
+ "IGNORE": 2,
+ "NOTIFY": 3,
+}
+
+func (x Criticality) String() string {
+ return proto.EnumName(Criticality_name, int32(x))
+}
+
+func (Criticality) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{3}
+}
+
+type RadioNetworkLayer_Cause int32
+
+const (
+ RadioNetworkLayer_UNKNOWN RadioNetworkLayer_Cause = 0
+ RadioNetworkLayer_HANDOVER_DESIRABLE_FOR_RADIO_REASONS RadioNetworkLayer_Cause = 1
+ RadioNetworkLayer_TIME_CRITICAL_HANDOVER RadioNetworkLayer_Cause = 2
+ RadioNetworkLayer_RESOURCE_OPTIMISATION_HANDOVER RadioNetworkLayer_Cause = 3
+ RadioNetworkLayer_REDUCE_LOAD_IN_SERVING_CELL RadioNetworkLayer_Cause = 4
+ RadioNetworkLayer_PARTIAL_HANDOVER RadioNetworkLayer_Cause = 5
+ RadioNetworkLayer_UNKNOWN_NEW_ENB_UE_X2AP_ID RadioNetworkLayer_Cause = 6
+ RadioNetworkLayer_UNKNOWN_OLD_ENBME_UE_X2AP_ID RadioNetworkLayer_Cause = 7
+ RadioNetworkLayer_UNKNOWN_PAIR_OF_UE_X2AP_ID RadioNetworkLayer_Cause = 8
+ RadioNetworkLayer_HO_TARGET_NOT_ALLOWED RadioNetworkLayer_Cause = 9
+ RadioNetworkLayer_TX2_RELOC_OVERALL_EXPIRY RadioNetworkLayer_Cause = 10
+ RadioNetworkLayer_T_RELOC_PREP_EXPIRY RadioNetworkLayer_Cause = 11
+ RadioNetworkLayer_CELL_NOT_AVAILABLE RadioNetworkLayer_Cause = 12
+ RadioNetworkLayer_NO_RADIO_RESOURCES_AVAILABLE_IN_TARGET_CELL RadioNetworkLayer_Cause = 13
+ RadioNetworkLayer_INVALID_MME_GROUP_ID RadioNetworkLayer_Cause = 14
+ RadioNetworkLayer_UNKNOWN_MME_CODE RadioNetworkLayer_Cause = 15
+ RadioNetworkLayer_ENCRYPTION_INTEGRITY_PROTECTION_ALGORITHMS_NOT_SUPPORTED RadioNetworkLayer_Cause = 16
+ RadioNetworkLayer_REPORT_CHARACTERISTICS_EMPTY RadioNetworkLayer_Cause = 17
+ RadioNetworkLayer_NO_REPORT_PERIODICITY RadioNetworkLayer_Cause = 18
+ RadioNetworkLayer_EXISTING_MEASUREMENT_ID RadioNetworkLayer_Cause = 19
+ RadioNetworkLayer_UNKNOWN_ENB_MEASUREMENT_ID RadioNetworkLayer_Cause = 20
+ RadioNetworkLayer_MEASUREMENT_TEMPORARILY_NOT_AVAILABLE RadioNetworkLayer_Cause = 21
+ RadioNetworkLayer_UNSPECIFIED RadioNetworkLayer_Cause = 22
+ RadioNetworkLayer_LOAD_BALANCING RadioNetworkLayer_Cause = 23
+ RadioNetworkLayer_HANDOVER_OPTIMISATION RadioNetworkLayer_Cause = 24
+ RadioNetworkLayer_VALUE_OUT_OF_ALLOWED_RANGE RadioNetworkLayer_Cause = 25
+ RadioNetworkLayer_MULTIPLE_E_RAB_ID_INSTANCES RadioNetworkLayer_Cause = 26
+ RadioNetworkLayer_SWITCH_OFF_ONGOING RadioNetworkLayer_Cause = 27
+ RadioNetworkLayer_NOT_SUPPORTED_QCI_VALUE RadioNetworkLayer_Cause = 28
+ RadioNetworkLayer_MEASUREMENT_NOT_SUPPORTED_FOR_THE_OBJECT RadioNetworkLayer_Cause = 29
+ RadioNetworkLayer_TDC_OVERALL_EXPIRY RadioNetworkLayer_Cause = 30
+ RadioNetworkLayer_TDC_PREP_EXPIRY RadioNetworkLayer_Cause = 31
+ RadioNetworkLayer_ACTION_DESIRABLE_FOR_RADIO_REASONS RadioNetworkLayer_Cause = 32
+ RadioNetworkLayer_REDUCE_LOAD RadioNetworkLayer_Cause = 33
+ RadioNetworkLayer_RESOURCE_OPTIMISATION RadioNetworkLayer_Cause = 34
+ RadioNetworkLayer_TIME_CRITICAL_ACTION RadioNetworkLayer_Cause = 35
+ RadioNetworkLayer_TARGET_NOT_ALLOWED RadioNetworkLayer_Cause = 36
+ RadioNetworkLayer_NO_RADIO_RESOURCES_AVAILABLE RadioNetworkLayer_Cause = 37
+ RadioNetworkLayer_INVALID_QOS_COMBINATION RadioNetworkLayer_Cause = 38
+ RadioNetworkLayer_ENCRYPTION_ALGORITHMS_NOT_SUPPORTED RadioNetworkLayer_Cause = 39
+ RadioNetworkLayer_PROCEDURE_CANCELLED RadioNetworkLayer_Cause = 40
+ RadioNetworkLayer_RRM_PURPOSE RadioNetworkLayer_Cause = 41
+ RadioNetworkLayer_IMPROVE_USER_BIT_RATE RadioNetworkLayer_Cause = 42
+ RadioNetworkLayer_USER_INACTIVITY RadioNetworkLayer_Cause = 43
+ RadioNetworkLayer_RADIO_CONNECTION_WITH_UE_LOST RadioNetworkLayer_Cause = 44
+ RadioNetworkLayer_FAILURE_IN_THE_RADIO_INTERFACE_PROCEDURE RadioNetworkLayer_Cause = 45
+ RadioNetworkLayer_BEARER_OPTION_NOT_SUPPORTED RadioNetworkLayer_Cause = 46
+ RadioNetworkLayer_MCG_MOBILITY RadioNetworkLayer_Cause = 47
+ RadioNetworkLayer_SCG_MOBILITY RadioNetworkLayer_Cause = 48
+ RadioNetworkLayer_COUNT_REACHES_MAX_VALUE RadioNetworkLayer_Cause = 49
+ RadioNetworkLayer_UNKNOWN_OLD_EN_GNB_UE_X2AP_ID RadioNetworkLayer_Cause = 50
+ RadioNetworkLayer_PDCP_OVERLOAD RadioNetworkLayer_Cause = 51
+)
+
+var RadioNetworkLayer_Cause_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "HANDOVER_DESIRABLE_FOR_RADIO_REASONS",
+ 2: "TIME_CRITICAL_HANDOVER",
+ 3: "RESOURCE_OPTIMISATION_HANDOVER",
+ 4: "REDUCE_LOAD_IN_SERVING_CELL",
+ 5: "PARTIAL_HANDOVER",
+ 6: "UNKNOWN_NEW_ENB_UE_X2AP_ID",
+ 7: "UNKNOWN_OLD_ENBME_UE_X2AP_ID",
+ 8: "UNKNOWN_PAIR_OF_UE_X2AP_ID",
+ 9: "HO_TARGET_NOT_ALLOWED",
+ 10: "TX2_RELOC_OVERALL_EXPIRY",
+ 11: "T_RELOC_PREP_EXPIRY",
+ 12: "CELL_NOT_AVAILABLE",
+ 13: "NO_RADIO_RESOURCES_AVAILABLE_IN_TARGET_CELL",
+ 14: "INVALID_MME_GROUP_ID",
+ 15: "UNKNOWN_MME_CODE",
+ 16: "ENCRYPTION_INTEGRITY_PROTECTION_ALGORITHMS_NOT_SUPPORTED",
+ 17: "REPORT_CHARACTERISTICS_EMPTY",
+ 18: "NO_REPORT_PERIODICITY",
+ 19: "EXISTING_MEASUREMENT_ID",
+ 20: "UNKNOWN_ENB_MEASUREMENT_ID",
+ 21: "MEASUREMENT_TEMPORARILY_NOT_AVAILABLE",
+ 22: "UNSPECIFIED",
+ 23: "LOAD_BALANCING",
+ 24: "HANDOVER_OPTIMISATION",
+ 25: "VALUE_OUT_OF_ALLOWED_RANGE",
+ 26: "MULTIPLE_E_RAB_ID_INSTANCES",
+ 27: "SWITCH_OFF_ONGOING",
+ 28: "NOT_SUPPORTED_QCI_VALUE",
+ 29: "MEASUREMENT_NOT_SUPPORTED_FOR_THE_OBJECT",
+ 30: "TDC_OVERALL_EXPIRY",
+ 31: "TDC_PREP_EXPIRY",
+ 32: "ACTION_DESIRABLE_FOR_RADIO_REASONS",
+ 33: "REDUCE_LOAD",
+ 34: "RESOURCE_OPTIMISATION",
+ 35: "TIME_CRITICAL_ACTION",
+ 36: "TARGET_NOT_ALLOWED",
+ 37: "NO_RADIO_RESOURCES_AVAILABLE",
+ 38: "INVALID_QOS_COMBINATION",
+ 39: "ENCRYPTION_ALGORITHMS_NOT_SUPPORTED",
+ 40: "PROCEDURE_CANCELLED",
+ 41: "RRM_PURPOSE",
+ 42: "IMPROVE_USER_BIT_RATE",
+ 43: "USER_INACTIVITY",
+ 44: "RADIO_CONNECTION_WITH_UE_LOST",
+ 45: "FAILURE_IN_THE_RADIO_INTERFACE_PROCEDURE",
+ 46: "BEARER_OPTION_NOT_SUPPORTED",
+ 47: "MCG_MOBILITY",
+ 48: "SCG_MOBILITY",
+ 49: "COUNT_REACHES_MAX_VALUE",
+ 50: "UNKNOWN_OLD_EN_GNB_UE_X2AP_ID",
+ 51: "PDCP_OVERLOAD",
+}
+
+var RadioNetworkLayer_Cause_value = map[string]int32{
+ "UNKNOWN": 0,
+ "HANDOVER_DESIRABLE_FOR_RADIO_REASONS": 1,
+ "TIME_CRITICAL_HANDOVER": 2,
+ "RESOURCE_OPTIMISATION_HANDOVER": 3,
+ "REDUCE_LOAD_IN_SERVING_CELL": 4,
+ "PARTIAL_HANDOVER": 5,
+ "UNKNOWN_NEW_ENB_UE_X2AP_ID": 6,
+ "UNKNOWN_OLD_ENBME_UE_X2AP_ID": 7,
+ "UNKNOWN_PAIR_OF_UE_X2AP_ID": 8,
+ "HO_TARGET_NOT_ALLOWED": 9,
+ "TX2_RELOC_OVERALL_EXPIRY": 10,
+ "T_RELOC_PREP_EXPIRY": 11,
+ "CELL_NOT_AVAILABLE": 12,
+ "NO_RADIO_RESOURCES_AVAILABLE_IN_TARGET_CELL": 13,
+ "INVALID_MME_GROUP_ID": 14,
+ "UNKNOWN_MME_CODE": 15,
+ "ENCRYPTION_INTEGRITY_PROTECTION_ALGORITHMS_NOT_SUPPORTED": 16,
+ "REPORT_CHARACTERISTICS_EMPTY": 17,
+ "NO_REPORT_PERIODICITY": 18,
+ "EXISTING_MEASUREMENT_ID": 19,
+ "UNKNOWN_ENB_MEASUREMENT_ID": 20,
+ "MEASUREMENT_TEMPORARILY_NOT_AVAILABLE": 21,
+ "UNSPECIFIED": 22,
+ "LOAD_BALANCING": 23,
+ "HANDOVER_OPTIMISATION": 24,
+ "VALUE_OUT_OF_ALLOWED_RANGE": 25,
+ "MULTIPLE_E_RAB_ID_INSTANCES": 26,
+ "SWITCH_OFF_ONGOING": 27,
+ "NOT_SUPPORTED_QCI_VALUE": 28,
+ "MEASUREMENT_NOT_SUPPORTED_FOR_THE_OBJECT": 29,
+ "TDC_OVERALL_EXPIRY": 30,
+ "TDC_PREP_EXPIRY": 31,
+ "ACTION_DESIRABLE_FOR_RADIO_REASONS": 32,
+ "REDUCE_LOAD": 33,
+ "RESOURCE_OPTIMISATION": 34,
+ "TIME_CRITICAL_ACTION": 35,
+ "TARGET_NOT_ALLOWED": 36,
+ "NO_RADIO_RESOURCES_AVAILABLE": 37,
+ "INVALID_QOS_COMBINATION": 38,
+ "ENCRYPTION_ALGORITHMS_NOT_SUPPORTED": 39,
+ "PROCEDURE_CANCELLED": 40,
+ "RRM_PURPOSE": 41,
+ "IMPROVE_USER_BIT_RATE": 42,
+ "USER_INACTIVITY": 43,
+ "RADIO_CONNECTION_WITH_UE_LOST": 44,
+ "FAILURE_IN_THE_RADIO_INTERFACE_PROCEDURE": 45,
+ "BEARER_OPTION_NOT_SUPPORTED": 46,
+ "MCG_MOBILITY": 47,
+ "SCG_MOBILITY": 48,
+ "COUNT_REACHES_MAX_VALUE": 49,
+ "UNKNOWN_OLD_EN_GNB_UE_X2AP_ID": 50,
+ "PDCP_OVERLOAD": 51,
+}
+
+func (x RadioNetworkLayer_Cause) String() string {
+ return proto.EnumName(RadioNetworkLayer_Cause_name, int32(x))
+}
+
+func (RadioNetworkLayer_Cause) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{1, 0}
+}
+
+type TransportLayer_Cause int32
+
+const (
+ TransportLayer_UNKNOWN TransportLayer_Cause = 0
+ TransportLayer_TRANSPORT_RESOURCE_UNAVAILABLE TransportLayer_Cause = 1
+ TransportLayer_UNSPECIFIED TransportLayer_Cause = 2
+)
+
+var TransportLayer_Cause_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "TRANSPORT_RESOURCE_UNAVAILABLE",
+ 2: "UNSPECIFIED",
+}
+
+var TransportLayer_Cause_value = map[string]int32{
+ "UNKNOWN": 0,
+ "TRANSPORT_RESOURCE_UNAVAILABLE": 1,
+ "UNSPECIFIED": 2,
+}
+
+func (x TransportLayer_Cause) String() string {
+ return proto.EnumName(TransportLayer_Cause_name, int32(x))
+}
+
+func (TransportLayer_Cause) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{2, 0}
+}
+
+type Protocol_Cause int32
+
+const (
+ Protocol_UNKNOWN Protocol_Cause = 0
+ Protocol_TRANSFER_SYNTAX_ERROR Protocol_Cause = 1
+ Protocol_ABSTRACT_SYNTAX_ERROR_REJECT Protocol_Cause = 2
+ Protocol_ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY Protocol_Cause = 3
+ Protocol_MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE Protocol_Cause = 4
+ Protocol_SEMANTIC_ERROR Protocol_Cause = 5
+ Protocol_UNSPECIFIED Protocol_Cause = 6
+ Protocol_ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE Protocol_Cause = 7
+)
+
+var Protocol_Cause_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "TRANSFER_SYNTAX_ERROR",
+ 2: "ABSTRACT_SYNTAX_ERROR_REJECT",
+ 3: "ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY",
+ 4: "MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE",
+ 5: "SEMANTIC_ERROR",
+ 6: "UNSPECIFIED",
+ 7: "ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE",
+}
+
+var Protocol_Cause_value = map[string]int32{
+ "UNKNOWN": 0,
+ "TRANSFER_SYNTAX_ERROR": 1,
+ "ABSTRACT_SYNTAX_ERROR_REJECT": 2,
+ "ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY": 3,
+ "MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE": 4,
+ "SEMANTIC_ERROR": 5,
+ "UNSPECIFIED": 6,
+ "ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE": 7,
+}
+
+func (x Protocol_Cause) String() string {
+ return proto.EnumName(Protocol_Cause_name, int32(x))
+}
+
+func (Protocol_Cause) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{3, 0}
+}
+
+type Miscellaneous_Cause int32
+
+const (
+ Miscellaneous_UNKNOWN Miscellaneous_Cause = 0
+ Miscellaneous_CONTROL_PROCESSING_OVERLOAD Miscellaneous_Cause = 1
+ Miscellaneous_HARDWARE_FAILURE Miscellaneous_Cause = 2
+ Miscellaneous_OM_INTERVENTION Miscellaneous_Cause = 3
+ Miscellaneous_NOT_ENOUGH_USER_PLANE_PROCESSING_RESOURCES Miscellaneous_Cause = 4
+ Miscellaneous_UNSPECIFIED Miscellaneous_Cause = 5
+)
+
+var Miscellaneous_Cause_name = map[int32]string{
+ 0: "UNKNOWN",
+ 1: "CONTROL_PROCESSING_OVERLOAD",
+ 2: "HARDWARE_FAILURE",
+ 3: "OM_INTERVENTION",
+ 4: "NOT_ENOUGH_USER_PLANE_PROCESSING_RESOURCES",
+ 5: "UNSPECIFIED",
+}
+
+var Miscellaneous_Cause_value = map[string]int32{
+ "UNKNOWN": 0,
+ "CONTROL_PROCESSING_OVERLOAD": 1,
+ "HARDWARE_FAILURE": 2,
+ "OM_INTERVENTION": 3,
+ "NOT_ENOUGH_USER_PLANE_PROCESSING_RESOURCES": 4,
+ "UNSPECIFIED": 5,
+}
+
+func (x Miscellaneous_Cause) String() string {
+ return proto.EnumName(Miscellaneous_Cause_name, int32(x))
+}
+
+func (Miscellaneous_Cause) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{4, 0}
+}
+
+type SetupFailure struct {
+ // Types that are valid to be assigned to CauseGroup:
+ // *SetupFailure_NetworkLayerCause
+ // *SetupFailure_TransportLayerCause
+ // *SetupFailure_ProtocolCause
+ // *SetupFailure_MiscellaneousCause
+ CauseGroup isSetupFailure_CauseGroup `protobuf_oneof:"cause_group"`
+ TimeToWait TimeToWait `protobuf:"varint,5,opt,name=time_to_wait,json=timeToWait,proto3,enum=entities.TimeToWait" json:"time_to_wait,omitempty"`
+ CriticalityDiagnostics *CriticalityDiagnostics `protobuf:"bytes,6,opt,name=criticality_diagnostics,json=criticalityDiagnostics,proto3" json:"criticality_diagnostics,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SetupFailure) Reset() { *m = SetupFailure{} }
+func (m *SetupFailure) String() string { return proto.CompactTextString(m) }
+func (*SetupFailure) ProtoMessage() {}
+func (*SetupFailure) Descriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{0}
+}
+
+func (m *SetupFailure) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SetupFailure.Unmarshal(m, b)
+}
+func (m *SetupFailure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SetupFailure.Marshal(b, m, deterministic)
+}
+func (m *SetupFailure) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SetupFailure.Merge(m, src)
+}
+func (m *SetupFailure) XXX_Size() int {
+ return xxx_messageInfo_SetupFailure.Size(m)
+}
+func (m *SetupFailure) XXX_DiscardUnknown() {
+ xxx_messageInfo_SetupFailure.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SetupFailure proto.InternalMessageInfo
+
+type isSetupFailure_CauseGroup interface {
+ isSetupFailure_CauseGroup()
+}
+
+type SetupFailure_NetworkLayerCause struct {
+ NetworkLayerCause RadioNetworkLayer_Cause `protobuf:"varint,1,opt,name=network_layer_cause,json=networkLayerCause,proto3,enum=entities.RadioNetworkLayer_Cause,oneof"`
+}
+
+type SetupFailure_TransportLayerCause struct {
+ TransportLayerCause TransportLayer_Cause `protobuf:"varint,2,opt,name=transport_layer_cause,json=transportLayerCause,proto3,enum=entities.TransportLayer_Cause,oneof"`
+}
+
+type SetupFailure_ProtocolCause struct {
+ ProtocolCause Protocol_Cause `protobuf:"varint,3,opt,name=protocol_cause,json=protocolCause,proto3,enum=entities.Protocol_Cause,oneof"`
+}
+
+type SetupFailure_MiscellaneousCause struct {
+ MiscellaneousCause Miscellaneous_Cause `protobuf:"varint,4,opt,name=miscellaneous_cause,json=miscellaneousCause,proto3,enum=entities.Miscellaneous_Cause,oneof"`
+}
+
+func (*SetupFailure_NetworkLayerCause) isSetupFailure_CauseGroup() {}
+
+func (*SetupFailure_TransportLayerCause) isSetupFailure_CauseGroup() {}
+
+func (*SetupFailure_ProtocolCause) isSetupFailure_CauseGroup() {}
+
+func (*SetupFailure_MiscellaneousCause) isSetupFailure_CauseGroup() {}
+
+func (m *SetupFailure) GetCauseGroup() isSetupFailure_CauseGroup {
+ if m != nil {
+ return m.CauseGroup
+ }
+ return nil
+}
+
+func (m *SetupFailure) GetNetworkLayerCause() RadioNetworkLayer_Cause {
+ if x, ok := m.GetCauseGroup().(*SetupFailure_NetworkLayerCause); ok {
+ return x.NetworkLayerCause
+ }
+ return RadioNetworkLayer_UNKNOWN
+}
+
+func (m *SetupFailure) GetTransportLayerCause() TransportLayer_Cause {
+ if x, ok := m.GetCauseGroup().(*SetupFailure_TransportLayerCause); ok {
+ return x.TransportLayerCause
+ }
+ return TransportLayer_UNKNOWN
+}
+
+func (m *SetupFailure) GetProtocolCause() Protocol_Cause {
+ if x, ok := m.GetCauseGroup().(*SetupFailure_ProtocolCause); ok {
+ return x.ProtocolCause
+ }
+ return Protocol_UNKNOWN
+}
+
+func (m *SetupFailure) GetMiscellaneousCause() Miscellaneous_Cause {
+ if x, ok := m.GetCauseGroup().(*SetupFailure_MiscellaneousCause); ok {
+ return x.MiscellaneousCause
+ }
+ return Miscellaneous_UNKNOWN
+}
+
+func (m *SetupFailure) GetTimeToWait() TimeToWait {
+ if m != nil {
+ return m.TimeToWait
+ }
+ return TimeToWait_UNKNOWN_TIMEOUT
+}
+
+func (m *SetupFailure) GetCriticalityDiagnostics() *CriticalityDiagnostics {
+ if m != nil {
+ return m.CriticalityDiagnostics
+ }
+ return nil
+}
+
+// XXX_OneofWrappers is for the internal use of the proto package.
+func (*SetupFailure) XXX_OneofWrappers() []interface{} {
+ return []interface{}{
+ (*SetupFailure_NetworkLayerCause)(nil),
+ (*SetupFailure_TransportLayerCause)(nil),
+ (*SetupFailure_ProtocolCause)(nil),
+ (*SetupFailure_MiscellaneousCause)(nil),
+ }
+}
+
+type RadioNetworkLayer struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *RadioNetworkLayer) Reset() { *m = RadioNetworkLayer{} }
+func (m *RadioNetworkLayer) String() string { return proto.CompactTextString(m) }
+func (*RadioNetworkLayer) ProtoMessage() {}
+func (*RadioNetworkLayer) Descriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{1}
+}
+
+func (m *RadioNetworkLayer) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_RadioNetworkLayer.Unmarshal(m, b)
+}
+func (m *RadioNetworkLayer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_RadioNetworkLayer.Marshal(b, m, deterministic)
+}
+func (m *RadioNetworkLayer) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_RadioNetworkLayer.Merge(m, src)
+}
+func (m *RadioNetworkLayer) XXX_Size() int {
+ return xxx_messageInfo_RadioNetworkLayer.Size(m)
+}
+func (m *RadioNetworkLayer) XXX_DiscardUnknown() {
+ xxx_messageInfo_RadioNetworkLayer.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RadioNetworkLayer proto.InternalMessageInfo
+
+type TransportLayer struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *TransportLayer) Reset() { *m = TransportLayer{} }
+func (m *TransportLayer) String() string { return proto.CompactTextString(m) }
+func (*TransportLayer) ProtoMessage() {}
+func (*TransportLayer) Descriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{2}
+}
+
+func (m *TransportLayer) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_TransportLayer.Unmarshal(m, b)
+}
+func (m *TransportLayer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_TransportLayer.Marshal(b, m, deterministic)
+}
+func (m *TransportLayer) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TransportLayer.Merge(m, src)
+}
+func (m *TransportLayer) XXX_Size() int {
+ return xxx_messageInfo_TransportLayer.Size(m)
+}
+func (m *TransportLayer) XXX_DiscardUnknown() {
+ xxx_messageInfo_TransportLayer.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TransportLayer proto.InternalMessageInfo
+
+type Protocol struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Protocol) Reset() { *m = Protocol{} }
+func (m *Protocol) String() string { return proto.CompactTextString(m) }
+func (*Protocol) ProtoMessage() {}
+func (*Protocol) Descriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{3}
+}
+
+func (m *Protocol) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Protocol.Unmarshal(m, b)
+}
+func (m *Protocol) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Protocol.Marshal(b, m, deterministic)
+}
+func (m *Protocol) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Protocol.Merge(m, src)
+}
+func (m *Protocol) XXX_Size() int {
+ return xxx_messageInfo_Protocol.Size(m)
+}
+func (m *Protocol) XXX_DiscardUnknown() {
+ xxx_messageInfo_Protocol.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Protocol proto.InternalMessageInfo
+
+type Miscellaneous struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Miscellaneous) Reset() { *m = Miscellaneous{} }
+func (m *Miscellaneous) String() string { return proto.CompactTextString(m) }
+func (*Miscellaneous) ProtoMessage() {}
+func (*Miscellaneous) Descriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{4}
+}
+
+func (m *Miscellaneous) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Miscellaneous.Unmarshal(m, b)
+}
+func (m *Miscellaneous) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Miscellaneous.Marshal(b, m, deterministic)
+}
+func (m *Miscellaneous) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Miscellaneous.Merge(m, src)
+}
+func (m *Miscellaneous) XXX_Size() int {
+ return xxx_messageInfo_Miscellaneous.Size(m)
+}
+func (m *Miscellaneous) XXX_DiscardUnknown() {
+ xxx_messageInfo_Miscellaneous.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Miscellaneous proto.InternalMessageInfo
+
+type CriticalityDiagnostics struct {
+ ProcedureCode uint32 `protobuf:"varint,1,opt,name=procedure_code,json=procedureCode,proto3" json:"procedure_code,omitempty"`
+ TriggeringMessage TriggeringMessage `protobuf:"varint,2,opt,name=triggering_message,json=triggeringMessage,proto3,enum=entities.TriggeringMessage" json:"triggering_message,omitempty"`
+ ProcedureCriticality Criticality `protobuf:"varint,3,opt,name=procedure_criticality,json=procedureCriticality,proto3,enum=entities.Criticality" json:"procedure_criticality,omitempty"`
+ InformationElementCriticalityDiagnostics []*InformationElementCriticalityDiagnostic `protobuf:"bytes,4,rep,name=information_element_criticality_diagnostics,json=informationElementCriticalityDiagnostics,proto3" json:"information_element_criticality_diagnostics,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *CriticalityDiagnostics) Reset() { *m = CriticalityDiagnostics{} }
+func (m *CriticalityDiagnostics) String() string { return proto.CompactTextString(m) }
+func (*CriticalityDiagnostics) ProtoMessage() {}
+func (*CriticalityDiagnostics) Descriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{5}
+}
+
+func (m *CriticalityDiagnostics) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_CriticalityDiagnostics.Unmarshal(m, b)
+}
+func (m *CriticalityDiagnostics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_CriticalityDiagnostics.Marshal(b, m, deterministic)
+}
+func (m *CriticalityDiagnostics) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CriticalityDiagnostics.Merge(m, src)
+}
+func (m *CriticalityDiagnostics) XXX_Size() int {
+ return xxx_messageInfo_CriticalityDiagnostics.Size(m)
+}
+func (m *CriticalityDiagnostics) XXX_DiscardUnknown() {
+ xxx_messageInfo_CriticalityDiagnostics.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CriticalityDiagnostics proto.InternalMessageInfo
+
+func (m *CriticalityDiagnostics) GetProcedureCode() uint32 {
+ if m != nil {
+ return m.ProcedureCode
+ }
+ return 0
+}
+
+func (m *CriticalityDiagnostics) GetTriggeringMessage() TriggeringMessage {
+ if m != nil {
+ return m.TriggeringMessage
+ }
+ return TriggeringMessage_UNKNOWN_MESSAGE
+}
+
+func (m *CriticalityDiagnostics) GetProcedureCriticality() Criticality {
+ if m != nil {
+ return m.ProcedureCriticality
+ }
+ return Criticality_UNKNOWN_CRITICALITY
+}
+
+func (m *CriticalityDiagnostics) GetInformationElementCriticalityDiagnostics() []*InformationElementCriticalityDiagnostic {
+ if m != nil {
+ return m.InformationElementCriticalityDiagnostics
+ }
+ return nil
+}
+
+type InformationElementCriticalityDiagnostic struct {
+ IeCriticality Criticality `protobuf:"varint,1,opt,name=ie_criticality,json=ieCriticality,proto3,enum=entities.Criticality" json:"ie_criticality,omitempty"`
+ IeId uint32 `protobuf:"varint,2,opt,name=ie_id,json=ieId,proto3" json:"ie_id,omitempty"`
+ TypeOfError TypeOfError `protobuf:"varint,3,opt,name=type_of_error,json=typeOfError,proto3,enum=entities.TypeOfError" json:"type_of_error,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *InformationElementCriticalityDiagnostic) Reset() {
+ *m = InformationElementCriticalityDiagnostic{}
+}
+func (m *InformationElementCriticalityDiagnostic) String() string { return proto.CompactTextString(m) }
+func (*InformationElementCriticalityDiagnostic) ProtoMessage() {}
+func (*InformationElementCriticalityDiagnostic) Descriptor() ([]byte, []int) {
+ return fileDescriptor_3bd8eb0d0558962c, []int{6}
+}
+
+func (m *InformationElementCriticalityDiagnostic) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_InformationElementCriticalityDiagnostic.Unmarshal(m, b)
+}
+func (m *InformationElementCriticalityDiagnostic) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_InformationElementCriticalityDiagnostic.Marshal(b, m, deterministic)
+}
+func (m *InformationElementCriticalityDiagnostic) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_InformationElementCriticalityDiagnostic.Merge(m, src)
+}
+func (m *InformationElementCriticalityDiagnostic) XXX_Size() int {
+ return xxx_messageInfo_InformationElementCriticalityDiagnostic.Size(m)
+}
+func (m *InformationElementCriticalityDiagnostic) XXX_DiscardUnknown() {
+ xxx_messageInfo_InformationElementCriticalityDiagnostic.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InformationElementCriticalityDiagnostic proto.InternalMessageInfo
+
+func (m *InformationElementCriticalityDiagnostic) GetIeCriticality() Criticality {
+ if m != nil {
+ return m.IeCriticality
+ }
+ return Criticality_UNKNOWN_CRITICALITY
+}
+
+func (m *InformationElementCriticalityDiagnostic) GetIeId() uint32 {
+ if m != nil {
+ return m.IeId
+ }
+ return 0
+}
+
+func (m *InformationElementCriticalityDiagnostic) GetTypeOfError() TypeOfError {
+ if m != nil {
+ return m.TypeOfError
+ }
+ return TypeOfError_UNKNOWN_ERROR
+}
+
+func init() {
+ proto.RegisterEnum("entities.TypeOfError", TypeOfError_name, TypeOfError_value)
+ proto.RegisterEnum("entities.TimeToWait", TimeToWait_name, TimeToWait_value)
+ proto.RegisterEnum("entities.TriggeringMessage", TriggeringMessage_name, TriggeringMessage_value)
+ proto.RegisterEnum("entities.Criticality", Criticality_name, Criticality_value)
+ proto.RegisterEnum("entities.RadioNetworkLayer_Cause", RadioNetworkLayer_Cause_name, RadioNetworkLayer_Cause_value)
+ proto.RegisterEnum("entities.TransportLayer_Cause", TransportLayer_Cause_name, TransportLayer_Cause_value)
+ proto.RegisterEnum("entities.Protocol_Cause", Protocol_Cause_name, Protocol_Cause_value)
+ proto.RegisterEnum("entities.Miscellaneous_Cause", Miscellaneous_Cause_name, Miscellaneous_Cause_value)
+ proto.RegisterType((*SetupFailure)(nil), "entities.SetupFailure")
+ proto.RegisterType((*RadioNetworkLayer)(nil), "entities.RadioNetworkLayer")
+ proto.RegisterType((*TransportLayer)(nil), "entities.TransportLayer")
+ proto.RegisterType((*Protocol)(nil), "entities.Protocol")
+ proto.RegisterType((*Miscellaneous)(nil), "entities.Miscellaneous")
+ proto.RegisterType((*CriticalityDiagnostics)(nil), "entities.CriticalityDiagnostics")
+ proto.RegisterType((*InformationElementCriticalityDiagnostic)(nil), "entities.InformationElementCriticalityDiagnostic")
+}
+
+func init() { proto.RegisterFile("x2_setup_failure_response.proto", fileDescriptor_3bd8eb0d0558962c) }
+
+var fileDescriptor_3bd8eb0d0558962c = []byte{
+ // 1721 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x57, 0xcd, 0x72, 0x1b, 0xb9,
+ 0xf1, 0x17, 0xa9, 0x2f, 0xff, 0x41, 0x49, 0x86, 0xa0, 0x4f, 0x5b, 0xb6, 0x2c, 0x73, 0xd7, 0x6b,
+ 0xad, 0xbc, 0x7f, 0xad, 0xa5, 0xad, 0xdd, 0x4a, 0xaa, 0xf6, 0x02, 0x62, 0x40, 0x12, 0xce, 0x0c,
+ 0x30, 0x0b, 0x60, 0x28, 0x31, 0x39, 0xa0, 0x18, 0x69, 0xac, 0x9a, 0x8a, 0x44, 0xaa, 0xc8, 0x51,
+ 0x6d, 0xfc, 0x04, 0xa9, 0xca, 0x29, 0xb7, 0x9c, 0x72, 0xc8, 0x33, 0xe4, 0x90, 0x77, 0xca, 0x29,
+ 0x8f, 0x90, 0xea, 0x99, 0xa1, 0x38, 0x94, 0xb8, 0xae, 0xbd, 0x81, 0xdd, 0x3d, 0x8d, 0xee, 0x5f,
+ 0xff, 0xba, 0xd1, 0x44, 0xaf, 0xfe, 0x7c, 0xea, 0x46, 0x71, 0x7a, 0x77, 0xeb, 0x3e, 0xf6, 0x92,
+ 0xeb, 0xbb, 0x61, 0xec, 0x86, 0xf1, 0xe8, 0x76, 0xd0, 0x1f, 0xc5, 0xc7, 0xb7, 0xc3, 0x41, 0x3a,
+ 0x20, 0x4f, 0xe2, 0x7e, 0x9a, 0xa4, 0x49, 0x3c, 0xaa, 0xff, 0x77, 0x1e, 0xad, 0x18, 0x30, 0x6d,
+ 0xe6, 0x96, 0xc4, 0xa0, 0x8d, 0x7e, 0x9c, 0xfe, 0x3c, 0x18, 0xfe, 0xc9, 0x5d, 0xf7, 0x3e, 0xc5,
+ 0x43, 0x77, 0xd1, 0xbb, 0x1b, 0xc5, 0xbb, 0x95, 0x83, 0xca, 0xe1, 0xda, 0xe9, 0xeb, 0xe3, 0xf1,
+ 0x87, 0xc7, 0xba, 0x77, 0x99, 0x0c, 0x64, 0x6e, 0xe9, 0x83, 0xe1, 0x31, 0x03, 0xc3, 0xf6, 0x9c,
+ 0x5e, 0xef, 0x97, 0xa4, 0x99, 0x90, 0x58, 0xb4, 0x95, 0x0e, 0x7b, 0xfd, 0xd1, 0xed, 0x60, 0x98,
+ 0x4e, 0xb9, 0xad, 0x66, 0x6e, 0xf7, 0x27, 0x6e, 0xed, 0xd8, 0x6c, 0xda, 0xe7, 0x46, 0x3a, 0x25,
+ 0xcf, 0xbd, 0x52, 0xb4, 0x96, 0xa5, 0x73, 0x31, 0xb8, 0x2e, 0xdc, 0xcd, 0x67, 0xee, 0x76, 0x27,
+ 0xee, 0xc2, 0x42, 0x7f, 0xef, 0x68, 0x75, 0xfc, 0x45, 0xee, 0x22, 0x44, 0x1b, 0x37, 0xc9, 0xe8,
+ 0x22, 0xbe, 0xbe, 0xee, 0xf5, 0xe3, 0xc1, 0xdd, 0xa8, 0xf0, 0xb3, 0x90, 0xf9, 0x79, 0x39, 0xf1,
+ 0x13, 0x94, 0x8d, 0xee, 0x9d, 0x91, 0xa9, 0x6f, 0x73, 0x8f, 0x3f, 0xa0, 0x95, 0x34, 0xb9, 0x89,
+ 0x5d, 0x3a, 0x70, 0x3f, 0xf7, 0x92, 0x74, 0x77, 0x31, 0x73, 0xb5, 0x59, 0xca, 0x30, 0xb9, 0x89,
+ 0xed, 0xe0, 0xac, 0x97, 0xa4, 0x1a, 0xa5, 0xf7, 0x67, 0xd2, 0x45, 0x3b, 0x17, 0xc3, 0x24, 0x4d,
+ 0x2e, 0x7a, 0xd7, 0x49, 0xfa, 0xc9, 0x5d, 0x26, 0xbd, 0xab, 0xfe, 0x60, 0x94, 0x26, 0x17, 0xa3,
+ 0xdd, 0xa5, 0x83, 0xca, 0x61, 0xed, 0xf4, 0x60, 0xe2, 0x82, 0x4d, 0x0c, 0xbd, 0x89, 0x9d, 0xde,
+ 0xbe, 0x98, 0x29, 0x6f, 0xac, 0xa2, 0x5a, 0x96, 0x96, 0xbb, 0x1a, 0x0e, 0xee, 0x6e, 0xeb, 0xff,
+ 0x58, 0x41, 0xeb, 0x8f, 0xaa, 0x57, 0xff, 0xcb, 0x0a, 0x5a, 0xcc, 0x33, 0xa8, 0xa1, 0xe5, 0x48,
+ 0xfe, 0x4e, 0xaa, 0x33, 0x89, 0xe7, 0xc8, 0x21, 0xfa, 0xb2, 0x4d, 0xa5, 0xa7, 0x3a, 0x5c, 0x3b,
+ 0x8f, 0x1b, 0xa1, 0x69, 0xc3, 0xe7, 0xae, 0xa9, 0xb4, 0xd3, 0xd4, 0x13, 0xca, 0x69, 0x4e, 0x8d,
+ 0x92, 0x06, 0x57, 0xc8, 0x73, 0xb4, 0x6d, 0x45, 0xc0, 0x1d, 0xd3, 0xc2, 0x0a, 0x46, 0x7d, 0x37,
+ 0xfe, 0x0e, 0x57, 0x49, 0x1d, 0xed, 0x6b, 0x6e, 0x54, 0xa4, 0x19, 0x77, 0x2a, 0xb4, 0x22, 0x10,
+ 0x86, 0x5a, 0xa1, 0xe4, 0xc4, 0x66, 0x9e, 0xbc, 0x42, 0x7b, 0x9a, 0x7b, 0x11, 0xe3, 0xce, 0x57,
+ 0xd4, 0x73, 0x42, 0x3a, 0xc3, 0x75, 0x47, 0xc8, 0x96, 0x63, 0xdc, 0xf7, 0xf1, 0x02, 0xd9, 0x44,
+ 0x38, 0xa4, 0xda, 0x8a, 0xb2, 0xeb, 0x45, 0xb2, 0x8f, 0x9e, 0x17, 0xd1, 0x3a, 0xc9, 0xcf, 0x1c,
+ 0x97, 0x0d, 0x17, 0x71, 0x77, 0x7e, 0x4a, 0x43, 0x27, 0x3c, 0xbc, 0x44, 0x0e, 0xd0, 0x8b, 0xb1,
+ 0x5e, 0xf9, 0x1e, 0xe8, 0x03, 0x5e, 0xb6, 0x58, 0x2e, 0x7b, 0x08, 0xa9, 0xd0, 0x4e, 0x35, 0xcb,
+ 0xfa, 0x27, 0xe4, 0x19, 0xda, 0x6a, 0x2b, 0x67, 0xa9, 0x6e, 0x71, 0xeb, 0xa4, 0xb2, 0x8e, 0xfa,
+ 0xbe, 0x3a, 0xe3, 0x1e, 0xfe, 0x3f, 0xf2, 0x02, 0xed, 0xda, 0xf3, 0x53, 0xa7, 0xb9, 0xaf, 0x98,
+ 0x83, 0x80, 0xa8, 0xef, 0x3b, 0x7e, 0x1e, 0x0a, 0xdd, 0xc5, 0x88, 0xec, 0xa0, 0x0d, 0x5b, 0xe8,
+ 0x42, 0xcd, 0xc3, 0xb1, 0xa2, 0x46, 0xb6, 0x11, 0x81, 0x9c, 0x72, 0x67, 0x1d, 0x2a, 0x7c, 0x00,
+ 0x15, 0xaf, 0x90, 0x6f, 0xd1, 0x3b, 0xa9, 0xee, 0x81, 0xcd, 0xf1, 0x32, 0x13, 0x0b, 0xc0, 0xa4,
+ 0x08, 0x23, 0x83, 0x64, 0x95, 0xec, 0xa2, 0x4d, 0x21, 0x3b, 0xd4, 0x17, 0x9e, 0x0b, 0x02, 0xee,
+ 0x5a, 0x5a, 0x45, 0x59, 0xd0, 0x6b, 0x00, 0xd6, 0x38, 0x29, 0xd0, 0x30, 0xe5, 0x71, 0xfc, 0x94,
+ 0xfc, 0x88, 0x7e, 0xc3, 0x25, 0xd3, 0xdd, 0x30, 0x03, 0x5f, 0x48, 0xcb, 0x5b, 0x5a, 0xd8, 0xae,
+ 0x0b, 0xb5, 0xb2, 0x9c, 0x65, 0x42, 0xea, 0xb7, 0x94, 0x16, 0xb6, 0x1d, 0x98, 0x2c, 0x3c, 0x13,
+ 0x85, 0xa1, 0xd2, 0x96, 0x7b, 0x18, 0x03, 0x94, 0x9a, 0xc3, 0x2f, 0xc7, 0xda, 0x54, 0x53, 0x66,
+ 0xb9, 0x16, 0xc6, 0x0a, 0x66, 0x1c, 0x0f, 0x42, 0xdb, 0xc5, 0xeb, 0x00, 0x15, 0x24, 0x90, 0x1b,
+ 0x85, 0x5c, 0x0b, 0xe5, 0x09, 0x26, 0x6c, 0x17, 0x13, 0xb2, 0x87, 0x76, 0xf8, 0x39, 0x98, 0xcb,
+ 0x96, 0x0b, 0x38, 0x35, 0x91, 0xe6, 0x01, 0x97, 0x16, 0xa2, 0xdd, 0x28, 0x97, 0x00, 0x0a, 0xf8,
+ 0x40, 0xbf, 0x49, 0xbe, 0x46, 0x6f, 0xca, 0x32, 0xcb, 0x83, 0x50, 0x69, 0xaa, 0x85, 0xdf, 0x7d,
+ 0x80, 0xe1, 0x16, 0x79, 0x8a, 0x6a, 0x91, 0x34, 0x21, 0x67, 0xa2, 0x29, 0xb8, 0x87, 0xb7, 0x09,
+ 0x41, 0x6b, 0x19, 0xa1, 0x1a, 0xd4, 0xa7, 0x92, 0x09, 0xd9, 0xc2, 0x3b, 0x59, 0x49, 0xc7, 0xac,
+ 0x2e, 0xf3, 0x11, 0xef, 0x42, 0x28, 0x1d, 0xea, 0x47, 0xdc, 0xa9, 0xc8, 0x02, 0x15, 0x8a, 0x62,
+ 0x3b, 0x4d, 0x65, 0x8b, 0xe3, 0x67, 0x40, 0xd3, 0x20, 0xf2, 0xad, 0x08, 0x7d, 0xee, 0xb8, 0xd3,
+ 0xb4, 0xe1, 0x04, 0x90, 0xd5, 0x58, 0x2a, 0x19, 0x37, 0xf8, 0x39, 0x14, 0xd7, 0x9c, 0x09, 0xcb,
+ 0xda, 0x4e, 0x35, 0x9b, 0x4e, 0xc9, 0x96, 0x82, 0x3b, 0xf7, 0x00, 0x80, 0x29, 0x40, 0xdd, 0x4f,
+ 0x4c, 0xb8, 0xec, 0x2a, 0xfc, 0x82, 0x7c, 0x83, 0x0e, 0xcb, 0x09, 0x4e, 0x1b, 0x42, 0xb7, 0xd9,
+ 0x36, 0x77, 0xaa, 0xf1, 0x81, 0x33, 0x8b, 0x5f, 0xc2, 0x15, 0xd6, 0x7b, 0x44, 0xb8, 0x7d, 0xb2,
+ 0x81, 0x9e, 0x82, 0xbc, 0x4c, 0xb6, 0x57, 0xe4, 0x2b, 0x54, 0xa7, 0x79, 0x69, 0x3f, 0xd7, 0xbf,
+ 0x07, 0x00, 0x5c, 0xa9, 0xff, 0xf0, 0x6b, 0x00, 0x69, 0x66, 0xd3, 0xe2, 0x3a, 0xf0, 0x6e, 0xba,
+ 0xd7, 0xf3, 0x1b, 0xf0, 0x17, 0x59, 0x68, 0x8f, 0x3b, 0xe5, 0x4b, 0xe0, 0xce, 0xe7, 0xa8, 0x8d,
+ 0xdf, 0x00, 0x3e, 0x63, 0x2e, 0xff, 0xa4, 0x8c, 0x63, 0x2a, 0x68, 0x08, 0x99, 0x5f, 0xf8, 0x15,
+ 0x79, 0x8b, 0xbe, 0x28, 0x11, 0xf7, 0x17, 0x39, 0xfa, 0x16, 0x7a, 0x2e, 0xd4, 0x8a, 0x71, 0x2f,
+ 0xd2, 0xdc, 0x31, 0xa8, 0x89, 0xef, 0x73, 0x0f, 0x1f, 0x66, 0xe9, 0xe9, 0xc0, 0x85, 0x91, 0x0e,
+ 0x95, 0xe1, 0xf8, 0x6b, 0x48, 0x4f, 0x04, 0xa1, 0x56, 0x1d, 0xee, 0x22, 0xc3, 0xb5, 0x6b, 0x08,
+ 0xeb, 0x34, 0xb5, 0x1c, 0x1f, 0x01, 0x8e, 0x99, 0x48, 0x48, 0xc8, 0xab, 0x03, 0x04, 0x7e, 0x47,
+ 0x5e, 0xa3, 0x97, 0x79, 0xf8, 0x4c, 0x49, 0x59, 0x34, 0xcb, 0x99, 0xb0, 0x6d, 0x18, 0x16, 0xbe,
+ 0x32, 0x16, 0x7f, 0x03, 0x55, 0x6c, 0x52, 0xe1, 0xc3, 0xd5, 0xd0, 0xaa, 0x6d, 0x5e, 0x24, 0x0c,
+ 0x8d, 0xa6, 0x9b, 0x94, 0x71, 0x77, 0x1f, 0x1b, 0xfe, 0x7f, 0x60, 0x52, 0x83, 0x53, 0x5d, 0x50,
+ 0x50, 0xc9, 0x07, 0xb9, 0x1c, 0x13, 0x8c, 0x56, 0x02, 0xd6, 0x72, 0x81, 0x6a, 0x08, 0x1f, 0x62,
+ 0xf8, 0x16, 0x24, 0xa6, 0x2c, 0x79, 0x0f, 0xa8, 0x31, 0x15, 0x49, 0x98, 0x33, 0x94, 0xb5, 0xb9,
+ 0x71, 0x01, 0x3d, 0x2f, 0x58, 0x75, 0x02, 0x21, 0x4f, 0xcf, 0x3e, 0xd7, 0x9a, 0x1e, 0x8f, 0xa7,
+ 0x64, 0x1d, 0xad, 0x86, 0x1e, 0x0b, 0x33, 0x2e, 0x65, 0x75, 0xff, 0xae, 0xfe, 0x07, 0xb4, 0x36,
+ 0xfd, 0x0a, 0xd7, 0xc5, 0xcc, 0xa7, 0xa1, 0x8e, 0xf6, 0xad, 0xa6, 0xd2, 0x64, 0xcd, 0x7e, 0xcf,
+ 0x94, 0x48, 0x4e, 0x8a, 0x5a, 0x79, 0xd8, 0x8d, 0xd5, 0xfa, 0xdf, 0xab, 0xe8, 0xc9, 0xf8, 0x51,
+ 0xae, 0xff, 0xb5, 0x3a, 0xd3, 0xf1, 0x33, 0xb4, 0x95, 0x39, 0x6e, 0x72, 0xed, 0x4c, 0x57, 0x5a,
+ 0x7a, 0xee, 0xb8, 0xd6, 0x4a, 0xe3, 0x0a, 0xd0, 0x88, 0x36, 0x8c, 0x85, 0xe1, 0x33, 0xa5, 0x72,
+ 0x9a, 0x67, 0xbd, 0x51, 0x25, 0xef, 0xd0, 0xdb, 0xd9, 0x16, 0xa2, 0x25, 0x95, 0xe6, 0x8e, 0x4a,
+ 0x0f, 0x80, 0x16, 0xcd, 0x2e, 0x9e, 0x27, 0xc7, 0xe8, 0x28, 0xe0, 0xc6, 0xd0, 0x16, 0xcf, 0xc0,
+ 0x67, 0x2a, 0x08, 0xa9, 0x15, 0xd0, 0x21, 0x59, 0x65, 0x35, 0x67, 0x5c, 0xc0, 0x8c, 0x30, 0x16,
+ 0x88, 0xb1, 0x00, 0xb3, 0xc4, 0xf0, 0x80, 0x4a, 0x2b, 0x58, 0x11, 0xd2, 0xe2, 0xc3, 0x14, 0x97,
+ 0xc8, 0xf7, 0xe8, 0x64, 0x76, 0x04, 0x4d, 0xea, 0x1b, 0xee, 0x77, 0x81, 0x40, 0xc6, 0xea, 0x88,
+ 0x41, 0x6f, 0x17, 0xd7, 0xe3, 0xe5, 0xfa, 0xbf, 0x2a, 0x68, 0x75, 0x6a, 0xcd, 0xa8, 0xff, 0xb3,
+ 0x32, 0x13, 0x9e, 0x57, 0x68, 0x8f, 0x29, 0x69, 0xb5, 0xf2, 0x73, 0x3a, 0x19, 0x03, 0x33, 0xf5,
+ 0xbe, 0x80, 0x15, 0x98, 0xfd, 0x6d, 0xaa, 0xbd, 0x33, 0xaa, 0xb9, 0x2b, 0xf8, 0x88, 0xab, 0x40,
+ 0x6a, 0x15, 0xe4, 0x54, 0xec, 0x70, 0x99, 0xf5, 0x55, 0x06, 0x00, 0x24, 0xce, 0xa5, 0x8a, 0x5a,
+ 0xed, 0xbc, 0x0f, 0x42, 0x9f, 0x4a, 0x5e, 0xf6, 0x7c, 0xdf, 0xae, 0x78, 0xe1, 0x61, 0xb2, 0x8b,
+ 0xf5, 0xff, 0x54, 0xd1, 0xf6, 0xec, 0x75, 0x84, 0xbc, 0xc9, 0xd6, 0xb3, 0x8b, 0xf8, 0x12, 0x16,
+ 0xd0, 0x8b, 0xc1, 0x65, 0xbe, 0x44, 0xae, 0x66, 0x2b, 0x58, 0x2e, 0x65, 0x83, 0xcb, 0x98, 0x7c,
+ 0x40, 0x24, 0x1d, 0x26, 0x57, 0x57, 0xf1, 0x30, 0xe9, 0x5f, 0xb9, 0x9b, 0x78, 0x34, 0xea, 0x5d,
+ 0x8d, 0x17, 0xc3, 0xbd, 0xf2, 0x62, 0x38, 0xb6, 0x09, 0x72, 0x13, 0xbd, 0x9e, 0x3e, 0x14, 0x91,
+ 0x0f, 0x68, 0xab, 0x74, 0xe5, 0x24, 0xac, 0x62, 0x31, 0xdc, 0x9a, 0xb9, 0x42, 0xe9, 0xcd, 0x49,
+ 0x40, 0x13, 0x29, 0xf9, 0x5b, 0x05, 0xbd, 0x4b, 0xfa, 0x1f, 0x07, 0xc3, 0x9b, 0x5e, 0x9a, 0x0c,
+ 0xfa, 0x2e, 0xbe, 0x8e, 0x6f, 0xe2, 0x7e, 0xea, 0x7e, 0x69, 0x4b, 0x5b, 0x38, 0x98, 0x3f, 0xac,
+ 0x9d, 0x9e, 0x4c, 0xae, 0x10, 0x93, 0x8f, 0x79, 0xfe, 0xed, 0x4c, 0xa0, 0xf4, 0x61, 0xf2, 0xeb,
+ 0x0c, 0x47, 0xf5, 0x7f, 0x57, 0xd0, 0xdb, 0x5f, 0xe9, 0x95, 0xfc, 0x88, 0xd6, 0x92, 0x69, 0x0c,
+ 0x2a, 0x9f, 0xc3, 0x60, 0x35, 0x99, 0x4a, 0x7e, 0x03, 0x2d, 0x26, 0xb1, 0x4b, 0x2e, 0xb3, 0x3a,
+ 0xac, 0xea, 0x85, 0x24, 0x16, 0x97, 0xe4, 0xb7, 0x68, 0x35, 0xfd, 0x74, 0x1b, 0xbb, 0xc1, 0x47,
+ 0x17, 0x0f, 0x87, 0x83, 0xe1, 0x63, 0x54, 0xed, 0xa7, 0xdb, 0x58, 0x7d, 0xe4, 0xa0, 0xd4, 0xb5,
+ 0x74, 0xf2, 0xe3, 0x88, 0xa2, 0x5a, 0x49, 0x07, 0x53, 0xe7, 0xfe, 0xbd, 0xcf, 0xda, 0x68, 0x0e,
+ 0x5a, 0x0b, 0x98, 0x18, 0x49, 0x8f, 0x6b, 0x63, 0x95, 0x02, 0x22, 0xd7, 0xd0, 0x72, 0x20, 0x32,
+ 0x12, 0xe2, 0xea, 0xd1, 0xef, 0x11, 0x9a, 0xac, 0xce, 0xd9, 0x88, 0x2e, 0x3c, 0xc0, 0x4b, 0xa4,
+ 0x22, 0x8b, 0xe7, 0xc8, 0x32, 0x9a, 0xef, 0x9c, 0xc0, 0x2e, 0x0a, 0x87, 0x53, 0x83, 0xab, 0xd9,
+ 0xe1, 0x7b, 0x83, 0xe7, 0xc9, 0x13, 0xb4, 0xd0, 0x39, 0x79, 0x0f, 0x14, 0x86, 0xd3, 0xe9, 0x7b,
+ 0x83, 0x17, 0xb3, 0xd3, 0x0f, 0xef, 0x0d, 0x5e, 0x3a, 0x1a, 0xa2, 0xf5, 0x47, 0xfc, 0x2a, 0x5f,
+ 0x31, 0xee, 0xd2, 0x39, 0x78, 0xdf, 0x84, 0x14, 0x56, 0xd0, 0x62, 0x91, 0xc9, 0xe5, 0x95, 0xec,
+ 0xd5, 0x8f, 0x18, 0xb4, 0x4c, 0x33, 0xf2, 0x61, 0x77, 0x60, 0x2a, 0x80, 0xae, 0xdb, 0x45, 0x9b,
+ 0x91, 0x9c, 0xa1, 0x99, 0x3f, 0xfa, 0x80, 0x6a, 0x65, 0xc4, 0x77, 0xd0, 0xc6, 0xf8, 0xb6, 0xf1,
+ 0xab, 0x0a, 0x13, 0x7e, 0x8e, 0x20, 0xb4, 0x54, 0x0c, 0xb7, 0x0a, 0x9c, 0xf3, 0x31, 0x86, 0xab,
+ 0x70, 0x1e, 0xcf, 0xb1, 0x3f, 0x2e, 0x65, 0xff, 0x6a, 0xbe, 0xfb, 0x5f, 0x00, 0x00, 0x00, 0xff,
+ 0xff, 0x99, 0x45, 0x26, 0x39, 0xf9, 0x0d, 0x00, 0x00,
+}
--- /dev/null
+syntax = "proto3";
+package entities;
+
+message SetupFailure{
+ oneof cause_group{
+ RadioNetworkLayer.Cause network_layer_cause = 1;
+ TransportLayer.Cause transport_layer_cause = 2;
+ Protocol.Cause protocol_cause = 3;
+ Miscellaneous.Cause miscellaneous_cause = 4;
+ }
+ TimeToWait time_to_wait = 5;
+ CriticalityDiagnostics criticality_diagnostics = 6;
+}
+
+message RadioNetworkLayer{
+ enum Cause{
+ UNKNOWN = 0;
+ HANDOVER_DESIRABLE_FOR_RADIO_REASONS = 1;
+ TIME_CRITICAL_HANDOVER = 2;
+ RESOURCE_OPTIMISATION_HANDOVER = 3;
+ REDUCE_LOAD_IN_SERVING_CELL = 4;
+ PARTIAL_HANDOVER = 5;
+ UNKNOWN_NEW_ENB_UE_X2AP_ID = 6;
+ UNKNOWN_OLD_ENBME_UE_X2AP_ID = 7;
+ UNKNOWN_PAIR_OF_UE_X2AP_ID = 8;
+ HO_TARGET_NOT_ALLOWED = 9;
+ TX2_RELOC_OVERALL_EXPIRY = 10;
+ T_RELOC_PREP_EXPIRY = 11;
+ CELL_NOT_AVAILABLE = 12;
+ NO_RADIO_RESOURCES_AVAILABLE_IN_TARGET_CELL = 13;
+ INVALID_MME_GROUP_ID = 14;
+ UNKNOWN_MME_CODE = 15;
+ ENCRYPTION_INTEGRITY_PROTECTION_ALGORITHMS_NOT_SUPPORTED = 16;
+ REPORT_CHARACTERISTICS_EMPTY = 17;
+ NO_REPORT_PERIODICITY = 18;
+ EXISTING_MEASUREMENT_ID = 19;
+ UNKNOWN_ENB_MEASUREMENT_ID = 20;
+ MEASUREMENT_TEMPORARILY_NOT_AVAILABLE = 21;
+ UNSPECIFIED = 22;
+ LOAD_BALANCING = 23;
+ HANDOVER_OPTIMISATION = 24;
+ VALUE_OUT_OF_ALLOWED_RANGE = 25;
+ MULTIPLE_E_RAB_ID_INSTANCES = 26;
+ SWITCH_OFF_ONGOING = 27;
+ NOT_SUPPORTED_QCI_VALUE = 28;
+ MEASUREMENT_NOT_SUPPORTED_FOR_THE_OBJECT = 29;
+ TDC_OVERALL_EXPIRY = 30;
+ TDC_PREP_EXPIRY = 31;
+ ACTION_DESIRABLE_FOR_RADIO_REASONS = 32;
+ REDUCE_LOAD = 33;
+ RESOURCE_OPTIMISATION = 34;
+ TIME_CRITICAL_ACTION = 35;
+ TARGET_NOT_ALLOWED = 36;
+ NO_RADIO_RESOURCES_AVAILABLE = 37;
+ INVALID_QOS_COMBINATION = 38;
+ ENCRYPTION_ALGORITHMS_NOT_SUPPORTED = 39;
+ PROCEDURE_CANCELLED = 40;
+ RRM_PURPOSE = 41;
+ IMPROVE_USER_BIT_RATE = 42;
+ USER_INACTIVITY = 43;
+ RADIO_CONNECTION_WITH_UE_LOST = 44;
+ FAILURE_IN_THE_RADIO_INTERFACE_PROCEDURE = 45;
+ BEARER_OPTION_NOT_SUPPORTED = 46;
+ MCG_MOBILITY = 47;
+ SCG_MOBILITY = 48;
+ COUNT_REACHES_MAX_VALUE = 49;
+ UNKNOWN_OLD_EN_GNB_UE_X2AP_ID = 50;
+ PDCP_OVERLOAD = 51;
+ }
+}
+
+message TransportLayer{
+ enum Cause {
+ UNKNOWN = 0;
+ TRANSPORT_RESOURCE_UNAVAILABLE = 1;
+ UNSPECIFIED = 2;
+ }
+}
+
+message Protocol{
+ enum Cause {
+ UNKNOWN = 0;
+ TRANSFER_SYNTAX_ERROR = 1;
+ ABSTRACT_SYNTAX_ERROR_REJECT = 2;
+ ABSTRACT_SYNTAX_ERROR_IGNORE_AND_NOTIFY = 3;
+ MESSAGE_NOT_COMPATIBLE_WITH_RECEIVER_STATE = 4;
+ SEMANTIC_ERROR = 5;
+ UNSPECIFIED = 6;
+ ABSTRACT_SYNTAX_ERROR_FALSELY_CONSTRUCTED_MESSAGE = 7;
+ }
+}
+
+message Miscellaneous{
+ enum Cause {
+ UNKNOWN = 0;
+ CONTROL_PROCESSING_OVERLOAD = 1;
+ HARDWARE_FAILURE = 2;
+ OM_INTERVENTION = 3;
+ NOT_ENOUGH_USER_PLANE_PROCESSING_RESOURCES = 4;
+ UNSPECIFIED = 5;
+ }
+}
+
+message CriticalityDiagnostics{
+ uint32 procedure_code = 1;
+ TriggeringMessage triggering_message = 2;
+ Criticality procedure_criticality = 3;
+ repeated InformationElementCriticalityDiagnostic information_element_criticality_diagnostics = 4;
+}
+
+message InformationElementCriticalityDiagnostic{
+ Criticality ie_criticality = 1;
+ uint32 ie_id = 2;
+ TypeOfError type_of_error = 3;
+}
+
+enum TypeOfError{
+ UNKNOWN_ERROR = 0;
+ NOT_UNDERSTOOD = 1;
+ MISSING = 2;
+}
+
+enum TimeToWait{
+ UNKNOWN_TIMEOUT = 0;
+ V1S = 1;
+ V2S = 2;
+ V5S = 3;
+ V10S = 4;
+ V20S = 5;
+ V60S = 6;
+}
+
+enum TriggeringMessage{
+ UNKNOWN_MESSAGE = 0;
+ INITIATING_MESSAGE = 1;
+ SUCCESSFUL_OUTCOME = 2;
+ UNSUCCESSFUL_OUTCOME = 3;
+}
+
+enum Criticality{
+ UNKNOWN_CRITICALITY = 0;
+ REJECT = 1;
+ IGNORE = 2;
+ NOTIFY = 3;
+}
+
--- /dev/null
+module gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/reader
+
+go 1.12
+
+require (
+ gerrit.o-ran-sc.org/r/ric-plt/sdlgo v0.2.0
+ gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/common v1.0.4
+ gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/entities v1.0.4
+ github.com/golang/protobuf v1.3.1
+ github.com/pkg/errors v0.8.1
+ github.com/stretchr/testify v1.3.0
+)
+
+replace gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/common => ../common
+
+replace gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/entities => ../entities
+
+replace gerrit.o-ran-sc.org/r/ric-plt/sdlgo => gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.2.0
--- /dev/null
+gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.2.0 h1:7edCLIQtk9xCwxTtLRUlXr8wQ6nmr/Mo4ZoqjF3m0NE=
+gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.2.0/go.mod h1:2Y8gw2jqj9urI8VFqFQn7BX0J3A852+YrXVV9V8gOt4=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/go-redis/redis v6.15.2+incompatible h1:9SpNVG76gr6InJGxoZ6IuuxaCOQwDAhzyXg+Bs+0Sb4=
+github.com/go-redis/redis v6.15.2+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package reader
+
+import (
+ "gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/entities"
+ "gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/common"
+ "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
+ "github.com/golang/protobuf/proto"
+ "github.com/pkg/errors"
+)
+
+var readerPool *common.Pool
+
+type rNibReaderInstance struct {
+ sdl *common.ISdlInstance
+ namespace string
+}
+
+/*
+RNibReader interface allows retrieving data from redis BD by various keys
+ */
+type RNibReader interface {
+ // GetNodeb retrieves responding nodeb entity from redis DB by nodeb inventory name
+ GetNodeb(inventoryName string) (*entities.NodebInfo, common.IRNibError)
+ // GetNodebByGlobalNbId retrieves responding nodeb entity from redis DB by nodeb global Id
+ GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId) (*entities.NodebInfo, common.IRNibError)
+ // GetCellList retrieves the list of cell entities belonging to responding nodeb entity from redis DB by nodeb inventory name
+ GetCellList(inventoryName string) (*entities.Cells, common.IRNibError)
+ // GetListGnbIds retrieves the list of gNodeb identity entities
+ GetListGnbIds()(*[]*entities.NbIdentity, common.IRNibError)
+ // GetListEnbIds retrieves the list of eNodeb identity entities
+ GetListEnbIds()(*[]*entities.NbIdentity, common.IRNibError)
+ // Close closes reader's pool
+ GetCountGnbList()(int, common.IRNibError)
+ // GetCell retrieves the cell entity belonging to responding nodeb from redis DB by nodeb inventory name and cell pci
+ GetCell(inventoryName string, pci uint32) (*entities.Cell, common.IRNibError)
+ // GetCellById retrieves the cell entity from redis DB by cell type and cell Id
+ GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, common.IRNibError)
+}
+/*
+ Init initializes the infrastructure required for the RNibReader instance
+*/
+func Init(namespace string, poolSize int) {
+ initPool(poolSize,
+ func() interface{} {
+ var sdlI common.ISdlInstance = sdlgo.NewSdlInstance(namespace, sdlgo.NewDatabase())
+ return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
+ },
+ func(obj interface{}) {
+ (*obj.(*rNibReaderInstance).sdl).Close()
+ })
+}
+
+func initPool(poolSize int, newObj func() interface{}, destroyObj func(interface{})) {
+ readerPool = common.NewPool(poolSize, newObj, destroyObj)
+}
+
+/*
+GetRNibReader returns RNibReader instance from the pool
+ */
+func GetRNibReader() RNibReader {
+ return readerPool.Get().(RNibReader)
+}
+
+func (w *rNibReaderInstance) GetNodeb(inventoryName string) (*entities.NodebInfo, common.IRNibError) {
+ name, rNibErr := common.ValidateAndBuildNodeBNameKey(inventoryName)
+ if rNibErr != nil{
+ return nil, rNibErr
+ }
+ defer readerPool.Put(w)
+ data, err := (*w.sdl).Get([]string{name})
+ if err != nil{
+ return nil, common.NewInternalError(err)
+ }
+ nb := entities.NodebInfo{}
+ if data != nil && data[name] != nil{
+ err = proto.Unmarshal( []byte(data[name].(string)), &nb)
+ if err != nil{
+ return nil, common.NewInternalError(err)
+ }
+ return &nb, nil
+ }
+ return nil, common.NewResourceNotFoundError(errors.Errorf("#rNibReader.GetNodeb - responding node %s not found", inventoryName))
+}
+
+func (w *rNibReaderInstance) GetNodebByGlobalNbId(nodeType entities.Node_Type, globalNbId *entities.GlobalNbId) (*entities.NodebInfo, common.IRNibError) {
+ key, rNibErr := common.ValidateAndBuildNodeBIdKey(nodeType.String(), globalNbId.GetPlmnId(), globalNbId.GetNbId())
+ if rNibErr != nil{
+ return nil, rNibErr
+ }
+ defer readerPool.Put(w)
+ data, err := (*w.sdl).Get([]string{key})
+ if err != nil{
+ return nil, common.NewInternalError(err)
+ }
+ nb := entities.NodebInfo{}
+ if data != nil && data[key] != nil{
+ err = proto.Unmarshal( []byte(data[key].(string)), &nb)
+ if err != nil{
+ return nil, common.NewInternalError(err)
+ }
+ return &nb, nil
+ }
+ return nil, common.NewResourceNotFoundError(errors.Errorf("#rNibReader.GetNodebByGlobalNbId - responding node not found, global nodeb Id: %s", key))
+}
+
+func (w *rNibReaderInstance) GetCellList(inventoryName string) (*entities.Cells, common.IRNibError){
+ cells := &entities.Cells{}
+ nb, err := w.GetNodeb(inventoryName)
+ if err != nil{
+ return nil, err
+ }
+ if nb.GetEnb() != nil && len(nb.GetEnb().GetServedCells()) > 0{
+ cells.Type = entities.Cell_LTE_CELL
+ cells.List = &entities.Cells_ServedCellInfos{ServedCellInfos:&entities.ServedCellInfoList{ServedCells:nb.GetEnb().GetServedCells()}}
+ return cells, nil
+ } else if nb.GetGnb() != nil && len(nb.GetGnb().GetServedNrCells()) > 0{
+ cells.Type = entities.Cell_NR_CELL
+ cells.List = &entities.Cells_ServedNrCells{ServedNrCells:&entities.ServedNRCellList{ServedCells:nb.GetGnb().GetServedNrCells()}}
+ return cells, nil
+ }
+ return nil, common.NewResourceNotFoundError(errors.Errorf("#rNibReader.GetCellList - served cells not found. Responding node RAN name: %s.", inventoryName))
+}
+
+func (w *rNibReaderInstance) GetListGnbIds()(*[]*entities.NbIdentity, common.IRNibError){
+ defer readerPool.Put(w)
+ data, err := (*w.sdl).GetMembers("GNB")
+ if err != nil{
+ return nil, common.NewInternalError(err)
+ }
+ return unmarshalIdentityList(data)
+}
+
+func (w *rNibReaderInstance) GetListEnbIds()(*[]*entities.NbIdentity, common.IRNibError){
+ defer readerPool.Put(w)
+ data, err := (*w.sdl).GetMembers("ENB")
+ if err != nil{
+ return nil, common.NewInternalError(err)
+ }
+ return unmarshalIdentityList(data)
+}
+
+func (w *rNibReaderInstance) GetCountGnbList()(int, common.IRNibError){
+ defer readerPool.Put(w)
+ data, err := (*w.sdl).GetMembers("GNB")
+ if err != nil{
+ return 0, common.NewInternalError(err)
+ }
+ return len(data), nil
+}
+
+func (w *rNibReaderInstance) GetCell(inventoryName string, pci uint32) (*entities.Cell, common.IRNibError){
+ key, rNibErr := common.ValidateAndBuildCellNamePciKey(inventoryName, pci)
+ if rNibErr != nil{
+ return nil, rNibErr
+ }
+ return (*w).getCellByKey(key)
+}
+
+func (w *rNibReaderInstance) GetCellById(cellType entities.Cell_Type, cellId string) (*entities.Cell, common.IRNibError){
+ var key string
+ var rNibErr common.IRNibError
+ if cellType == entities.Cell_LTE_CELL {
+ key, rNibErr = common.ValidateAndBuildCellIdKey(cellId)
+ } else if cellType == entities.Cell_NR_CELL {
+ key, rNibErr = common.ValidateAndBuildNrCellIdKey(cellId)
+ } else {
+ return nil, common.NewValidationError(errors.Errorf("#rNibReader.GetCellById - invalid cell type: %v", cellType))
+ }
+ if rNibErr != nil{
+ return nil, rNibErr
+ }
+ return (*w).getCellByKey(key)
+}
+
+func (w *rNibReaderInstance) getCellByKey(key string) (*entities.Cell, common.IRNibError){
+ defer readerPool.Put(w)
+ data, err := (*w.sdl).Get([]string{key})
+ if err != nil{
+ return nil, common.NewInternalError(err)
+ }
+ cell := entities.Cell{}
+ if data != nil && data[key] != nil{
+ err = proto.Unmarshal( []byte(data[key].(string)), &cell)
+ if err != nil{
+ return nil, common.NewInternalError(err)
+ }
+ return &cell, nil
+ }
+ return nil, common.NewResourceNotFoundError(errors.Errorf("#rNibReader.getCellByKey - cell not found, key: %s", key))
+}
+
+func unmarshalIdentityList(data []string ) (*[]*entities.NbIdentity, common.IRNibError){
+ var members []*entities.NbIdentity
+ for _, d := range data{
+ member := entities.NbIdentity{}
+ err := proto.Unmarshal([]byte(d), &member)
+ if err != nil{
+ return nil, common.NewInternalError(err)
+ }
+ members = append(members, &member)
+ }
+ return &members, nil
+}
+
+func Close(){
+ readerPool.Close()
+}
\ No newline at end of file
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package reader
+
+import (
+ "errors"
+ "gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/common"
+ "gerrit.ranco-dev-tools.eastus.cloudapp.azure.com/ric-plt/nodeb-rnib.git/entities"
+ "github.com/golang/protobuf/proto"
+ "github.com/stretchr/testify/assert"
+ "testing"
+)
+
+var namespace = "namespace"
+
+func TestInit(t *testing.T) {
+ readerPool = nil
+ Init("", 1)
+ assert.NotNil(t, readerPool)
+ assert.NotNil(t, readerPool.New)
+ assert.NotNil(t, readerPool.Destroy)
+ available, created := readerPool.Stats()
+ assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
+ assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
+}
+
+func TestInitPool(t *testing.T) {
+ readerPool = nil
+ sdlInstanceMock := new(MockSdlInstance)
+ initPool(1, func() interface{} {
+ sdlI := common.ISdlInstance(sdlInstanceMock)
+ return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
+ },
+ func(obj interface{}) {
+ },
+ )
+ assert.NotNil(t, readerPool)
+ assert.NotNil(t, readerPool.New)
+ assert.NotNil(t, readerPool.Destroy)
+ available, created := readerPool.Stats()
+ assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
+ assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
+}
+
+func initSdlInstanceMock(namespace string, poolSize int) * MockSdlInstance {
+ sdlInstanceMock := new( MockSdlInstance)
+ initPool(poolSize, func() interface{} {
+ sdlI := common.ISdlInstance(sdlInstanceMock)
+ return &rNibReaderInstance{sdl: &sdlI, namespace: namespace}
+ },
+ func(obj interface{}) {
+ },
+ )
+ return sdlInstanceMock
+}
+
+func TestGetNodeB(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ nb := entities.NodebInfo{}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ enb := entities.Enb{}
+ cell := entities.ServedCellInfo{Tac:"tac"}
+ enb.ServedCells = []*entities.ServedCellInfo{&cell}
+ nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetNb - Failed to marshal ENB instance. Error: %v", err)
+ }
+ ret := map[string]interface{}{"RAN:" + name:string(data)}
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ getNb, er := w.GetNodeb(name)
+ assert.Nil(t, er)
+ assert.Equal(t, getNb.Ip, nb.Ip)
+ assert.Equal(t, getNb.Port, nb.Port)
+ assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
+ assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
+ assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
+}
+
+func TestGetNodeBNotFoundFailure(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ getNb, er := w.GetNodeb(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.Equal(t, 1, er.GetCode())
+ assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetNodeb - responding node name not found", er.Error())
+}
+
+func TestGetNodeBUnmarshalFailure(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ ret := make( map[string]interface{}, 1)
+ ret["RAN:" + name] = "data"
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ getNb, er := w.GetNodeb(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+}
+
+func TestGetNodeBSdlgoFailure(t *testing.T) {
+ name := "name"
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ e := errors.New(errMsg)
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ getNb, er := w.GetNodeb(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetNodeBCellsListEnb(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ nb := entities.NodebInfo{}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ enb := entities.Enb{}
+ cell := entities.ServedCellInfo{Tac:"tac"}
+ enb.ServedCells = []*entities.ServedCellInfo{&cell}
+ nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal ENB instance. Error: %v", err)
+ }
+ ret := map[string]interface{}{"RAN:" + name:string(data)}
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ cells, er := w.GetCellList(name)
+ assert.Nil(t, er)
+ assert.NotNil(t, cells)
+ assert.Len(t, cells.GetServedCellInfos().GetServedCells(), 1)
+ retCell := cells.GetServedCellInfos().GetServedCells()[0]
+ assert.Equal(t, retCell.Tac, "tac")
+}
+
+func TestGetNodeBCellsListGnb(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ nb := entities.NodebInfo{}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ nb.NodeType = entities.Node_GNB
+ gnb := entities.Gnb{}
+ cell := entities.ServedNRCell{ServedNrCellInformation:&entities.ServedNRCellInformation{NrPci:10}}
+ gnb.ServedNrCells = []*entities.ServedNRCell{&cell}
+ nb.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibReader_test.GetNodeBCellsList - Failed to marshal GNB instance. Error: %v", err)
+ }
+ ret := map[string]interface{}{"RAN:" + name:string(data)}
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ cells, er := w.GetCellList(name)
+ assert.Nil(t, er)
+ assert.NotNil(t, cells)
+ assert.Len(t, cells.GetServedNrCells().GetServedCells(), 1)
+ retCell := cells.GetServedNrCells().GetServedCells()[0]
+ assert.Equal(t, retCell.GetServedNrCellInformation().GetNrPci(), uint32(10))
+}
+
+func TestGetNodeBCellsListNodeUnmarshalFailure(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ ret := make( map[string]interface{}, 1)
+ ret["RAN:" + name] = "data"
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ cells, er := w.GetCellList(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, cells)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+}
+
+func TestGetNodeBCellsListNodeNotFoundFailure(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ cells, er := w.GetCellList(name)
+ assert.NotNil(t, er)
+ assert.Nil(t, cells)
+ assert.Equal(t, 1, er.GetCode())
+ assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetNodeb - responding node name not found", er.Error())
+}
+
+func TestGetNodeBCellsListNotFoundFailureEnb(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ nb := entities.NodebInfo{}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ enb := entities.Enb{}
+ nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
+ }
+ ret := map[string]interface{}{"RAN:" + name:string(data)}
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ _, er := w.GetCellList(name)
+ assert.NotNil(t, er)
+ assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
+}
+
+func TestGetNodeBCellsListNotFoundFailureGnb(t *testing.T) {
+ name := "name"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ nb := entities.NodebInfo{}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ gnb := entities.Gnb{}
+ nb.Configuration = &entities.NodebInfo_Gnb{Gnb:&gnb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetNbCellsListNotFoundFailure - Failed to marshal ENB instance. Error: %v", err)
+ }
+ ret := map[string]interface{}{"RAN:" + name:string(data)}
+ sdlInstanceMock.On("Get", []string{"RAN:" + name}).Return(ret, e)
+ _, er := w.GetCellList(name)
+ assert.NotNil(t, er)
+ assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetCellList - served cells not found. Responding node RAN name: name.", er.Error())
+}
+
+func TestCloseOnClosedPoolFailure(t *testing.T) {
+ readerPool = nil
+ instanceMock := initSdlInstanceMock(namespace, 1)
+ w1 := GetRNibReader()
+ readerPool.Put(w1)
+ available, created := readerPool.Stats()
+ assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
+ assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
+ var e error
+ instanceMock.On("Close").Return(e)
+ Close()
+ assert.Panics(t, func(){Close()})
+}
+
+func TestCloseFailure(t *testing.T) {
+ readerPool = nil
+ instanceMock := initSdlInstanceMock(namespace, 2)
+ w1 := GetRNibReader()
+ readerPool.Put(w1)
+ available, created := readerPool.Stats()
+ assert.Equal(t, 1, available, "number of available objects in the readerPool should be 1")
+ assert.Equal(t, 1, created, "number of created objects in the readerPool should be 1")
+ e := errors.New("expected error")
+ instanceMock.On("Close").Return(e)
+ Close()
+ available, created = readerPool.Stats()
+ assert.Equal(t, 0, available, "number of available objects in the readerPool should be 0")
+ assert.Equal(t, 0, created, "number of created objects in the readerPool should be 0")
+}
+
+func TestGetListGnbIdsUnmarshalFailure(t *testing.T) {
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ sdlInstanceMock.On("GetMembers", "GNB").Return([]string{"data"}, e)
+ ids, er := w.GetListGnbIds()
+ assert.NotNil(t, er)
+ assert.Nil(t, ids)
+ assert.Equal(t, 2, er.GetCode())
+ assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+}
+
+func TestGetListGnbIdsSdlgoFailure(t *testing.T) {
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ e := errors.New(errMsg)
+ var data []string
+ sdlInstanceMock.On("GetMembers", "GNB").Return(data, e)
+ ids, er := w.GetListGnbIds()
+ assert.NotNil(t, er)
+ assert.Nil(t, ids)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, errMsgExpected,er.Error())
+}
+
+func TestGetListEnbIdsUnmarshalFailure(t *testing.T) {
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ sdlInstanceMock.On("GetMembers", "ENB").Return([]string{"data"}, e)
+ ids, er := w.GetListEnbIds()
+ assert.NotNil(t, er)
+ assert.Nil(t, ids)
+ assert.Equal(t, 2, er.GetCode())
+ assert.Equal(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+}
+
+func TestGetListEnbIdsOneId(t *testing.T) {
+ name := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}}
+ var e error
+ data, err := proto.Marshal(nbIdentity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+ sdlInstanceMock.On("GetMembers", "ENB").Return([]string{string(data)}, e)
+ ids, er := w.GetListEnbIds()
+ assert.Nil(t, er)
+ assert.Len(t, *ids, 1)
+ assert.Equal(t, (*ids)[0].GetInventoryName(), name)
+ assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
+ assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
+}
+
+func TestGetListEnbIdsNoIds(t *testing.T) {
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ sdlInstanceMock.On("GetMembers", "ENB").Return([]string{}, e)
+ ids, er := w.GetListEnbIds()
+ assert.Nil(t, er)
+ assert.Len(t, *ids, 0)
+}
+
+func TestGetListEnbIds(t *testing.T) {
+ name := "name"
+ plmnId := 0x02f829
+ nbId := 0x4a952a0a
+ listSize := 3
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ idsData := make([]string, listSize)
+ idsEntities := make([]*entities.NbIdentity, listSize)
+ for i:=0; i< listSize ;i++{
+ nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:string(plmnId + i), NbId:string(nbId + i)}}
+ data, err := proto.Marshal(nbIdentity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetListEnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+ idsData[i] = string(data)
+ idsEntities[i] = nbIdentity
+ }
+ var e error
+ sdlInstanceMock.On("GetMembers", "ENB").Return(idsData, e)
+ ids, er := w.GetListEnbIds()
+ assert.Nil(t, er)
+ assert.Len(t, *ids, listSize)
+ for i, id :=range *ids{
+ assert.Equal(t, id.GetInventoryName(), name)
+ assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
+ assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
+ }
+}
+
+func TestGetListGnbIdsOneId(t *testing.T) {
+ name := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}}
+ var e error
+ data, err := proto.Marshal(nbIdentity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+ sdlInstanceMock.On("GetMembers", "GNB").Return([]string{string(data)}, e)
+ ids, er := w.GetListGnbIds()
+ assert.Nil(t, er)
+ assert.Len(t, *ids, 1)
+ assert.Equal(t, (*ids)[0].GetInventoryName(), name)
+ assert.Equal(t, (*ids)[0].GetGlobalNbId().GetPlmnId(), nbIdentity.GetGlobalNbId().GetPlmnId())
+ assert.Equal(t, (*ids)[0].GetGlobalNbId().GetNbId(), nbIdentity.GetGlobalNbId().GetNbId())
+}
+
+func TestGetListGnbIdsNoIds(t *testing.T) {
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ sdlInstanceMock.On("GetMembers", "GNB").Return([]string{}, e)
+ ids, er := w.GetListGnbIds()
+ assert.Nil(t, er)
+ assert.Len(t, *ids, 0)
+}
+
+func TestGetListGnbIds(t *testing.T) {
+ name := "name"
+ plmnId := 0x02f829
+ nbId := 0x4a952a0a
+ listSize := 3
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ idsData := make([]string, listSize)
+ idsEntities := make([]*entities.NbIdentity, listSize)
+ for i:=0; i< listSize ;i++{
+ nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:string(plmnId + i), NbId:string(nbId + i)}}
+ data, err := proto.Marshal(nbIdentity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+ idsData[i] = string(data)
+ idsEntities[i] = nbIdentity
+ }
+ var e error
+ sdlInstanceMock.On("GetMembers", "GNB").Return(idsData, e)
+ ids, er := w.GetListGnbIds()
+ assert.Nil(t, er)
+ assert.Len(t, *ids, listSize)
+ for i, id :=range *ids{
+ assert.Equal(t, id.GetInventoryName(), name)
+ assert.Equal(t, id.GetGlobalNbId().GetPlmnId(), idsEntities[i].GetGlobalNbId().GetPlmnId())
+ assert.Equal(t, id.GetGlobalNbId().GetNbId(), idsEntities[i].GetGlobalNbId().GetNbId())
+ }
+}
+
+func TestGetListEnbIdsSdlgoFailure(t *testing.T) {
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ e := errors.New(errMsg)
+ var data []string
+ sdlInstanceMock.On("GetMembers", "ENB").Return(data, e)
+ ids, er := w.GetListEnbIds()
+ assert.NotNil(t, er)
+ assert.Nil(t, ids)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetCountGnbListOneId(t *testing.T) {
+ name := "name"
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}}
+ var e error
+ data, err := proto.Marshal(nbIdentity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetCountGnbList - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+ sdlInstanceMock.On("GetMembers", "GNB").Return([]string{string(data)}, e)
+ count, er := w.GetCountGnbList()
+ assert.Nil(t, er)
+ assert.Equal(t, count, 1)
+}
+
+func TestGetCountGnbList(t *testing.T) {
+ listSize := 3
+ name := "name"
+ plmnId := 0x02f823
+ nbId := 0x4a952a1f
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ idsData := make([]string, listSize)
+ idsEntities := make([]*entities.NbIdentity, listSize)
+ for i:=0; i< listSize ;i++{
+ nbIdentity := &entities.NbIdentity{InventoryName:name, GlobalNbId:&entities.GlobalNbId{PlmnId:string(plmnId + i), NbId:string(nbId + i)}}
+ data, err := proto.Marshal(nbIdentity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetListGnbIds - Failed to marshal nodeb identity entity. Error: %v", err)
+ }
+ idsData[i] = string(data)
+ idsEntities[i] = nbIdentity
+ }
+ sdlInstanceMock.On("GetMembers", "GNB").Return(idsData, e)
+ count, er := w.GetCountGnbList()
+ assert.Nil(t, er)
+ assert.Equal(t, count, 3)
+}
+
+func TestGetCountGnbListSdlgoFailure(t *testing.T) {
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ e := errors.New(errMsg)
+ var data []string
+ sdlInstanceMock.On("GetMembers", "GNB").Return(data, e)
+ count, er := w.GetCountGnbList()
+ assert.NotNil(t, er)
+ assert.Equal(t, 0, count)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetCell(t *testing.T) {
+ name := "name"
+ var pci uint32
+ pci = 10
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ cellEntity := entities.Cell{Type:entities.Cell_LTE_CELL, Cell:&entities.Cell_ServedCellInfo{ServedCellInfo:&entities.ServedCellInfo{Pci:pci}}}
+ cellData, err := proto.Marshal(&cellEntity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetCell - Failed to marshal Cell entity. Error: %v", err)
+ }
+ var e error
+ key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetCell - failed to validate key parameter")
+ }
+ ret := map[string]interface{}{key:string(cellData)}
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ cell, er := w.GetCell(name, pci)
+ assert.Nil(t, er)
+ assert.NotNil(t, cell)
+ assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
+ assert.NotNil(t, cell.GetServedCellInfo())
+ assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
+}
+
+func TestGetCellNotFoundFailure(t *testing.T) {
+ name := "name"
+ var pci uint32
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ var ret map[string]interface{}
+ key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetCellNotFoundFailure - failed to validate key parameter")
+ }
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ cell, er := w.GetCell(name, pci)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.Equal(t, 1, er.GetCode())
+ assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: PCI:name:00", er.Error())
+}
+
+func TestGetCellUnmarshalFailure(t *testing.T) {
+ name := "name"
+ var pci uint32
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ ret := make( map[string]interface{}, 1)
+ key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetCellUnmarshalFailure - failed to validate key parameter")
+ }
+ ret[key] = "data"
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ cell, er := w.GetCell(name, pci)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+}
+
+func TestGetCellSdlgoFailure(t *testing.T) {
+ name := "name"
+ var pci uint32
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ e := errors.New(errMsg)
+ var ret map[string]interface{}
+ key, rNibErr := common.ValidateAndBuildCellNamePciKey(name, pci)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetCellSdlgoFailure - failed to validate key parameter")
+ }
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ cell, er := w.GetCell(name, pci)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetNodebById(t *testing.T) {
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ nb := entities.NodebInfo{NodeType:entities.Node_ENB}
+ nb.ConnectionStatus = 1
+ nb.Ip = "localhost"
+ nb.Port = 5656
+ enb := entities.Enb{}
+ cell := entities.ServedCellInfo{Tac:"tac"}
+ enb.ServedCells = []*entities.ServedCellInfo{&cell}
+ nb.Configuration = &entities.NodebInfo_Enb{Enb:&enb}
+ var e error
+ data, err := proto.Marshal(&nb)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetNodebById - Failed to marshal ENB instance. Error: %v", err)
+ }
+
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
+ if rNibErr != nil{
+ t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
+ }
+ ret := map[string]interface{}{key:string(data)}
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ globalNbId := &entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}
+ getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
+ assert.Nil(t, er)
+ assert.Equal(t, getNb.Ip, nb.Ip)
+ assert.Equal(t, getNb.Port, nb.Port)
+ assert.Equal(t, getNb.ConnectionStatus, nb.ConnectionStatus)
+ assert.Len(t, getNb.GetEnb().GetServedCells(), 1)
+ assert.Equal(t, getNb.GetEnb().GetServedCells()[0].Tac, nb.GetEnb().GetServedCells()[0].Tac)
+}
+
+func TestGetNodebByIdNotFoundFailureEnb(t *testing.T) {
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
+ if rNibErr != nil{
+ t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
+ }
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ globalNbId := &entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}
+ getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.Equal(t, 1, er.GetCode())
+ assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetNodebByGlobalNbId - responding node not found, global nodeb Id: ENB:02f829:4a952a0a", er.Error())
+}
+
+func TestGetNodebByIdNotFoundFailureGnb(t *testing.T) {
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
+ if rNibErr != nil{
+ t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
+ }
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ globalNbId := &entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}
+ getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.Equal(t, 1, er.GetCode())
+ assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.GetNodebByGlobalNbId - responding node not found, global nodeb Id: GNB:02f829:4a952a0a", er.Error())
+}
+
+func TestGetNodeByIdUnmarshalFailure(t *testing.T) {
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_ENB.String(), plmnId, nbId)
+ if rNibErr != nil{
+ t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
+ }
+ var e error
+ ret := make( map[string]interface{}, 1)
+ ret[key] = "data"
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ globalNbId := &entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}
+ getNb, er := w.GetNodebByGlobalNbId(entities.Node_ENB, globalNbId)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, "2 INTERNAL_ERROR - proto: can't skip unknown wire type 4", er.Error())
+}
+
+func TestGetNodeByIdSdlgoFailure(t *testing.T) {
+ plmnId := "02f829"
+ nbId := "4a952a0a"
+ errMsg := "expected Sdlgo error"
+ errMsgExpected := "2 INTERNAL_ERROR - expected Sdlgo error"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ key, rNibErr := common.ValidateAndBuildNodeBIdKey(entities.Node_GNB.String(), plmnId, nbId)
+ if rNibErr != nil{
+ t.Errorf("Failed to validate nodeb identity, plmnId: %s, nbId: %s", plmnId, nbId)
+ }
+ e := errors.New(errMsg)
+ var ret map[string]interface{}
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ globalNbId := &entities.GlobalNbId{PlmnId:plmnId, NbId:nbId}
+ getNb, er := w.GetNodebByGlobalNbId(entities.Node_GNB, globalNbId)
+ assert.NotNil(t, er)
+ assert.Nil(t, getNb)
+ assert.Equal(t, 2, er.GetCode())
+ assert.EqualValues(t, errMsgExpected, er.Error())
+}
+
+func TestGetCellById(t *testing.T) {
+ cellId := "aaaa"
+ var pci uint32
+ pci = 10
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ cellEntity := entities.Cell{Type:entities.Cell_LTE_CELL, Cell:&entities.Cell_ServedCellInfo{ServedCellInfo:&entities.ServedCellInfo{Pci:pci}}}
+ cellData, err := proto.Marshal(&cellEntity)
+ if err != nil {
+ t.Errorf("#rNibReader_test.TestGetCellById - Failed to marshal Cell entity. Error: %v", err)
+ }
+ var e error
+ key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetCellById - failed to validate key parameter")
+ }
+ ret := map[string]interface{}{key:string(cellData)}
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
+ assert.Nil(t, er)
+ assert.NotNil(t, cell)
+ assert.Equal(t, cell.Type, entities.Cell_LTE_CELL)
+ assert.NotNil(t, cell.GetServedCellInfo())
+ assert.Equal(t, cell.GetServedCellInfo().GetPci(), pci)
+}
+
+func TestGetCellByIdNotFoundFailureEnb(t *testing.T) {
+ cellId := "bbbb"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ var ret map[string]interface{}
+ key, rNibErr := common.ValidateAndBuildCellIdKey(cellId)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
+ }
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.Equal(t, 1, er.GetCode())
+ assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: CELL:bbbb", er.Error())
+}
+
+func TestGetCellByIdNotFoundFailureGnb(t *testing.T) {
+ cellId := "bbbb"
+ readerPool = nil
+ sdlInstanceMock := initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ var e error
+ var ret map[string]interface{}
+ key, rNibErr := common.ValidateAndBuildNrCellIdKey(cellId)
+ if rNibErr != nil {
+ t.Errorf("#rNibReader_test.TestGetCellByIdNotFoundFailure - failed to validate key parameter")
+ }
+ sdlInstanceMock.On("Get", []string{key}).Return(ret, e)
+ cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.Equal(t, 1, er.GetCode())
+ assert.EqualValues(t, "1 RESOURCE_NOT_FOUND - #rNibReader.getCellByKey - cell not found, key: NRCELL:bbbb", er.Error())
+}
+
+func TestGetCellByIdTypeValidationFailure(t *testing.T) {
+ cellId := "dddd"
+ readerPool = nil
+ initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ cell, er := w.GetCellById(5, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.Equal(t, 3, er.GetCode())
+ assert.EqualValues(t, "3 VALIDATION_ERROR - #rNibReader.GetCellById - invalid cell type: 5", er.Error())
+}
+
+func TestGetCellByIdValidationFailureGnb(t *testing.T) {
+ cellId := ""
+ readerPool = nil
+ initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ cell, er := w.GetCellById(entities.Cell_NR_CELL, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.Equal(t, 3, er.GetCode())
+ assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildNrCellIdKey - an empty cell id received", er.Error())
+}
+
+func TestGetCellByIdValidationFailureEnb(t *testing.T) {
+ cellId := ""
+ readerPool = nil
+ initSdlInstanceMock(namespace, 1)
+ w := GetRNibReader()
+ cell, er := w.GetCellById(entities.Cell_LTE_CELL, cellId)
+ assert.NotNil(t, er)
+ assert.Nil(t, cell)
+ assert.Equal(t, 3, er.GetCode())
+ assert.EqualValues(t, "3 VALIDATION_ERROR - #utils.ValidateAndBuildCellIdKey - an empty cell id received", er.Error())
+}
+
+//integration tests
+
+//func TestGetEnbInteg(t *testing.T){
+// name := "nameEnb1"
+// Init("namespace", 1)
+// w := GetRNibReader()
+// nb, err := w.GetNodeb(name)
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// fmt.Printf("#TestGetEnbInteg - responding node type: %v\n", nb)
+// }
+//}
+//
+//func TestGetEnbCellsInteg(t *testing.T){
+// name := "nameEnb1"
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cells, err := w.GetCellList(name)
+// if err != nil{
+// fmt.Println(err)
+// } else if cells != nil{
+// for _, cell := range cells.GetServedCellInfos().ServedCells{
+// fmt.Printf("responding node type Cell: %v\n", *cell)
+// }
+// }
+//}
+//
+//func TestGetGnbInteg(t *testing.T){
+// name := "nameGnb1"
+// Init("namespace", 1)
+// w := GetRNibReader()
+// nb, err := w.GetNodeb(name)
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// fmt.Printf("#TestGetGnbInteg - responding node type: %v\n", nb)
+// }
+//}
+//
+//func TestGetGnbCellsInteg(t *testing.T){
+// name := "nameGnb1"
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cells, err := w.GetCellList(name)
+// if err != nil{
+// fmt.Println(err)
+// } else if cells != nil{
+// for _, cell := range cells.GetServedNrCells().ServedCells{
+// fmt.Printf("responding node type NR Cell: %v\n", *cell)
+// }
+// }
+//}
+//
+//func TestGetListEnbIdsInteg(t *testing.T) {
+// Init("namespace", 1)
+// w := GetRNibReader()
+// ids, err := w.GetListEnbIds()
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// for _, id := range *ids{
+// fmt.Printf("#TestGetListEnbIdsInteg - ENB ID: %s\n", id)
+// }
+// }
+//}
+//
+//func TestGetListGnbIdsInteg(t *testing.T) {
+// Init("namespace", 1)
+// w := GetRNibReader()
+// ids, err := w.GetListGnbIds()
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// for _, id := range *ids{
+// fmt.Printf("#TestGetListGnbIdsInteg - GNB ID: %s\n", id)
+// }
+// }
+//}
+//
+//func TestGetCountGnbListInteg(t *testing.T) {
+// Init("namespace", 1)
+// w := GetRNibReader()
+// count, err := w.GetCountGnbList()
+// if err != nil{
+// fmt.Println(err)
+// } else {
+// fmt.Printf("#TestGetCountGnbListInteg - count Gnb list: %d\n", count)
+// }
+//}
+//
+//func TestGetGnbCellInteg(t *testing.T){
+// name := "nameGnb7"
+// pci := 0x0a
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cell, err := w.GetCell(name, uint32(pci))
+// if err != nil{
+// fmt.Println(err)
+// } else if cell != nil{
+// fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
+// }
+//}
+//
+//func TestGetEnbCellInteg(t *testing.T) {
+// name := "nameEnb1"
+// pci := 0x22
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cell, err := w.GetCell(name, uint32(pci))
+// if err != nil {
+// fmt.Println(err)
+// } else if cell != nil {
+// fmt.Printf("responding node type LTE Cell: %v\n", cell.GetServedCellInfo())
+// }
+//}
+//
+//func TestGetEnbCellByIdInteg(t *testing.T){
+// Init("namespace", 1)
+// w := GetRNibReader()
+// cell, err := w.GetCellById(entities.Cell_NR_CELL, "45d")
+// if err != nil{
+// fmt.Println(err)
+// } else if cell != nil{
+// fmt.Printf("responding node type NR Cell: %v\n", cell.GetServedNrCell())
+// }
+//}
\ No newline at end of file
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package reader
+
+import "github.com/stretchr/testify/mock"
+
+type MockSdlInstance struct {
+ mock.Mock
+}
+
+func (m *MockSdlInstance) SubscribeChannel(cb func(string, ...string), channels ...string) error {
+ a := m.Called(cb, channels)
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) UnsubscribeChannel(channels ...string) error {
+ a := m.Called(channels)
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) SetAndPublish(channelsAndEvents []string, pairs ...interface{}) error {
+ a := m.Called(channelsAndEvents, pairs)
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) SetIfAndPublish(channelsAndEvents []string, key string, oldData, newData interface{}) (bool, error) {
+ a := m.Called(channelsAndEvents, key, oldData, newData)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlInstance) SetIfNotExistsAndPublish(channelsAndEvents []string, key string, data interface{}) (bool, error) {
+ a := m.Called(channelsAndEvents, key, data)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlInstance) RemoveAndPublish(channelsAndEvents []string, keys []string) error {
+ a := m.Called(channelsAndEvents, keys)
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) RemoveIfAndPublish(channelsAndEvents []string, key string, data interface{}) (bool, error) {
+ a := m.Called(channelsAndEvents, key, data)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlInstance) RemoveAllAndPublish(channelsAndEvents []string) error {
+ a := m.Called(channelsAndEvents)
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) Set(pairs ...interface{}) error {
+ a := m.Called(pairs)
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) Get(keys []string) (map[string]interface{}, error) {
+ a := m.Called(keys)
+ return a.Get(0).(map[string]interface{}), a.Error(1)
+}
+
+func (m *MockSdlInstance) GetAll() ([]string, error) {
+ a := m.Called()
+ return a.Get(0).([]string), a.Error(1)
+}
+
+func (m *MockSdlInstance) Close() error {
+ a := m.Called()
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) Remove(keys []string) error {
+ a := m.Called(keys)
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) RemoveAll() error {
+ a := m.Called()
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) SetIf(key string, oldData, newData interface{}) (bool, error) {
+ a := m.Called(key, oldData, newData)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlInstance) SetIfNotExists(key string, data interface{}) (bool, error) {
+ a := m.Called(key, data)
+ return a.Bool(0), a.Error(1)
+}
+func (m *MockSdlInstance) RemoveIf(key string, data interface{}) (bool, error) {
+ a := m.Called(key, data)
+ return a.Bool(0), a.Error(1)
+}
+
+func (m *MockSdlInstance) AddMember(group string, member ...interface{}) error{
+ a := m.Called(group, member)
+ return a.Error(0)
+}
+
+func (m *MockSdlInstance) RemoveMember(group string, member ...interface{}) error {
+ a := m.Called(group, member)
+ return a.Error(0)
+}
+func (m *MockSdlInstance) RemoveGroup(group string) error {
+ a := m.Called(group)
+ return a.Error(0)
+}
+func (m *MockSdlInstance) GetMembers(group string) ([]string, error) {
+ a := m.Called(group)
+ return a.Get(0).([]string), a.Error(1)
+}
+func (m *MockSdlInstance) IsMember(group string, member interface{}) (bool, error){
+ a := m.Called(group, member)
+ return a.Bool(0), a.Error(1)
+}
+func (m *MockSdlInstance) GroupSize(group string) (int64, error){
+ a := m.Called(group,)
+ return int64(a.Int(0)), a.Error(1)
+}
Code Review / ric-plt / nodeb-rnib.git / commitdiff