blob: 6fcd511b53f71a568f18cf4334544558011eb666 [file] [log] [blame]
/*
* Copyright 2019-present Open Networking Foundation
*
* 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 api
import (
"context"
"fmt"
"time"
"github.com/golang/protobuf/ptypes/empty"
"github.com/google/uuid"
"github.com/opencord/voltha-protos/v3/go/voltha"
"google.golang.org/grpc/metadata"
)
const (
volthaSerialNumberKey = "voltha_serial_number"
retryInterval = 50 * time.Millisecond
)
var (
coreInCompeteMode bool
)
type isLogicalDeviceConditionSatisfied func(ld *voltha.LogicalDevice) bool
type isLogicalDevicePortsConditionSatisfied func(ports []*voltha.LogicalPort) bool
type isDeviceConditionSatisfied func(ld *voltha.Device) bool
type isDevicesConditionSatisfied func(ds *voltha.Devices) bool
type isLogicalDevicesConditionSatisfied func(lds *voltha.LogicalDevices) bool
type isConditionSatisfied func() bool
func init() {
//Default mode is two rw-core running in a pair of competing cores
coreInCompeteMode = true
}
func setCoreCompeteMode(mode bool) {
coreInCompeteMode = mode
}
func getContext() context.Context {
if coreInCompeteMode {
return metadata.NewIncomingContext(context.Background(), metadata.Pairs(volthaSerialNumberKey, uuid.New().String()))
}
return context.Background()
}
func waitUntilDeviceReadiness(deviceID string,
timeout time.Duration,
verificationFunction isDeviceConditionSatisfied,
nbi *NBIHandler) error {
ch := make(chan int, 1)
done := false
go func() {
for {
device, _ := nbi.GetDevice(getContext(), &voltha.ID{Id: deviceID})
if verificationFunction(device) {
ch <- 1
break
}
if done {
break
}
time.Sleep(retryInterval)
}
}()
timer := time.NewTimer(timeout)
defer timer.Stop()
select {
case <-ch:
return nil
case <-timer.C:
done = true
return fmt.Errorf("expected-states-not-reached-for-device%s", deviceID)
}
}
func waitUntilLogicalDeviceReadiness(oltDeviceID string,
timeout time.Duration,
nbi *NBIHandler,
verificationFunction isLogicalDeviceConditionSatisfied,
) error {
ch := make(chan int, 1)
done := false
go func() {
for {
// Get the logical device from the olt device
d, _ := nbi.GetDevice(getContext(), &voltha.ID{Id: oltDeviceID})
if d != nil && d.ParentId != "" {
ld, _ := nbi.GetLogicalDevice(getContext(), &voltha.ID{Id: d.ParentId})
if verificationFunction(ld) {
ch <- 1
break
}
if done {
break
}
} else if d != nil && d.ParentId == "" { // case where logical device deleted
if verificationFunction(nil) {
ch <- 1
break
}
if done {
break
}
}
time.Sleep(retryInterval)
}
}()
timer := time.NewTimer(timeout)
defer timer.Stop()
select {
case <-ch:
return nil
case <-timer.C:
done = true
return fmt.Errorf("timeout-waiting-for-logical-device-readiness%s", oltDeviceID)
}
}
func waitUntilLogicalDevicePortsReadiness(oltDeviceID string,
timeout time.Duration,
nbi *NBIHandler,
verificationFunction isLogicalDevicePortsConditionSatisfied,
) error {
ch := make(chan int, 1)
done := false
go func() {
for {
// Get the logical device from the olt device
d, _ := nbi.GetDevice(getContext(), &voltha.ID{Id: oltDeviceID})
if d != nil && d.ParentId != "" {
ports, err := nbi.ListLogicalDevicePorts(getContext(), &voltha.ID{Id: d.ParentId})
if err == nil && verificationFunction(ports.Items) {
ch <- 1
break
}
if done {
break
}
}
time.Sleep(retryInterval)
}
}()
timer := time.NewTimer(timeout)
defer timer.Stop()
select {
case <-ch:
return nil
case <-timer.C:
done = true
return fmt.Errorf("timeout-waiting-for-logical-device-readiness%s", oltDeviceID)
}
}
func waitUntilConditionForDevices(timeout time.Duration, nbi *NBIHandler, verificationFunction isDevicesConditionSatisfied) error {
ch := make(chan int, 1)
done := false
go func() {
for {
devices, _ := nbi.ListDevices(getContext(), &empty.Empty{})
if verificationFunction(devices) {
ch <- 1
break
}
if done {
break
}
time.Sleep(retryInterval)
}
}()
timer := time.NewTimer(timeout)
defer timer.Stop()
select {
case <-ch:
return nil
case <-timer.C:
done = true
return fmt.Errorf("timeout-waiting-devices")
}
}
func waitUntilConditionForLogicalDevices(timeout time.Duration, nbi *NBIHandler, verificationFunction isLogicalDevicesConditionSatisfied) error {
ch := make(chan int, 1)
done := false
go func() {
for {
lDevices, _ := nbi.ListLogicalDevices(getContext(), &empty.Empty{})
if verificationFunction(lDevices) {
ch <- 1
break
}
if done {
break
}
time.Sleep(retryInterval)
}
}()
timer := time.NewTimer(timeout)
defer timer.Stop()
select {
case <-ch:
return nil
case <-timer.C:
done = true
return fmt.Errorf("timeout-waiting-logical-devices")
}
}
func waitUntilCondition(timeout time.Duration, nbi *NBIHandler, verificationFunction isConditionSatisfied) error {
ch := make(chan int, 1)
done := false
go func() {
for {
if verificationFunction() {
ch <- 1
break
}
if done {
break
}
time.Sleep(retryInterval)
}
}()
timer := time.NewTimer(timeout)
defer timer.Stop()
select {
case <-ch:
return nil
case <-timer.C:
done = true
return fmt.Errorf("timeout-waiting-for-condition")
}
}