From: ss412g Date: Thu, 4 Jul 2019 11:00:29 +0000 (+0300) Subject: upload nodeb rnib reader version 1.0.5 X-Git-Tag: common/v1.0.5 X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=commitdiff_plain;h=286ce41c7d5049e688a40f68e4c6681a645add3d;p=ric-plt%2Fnodeb-rnib.git upload nodeb rnib reader version 1.0.5 Change-Id: I705a12bcf28e764689dacebea2698da6eea18146 Signed-off-by: ss412g --- diff --git a/.gitreview b/.gitreview new file mode 100644 index 0000000..283adf8 --- /dev/null +++ b/.gitreview @@ -0,0 +1,5 @@ +[gerrit] +host=gerrit.o-ran-sc.org +port=29418 +project=ric-plt/nodeb-rnib +defaultbranch=master \ No newline at end of file diff --git a/common/go.mod b/common/go.mod new file mode 100644 index 0000000..6e5ee93 --- /dev/null +++ b/common/go.mod @@ -0,0 +1,5 @@ +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 diff --git a/common/go.sum b/common/go.sum new file mode 100644 index 0000000..93b73c6 --- /dev/null +++ b/common/go.sum @@ -0,0 +1,6 @@ +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= diff --git a/common/iSdlInstance.go b/common/iSdlInstance.go new file mode 100644 index 0000000..4525d8c --- /dev/null +++ b/common/iSdlInstance.go @@ -0,0 +1,46 @@ +// +// 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) +} diff --git a/common/rNibErrors.go b/common/rNibErrors.go new file mode 100644 index 0000000..c5d6620 --- /dev/null +++ b/common/rNibErrors.go @@ -0,0 +1,67 @@ +// +// 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 diff --git a/common/rNibErrors_test.go b/common/rNibErrors_test.go new file mode 100644 index 0000000..5e4ea77 --- /dev/null +++ b/common/rNibErrors_test.go @@ -0,0 +1,100 @@ +// +// 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 diff --git a/common/rNibPool.go b/common/rNibPool.go new file mode 100644 index 0000000..2d90704 --- /dev/null +++ b/common/rNibPool.go @@ -0,0 +1,83 @@ +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) +} diff --git a/common/rNibPool_test.go b/common/rNibPool_test.go new file mode 100644 index 0000000..e7eb662 --- /dev/null +++ b/common/rNibPool_test.go @@ -0,0 +1,237 @@ +// +// 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()}) +} diff --git a/common/utils.go b/common/utils.go new file mode 100644 index 0000000..f7a84ad --- /dev/null +++ b/common/utils.go @@ -0,0 +1,80 @@ +// +// 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 diff --git a/common/utils_test.go b/common/utils_test.go new file mode 100644 index 0000000..640362c --- /dev/null +++ b/common/utils_test.go @@ -0,0 +1,127 @@ +// +// 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 diff --git a/entities/cell.pb.go b/entities/cell.pb.go new file mode 100644 index 0000000..c7ee74c --- /dev/null +++ b/entities/cell.pb.go @@ -0,0 +1,163 @@ +// 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, +} diff --git a/entities/cell.proto b/entities/cell.proto new file mode 100644 index 0000000..19efaea --- /dev/null +++ b/entities/cell.proto @@ -0,0 +1,17 @@ +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 diff --git a/entities/cells.pb.go b/entities/cells.pb.go new file mode 100644 index 0000000..210e7f8 --- /dev/null +++ b/entities/cells.pb.go @@ -0,0 +1,215 @@ +// 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, +} diff --git a/entities/cells.proto b/entities/cells.proto new file mode 100644 index 0000000..4fd2129 --- /dev/null +++ b/entities/cells.proto @@ -0,0 +1,21 @@ +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 diff --git a/entities/enb.pb.go b/entities/enb.pb.go new file mode 100644 index 0000000..b0faf6a --- /dev/null +++ b/entities/enb.pb.go @@ -0,0 +1,1512 @@ +// 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, +} diff --git a/entities/enb.proto b/entities/enb.proto new file mode 100644 index 0000000..06d0187 --- /dev/null +++ b/entities/enb.proto @@ -0,0 +1,203 @@ +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; +} + diff --git a/entities/gnb.pb.go b/entities/gnb.pb.go new file mode 100644 index 0000000..1fd9493 --- /dev/null +++ b/entities/gnb.pb.go @@ -0,0 +1,1071 @@ +// 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, +} diff --git a/entities/gnb.proto b/entities/gnb.proto new file mode 100644 index 0000000..cdfaac1 --- /dev/null +++ b/entities/gnb.proto @@ -0,0 +1,124 @@ +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 diff --git a/entities/go.mod b/entities/go.mod new file mode 100644 index 0000000..d83e75d --- /dev/null +++ b/entities/go.mod @@ -0,0 +1,5 @@ +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 diff --git a/entities/go.sum b/entities/go.sum new file mode 100644 index 0000000..04e9e7c --- /dev/null +++ b/entities/go.sum @@ -0,0 +1,7 @@ +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= diff --git a/entities/nb_identity.pb.go b/entities/nb_identity.pb.go new file mode 100644 index 0000000..4a6a941 --- /dev/null +++ b/entities/nb_identity.pb.go @@ -0,0 +1,137 @@ +// 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, +} diff --git a/entities/nb_identity.proto b/entities/nb_identity.proto new file mode 100644 index 0000000..86b7936 --- /dev/null +++ b/entities/nb_identity.proto @@ -0,0 +1,12 @@ +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; +} diff --git a/entities/nodeb_info.pb.go b/entities/nodeb_info.pb.go new file mode 100644 index 0000000..e73361c --- /dev/null +++ b/entities/nodeb_info.pb.go @@ -0,0 +1,364 @@ +// 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, +} diff --git a/entities/nodeb_info.proto b/entities/nodeb_info.proto new file mode 100644 index 0000000..a8e4123 --- /dev/null +++ b/entities/nodeb_info.proto @@ -0,0 +1,45 @@ +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; + } +} diff --git a/entities/x2_setup_failure_response.pb.go b/entities/x2_setup_failure_response.pb.go new file mode 100644 index 0000000..140e12c --- /dev/null +++ b/entities/x2_setup_failure_response.pb.go @@ -0,0 +1,936 @@ +// 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, +} diff --git a/entities/x2_setup_failure_response.proto b/entities/x2_setup_failure_response.proto new file mode 100644 index 0000000..61a65cf --- /dev/null +++ b/entities/x2_setup_failure_response.proto @@ -0,0 +1,146 @@ +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; +} + diff --git a/reader/go.mod b/reader/go.mod new file mode 100644 index 0000000..bac5cdf --- /dev/null +++ b/reader/go.mod @@ -0,0 +1,18 @@ +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 diff --git a/reader/go.sum b/reader/go.sum new file mode 100644 index 0000000..151bf6a --- /dev/null +++ b/reader/go.sum @@ -0,0 +1,30 @@ +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= diff --git a/reader/rNibReader.go b/reader/rNibReader.go new file mode 100644 index 0000000..e24f4da --- /dev/null +++ b/reader/rNibReader.go @@ -0,0 +1,223 @@ +// +// 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 diff --git a/reader/rNibReader_test.go b/reader/rNibReader_test.go new file mode 100644 index 0000000..105c0ba --- /dev/null +++ b/reader/rNibReader_test.go @@ -0,0 +1,999 @@ +// +// 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 diff --git a/reader/sdlInstanceMock.go b/reader/sdlInstanceMock.go new file mode 100644 index 0000000..dd0a640 --- /dev/null +++ b/reader/sdlInstanceMock.go @@ -0,0 +1,133 @@ +// +// 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) +}