blob: e288838f5c28c925d5ea7799f89a37543fa7090a [file] [log] [blame]
Phaneendra Manda4c62c802019-03-06 21:37:49 +05301/*
2 * Copyright 2018-present Open Networking Foundation
3
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7
8 * http://www.apache.org/licenses/LICENSE-2.0
9
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Girish Gowdru6a80bbd2019-07-02 07:36:09 -070016
Scott Bakerdbd960e2020-02-28 08:57:51 -080017//Package core provides the utility for olt devices, flows and statistics
18package core
Phaneendra Manda4c62c802019-03-06 21:37:49 +053019
20import (
cuilin20187b2a8c32019-03-26 19:52:28 -070021 "context"
Matt Jeanneretceea2e02020-03-27 14:19:57 -040022 "encoding/binary"
Matt Jeanneret1359c732019-08-01 21:40:02 -040023 "encoding/hex"
Girish Gowdra491a9c62021-01-06 16:43:07 -080024 "errors"
cuilin20187b2a8c32019-03-26 19:52:28 -070025 "fmt"
26 "io"
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -040027 "net"
cuilin20187b2a8c32019-03-26 19:52:28 -070028 "strconv"
29 "strings"
30 "sync"
31 "time"
Phaneendra Manda4c62c802019-03-06 21:37:49 +053032
Matteo Scandolo945e4012019-12-12 14:16:11 -080033 "github.com/cenkalti/backoff/v3"
cuilin20187b2a8c32019-03-26 19:52:28 -070034 "github.com/gogo/protobuf/proto"
35 "github.com/golang/protobuf/ptypes"
Girish Kumar93e91742020-07-27 16:43:19 +000036 grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
37 grpc_opentracing "github.com/grpc-ecosystem/go-grpc-middleware/tracing/opentracing"
Girish Gowdraa09aeab2020-09-14 16:30:52 -070038 "github.com/opencord/voltha-lib-go/v4/pkg/adapters/adapterif"
Matteo Scandolodfa7a972020-11-06 13:03:40 -080039 "github.com/opencord/voltha-lib-go/v4/pkg/config"
Himani Chawlacd407802020-12-10 12:08:59 +053040 "github.com/opencord/voltha-lib-go/v4/pkg/events/eventif"
Girish Gowdra491a9c62021-01-06 16:43:07 -080041 flow_utils "github.com/opencord/voltha-lib-go/v4/pkg/flows"
Girish Gowdraa09aeab2020-09-14 16:30:52 -070042 "github.com/opencord/voltha-lib-go/v4/pkg/log"
43 "github.com/opencord/voltha-lib-go/v4/pkg/pmmetrics"
Matteo Scandolodfa7a972020-11-06 13:03:40 -080044
Thomas Lee S94109f12020-03-03 16:39:29 +053045 "github.com/opencord/voltha-openolt-adapter/internal/pkg/olterrors"
Scott Bakerdbd960e2020-02-28 08:57:51 -080046 rsrcMgr "github.com/opencord/voltha-openolt-adapter/internal/pkg/resourcemanager"
Girish Gowdraa09aeab2020-09-14 16:30:52 -070047 "github.com/opencord/voltha-protos/v4/go/common"
48 ic "github.com/opencord/voltha-protos/v4/go/inter_container"
49 of "github.com/opencord/voltha-protos/v4/go/openflow_13"
50 oop "github.com/opencord/voltha-protos/v4/go/openolt"
51 "github.com/opencord/voltha-protos/v4/go/voltha"
cuilin20187b2a8c32019-03-26 19:52:28 -070052 "google.golang.org/grpc"
Devmalya Paula1efa642020-04-20 01:36:43 -040053 "google.golang.org/grpc/codes"
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -040054 "google.golang.org/grpc/status"
Phaneendra Manda4c62c802019-03-06 21:37:49 +053055)
56
salmansiddiqui7ac62132019-08-22 03:58:50 +000057// Constants for number of retries and for timeout
Manikkaraj kb1d51442019-07-23 10:41:02 -040058const (
Girish Gowdra491a9c62021-01-06 16:43:07 -080059 InvalidPort = 0xffffffff
60 MaxNumOfGroupHandlerChannels = 256
61
62 McastFlowOrGroupAdd = "McastFlowOrGroupAdd"
63 McastFlowOrGroupModify = "McastFlowOrGroupModify"
64 McastFlowOrGroupRemove = "McastFlowOrGroupRemove"
Manikkaraj kb1d51442019-07-23 10:41:02 -040065)
66
Phaneendra Manda4c62c802019-03-06 21:37:49 +053067//DeviceHandler will interact with the OLT device.
68type DeviceHandler struct {
Matteo Scandolodfa7a972020-11-06 13:03:40 -080069 cm *config.ConfigManager
cuilin20187b2a8c32019-03-26 19:52:28 -070070 device *voltha.Device
kdarapu381c6902019-07-31 18:23:16 +053071 coreProxy adapterif.CoreProxy
72 AdapterProxy adapterif.AdapterProxy
Himani Chawlacd407802020-12-10 12:08:59 +053073 EventProxy eventif.EventProxy
cuilin20187b2a8c32019-03-26 19:52:28 -070074 openOLT *OpenOLT
cuilin20187b2a8c32019-03-26 19:52:28 -070075 exitChannel chan int
76 lockDevice sync.RWMutex
manikkaraj kbf256be2019-03-25 00:13:48 +053077 Client oop.OpenoltClient
cuilin20187b2a8c32019-03-26 19:52:28 -070078 transitionMap *TransitionMap
79 clientCon *grpc.ClientConn
Girish Gowdra9602eb42020-09-09 15:50:39 -070080 flowMgr []*OpenOltFlowMgr
81 groupMgr *OpenOltGroupMgr
Devmalya Paulfb990a52019-07-09 10:01:49 -040082 eventMgr *OpenOltEventMgr
manikkaraj kbf256be2019-03-25 00:13:48 +053083 resourceMgr *rsrcMgr.OpenOltResourceMgr
Naga Manjunatha8dc9372019-10-31 23:01:18 +053084
Girish Gowdra3ab6d212020-03-24 17:33:15 -070085 discOnus sync.Map
86 onus sync.Map
87 portStats *OpenOltStatisticsMgr
88 metrics *pmmetrics.PmMetrics
89 stopCollector chan bool
90 stopHeartbeatCheck chan bool
91 activePorts sync.Map
92 stopIndications chan bool
93 isReadIndicationRoutineActive bool
Girish Gowdracefae192020-03-19 18:14:10 -070094
Mahir Gunyel2fb81472020-12-16 23:18:34 -080095 totalPonPorts uint32
96 perOnuChannel map[string]onuIndicationChannels
97 perOnuChannelLock sync.Mutex
Girish Gowdra491a9c62021-01-06 16:43:07 -080098
99 // Slice of channels. Each channel in slice, index by (mcast-group-id modulo MaxNumOfGroupHandlerChannels)
100 // A go routine per index, waits on a unique channel for incoming mcast flow or group (add/modify/remove).
101 incomingMcastFlowOrGroup []chan McastFlowOrGroupControlBlock
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700102}
103
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700104//OnuDevice represents ONU related info
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700105type OnuDevice struct {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700106 deviceID string
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700107 deviceType string
108 serialNumber string
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700109 onuID uint32
110 intfID uint32
111 proxyDeviceID string
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530112 losRaised bool
Devmalya Paula1efa642020-04-20 01:36:43 -0400113 rdiRaised bool
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700114}
115
Mahir Gunyel2fb81472020-12-16 23:18:34 -0800116type perOnuIndication struct {
117 ctx context.Context
118 indication *oop.Indication
119 serialNumber string
120}
121
122type onuIndicationChannels struct {
123 indicationChannel chan perOnuIndication
124 stopChannel chan struct{}
125}
126
Girish Gowdra491a9c62021-01-06 16:43:07 -0800127//McastFlowOrGroupControlBlock is created per mcast flow/group add/modify/remove and pushed on the incomingMcastFlowOrGroup channel slice
128//The McastFlowOrGroupControlBlock is then picked by the mcastFlowOrGroupChannelHandlerRoutine for further processing.
129//There are MaxNumOfGroupHandlerChannels number of mcastFlowOrGroupChannelHandlerRoutine routines which monitor for any incoming mcast flow/group messages
130//and process them serially. The mcast flow/group are assigned these routines based on formula (group-id modulo MaxNumOfGroupHandlerChannels)
131type McastFlowOrGroupControlBlock struct {
132 ctx context.Context // Flow/group handler context
133 flowOrGroupAction string // one of McastFlowOrGroupAdd, McastFlowOrGroupModify or McastFlowOrGroupDelete
134 flow *voltha.OfpFlowStats // Flow message (can be nil or valid flow)
135 group *voltha.OfpGroupEntry // Group message (can be nil or valid group)
136 errChan *chan error // channel to report the mcast Flow/group handling error
137}
138
Naga Manjunath7615e552019-10-11 22:35:47 +0530139var pmNames = []string{
140 "rx_bytes",
141 "rx_packets",
142 "rx_mcast_packets",
143 "rx_bcast_packets",
144 "tx_bytes",
145 "tx_packets",
146 "tx_mcast_packets",
147 "tx_bcast_packets",
148}
149
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700150//NewOnuDevice creates a new Onu Device
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530151func NewOnuDevice(devID, deviceTp, serialNum string, onuID, intfID uint32, proxyDevID string, losRaised bool) *OnuDevice {
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700152 var device OnuDevice
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700153 device.deviceID = devID
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700154 device.deviceType = deviceTp
155 device.serialNumber = serialNum
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700156 device.onuID = onuID
157 device.intfID = intfID
158 device.proxyDeviceID = proxyDevID
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530159 device.losRaised = losRaised
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700160 return &device
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530161}
162
163//NewDeviceHandler creates a new device handler
Himani Chawlacd407802020-12-10 12:08:59 +0530164func NewDeviceHandler(cp adapterif.CoreProxy, ap adapterif.AdapterProxy, ep eventif.EventProxy, device *voltha.Device, adapter *OpenOLT, cm *config.ConfigManager) *DeviceHandler {
cuilin20187b2a8c32019-03-26 19:52:28 -0700165 var dh DeviceHandler
Matteo Scandolodfa7a972020-11-06 13:03:40 -0800166 dh.cm = cm
cuilin20187b2a8c32019-03-26 19:52:28 -0700167 dh.coreProxy = cp
Girish Gowdru0c588b22019-04-23 23:24:56 -0400168 dh.AdapterProxy = ap
Devmalya Paulfb990a52019-07-09 10:01:49 -0400169 dh.EventProxy = ep
cuilin20187b2a8c32019-03-26 19:52:28 -0700170 cloned := (proto.Clone(device)).(*voltha.Device)
cuilin20187b2a8c32019-03-26 19:52:28 -0700171 dh.device = cloned
172 dh.openOLT = adapter
173 dh.exitChannel = make(chan int, 1)
174 dh.lockDevice = sync.RWMutex{}
Naga Manjunath7615e552019-10-11 22:35:47 +0530175 dh.stopCollector = make(chan bool, 2)
Abhilash Laxmeshwarf9942e92020-01-07 15:32:44 +0530176 dh.stopHeartbeatCheck = make(chan bool, 2)
Naga Manjunath7615e552019-10-11 22:35:47 +0530177 dh.metrics = pmmetrics.NewPmMetrics(cloned.Id, pmmetrics.Frequency(150), pmmetrics.FrequencyOverride(false), pmmetrics.Grouped(false), pmmetrics.Metrics(pmNames))
Chaitrashree G Sef088112020-02-03 21:39:27 -0500178 dh.activePorts = sync.Map{}
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400179 dh.stopIndications = make(chan bool, 1)
Mahir Gunyel2fb81472020-12-16 23:18:34 -0800180 dh.perOnuChannel = make(map[string]onuIndicationChannels)
Girish Gowdra491a9c62021-01-06 16:43:07 -0800181 // Create a slice of buffered channels for handling concurrent mcast flow/group.
182 dh.incomingMcastFlowOrGroup = make([]chan McastFlowOrGroupControlBlock, MaxNumOfGroupHandlerChannels)
183 for i := range dh.incomingMcastFlowOrGroup {
184 dh.incomingMcastFlowOrGroup[i] = make(chan McastFlowOrGroupControlBlock, MaxNumOfGroupHandlerChannels)
185 // Spin up a go routine to handling incoming mcast flow/group (add/modify/remove).
186 // There will be MaxNumOfGroupHandlerChannels number of mcastFlowOrGroupChannelHandlerRoutine go routines.
187 // These routines will be blocked on the dh.incomingMcastFlowOrGroup[mcast-group-id modulo MaxNumOfGroupHandlerChannels] channel
188 // for incoming mcast flow/group to be processed serially.
189 go dh.mcastFlowOrGroupChannelHandlerRoutine(dh.incomingMcastFlowOrGroup[i])
190 }
cuilin20187b2a8c32019-03-26 19:52:28 -0700191 //TODO initialize the support classes.
192 return &dh
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530193}
194
195// start save the device to the data model
196func (dh *DeviceHandler) start(ctx context.Context) {
cuilin20187b2a8c32019-03-26 19:52:28 -0700197 dh.lockDevice.Lock()
198 defer dh.lockDevice.Unlock()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000199 logger.Debugw(ctx, "starting-device-agent", log.Fields{"device": dh.device})
cuilin20187b2a8c32019-03-26 19:52:28 -0700200 // Add the initial device to the local model
Neha Sharma96b7bf22020-06-15 10:37:32 +0000201 logger.Debug(ctx, "device-agent-started")
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530202}
203
204// stop stops the device dh. Not much to do for now
205func (dh *DeviceHandler) stop(ctx context.Context) {
cuilin20187b2a8c32019-03-26 19:52:28 -0700206 dh.lockDevice.Lock()
207 defer dh.lockDevice.Unlock()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000208 logger.Debug(ctx, "stopping-device-agent")
cuilin20187b2a8c32019-03-26 19:52:28 -0700209 dh.exitChannel <- 1
Neha Sharma96b7bf22020-06-15 10:37:32 +0000210 logger.Debug(ctx, "device-agent-stopped")
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530211}
212
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400213func macifyIP(ip net.IP) string {
214 if len(ip) > 0 {
215 oct1 := strconv.FormatInt(int64(ip[12]), 16)
216 oct2 := strconv.FormatInt(int64(ip[13]), 16)
217 oct3 := strconv.FormatInt(int64(ip[14]), 16)
218 oct4 := strconv.FormatInt(int64(ip[15]), 16)
219 return fmt.Sprintf("00:00:%02v:%02v:%02v:%02v", oct1, oct2, oct3, oct4)
220 }
221 return ""
222}
223
Neha Sharma96b7bf22020-06-15 10:37:32 +0000224func generateMacFromHost(ctx context.Context, host string) (string, error) {
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400225 var genmac string
226 var addr net.IP
227 var ips []string
228 var err error
229
Neha Sharma96b7bf22020-06-15 10:37:32 +0000230 logger.Debugw(ctx, "generating-mac-from-host", log.Fields{"host": host})
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400231
232 if addr = net.ParseIP(host); addr == nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000233 logger.Debugw(ctx, "looking-up-hostname", log.Fields{"host": host})
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400234
235 if ips, err = net.LookupHost(host); err == nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000236 logger.Debugw(ctx, "dns-result-ips", log.Fields{"ips": ips})
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400237 if addr = net.ParseIP(ips[0]); addr == nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000238 return "", olterrors.NewErrInvalidValue(log.Fields{"ip": ips[0]}, nil)
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400239 }
240 genmac = macifyIP(addr)
Neha Sharma96b7bf22020-06-15 10:37:32 +0000241 logger.Debugw(ctx, "using-ip-as-mac",
Shrey Baid807a2a02020-04-09 12:52:45 +0530242 log.Fields{"host": ips[0],
243 "mac": genmac})
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400244 return genmac, nil
245 }
Girish Kumarf26e4882020-03-05 06:49:10 +0000246 return "", olterrors.NewErrAdapter("cannot-resolve-hostname-to-ip", log.Fields{"host": host}, err)
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400247 }
248
249 genmac = macifyIP(addr)
Neha Sharma96b7bf22020-06-15 10:37:32 +0000250 logger.Debugw(ctx, "using-ip-as-mac",
Shrey Baid807a2a02020-04-09 12:52:45 +0530251 log.Fields{"host": host,
252 "mac": genmac})
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400253 return genmac, nil
254}
255
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530256func macAddressToUint32Array(mac string) []uint32 {
cuilin20187b2a8c32019-03-26 19:52:28 -0700257 slist := strings.Split(mac, ":")
258 result := make([]uint32, len(slist))
259 var err error
260 var tmp int64
261 for index, val := range slist {
262 if tmp, err = strconv.ParseInt(val, 16, 32); err != nil {
263 return []uint32{1, 2, 3, 4, 5, 6}
264 }
265 result[index] = uint32(tmp)
266 }
267 return result
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530268}
269
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700270//GetportLabel returns the label for the NNI and the PON port based on port number and port type
David K. Bainbridge794735f2020-02-11 21:01:37 -0800271func GetportLabel(portNum uint32, portType voltha.Port_PortType) (string, error) {
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530272
David K. Bainbridge794735f2020-02-11 21:01:37 -0800273 switch portType {
274 case voltha.Port_ETHERNET_NNI:
275 return fmt.Sprintf("nni-%d", portNum), nil
276 case voltha.Port_PON_OLT:
277 return fmt.Sprintf("pon-%d", portNum), nil
cuilin20187b2a8c32019-03-26 19:52:28 -0700278 }
David K. Bainbridge794735f2020-02-11 21:01:37 -0800279
Girish Kumarf26e4882020-03-05 06:49:10 +0000280 return "", olterrors.NewErrInvalidValue(log.Fields{"port-type": portType}, nil)
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530281}
282
Neha Sharma96b7bf22020-06-15 10:37:32 +0000283func (dh *DeviceHandler) addPort(ctx context.Context, intfID uint32, portType voltha.Port_PortType, state string) error {
Esin Karamanccb714b2019-11-29 15:02:06 +0000284 var operStatus common.OperStatus_Types
cuilin20187b2a8c32019-03-26 19:52:28 -0700285 if state == "up" {
286 operStatus = voltha.OperStatus_ACTIVE
kesavand39e0aa32020-01-28 20:58:50 -0500287 //populating the intfStatus map
Chaitrashree G Sef088112020-02-03 21:39:27 -0500288 dh.activePorts.Store(intfID, true)
cuilin20187b2a8c32019-03-26 19:52:28 -0700289 } else {
290 operStatus = voltha.OperStatus_DISCOVERED
Chaitrashree G Sef088112020-02-03 21:39:27 -0500291 dh.activePorts.Store(intfID, false)
cuilin20187b2a8c32019-03-26 19:52:28 -0700292 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700293 portNum := IntfIDToPortNo(intfID, portType)
Chaitrashree G Sc0878ec2020-05-21 04:59:53 -0400294 label, err := GetportLabel(intfID, portType)
David K. Bainbridge794735f2020-02-11 21:01:37 -0800295 if err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000296 return olterrors.NewErrNotFound("port-label", log.Fields{"port-number": portNum, "port-type": portType}, err)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400297 }
Chaitrashree G Sded0a832020-01-09 20:21:48 -0500298
Neha Sharma8f4e4322020-08-06 10:51:53 +0000299 if port, err := dh.coreProxy.GetDevicePort(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, portNum); err == nil && port.Type == portType {
Girish Kumara1ea2aa2020-08-19 18:14:22 +0000300 logger.Debug(ctx, "port-already-exists-updating-oper-status-of-port")
Neha Sharma8f4e4322020-08-06 10:51:53 +0000301 if err := dh.coreProxy.PortStateUpdate(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, portType, portNum, operStatus); err != nil {
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400302 return olterrors.NewErrAdapter("failed-to-update-port-state", log.Fields{
303 "device-id": dh.device.Id,
304 "port-type": portType,
305 "port-number": portNum,
306 "oper-status": operStatus}, err).Log()
Chaitrashree G Sded0a832020-01-09 20:21:48 -0500307 }
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400308 return nil
Chaitrashree G Sded0a832020-01-09 20:21:48 -0500309 }
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400310 // Now create Port
Girish Gowdra631ef3d2020-06-15 10:45:52 -0700311 capacity := uint32(of.OfpPortFeatures_OFPPF_1GB_FD | of.OfpPortFeatures_OFPPF_FIBER)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400312 port := &voltha.Port{
cuilin20187b2a8c32019-03-26 19:52:28 -0700313 PortNo: portNum,
314 Label: label,
315 Type: portType,
316 OperStatus: operStatus,
Girish Gowdra631ef3d2020-06-15 10:45:52 -0700317 OfpPort: &of.OfpPort{
318 HwAddr: macAddressToUint32Array(dh.device.MacAddress),
319 Config: 0,
320 State: uint32(of.OfpPortState_OFPPS_LIVE),
321 Curr: capacity,
322 Advertised: capacity,
323 Peer: capacity,
324 CurrSpeed: uint32(of.OfpPortFeatures_OFPPF_1GB_FD),
325 MaxSpeed: uint32(of.OfpPortFeatures_OFPPF_1GB_FD),
326 },
cuilin20187b2a8c32019-03-26 19:52:28 -0700327 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000328 logger.Debugw(ctx, "sending-port-update-to-core", log.Fields{"port": port})
cuilin20187b2a8c32019-03-26 19:52:28 -0700329 // Synchronous call to update device - this method is run in its own go routine
Neha Sharma8f4e4322020-08-06 10:51:53 +0000330 if err := dh.coreProxy.PortCreated(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, port); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000331 return olterrors.NewErrAdapter("error-creating-port", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -0800332 "device-id": dh.device.Id,
Girish Kumarf26e4882020-03-05 06:49:10 +0000333 "port-type": portType}, err)
Girish Gowdru1110ef22019-06-24 11:17:59 -0400334 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000335 go dh.updateLocalDevice(ctx)
Kishore Darapuaaf9c102020-05-04 13:06:57 +0530336 return nil
337}
338
Kent Hagermane6ff1012020-07-14 15:07:53 -0400339func (dh *DeviceHandler) updateLocalDevice(ctx context.Context) {
Kishore Darapuaaf9c102020-05-04 13:06:57 +0530340 dh.lockDevice.Lock()
341 defer dh.lockDevice.Unlock()
Neha Sharma8f4e4322020-08-06 10:51:53 +0000342 device, err := dh.coreProxy.GetDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, dh.device.Id)
Kishore Darapuaaf9c102020-05-04 13:06:57 +0530343 if err != nil || device == nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400344 logger.Errorf(ctx, "device-not-found", log.Fields{"device-id": dh.device.Id}, err)
345 return
Kishore Darapuaaf9c102020-05-04 13:06:57 +0530346 }
347 dh.device = device
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530348}
349
David Bainbridge95a3fcf2020-06-09 10:49:31 -0700350// nolint: gocyclo
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530351// readIndications to read the indications from the OLT device
David K. Bainbridge794735f2020-02-11 21:01:37 -0800352func (dh *DeviceHandler) readIndications(ctx context.Context) error {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000353 defer logger.Debugw(ctx, "indications-ended", log.Fields{"device-id": dh.device.Id})
Girish Gowdra3ab6d212020-03-24 17:33:15 -0700354 defer func() {
355 dh.lockDevice.Lock()
356 dh.isReadIndicationRoutineActive = false
357 dh.lockDevice.Unlock()
358 }()
Girish Gowdra3f974912020-03-23 20:35:18 -0700359 indications, err := dh.startOpenOltIndicationStream(ctx)
cuilin20187b2a8c32019-03-26 19:52:28 -0700360 if err != nil {
Girish Gowdra3f974912020-03-23 20:35:18 -0700361 return err
cuilin20187b2a8c32019-03-26 19:52:28 -0700362 }
Girish Gowdru5ba46c92019-04-25 05:00:05 -0400363 /* get device state */
npujarec5762e2020-01-01 14:08:48 +0530364 device, err := dh.coreProxy.GetDevice(ctx, dh.device.Id, dh.device.Id)
Girish Gowdru5ba46c92019-04-25 05:00:05 -0400365 if err != nil || device == nil {
366 /*TODO: needs to handle error scenarios */
Girish Kumarf26e4882020-03-05 06:49:10 +0000367 return olterrors.NewErrNotFound("device", log.Fields{"device-id": dh.device.Id}, err)
Girish Gowdru5ba46c92019-04-25 05:00:05 -0400368 }
Girish Gowdru5ba46c92019-04-25 05:00:05 -0400369
David Bainbridgef5879ca2019-12-13 21:17:54 +0000370 // Create an exponential backoff around re-enabling indications. The
371 // maximum elapsed time for the back off is set to 0 so that we will
372 // continue to retry. The max interval defaults to 1m, but is set
373 // here for code clarity
374 indicationBackoff := backoff.NewExponentialBackOff()
375 indicationBackoff.MaxElapsedTime = 0
376 indicationBackoff.MaxInterval = 1 * time.Minute
Girish Gowdra3f974912020-03-23 20:35:18 -0700377
Girish Gowdra3ab6d212020-03-24 17:33:15 -0700378 dh.lockDevice.Lock()
379 dh.isReadIndicationRoutineActive = true
380 dh.lockDevice.Unlock()
381
Girish Gowdra3f974912020-03-23 20:35:18 -0700382Loop:
cuilin20187b2a8c32019-03-26 19:52:28 -0700383 for {
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400384 select {
385 case <-dh.stopIndications:
divyadesai3af43e12020-08-18 07:10:54 +0000386 logger.Debugw(ctx, "stopping-collecting-indications-for-olt", log.Fields{"device-id": dh.device.Id})
Girish Gowdra3f974912020-03-23 20:35:18 -0700387 break Loop
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400388 default:
389 indication, err := indications.Recv()
390 if err == io.EOF {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000391 logger.Infow(ctx, "eof-for-indications",
Shrey Baid807a2a02020-04-09 12:52:45 +0530392 log.Fields{"err": err,
Thomas Lee S985938d2020-05-04 11:40:41 +0530393 "device-id": dh.device.Id})
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400394 // Use an exponential back off to prevent getting into a tight loop
395 duration := indicationBackoff.NextBackOff()
396 if duration == backoff.Stop {
397 // If we reach a maximum then warn and reset the backoff
398 // timer and keep attempting.
Neha Sharma96b7bf22020-06-15 10:37:32 +0000399 logger.Warnw(ctx, "maximum-indication-backoff-reached--resetting-backoff-timer",
Shrey Baid807a2a02020-04-09 12:52:45 +0530400 log.Fields{"max-indication-backoff": indicationBackoff.MaxElapsedTime,
Thomas Lee S985938d2020-05-04 11:40:41 +0530401 "device-id": dh.device.Id})
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400402 indicationBackoff.Reset()
403 }
David Bainbridge95a3fcf2020-06-09 10:49:31 -0700404
405 // On failure process a backoff timer while watching for stopIndications
406 // events
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700407 backoffTimer := time.NewTimer(indicationBackoff.NextBackOff())
David Bainbridge95a3fcf2020-06-09 10:49:31 -0700408 select {
409 case <-dh.stopIndications:
divyadesai3af43e12020-08-18 07:10:54 +0000410 logger.Debugw(ctx, "stopping-collecting-indications-for-olt", log.Fields{"device-id": dh.device.Id})
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700411 if !backoffTimer.Stop() {
412 <-backoffTimer.C
David Bainbridge95a3fcf2020-06-09 10:49:31 -0700413 }
414 break Loop
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700415 case <-backoffTimer.C:
416 // backoffTimer expired continue
David Bainbridge95a3fcf2020-06-09 10:49:31 -0700417 }
Girish Gowdra3f974912020-03-23 20:35:18 -0700418 if indications, err = dh.startOpenOltIndicationStream(ctx); err != nil {
419 return err
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400420 }
421 continue
David Bainbridgef5879ca2019-12-13 21:17:54 +0000422 }
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530423 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000424 logger.Errorw(ctx, "read-indication-error",
Shrey Baid807a2a02020-04-09 12:52:45 +0530425 log.Fields{"err": err,
Thomas Lee S985938d2020-05-04 11:40:41 +0530426 "device-id": dh.device.Id})
Girish Gowdra3f974912020-03-23 20:35:18 -0700427 // Close the stream, and re-initialize it
428 if err = indications.CloseSend(); err != nil {
429 // Ok to ignore here, because we landed here due to a problem on the stream
430 // In all probability, the closeSend call may fail
Neha Sharma96b7bf22020-06-15 10:37:32 +0000431 logger.Debugw(ctx, "error-closing-send stream--error-ignored",
Shrey Baid807a2a02020-04-09 12:52:45 +0530432 log.Fields{"err": err,
Thomas Lee S985938d2020-05-04 11:40:41 +0530433 "device-id": dh.device.Id})
Girish Gowdra3f974912020-03-23 20:35:18 -0700434 }
435 if indications, err = dh.startOpenOltIndicationStream(ctx); err != nil {
436 return err
437 }
438 // once we re-initialized the indication stream, continue to read indications
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400439 continue
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +0530440 }
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400441 // Reset backoff if we have a successful receive
442 indicationBackoff.Reset()
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400443 // When OLT is admin down, ignore all indications.
Thomas Lee S985938d2020-05-04 11:40:41 +0530444 if device.AdminState == voltha.AdminState_DISABLED && !isIndicationAllowedDuringOltAdminDown(indication) {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000445 logger.Debugw(ctx, "olt-is-admin-down, ignore indication",
Shrey Baid807a2a02020-04-09 12:52:45 +0530446 log.Fields{"indication": indication,
Thomas Lee S985938d2020-05-04 11:40:41 +0530447 "device-id": dh.device.Id})
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400448 continue
Devmalya Paul495b94a2019-08-27 19:42:00 -0400449 }
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400450 dh.handleIndication(ctx, indication)
cuilin20187b2a8c32019-03-26 19:52:28 -0700451 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700452 }
Girish Gowdra3f974912020-03-23 20:35:18 -0700453 // Close the send stream
454 _ = indications.CloseSend() // Ok to ignore error, as we stopping the readIndication anyway
Girish Gowdra3ab6d212020-03-24 17:33:15 -0700455
Girish Gowdra3f974912020-03-23 20:35:18 -0700456 return nil
457}
458
459func (dh *DeviceHandler) startOpenOltIndicationStream(ctx context.Context) (oop.Openolt_EnableIndicationClient, error) {
460
461 indications, err := dh.Client.EnableIndication(ctx, new(oop.Empty))
462 if err != nil {
463 return nil, olterrors.NewErrCommunication("indication-read-failure", log.Fields{"device-id": dh.device.Id}, err).Log()
464 }
465 if indications == nil {
466 return nil, olterrors.NewErrInvalidValue(log.Fields{"indications": nil, "device-id": dh.device.Id}, nil).Log()
467 }
468
469 return indications, nil
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400470}
471
472// isIndicationAllowedDuringOltAdminDown returns true if the indication is allowed during OLT Admin down, else false
473func isIndicationAllowedDuringOltAdminDown(indication *oop.Indication) bool {
474 switch indication.Data.(type) {
475 case *oop.Indication_OltInd, *oop.Indication_IntfInd, *oop.Indication_IntfOperInd:
476 return true
477
478 default:
479 return false
480 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700481}
482
David K. Bainbridge794735f2020-02-11 21:01:37 -0800483func (dh *DeviceHandler) handleOltIndication(ctx context.Context, oltIndication *oop.OltIndication) error {
Daniele Rossi051466a2019-07-26 13:39:37 +0000484 raisedTs := time.Now().UnixNano()
Gamze Abakaa1a50522019-10-03 19:28:27 +0000485 if oltIndication.OperState == "up" && dh.transitionMap.currentDeviceState != deviceStateUp {
npujarec5762e2020-01-01 14:08:48 +0530486 dh.transitionMap.Handle(ctx, DeviceUpInd)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700487 } else if oltIndication.OperState == "down" {
npujarec5762e2020-01-01 14:08:48 +0530488 dh.transitionMap.Handle(ctx, DeviceDownInd)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700489 }
Daniele Rossi051466a2019-07-26 13:39:37 +0000490 // Send or clear Alarm
Neha Sharma96b7bf22020-06-15 10:37:32 +0000491 if err := dh.eventMgr.oltUpDownIndication(ctx, oltIndication, dh.device.Id, raisedTs); err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +0530492 return olterrors.NewErrAdapter("failed-indication", log.Fields{
divyadesai3af43e12020-08-18 07:10:54 +0000493 "device-id": dh.device.Id,
David K. Bainbridge794735f2020-02-11 21:01:37 -0800494 "indication": oltIndication,
Girish Kumarf26e4882020-03-05 06:49:10 +0000495 "timestamp": raisedTs}, err)
David K. Bainbridge794735f2020-02-11 21:01:37 -0800496 }
497 return nil
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700498}
499
David K. Bainbridge794735f2020-02-11 21:01:37 -0800500// nolint: gocyclo
npujarec5762e2020-01-01 14:08:48 +0530501func (dh *DeviceHandler) handleIndication(ctx context.Context, indication *oop.Indication) {
Devmalya Paulfb990a52019-07-09 10:01:49 -0400502 raisedTs := time.Now().UnixNano()
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700503 switch indication.Data.(type) {
504 case *oop.Indication_OltInd:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000505 span, ctx := log.CreateChildSpan(ctx, "olt-indication", log.Fields{"device-id": dh.device.Id})
506 defer span.Finish()
507
David K. Bainbridge794735f2020-02-11 21:01:37 -0800508 if err := dh.handleOltIndication(ctx, indication.GetOltInd()); err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400509 _ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "olt", "device-id": dh.device.Id}, err).Log()
David K. Bainbridge794735f2020-02-11 21:01:37 -0800510 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700511 case *oop.Indication_IntfInd:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000512 span, ctx := log.CreateChildSpan(ctx, "interface-indication", log.Fields{"device-id": dh.device.Id})
513 defer span.Finish()
514
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700515 intfInd := indication.GetIntfInd()
David K. Bainbridge794735f2020-02-11 21:01:37 -0800516 go func() {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000517 if err := dh.addPort(ctx, intfInd.GetIntfId(), voltha.Port_PON_OLT, intfInd.GetOperState()); err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400518 _ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "interface", "device-id": dh.device.Id}, err).Log()
David K. Bainbridge794735f2020-02-11 21:01:37 -0800519 }
520 }()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000521 logger.Infow(ctx, "received-interface-indication", log.Fields{"InterfaceInd": intfInd, "device-id": dh.device.Id})
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700522 case *oop.Indication_IntfOperInd:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000523 span, ctx := log.CreateChildSpan(ctx, "interface-oper-indication", log.Fields{"device-id": dh.device.Id})
524 defer span.Finish()
525
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700526 intfOperInd := indication.GetIntfOperInd()
527 if intfOperInd.GetType() == "nni" {
David K. Bainbridge794735f2020-02-11 21:01:37 -0800528 go func() {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000529 if err := dh.addPort(ctx, intfOperInd.GetIntfId(), voltha.Port_ETHERNET_NNI, intfOperInd.GetOperState()); err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400530 _ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "interface-oper-nni", "device-id": dh.device.Id}, err).Log()
David K. Bainbridge794735f2020-02-11 21:01:37 -0800531 }
532 }()
Kent Hagermane6ff1012020-07-14 15:07:53 -0400533 if err := dh.resourceMgr.AddNNIToKVStore(ctx, intfOperInd.GetIntfId()); err != nil {
534 logger.Warn(ctx, err)
535 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700536 } else if intfOperInd.GetType() == "pon" {
537 // TODO: Check what needs to be handled here for When PON PORT down, ONU will be down
538 // Handle pon port update
David K. Bainbridge794735f2020-02-11 21:01:37 -0800539 go func() {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000540 if err := dh.addPort(ctx, intfOperInd.GetIntfId(), voltha.Port_PON_OLT, intfOperInd.GetOperState()); err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400541 _ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "interface-oper-pon", "device-id": dh.device.Id}, err).Log()
David K. Bainbridge794735f2020-02-11 21:01:37 -0800542 }
543 }()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000544 go dh.eventMgr.oltIntfOperIndication(ctx, indication.GetIntfOperInd(), dh.device.Id, raisedTs)
cuilin20187b2a8c32019-03-26 19:52:28 -0700545 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000546 logger.Infow(ctx, "received-interface-oper-indication",
Shrey Baid807a2a02020-04-09 12:52:45 +0530547 log.Fields{"interfaceOperInd": intfOperInd,
Thomas Lee S985938d2020-05-04 11:40:41 +0530548 "device-id": dh.device.Id})
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700549 case *oop.Indication_OnuDiscInd:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000550 span, ctx := log.CreateChildSpan(ctx, "onu-discovery-indication", log.Fields{"device-id": dh.device.Id})
551 defer span.Finish()
552
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700553 onuDiscInd := indication.GetOnuDiscInd()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000554 logger.Infow(ctx, "received-onu-discovery-indication", log.Fields{"OnuDiscInd": onuDiscInd, "device-id": dh.device.Id})
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700555 sn := dh.stringifySerialNumber(onuDiscInd.SerialNumber)
Mahir Gunyel2fb81472020-12-16 23:18:34 -0800556 //put message to channel and return immediately
557 dh.putOnuIndicationToChannel(ctx, indication, sn)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700558 case *oop.Indication_OnuInd:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000559 span, ctx := log.CreateChildSpan(ctx, "onu-indication", log.Fields{"device-id": dh.device.Id})
560 defer span.Finish()
561
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700562 onuInd := indication.GetOnuInd()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000563 logger.Infow(ctx, "received-onu-indication", log.Fields{"OnuInd": onuInd, "device-id": dh.device.Id})
Mahir Gunyel2fb81472020-12-16 23:18:34 -0800564 sn := dh.stringifySerialNumber(onuInd.SerialNumber)
565 //put message to channel and return immediately
566 dh.putOnuIndicationToChannel(ctx, indication, sn)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700567 case *oop.Indication_OmciInd:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000568 span, ctx := log.CreateChildSpan(ctx, "omci-indication", log.Fields{"device-id": dh.device.Id})
569 defer span.Finish()
570
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700571 omciInd := indication.GetOmciInd()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000572 logger.Debugw(ctx, "received-omci-indication", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id})
David K. Bainbridge794735f2020-02-11 21:01:37 -0800573 go func() {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000574 if err := dh.omciIndication(ctx, omciInd); err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400575 _ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "omci", "device-id": dh.device.Id}, err).Log()
David K. Bainbridge794735f2020-02-11 21:01:37 -0800576 }
577 }()
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700578 case *oop.Indication_PktInd:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000579 span, ctx := log.CreateChildSpan(ctx, "packet-indication", log.Fields{"device-id": dh.device.Id})
580 defer span.Finish()
581
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700582 pktInd := indication.GetPktInd()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000583 logger.Debugw(ctx, "received-packet-indication", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -0700584 "intf-type": pktInd.IntfId,
585 "intf-id": pktInd.IntfId,
586 "gem-port-id": pktInd.GemportId,
587 "port-no": pktInd.PortNo,
588 "device-id": dh.device.Id,
589 })
590
591 if logger.V(log.DebugLevel) {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000592 logger.Debugw(ctx, "received-packet-indication-packet", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -0700593 "intf-type": pktInd.IntfId,
594 "intf-id": pktInd.IntfId,
595 "gem-port-id": pktInd.GemportId,
596 "port-no": pktInd.PortNo,
597 "packet": hex.EncodeToString(pktInd.Pkt),
598 "device-id": dh.device.Id,
599 })
600 }
601
David K. Bainbridge794735f2020-02-11 21:01:37 -0800602 go func() {
603 if err := dh.handlePacketIndication(ctx, pktInd); err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400604 _ = olterrors.NewErrAdapter("handle-indication-error", log.Fields{"type": "packet", "device-id": dh.device.Id}, err).Log()
David K. Bainbridge794735f2020-02-11 21:01:37 -0800605 }
606 }()
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700607 case *oop.Indication_PortStats:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000608 span, ctx := log.CreateChildSpan(ctx, "port-statistics-indication", log.Fields{"device-id": dh.device.Id})
609 defer span.Finish()
610
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700611 portStats := indication.GetPortStats()
Girish Gowdra9602eb42020-09-09 15:50:39 -0700612 go dh.portStats.PortStatisticsIndication(ctx, portStats, dh.totalPonPorts)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700613 case *oop.Indication_FlowStats:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000614 span, ctx := log.CreateChildSpan(ctx, "flow-stats-indication", log.Fields{"device-id": dh.device.Id})
615 defer span.Finish()
616
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700617 flowStats := indication.GetFlowStats()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000618 logger.Infow(ctx, "received-flow-stats", log.Fields{"FlowStats": flowStats, "device-id": dh.device.Id})
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700619 case *oop.Indication_AlarmInd:
Neha Sharma8f4e4322020-08-06 10:51:53 +0000620 span, ctx := log.CreateChildSpan(ctx, "alarm-indication", log.Fields{"device-id": dh.device.Id})
621 defer span.Finish()
622
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700623 alarmInd := indication.GetAlarmInd()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000624 logger.Infow(ctx, "received-alarm-indication", log.Fields{"AlarmInd": alarmInd, "device-id": dh.device.Id})
625 go dh.eventMgr.ProcessEvents(ctx, alarmInd, dh.device.Id, raisedTs)
cuilin20187b2a8c32019-03-26 19:52:28 -0700626 }
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530627}
628
629// doStateUp handle the olt up indication and update to voltha core
npujarec5762e2020-01-01 14:08:48 +0530630func (dh *DeviceHandler) doStateUp(ctx context.Context) error {
Thomas Lee S85f37312020-04-03 17:06:12 +0530631 //starting the stat collector
Neha Sharma96b7bf22020-06-15 10:37:32 +0000632 go startCollector(ctx, dh)
Thomas Lee S85f37312020-04-03 17:06:12 +0530633
Girish Gowdru0c588b22019-04-23 23:24:56 -0400634 // Synchronous call to update device state - this method is run in its own go routine
npujarec5762e2020-01-01 14:08:48 +0530635 if err := dh.coreProxy.DeviceStateUpdate(ctx, dh.device.Id, voltha.ConnectStatus_REACHABLE,
Girish Gowdru0c588b22019-04-23 23:24:56 -0400636 voltha.OperStatus_ACTIVE); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000637 return olterrors.NewErrAdapter("device-update-failed", log.Fields{"device-id": dh.device.Id}, err)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400638 }
Gamze Abaka07868a52020-12-17 14:19:28 +0000639
640 //Clear olt communication failure event
641 dh.device.ConnectStatus = voltha.ConnectStatus_REACHABLE
642 dh.device.OperStatus = voltha.OperStatus_ACTIVE
643 raisedTs := time.Now().UnixNano()
644 go dh.eventMgr.oltCommunicationEvent(ctx, dh.device, raisedTs)
645
Girish Gowdru0c588b22019-04-23 23:24:56 -0400646 return nil
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530647}
648
649// doStateDown handle the olt down indication
npujarec5762e2020-01-01 14:08:48 +0530650func (dh *DeviceHandler) doStateDown(ctx context.Context) error {
serkant.uluderya245caba2019-09-24 23:15:29 -0700651 dh.lockDevice.Lock()
652 defer dh.lockDevice.Unlock()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000653 logger.Debugw(ctx, "do-state-down-start", log.Fields{"device-id": dh.device.Id})
Girish Gowdrud4245152019-05-10 00:47:31 -0400654
npujarec5762e2020-01-01 14:08:48 +0530655 device, err := dh.coreProxy.GetDevice(ctx, dh.device.Id, dh.device.Id)
Girish Gowdrud4245152019-05-10 00:47:31 -0400656 if err != nil || device == nil {
657 /*TODO: needs to handle error scenarios */
Girish Kumarf26e4882020-03-05 06:49:10 +0000658 return olterrors.NewErrNotFound("device", log.Fields{"device-id": dh.device.Id}, err)
Girish Gowdrud4245152019-05-10 00:47:31 -0400659 }
660
661 cloned := proto.Clone(device).(*voltha.Device)
Girish Gowdrud4245152019-05-10 00:47:31 -0400662
663 //Update the device oper state and connection status
664 cloned.OperStatus = voltha.OperStatus_UNKNOWN
Girish Gowdrud4245152019-05-10 00:47:31 -0400665 dh.device = cloned
666
David K. Bainbridge794735f2020-02-11 21:01:37 -0800667 if err = dh.coreProxy.DeviceStateUpdate(ctx, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000668 return olterrors.NewErrAdapter("state-update-failed", log.Fields{"device-id": device.Id}, err)
Girish Gowdrud4245152019-05-10 00:47:31 -0400669 }
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -0400670
671 //get the child device for the parent device
npujarec5762e2020-01-01 14:08:48 +0530672 onuDevices, err := dh.coreProxy.GetChildDevices(ctx, dh.device.Id)
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -0400673 if err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000674 return olterrors.NewErrAdapter("child-device-fetch-failed", log.Fields{"device-id": dh.device.Id}, err)
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -0400675 }
676 for _, onuDevice := range onuDevices.Items {
677
678 // Update onu state as down in onu adapter
679 onuInd := oop.OnuIndication{}
680 onuInd.OperState = "down"
David K. Bainbridge794735f2020-02-11 21:01:37 -0800681 err := dh.AdapterProxy.SendInterAdapterMessage(ctx, &onuInd, ic.InterAdapterMessageType_ONU_IND_REQUEST,
serkant.uluderya4aff1862020-09-17 23:35:26 +0300682 dh.openOLT.config.Topic, onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "")
David K. Bainbridge794735f2020-02-11 21:01:37 -0800683 if err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400684 _ = olterrors.NewErrCommunication("inter-adapter-send-failed", log.Fields{
serkant.uluderya4aff1862020-09-17 23:35:26 +0300685 "source": dh.openOLT.config.Topic,
David K. Bainbridge794735f2020-02-11 21:01:37 -0800686 "onu-indicator": onuInd,
687 "device-type": onuDevice.Type,
688 "device-id": onuDevice.Id}, err).LogAt(log.ErrorLevel)
serkant.uluderya245caba2019-09-24 23:15:29 -0700689 //Do not return here and continue to process other ONUs
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700690 }
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -0400691 }
serkant.uluderya245caba2019-09-24 23:15:29 -0700692 /* Discovered ONUs entries need to be cleared , since after OLT
693 is up, it starts sending discovery indications again*/
Naga Manjunatha8dc9372019-10-31 23:01:18 +0530694 dh.discOnus = sync.Map{}
Neha Sharma96b7bf22020-06-15 10:37:32 +0000695 logger.Debugw(ctx, "do-state-down-end", log.Fields{"device-id": device.Id})
cuilin20187b2a8c32019-03-26 19:52:28 -0700696 return nil
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530697}
698
699// doStateInit dial the grpc before going to init state
npujarec5762e2020-01-01 14:08:48 +0530700func (dh *DeviceHandler) doStateInit(ctx context.Context) error {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400701 var err error
Girish Kumar93e91742020-07-27 16:43:19 +0000702 // Use Intercepters to automatically inject and publish Open Tracing Spans by this GRPC client
703 dh.clientCon, err = grpc.Dial(dh.device.GetHostAndPort(),
704 grpc.WithInsecure(),
705 grpc.WithBlock(),
706 grpc.WithStreamInterceptor(grpc_middleware.ChainStreamClient(
Girish Kumar935f7af2020-08-18 11:59:42 +0000707 grpc_opentracing.StreamClientInterceptor(grpc_opentracing.WithTracer(log.ActiveTracerProxy{})),
Girish Kumar93e91742020-07-27 16:43:19 +0000708 )),
709 grpc.WithUnaryInterceptor(grpc_middleware.ChainUnaryClient(
Girish Kumar935f7af2020-08-18 11:59:42 +0000710 grpc_opentracing.UnaryClientInterceptor(grpc_opentracing.WithTracer(log.ActiveTracerProxy{})),
Girish Kumar93e91742020-07-27 16:43:19 +0000711 )))
712
713 if err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +0530714 return olterrors.NewErrCommunication("dial-failure", log.Fields{
Thomas Lee S985938d2020-05-04 11:40:41 +0530715 "device-id": dh.device.Id,
Girish Kumarf26e4882020-03-05 06:49:10 +0000716 "host-and-port": dh.device.GetHostAndPort()}, err)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400717 }
718 return nil
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530719}
720
721// postInit create olt client instance to invoke RPC on the olt device
npujarec5762e2020-01-01 14:08:48 +0530722func (dh *DeviceHandler) postInit(ctx context.Context) error {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400723 dh.Client = oop.NewOpenoltClient(dh.clientCon)
npujarec5762e2020-01-01 14:08:48 +0530724 dh.transitionMap.Handle(ctx, GrpcConnected)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400725 return nil
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530726}
727
728// doStateConnected get the device info and update to voltha core
npujarec5762e2020-01-01 14:08:48 +0530729func (dh *DeviceHandler) doStateConnected(ctx context.Context) error {
Thomas Lee S985938d2020-05-04 11:40:41 +0530730 var err error
Neha Sharma96b7bf22020-06-15 10:37:32 +0000731 logger.Debugw(ctx, "olt-device-connected", log.Fields{"device-id": dh.device.Id})
Girish Gowdru0fe5f7e2019-05-28 05:12:27 -0400732
733 // Case where OLT is disabled and then rebooted.
Thomas Lee S985938d2020-05-04 11:40:41 +0530734 device, err := dh.coreProxy.GetDevice(ctx, dh.device.Id, dh.device.Id)
735 if err != nil || device == nil {
736 /*TODO: needs to handle error scenarios */
737 return olterrors.NewErrAdapter("device-fetch-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
738 }
739 if device.AdminState == voltha.AdminState_DISABLED {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000740 logger.Debugln(ctx, "do-state-connected--device-admin-state-down")
Girish Gowdru0fe5f7e2019-05-28 05:12:27 -0400741
742 cloned := proto.Clone(device).(*voltha.Device)
743 cloned.ConnectStatus = voltha.ConnectStatus_REACHABLE
744 cloned.OperStatus = voltha.OperStatus_UNKNOWN
745 dh.device = cloned
Thomas Lee S985938d2020-05-04 11:40:41 +0530746 if err = dh.coreProxy.DeviceStateUpdate(ctx, cloned.Id, cloned.ConnectStatus, cloned.OperStatus); err != nil {
747 return olterrors.NewErrAdapter("device-state-update-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
Girish Gowdru0fe5f7e2019-05-28 05:12:27 -0400748 }
749
Chaitrashree G S44124192019-08-07 20:21:36 -0400750 // Since the device was disabled before the OLT was rebooted, enforce the OLT to be Disabled after re-connection.
npujarec5762e2020-01-01 14:08:48 +0530751 _, err = dh.Client.DisableOlt(ctx, new(oop.Empty))
Girish Gowdru0fe5f7e2019-05-28 05:12:27 -0400752 if err != nil {
Thomas Lee S985938d2020-05-04 11:40:41 +0530753 return olterrors.NewErrAdapter("olt-disable-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
Girish Gowdru0fe5f7e2019-05-28 05:12:27 -0400754 }
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400755 // We should still go ahead an initialize various device handler modules so that when OLT is re-enabled, we have
756 // all the modules initialized and ready to handle incoming ONUs.
757
Thomas Lee S985938d2020-05-04 11:40:41 +0530758 err = dh.initializeDeviceHandlerModules(ctx)
759 if err != nil {
760 return olterrors.NewErrAdapter("device-handler-initialization-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400761 }
Girish Gowdru0fe5f7e2019-05-28 05:12:27 -0400762
763 // Start reading indications
David K. Bainbridge794735f2020-02-11 21:01:37 -0800764 go func() {
Thomas Lee S985938d2020-05-04 11:40:41 +0530765 if err = dh.readIndications(ctx); err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400766 _ = olterrors.NewErrAdapter("indication-read-failure", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
David K. Bainbridge794735f2020-02-11 21:01:37 -0800767 }
768 }()
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700769
770 go startHeartbeatCheck(ctx, dh)
771
Girish Gowdru0fe5f7e2019-05-28 05:12:27 -0400772 return nil
773 }
774
Neha Sharma8f4e4322020-08-06 10:51:53 +0000775 ports, err := dh.coreProxy.ListDevicePorts(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id)
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400776 if err != nil {
Girish Gowdrud4245152019-05-10 00:47:31 -0400777 /*TODO: needs to handle error scenarios */
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400778 return olterrors.NewErrAdapter("fetch-ports-failed", log.Fields{"device-id": dh.device.Id}, err)
Girish Gowdrud4245152019-05-10 00:47:31 -0400779 }
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400780 dh.populateActivePorts(ctx, ports)
781 if err := dh.disableAdminDownPorts(ctx, ports); err != nil {
782 return olterrors.NewErrAdapter("port-status-update-failed", log.Fields{"ports": ports}, err)
Girish Gowdrud4245152019-05-10 00:47:31 -0400783 }
784
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400785 if err := dh.initializeDeviceHandlerModules(ctx); err != nil {
Thomas Lee S985938d2020-05-04 11:40:41 +0530786 return olterrors.NewErrAdapter("device-handler-initialization-failed", log.Fields{"device-id": dh.device.Id}, err).LogAt(log.ErrorLevel)
Girish Gowdru0c588b22019-04-23 23:24:56 -0400787 }
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530788
cuilin20187b2a8c32019-03-26 19:52:28 -0700789 // Start reading indications
David K. Bainbridge794735f2020-02-11 21:01:37 -0800790 go func() {
791 if err := dh.readIndications(ctx); err != nil {
Kent Hagermane6ff1012020-07-14 15:07:53 -0400792 _ = olterrors.NewErrAdapter("read-indications-failure", log.Fields{"device-id": dh.device.Id}, err).Log()
David K. Bainbridge794735f2020-02-11 21:01:37 -0800793 }
794 }()
Neha Sharma96b7bf22020-06-15 10:37:32 +0000795 go dh.updateLocalDevice(ctx)
Rohan Agrawalda5e0b22020-05-20 11:10:26 +0000796
797 if device.PmConfigs != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000798 dh.UpdatePmConfig(ctx, device.PmConfigs)
Rohan Agrawalda5e0b22020-05-20 11:10:26 +0000799 }
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700800
801 go startHeartbeatCheck(ctx, dh)
802
cuilin20187b2a8c32019-03-26 19:52:28 -0700803 return nil
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530804}
805
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400806func (dh *DeviceHandler) initializeDeviceHandlerModules(ctx context.Context) error {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000807 deviceInfo, err := dh.populateDeviceInfo(ctx)
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400808
809 if err != nil {
810 return olterrors.NewErrAdapter("populate-device-info-failed", log.Fields{"device-id": dh.device.Id}, err)
811 }
Girish Gowdra9602eb42020-09-09 15:50:39 -0700812 dh.totalPonPorts = deviceInfo.GetPonPorts()
813
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400814 // Instantiate resource manager
Matteo Scandolodfa7a972020-11-06 13:03:40 -0800815 if dh.resourceMgr = rsrcMgr.NewResourceMgr(ctx, dh.device.Id, dh.openOLT.KVStoreAddress, dh.openOLT.KVStoreType, dh.device.Type, deviceInfo, dh.cm.Backend.PathPrefix); dh.resourceMgr == nil {
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400816 return olterrors.ErrResourceManagerInstantiating
817 }
818
Girish Gowdra9602eb42020-09-09 15:50:39 -0700819 dh.groupMgr = NewGroupManager(ctx, dh, dh.resourceMgr)
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400820
Girish Gowdra9602eb42020-09-09 15:50:39 -0700821 dh.flowMgr = make([]*OpenOltFlowMgr, dh.totalPonPorts)
822 for i := range dh.flowMgr {
823 // Instantiate flow manager
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700824 if dh.flowMgr[i] = NewFlowManager(ctx, dh, dh.resourceMgr, dh.groupMgr, uint32(i)); dh.flowMgr[i] == nil {
Girish Gowdra9602eb42020-09-09 15:50:39 -0700825 return olterrors.ErrResourceManagerInstantiating
826 }
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400827 }
Girish Gowdra9602eb42020-09-09 15:50:39 -0700828
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400829 /* TODO: Instantiate Alarm , stats , BW managers */
830 /* Instantiating Event Manager to handle Alarms and KPIs */
831 dh.eventMgr = NewEventMgr(dh.EventProxy, dh)
832
833 // Stats config for new device
Neha Sharma96b7bf22020-06-15 10:37:32 +0000834 dh.portStats = NewOpenOltStatsMgr(ctx, dh)
Chaitrashree G Sa4649252020-03-11 21:24:11 -0400835
836 return nil
837
838}
839
Neha Sharma96b7bf22020-06-15 10:37:32 +0000840func (dh *DeviceHandler) populateDeviceInfo(ctx context.Context) (*oop.DeviceInfo, error) {
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400841 var err error
842 var deviceInfo *oop.DeviceInfo
843
Neha Sharma8f4e4322020-08-06 10:51:53 +0000844 deviceInfo, err = dh.Client.GetDeviceInfo(log.WithSpanFromContext(context.Background(), ctx), new(oop.Empty))
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400845
846 if err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000847 return nil, olterrors.NewErrPersistence("get", "device", 0, nil, err)
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400848 }
849 if deviceInfo == nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000850 return nil, olterrors.NewErrInvalidValue(log.Fields{"device": nil}, nil)
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400851 }
852
Neha Sharma96b7bf22020-06-15 10:37:32 +0000853 logger.Debugw(ctx, "fetched-device-info", log.Fields{"deviceInfo": deviceInfo, "device-id": dh.device.Id})
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400854 dh.device.Root = true
855 dh.device.Vendor = deviceInfo.Vendor
856 dh.device.Model = deviceInfo.Model
857 dh.device.SerialNumber = deviceInfo.DeviceSerialNumber
858 dh.device.HardwareVersion = deviceInfo.HardwareVersion
859 dh.device.FirmwareVersion = deviceInfo.FirmwareVersion
860
861 if deviceInfo.DeviceId == "" {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000862 logger.Warnw(ctx, "no-device-id-provided-using-host", log.Fields{"hostport": dh.device.GetHostAndPort()})
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400863 host := strings.Split(dh.device.GetHostAndPort(), ":")[0]
Neha Sharma96b7bf22020-06-15 10:37:32 +0000864 genmac, err := generateMacFromHost(ctx, host)
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400865 if err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000866 return nil, olterrors.NewErrAdapter("failed-to-generate-mac-host", log.Fields{"host": host}, err)
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400867 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000868 logger.Debugw(ctx, "using-host-for-mac-address", log.Fields{"host": host, "mac": genmac})
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400869 dh.device.MacAddress = genmac
870 } else {
871 dh.device.MacAddress = deviceInfo.DeviceId
872 }
873
874 // Synchronous call to update device - this method is run in its own go routine
Neha Sharma8f4e4322020-08-06 10:51:53 +0000875 if err := dh.coreProxy.DeviceUpdate(log.WithSpanFromContext(context.TODO(), ctx), dh.device); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +0000876 return nil, olterrors.NewErrAdapter("device-update-failed", log.Fields{"device-id": dh.device.Id}, err)
Matt Jeanneretf4fdcd72019-07-19 20:03:23 -0400877 }
878
879 return deviceInfo, nil
880}
881
Neha Sharma96b7bf22020-06-15 10:37:32 +0000882func startCollector(ctx context.Context, dh *DeviceHandler) {
883 logger.Debugf(ctx, "starting-collector")
Naga Manjunath7615e552019-10-11 22:35:47 +0530884 for {
885 select {
886 case <-dh.stopCollector:
divyadesai3af43e12020-08-18 07:10:54 +0000887 logger.Debugw(ctx, "stopping-collector-for-olt", log.Fields{"device-id": dh.device.Id})
Naga Manjunath7615e552019-10-11 22:35:47 +0530888 return
Rohan Agrawalda5e0b22020-05-20 11:10:26 +0000889 case <-time.After(time.Duration(dh.metrics.ToPmConfigs().DefaultFreq) * time.Second):
Girish Gowdra34815db2020-05-11 17:18:04 -0700890
Neha Sharma8f4e4322020-08-06 10:51:53 +0000891 ports, err := dh.coreProxy.ListDevicePorts(log.WithSpanFromContext(context.Background(), ctx), dh.device.Id)
Kent Hagermanf1db18b2020-07-08 13:38:15 -0400892 if err != nil {
893 logger.Warnw(ctx, "failed-to-list-ports", log.Fields{"device-id": dh.device.Id, "error": err})
894 continue
895 }
Kishore Darapuaaf9c102020-05-04 13:06:57 +0530896 for _, port := range ports {
897 // NNI Stats
898 if port.Type == voltha.Port_ETHERNET_NNI {
899 intfID := PortNoToIntfID(port.PortNo, voltha.Port_ETHERNET_NNI)
900 cmnni := dh.portStats.collectNNIMetrics(intfID)
Neha Sharma96b7bf22020-06-15 10:37:32 +0000901 logger.Debugw(ctx, "collect-nni-metrics", log.Fields{"metrics": cmnni})
902 go dh.portStats.publishMetrics(ctx, cmnni, port, dh.device.Id, dh.device.Type)
903 logger.Debugw(ctx, "publish-nni-metrics", log.Fields{"nni-port": port.Label})
Kishore Darapuaaf9c102020-05-04 13:06:57 +0530904 }
905 // PON Stats
906 if port.Type == voltha.Port_PON_OLT {
907 intfID := PortNoToIntfID(port.PortNo, voltha.Port_PON_OLT)
908 if val, ok := dh.activePorts.Load(intfID); ok && val == true {
909 cmpon := dh.portStats.collectPONMetrics(intfID)
Neha Sharma96b7bf22020-06-15 10:37:32 +0000910 logger.Debugw(ctx, "collect-pon-metrics", log.Fields{"metrics": cmpon})
911 go dh.portStats.publishMetrics(ctx, cmpon, port, dh.device.Id, dh.device.Type)
Kishore Darapuaaf9c102020-05-04 13:06:57 +0530912 }
Neha Sharma96b7bf22020-06-15 10:37:32 +0000913 logger.Debugw(ctx, "publish-pon-metrics", log.Fields{"pon-port": port.Label})
Chaitrashree G Sef088112020-02-03 21:39:27 -0500914 }
Naga Manjunath7615e552019-10-11 22:35:47 +0530915 }
916 }
917 }
918}
919
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700920//AdoptDevice adopts the OLT device
npujarec5762e2020-01-01 14:08:48 +0530921func (dh *DeviceHandler) AdoptDevice(ctx context.Context, device *voltha.Device) {
Girish Gowdru0c588b22019-04-23 23:24:56 -0400922 dh.transitionMap = NewTransitionMap(dh)
Neha Sharma96b7bf22020-06-15 10:37:32 +0000923 logger.Infow(ctx, "adopt-device", log.Fields{"device-id": device.Id, "Address": device.GetHostAndPort()})
npujarec5762e2020-01-01 14:08:48 +0530924 dh.transitionMap.Handle(ctx, DeviceInit)
Naga Manjunath7615e552019-10-11 22:35:47 +0530925
926 // Now, set the initial PM configuration for that device
Kent Hagermane6ff1012020-07-14 15:07:53 -0400927 if err := dh.coreProxy.DevicePMConfigUpdate(ctx, dh.metrics.ToPmConfigs()); err != nil {
928 _ = olterrors.NewErrAdapter("error-updating-performance-metrics", log.Fields{"device-id": device.Id}, err).LogAt(log.ErrorLevel)
Naga Manjunath7615e552019-10-11 22:35:47 +0530929 }
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530930}
931
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700932//GetOfpDeviceInfo Gets the Ofp information of the given device
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530933func (dh *DeviceHandler) GetOfpDeviceInfo(device *voltha.Device) (*ic.SwitchCapability, error) {
cuilin20187b2a8c32019-03-26 19:52:28 -0700934 return &ic.SwitchCapability{
935 Desc: &of.OfpDesc{
Devmalya Paul70dd4972019-06-10 15:19:17 +0530936 MfrDesc: "VOLTHA Project",
cuilin20187b2a8c32019-03-26 19:52:28 -0700937 HwDesc: "open_pon",
938 SwDesc: "open_pon",
Girish Gowdraa09aeab2020-09-14 16:30:52 -0700939 SerialNum: device.SerialNumber,
cuilin20187b2a8c32019-03-26 19:52:28 -0700940 },
941 SwitchFeatures: &of.OfpSwitchFeatures{
942 NBuffers: 256,
943 NTables: 2,
944 Capabilities: uint32(of.OfpCapabilities_OFPC_FLOW_STATS |
945 of.OfpCapabilities_OFPC_TABLE_STATS |
946 of.OfpCapabilities_OFPC_PORT_STATS |
947 of.OfpCapabilities_OFPC_GROUP_STATS),
948 },
949 }, nil
Phaneendra Manda4c62c802019-03-06 21:37:49 +0530950}
951
Neha Sharma96b7bf22020-06-15 10:37:32 +0000952func (dh *DeviceHandler) omciIndication(ctx context.Context, omciInd *oop.OmciIndication) error {
953 logger.Debugw(ctx, "omci-indication", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id})
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700954 var deviceType string
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700955 var deviceID string
956 var proxyDeviceID string
cuilin20187b2a8c32019-03-26 19:52:28 -0700957
Matt Jeanneretceea2e02020-03-27 14:19:57 -0400958 transid := extractOmciTransactionID(omciInd.Pkt)
Matteo Scandolo92186242020-06-12 10:54:18 -0700959 if logger.V(log.DebugLevel) {
Neha Sharma96b7bf22020-06-15 10:37:32 +0000960 logger.Debugw(ctx, "recv-omci-msg", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id,
Matteo Scandolo92186242020-06-12 10:54:18 -0700961 "omci-transaction-id": transid, "omci-msg": hex.EncodeToString(omciInd.Pkt)})
962 }
Matt Jeanneretceea2e02020-03-27 14:19:57 -0400963
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700964 onuKey := dh.formOnuKey(omciInd.IntfId, omciInd.OnuId)
Naga Manjunatha8dc9372019-10-31 23:01:18 +0530965
966 if onuInCache, ok := dh.onus.Load(onuKey); !ok {
967
Neha Sharma96b7bf22020-06-15 10:37:32 +0000968 logger.Debugw(ctx, "omci-indication-for-a-device-not-in-cache.", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id})
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700969 ponPort := IntfIDToPortNo(omciInd.GetIntfId(), voltha.Port_PON_OLT)
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700970 kwargs := make(map[string]interface{})
971 kwargs["onu_id"] = omciInd.OnuId
972 kwargs["parent_port_no"] = ponPort
cuilin20187b2a8c32019-03-26 19:52:28 -0700973
Neha Sharma8f4e4322020-08-06 10:51:53 +0000974 onuDevice, err := dh.coreProxy.GetChildDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, kwargs)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700975 if err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +0530976 return olterrors.NewErrNotFound("onu", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -0700977 "intf-id": omciInd.IntfId,
978 "onu-id": omciInd.OnuId}, err)
cuilin20187b2a8c32019-03-26 19:52:28 -0700979 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -0700980 deviceType = onuDevice.Type
981 deviceID = onuDevice.Id
982 proxyDeviceID = onuDevice.ProxyAddress.DeviceId
983 //if not exist in cache, then add to cache.
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +0530984 dh.onus.Store(onuKey, NewOnuDevice(deviceID, deviceType, onuDevice.SerialNumber, omciInd.OnuId, omciInd.IntfId, proxyDeviceID, false))
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700985 } else {
986 //found in cache
Neha Sharma96b7bf22020-06-15 10:37:32 +0000987 logger.Debugw(ctx, "omci-indication-for-a-device-in-cache.", log.Fields{"intf-id": omciInd.IntfId, "onu-id": omciInd.OnuId, "device-id": dh.device.Id})
Naga Manjunatha8dc9372019-10-31 23:01:18 +0530988 deviceType = onuInCache.(*OnuDevice).deviceType
989 deviceID = onuInCache.(*OnuDevice).deviceID
990 proxyDeviceID = onuInCache.(*OnuDevice).proxyDeviceID
cuilin20187b2a8c32019-03-26 19:52:28 -0700991 }
Mahir Gunyela3f9add2019-06-06 15:13:19 -0700992
993 omciMsg := &ic.InterAdapterOmciMessage{Message: omciInd.Pkt}
Neha Sharma8f4e4322020-08-06 10:51:53 +0000994 if err := dh.AdapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.Background(), ctx), omciMsg,
serkant.uluderya4aff1862020-09-17 23:35:26 +0300995 ic.InterAdapterMessageType_OMCI_REQUEST, dh.openOLT.config.Topic, deviceType,
David K. Bainbridge794735f2020-02-11 21:01:37 -0800996 deviceID, proxyDeviceID, ""); err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +0530997 return olterrors.NewErrCommunication("omci-request", log.Fields{
serkant.uluderya4aff1862020-09-17 23:35:26 +0300998 "source": dh.openOLT.config.Topic,
David K. Bainbridge794735f2020-02-11 21:01:37 -0800999 "destination": deviceType,
1000 "onu-id": deviceID,
Girish Kumarf26e4882020-03-05 06:49:10 +00001001 "proxy-device-id": proxyDeviceID}, err)
Mahir Gunyela3f9add2019-06-06 15:13:19 -07001002 }
David K. Bainbridge794735f2020-02-11 21:01:37 -08001003 return nil
Phaneendra Manda4c62c802019-03-06 21:37:49 +05301004}
1005
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001006//ProcessInterAdapterMessage sends the proxied messages to the target device
1007// If the proxy address is not found in the unmarshalled message, it first fetches the onu device for which the message
1008// is meant, and then send the unmarshalled omci message to this onu
Neha Sharma96b7bf22020-06-15 10:37:32 +00001009func (dh *DeviceHandler) ProcessInterAdapterMessage(ctx context.Context, msg *ic.InterAdapterMessage) error {
1010 logger.Debugw(ctx, "process-inter-adapter-message", log.Fields{"msgID": msg.Header.Id})
cuilin20187b2a8c32019-03-26 19:52:28 -07001011 if msg.Header.Type == ic.InterAdapterMessageType_OMCI_REQUEST {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001012 msgID := msg.Header.Id
cuilin20187b2a8c32019-03-26 19:52:28 -07001013 fromTopic := msg.Header.FromTopic
1014 toTopic := msg.Header.ToTopic
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001015 toDeviceID := msg.Header.ToDeviceId
1016 proxyDeviceID := msg.Header.ProxyDeviceId
cuilin20187b2a8c32019-03-26 19:52:28 -07001017
Neha Sharma96b7bf22020-06-15 10:37:32 +00001018 logger.Debugw(ctx, "omci-request-message-header", log.Fields{"msgID": msgID, "fromTopic": fromTopic, "toTopic": toTopic, "toDeviceID": toDeviceID, "proxyDeviceID": proxyDeviceID})
cuilin20187b2a8c32019-03-26 19:52:28 -07001019
1020 msgBody := msg.GetBody()
1021
1022 omciMsg := &ic.InterAdapterOmciMessage{}
1023 if err := ptypes.UnmarshalAny(msgBody, omciMsg); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +00001024 return olterrors.NewErrAdapter("cannot-unmarshal-omci-msg-body", log.Fields{"msgbody": msgBody}, err)
cuilin20187b2a8c32019-03-26 19:52:28 -07001025 }
1026
Mahir Gunyela3f9add2019-06-06 15:13:19 -07001027 if omciMsg.GetProxyAddress() == nil {
Neha Sharma8f4e4322020-08-06 10:51:53 +00001028 onuDevice, err := dh.coreProxy.GetDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, toDeviceID)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001029 if err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301030 return olterrors.NewErrNotFound("onu", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001031 "device-id": dh.device.Id,
Girish Kumarf26e4882020-03-05 06:49:10 +00001032 "onu-device-id": toDeviceID}, err)
Mahir Gunyela3f9add2019-06-06 15:13:19 -07001033 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001034 logger.Debugw(ctx, "device-retrieved-from-core", log.Fields{"msgID": msgID, "fromTopic": fromTopic, "toTopic": toTopic, "toDeviceID": toDeviceID, "proxyDeviceID": proxyDeviceID})
1035 if err := dh.sendProxiedMessage(ctx, onuDevice, omciMsg); err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301036 return olterrors.NewErrCommunication("send-failed", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001037 "device-id": dh.device.Id,
Girish Kumarf26e4882020-03-05 06:49:10 +00001038 "onu-device-id": toDeviceID}, err)
David K. Bainbridge794735f2020-02-11 21:01:37 -08001039 }
cuilin20187b2a8c32019-03-26 19:52:28 -07001040 } else {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001041 logger.Debugw(ctx, "proxy-address-found-in-omci-message", log.Fields{"msgID": msgID, "fromTopic": fromTopic, "toTopic": toTopic, "toDeviceID": toDeviceID, "proxyDeviceID": proxyDeviceID})
1042 if err := dh.sendProxiedMessage(ctx, nil, omciMsg); err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301043 return olterrors.NewErrCommunication("send-failed", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001044 "device-id": dh.device.Id,
Girish Kumarf26e4882020-03-05 06:49:10 +00001045 "onu-device-id": toDeviceID}, err)
David K. Bainbridge794735f2020-02-11 21:01:37 -08001046 }
cuilin20187b2a8c32019-03-26 19:52:28 -07001047 }
cuilin20187b2a8c32019-03-26 19:52:28 -07001048 } else {
Girish Kumarf26e4882020-03-05 06:49:10 +00001049 return olterrors.NewErrInvalidValue(log.Fields{"inter-adapter-message-type": msg.Header.Type}, nil)
cuilin20187b2a8c32019-03-26 19:52:28 -07001050 }
1051 return nil
Phaneendra Manda4c62c802019-03-06 21:37:49 +05301052}
1053
Neha Sharma96b7bf22020-06-15 10:37:32 +00001054func (dh *DeviceHandler) sendProxiedMessage(ctx context.Context, onuDevice *voltha.Device, omciMsg *ic.InterAdapterOmciMessage) error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001055 var intfID uint32
1056 var onuID uint32
Esin Karamanccb714b2019-11-29 15:02:06 +00001057 var connectStatus common.ConnectStatus_Types
Mahir Gunyela3f9add2019-06-06 15:13:19 -07001058 if onuDevice != nil {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001059 intfID = onuDevice.ProxyAddress.GetChannelId()
1060 onuID = onuDevice.ProxyAddress.GetOnuId()
1061 connectStatus = onuDevice.ConnectStatus
Mahir Gunyela3f9add2019-06-06 15:13:19 -07001062 } else {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001063 intfID = omciMsg.GetProxyAddress().GetChannelId()
1064 onuID = omciMsg.GetProxyAddress().GetOnuId()
1065 connectStatus = omciMsg.GetConnectStatus()
Mahir Gunyela3f9add2019-06-06 15:13:19 -07001066 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001067 if connectStatus != voltha.ConnectStatus_REACHABLE {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001068 logger.Debugw(ctx, "onu-not-reachable--cannot-send-omci", log.Fields{"intf-id": intfID, "onu-id": onuID})
David K. Bainbridge794735f2020-02-11 21:01:37 -08001069
Thomas Lee S94109f12020-03-03 16:39:29 +05301070 return olterrors.NewErrCommunication("unreachable", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -07001071 "intf-id": intfID,
1072 "onu-id": onuID}, nil)
cuilin20187b2a8c32019-03-26 19:52:28 -07001073 }
1074
Matt Jeanneretceea2e02020-03-27 14:19:57 -04001075 // TODO: OpenOLT Agent oop.OmciMsg expects a hex encoded string for OMCI packets rather than the actual bytes.
1076 // Fix this in the agent and then we can pass byte array as Pkt: omciMsg.Message.
lcuie24ef182019-04-29 22:58:36 -07001077 var omciMessage *oop.OmciMsg
Matt Jeanneretceea2e02020-03-27 14:19:57 -04001078 hexPkt := make([]byte, hex.EncodedLen(len(omciMsg.Message)))
1079 hex.Encode(hexPkt, omciMsg.Message)
1080 omciMessage = &oop.OmciMsg{IntfId: intfID, OnuId: onuID, Pkt: hexPkt}
1081
1082 // TODO: Below logging illustrates the "stringify" of the omci Pkt.
1083 // once above is fixed this log line can change to just use hex.EncodeToString(omciMessage.Pkt)
1084 transid := extractOmciTransactionID(omciMsg.Message)
Neha Sharma96b7bf22020-06-15 10:37:32 +00001085 logger.Debugw(ctx, "sent-omci-msg", log.Fields{"intf-id": intfID, "onu-id": onuID,
Matt Jeanneretceea2e02020-03-27 14:19:57 -04001086 "omciTransactionID": transid, "omciMsg": string(omciMessage.Pkt)})
cuilin20187b2a8c32019-03-26 19:52:28 -07001087
Neha Sharma8f4e4322020-08-06 10:51:53 +00001088 _, err := dh.Client.OmciMsgOut(log.WithSpanFromContext(context.Background(), ctx), omciMessage)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001089 if err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301090 return olterrors.NewErrCommunication("omci-send-failed", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -07001091 "intf-id": intfID,
1092 "onu-id": onuID,
1093 "message": omciMessage}, err)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001094 }
David K. Bainbridge794735f2020-02-11 21:01:37 -08001095 return nil
cuilin20187b2a8c32019-03-26 19:52:28 -07001096}
1097
David K. Bainbridge794735f2020-02-11 21:01:37 -08001098func (dh *DeviceHandler) activateONU(ctx context.Context, intfID uint32, onuID int64, serialNum *oop.SerialNumber, serialNumber string) error {
kesavand494c2082020-08-31 11:16:12 +05301099 logger.Debugw(ctx, "activate-onu", log.Fields{"intf-id": intfID, "onu-id": onuID, "serialNum": serialNum, "serialNumber": serialNumber, "device-id": dh.device.Id, "OmccEncryption": dh.openOLT.config.OmccEncryption})
Girish Gowdra9602eb42020-09-09 15:50:39 -07001100 if err := dh.flowMgr[intfID].UpdateOnuInfo(ctx, intfID, uint32(onuID), serialNumber); err != nil {
Matteo Scandolo92186242020-06-12 10:54:18 -07001101 return olterrors.NewErrAdapter("onu-activate-failed", log.Fields{"onu": onuID, "intf-id": intfID}, err)
Andrea Campanellab83b39d2020-03-30 11:41:16 +02001102 }
cuilin20187b2a8c32019-03-26 19:52:28 -07001103 // TODO: need resource manager
1104 var pir uint32 = 1000000
kesavand494c2082020-08-31 11:16:12 +05301105 Onu := oop.Onu{IntfId: intfID, OnuId: uint32(onuID), SerialNumber: serialNum, Pir: pir, OmccEncryption: dh.openOLT.config.OmccEncryption}
npujarec5762e2020-01-01 14:08:48 +05301106 if _, err := dh.Client.ActivateOnu(ctx, &Onu); err != nil {
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -04001107 st, _ := status.FromError(err)
1108 if st.Code() == codes.AlreadyExists {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001109 logger.Debugw(ctx, "onu-activation-in-progress", log.Fields{"SerialNumber": serialNumber, "onu-id": onuID, "device-id": dh.device.Id})
1110
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -04001111 } else {
Thomas Lee S985938d2020-05-04 11:40:41 +05301112 return olterrors.NewErrAdapter("onu-activate-failed", log.Fields{"onu": Onu, "device-id": dh.device.Id}, err)
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -04001113 }
cuilin20187b2a8c32019-03-26 19:52:28 -07001114 } else {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001115 logger.Infow(ctx, "activated-onu", log.Fields{"SerialNumber": serialNumber, "device-id": dh.device.Id})
cuilin20187b2a8c32019-03-26 19:52:28 -07001116 }
David K. Bainbridge794735f2020-02-11 21:01:37 -08001117 return nil
cuilin20187b2a8c32019-03-26 19:52:28 -07001118}
1119
David K. Bainbridge794735f2020-02-11 21:01:37 -08001120func (dh *DeviceHandler) onuDiscIndication(ctx context.Context, onuDiscInd *oop.OnuDiscIndication, sn string) error {
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001121 channelID := onuDiscInd.GetIntfId()
1122 parentPortNo := IntfIDToPortNo(onuDiscInd.GetIntfId(), voltha.Port_PON_OLT)
Matt Jeanneret53539512019-07-20 14:47:02 -04001123
Neha Sharma96b7bf22020-06-15 10:37:32 +00001124 logger.Infow(ctx, "new-discovery-indication", log.Fields{"sn": sn})
Naga Manjunatha8dc9372019-10-31 23:01:18 +05301125
cuilin20187b2a8c32019-03-26 19:52:28 -07001126 kwargs := make(map[string]interface{})
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -04001127 if sn != "" {
1128 kwargs["serial_number"] = sn
Chaitrashree G S35b5d802019-07-08 23:12:03 -04001129 } else {
Girish Kumarf26e4882020-03-05 06:49:10 +00001130 return olterrors.NewErrInvalidValue(log.Fields{"serial-number": sn}, nil)
Chaitrashree G S35b5d802019-07-08 23:12:03 -04001131 }
1132
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +05301133 var alarmInd oop.OnuAlarmIndication
1134 raisedTs := time.Now().UnixNano()
Amit Ghoshe5c6a852020-02-10 15:09:46 +00001135 if _, loaded := dh.discOnus.LoadOrStore(sn, true); loaded {
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +05301136
1137 /* When PON cable disconnected and connected back from OLT, it was expected OnuAlarmIndication
1138 with "los_status: off" should be raised but BAL does not raise this Alarm hence manually sending
1139 OnuLosClear event on receiving OnuDiscoveryIndication for the Onu after checking whether
1140 OnuLosRaise event sent for it */
1141 dh.onus.Range(func(Onukey interface{}, onuInCache interface{}) bool {
1142 if onuInCache.(*OnuDevice).serialNumber == sn && onuInCache.(*OnuDevice).losRaised {
1143 if onuDiscInd.GetIntfId() != onuInCache.(*OnuDevice).intfID {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001144 logger.Warnw(ctx, "onu-is-on-a-different-intf-id-now", log.Fields{
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +05301145 "previousIntfId": onuInCache.(*OnuDevice).intfID,
1146 "currentIntfId": onuDiscInd.GetIntfId()})
1147 // TODO:: Should we need to ignore raising OnuLosClear event
1148 // when onu connected to different PON?
1149 }
1150 alarmInd.IntfId = onuInCache.(*OnuDevice).intfID
1151 alarmInd.OnuId = onuInCache.(*OnuDevice).onuID
1152 alarmInd.LosStatus = statusCheckOff
Kent Hagermane6ff1012020-07-14 15:07:53 -04001153 go func() {
1154 if err := dh.eventMgr.onuAlarmIndication(ctx, &alarmInd, onuInCache.(*OnuDevice).deviceID, raisedTs); err != nil {
1155 logger.Debugw(ctx, "indication-failed", log.Fields{"error": err})
1156 }
1157 }()
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +05301158 }
1159 return true
1160 })
1161
Neha Sharma96b7bf22020-06-15 10:37:32 +00001162 logger.Warnw(ctx, "onu-sn-is-already-being-processed", log.Fields{"sn": sn})
David K. Bainbridge794735f2020-02-11 21:01:37 -08001163 return nil
Amit Ghoshe5c6a852020-02-10 15:09:46 +00001164 }
1165
Chaitrashree G S35b5d802019-07-08 23:12:03 -04001166 var onuID uint32
Matteo Scandolo945e4012019-12-12 14:16:11 -08001167
1168 // check the ONU is already know to the OLT
1169 // NOTE the second time the ONU is discovered this should return a device
1170 onuDevice, err := dh.coreProxy.GetChildDevice(ctx, dh.device.Id, kwargs)
1171
1172 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001173 logger.Debugw(ctx, "core-proxy-get-child-device-failed", log.Fields{"parentDevice": dh.device.Id, "err": err, "sn": sn})
Matteo Scandolo945e4012019-12-12 14:16:11 -08001174 if e, ok := status.FromError(err); ok {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001175 logger.Debugw(ctx, "core-proxy-get-child-device-failed-with-code", log.Fields{"errCode": e.Code(), "sn": sn})
Matteo Scandolo945e4012019-12-12 14:16:11 -08001176 switch e.Code() {
1177 case codes.Internal:
1178 // this probably means NOT FOUND, so just create a new device
1179 onuDevice = nil
1180 case codes.DeadlineExceeded:
1181 // if the call times out, cleanup and exit
1182 dh.discOnus.Delete(sn)
Girish Kumarf26e4882020-03-05 06:49:10 +00001183 return olterrors.NewErrTimeout("get-child-device", log.Fields{"device-id": dh.device.Id}, err)
Matteo Scandolo945e4012019-12-12 14:16:11 -08001184 }
1185 }
1186 }
1187
1188 if onuDevice == nil {
1189 // NOTE this should happen a single time, and only if GetChildDevice returns NotFound
Neha Sharma96b7bf22020-06-15 10:37:32 +00001190 logger.Debugw(ctx, "creating-new-onu", log.Fields{"sn": sn})
Matteo Scandolo945e4012019-12-12 14:16:11 -08001191 // we need to create a new ChildDevice
Matt Jeanneret53539512019-07-20 14:47:02 -04001192 ponintfid := onuDiscInd.GetIntfId()
npujarec5762e2020-01-01 14:08:48 +05301193 onuID, err = dh.resourceMgr.GetONUID(ctx, ponintfid)
Chaitrashree G S35b5d802019-07-08 23:12:03 -04001194
Neha Sharma96b7bf22020-06-15 10:37:32 +00001195 logger.Infow(ctx, "creating-new-onu-got-onu-id", log.Fields{"sn": sn, "onuId": onuID})
Matteo Scandolo945e4012019-12-12 14:16:11 -08001196
1197 if err != nil {
1198 // if we can't create an ID in resource manager,
1199 // cleanup and exit
Matteo Scandolo945e4012019-12-12 14:16:11 -08001200 dh.discOnus.Delete(sn)
Girish Kumarf26e4882020-03-05 06:49:10 +00001201 return olterrors.NewErrAdapter("resource-manager-get-onu-id-failed", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -07001202 "pon-intf-id": ponintfid,
1203 "serial-number": sn}, err)
Matteo Scandolo945e4012019-12-12 14:16:11 -08001204 }
1205
Neha Sharma8f4e4322020-08-06 10:51:53 +00001206 if onuDevice, err = dh.coreProxy.ChildDeviceDetected(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, int(parentPortNo),
Matteo Scandolo945e4012019-12-12 14:16:11 -08001207 "", int(channelID), string(onuDiscInd.SerialNumber.GetVendorId()), sn, int64(onuID)); err != nil {
Matteo Scandolo945e4012019-12-12 14:16:11 -08001208 dh.discOnus.Delete(sn)
1209 dh.resourceMgr.FreeonuID(ctx, ponintfid, []uint32{onuID}) // NOTE I'm not sure this method is actually cleaning up the right thing
Thomas Lee S94109f12020-03-03 16:39:29 +05301210 return olterrors.NewErrAdapter("core-proxy-child-device-detected-failed", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -07001211 "pon-intf-id": ponintfid,
1212 "serial-number": sn}, err)
Matteo Scandolo945e4012019-12-12 14:16:11 -08001213 }
Kent Hagermane6ff1012020-07-14 15:07:53 -04001214 if err := dh.eventMgr.OnuDiscoveryIndication(ctx, onuDiscInd, dh.device.Id, onuDevice.Id, onuID, sn, time.Now().UnixNano()); err != nil {
1215 logger.Warnw(ctx, "discovery-indication-failed", log.Fields{"error": err})
1216 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001217 logger.Infow(ctx, "onu-child-device-added",
Shrey Baid807a2a02020-04-09 12:52:45 +05301218 log.Fields{"onuDevice": onuDevice,
1219 "sn": sn,
Matteo Scandolo92186242020-06-12 10:54:18 -07001220 "onu-id": onuID,
Thomas Lee S985938d2020-05-04 11:40:41 +05301221 "device-id": dh.device.Id})
Chaitrashree G Sbe6ab942019-05-24 06:42:49 -04001222 }
Matteo Scandolo945e4012019-12-12 14:16:11 -08001223
1224 // we can now use the existing ONU Id
1225 onuID = onuDevice.ProxyAddress.OnuId
Mahir Gunyele77977b2019-06-27 05:36:22 -07001226 //Insert the ONU into cache to use in OnuIndication.
1227 //TODO: Do we need to remove this from the cache on ONU change, or wait for overwritten on next discovery.
Neha Sharma96b7bf22020-06-15 10:37:32 +00001228 logger.Debugw(ctx, "onu-discovery-indication-key-create",
Matteo Scandolo92186242020-06-12 10:54:18 -07001229 log.Fields{"onu-id": onuID,
Shrey Baid807a2a02020-04-09 12:52:45 +05301230 "intfId": onuDiscInd.GetIntfId(),
1231 "sn": sn})
Mahir Gunyele77977b2019-06-27 05:36:22 -07001232 onuKey := dh.formOnuKey(onuDiscInd.GetIntfId(), onuID)
Matt Jeanneret53539512019-07-20 14:47:02 -04001233
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +05301234 onuDev := NewOnuDevice(onuDevice.Id, onuDevice.Type, onuDevice.SerialNumber, onuID, onuDiscInd.GetIntfId(), onuDevice.ProxyAddress.DeviceId, false)
Naga Manjunatha8dc9372019-10-31 23:01:18 +05301235 dh.onus.Store(onuKey, onuDev)
Neha Sharma96b7bf22020-06-15 10:37:32 +00001236 logger.Debugw(ctx, "new-onu-device-discovered",
Shrey Baid807a2a02020-04-09 12:52:45 +05301237 log.Fields{"onu": onuDev,
1238 "sn": sn})
Chaitrashree G S35b5d802019-07-08 23:12:03 -04001239
Kent Hagermane6ff1012020-07-14 15:07:53 -04001240 if err := dh.coreProxy.DeviceStateUpdate(ctx, onuDevice.Id, common.ConnectStatus_REACHABLE, common.OperStatus_DISCOVERED); err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301241 return olterrors.NewErrAdapter("failed-to-update-device-state", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001242 "device-id": onuDevice.Id,
Girish Kumarf26e4882020-03-05 06:49:10 +00001243 "serial-number": sn}, err)
cuilin20187b2a8c32019-03-26 19:52:28 -07001244 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001245 logger.Infow(ctx, "onu-discovered-reachable", log.Fields{"device-id": onuDevice.Id, "sn": sn})
Kent Hagermane6ff1012020-07-14 15:07:53 -04001246 if err := dh.activateONU(ctx, onuDiscInd.IntfId, int64(onuID), onuDiscInd.SerialNumber, sn); err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301247 return olterrors.NewErrAdapter("onu-activation-failed", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001248 "device-id": onuDevice.Id,
Girish Kumarf26e4882020-03-05 06:49:10 +00001249 "serial-number": sn}, err)
David K. Bainbridge794735f2020-02-11 21:01:37 -08001250 }
1251 return nil
cuilin20187b2a8c32019-03-26 19:52:28 -07001252}
1253
Mahir Gunyel2fb81472020-12-16 23:18:34 -08001254func (dh *DeviceHandler) onuIndication(ctx context.Context, onuInd *oop.OnuIndication, serialNumber string) error {
cuilin20187b2a8c32019-03-26 19:52:28 -07001255
1256 kwargs := make(map[string]interface{})
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001257 ponPort := IntfIDToPortNo(onuInd.GetIntfId(), voltha.Port_PON_OLT)
Mahir Gunyele77977b2019-06-27 05:36:22 -07001258 var onuDevice *voltha.Device
David K. Bainbridge794735f2020-02-11 21:01:37 -08001259 var err error
Mahir Gunyele77977b2019-06-27 05:36:22 -07001260 foundInCache := false
Neha Sharma96b7bf22020-06-15 10:37:32 +00001261 logger.Debugw(ctx, "onu-indication-key-create",
Shrey Baid807a2a02020-04-09 12:52:45 +05301262 log.Fields{"onuId": onuInd.OnuId,
1263 "intfId": onuInd.GetIntfId(),
Thomas Lee S985938d2020-05-04 11:40:41 +05301264 "device-id": dh.device.Id})
Mahir Gunyele77977b2019-06-27 05:36:22 -07001265 onuKey := dh.formOnuKey(onuInd.GetIntfId(), onuInd.OnuId)
Naga Manjunatha8dc9372019-10-31 23:01:18 +05301266
David K. Bainbridge794735f2020-02-11 21:01:37 -08001267 errFields := log.Fields{"device-id": dh.device.Id}
1268
Naga Manjunatha8dc9372019-10-31 23:01:18 +05301269 if onuInCache, ok := dh.onus.Load(onuKey); ok {
1270
Mahir Gunyele77977b2019-06-27 05:36:22 -07001271 //If ONU id is discovered before then use GetDevice to get onuDevice because it is cheaper.
1272 foundInCache = true
David K. Bainbridge794735f2020-02-11 21:01:37 -08001273 errFields["onu-id"] = onuInCache.(*OnuDevice).deviceID
Kent Hagermane6ff1012020-07-14 15:07:53 -04001274 onuDevice, err = dh.coreProxy.GetDevice(ctx, dh.device.Id, onuInCache.(*OnuDevice).deviceID)
cuilin20187b2a8c32019-03-26 19:52:28 -07001275 } else {
Mahir Gunyele77977b2019-06-27 05:36:22 -07001276 //If ONU not found in adapter cache then we have to use GetChildDevice to get onuDevice
1277 if serialNumber != "" {
1278 kwargs["serial_number"] = serialNumber
David K. Bainbridge794735f2020-02-11 21:01:37 -08001279 errFields["serial-number"] = serialNumber
Mahir Gunyele77977b2019-06-27 05:36:22 -07001280 } else {
1281 kwargs["onu_id"] = onuInd.OnuId
1282 kwargs["parent_port_no"] = ponPort
David K. Bainbridge794735f2020-02-11 21:01:37 -08001283 errFields["onu-id"] = onuInd.OnuId
1284 errFields["parent-port-no"] = ponPort
Mahir Gunyele77977b2019-06-27 05:36:22 -07001285 }
Neha Sharma8f4e4322020-08-06 10:51:53 +00001286 onuDevice, err = dh.coreProxy.GetChildDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, kwargs)
cuilin20187b2a8c32019-03-26 19:52:28 -07001287 }
Mahir Gunyele77977b2019-06-27 05:36:22 -07001288
David K. Bainbridge794735f2020-02-11 21:01:37 -08001289 if err != nil || onuDevice == nil {
Girish Kumarf26e4882020-03-05 06:49:10 +00001290 return olterrors.NewErrNotFound("onu-device", errFields, err)
cuilin20187b2a8c32019-03-26 19:52:28 -07001291 }
1292
David K. Bainbridge794735f2020-02-11 21:01:37 -08001293 if onuDevice.ParentPortNo != ponPort {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001294 logger.Warnw(ctx, "onu-is-on-a-different-intf-id-now", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001295 "previousIntfId": onuDevice.ParentPortNo,
1296 "currentIntfId": ponPort})
1297 }
1298
1299 if onuDevice.ProxyAddress.OnuId != onuInd.OnuId {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001300 logger.Warnw(ctx, "onu-id-mismatch-possible-if-voltha-and-olt-rebooted", log.Fields{
Shrey Baid807a2a02020-04-09 12:52:45 +05301301 "expected-onu-id": onuDevice.ProxyAddress.OnuId,
1302 "received-onu-id": onuInd.OnuId,
Thomas Lee S985938d2020-05-04 11:40:41 +05301303 "device-id": dh.device.Id})
David K. Bainbridge794735f2020-02-11 21:01:37 -08001304 }
1305 if !foundInCache {
1306 onuKey := dh.formOnuKey(onuInd.GetIntfId(), onuInd.GetOnuId())
1307
Thiyagarajan Subramani34a00282020-03-10 20:19:31 +05301308 dh.onus.Store(onuKey, NewOnuDevice(onuDevice.Id, onuDevice.Type, onuDevice.SerialNumber, onuInd.GetOnuId(), onuInd.GetIntfId(), onuDevice.ProxyAddress.DeviceId, false))
David K. Bainbridge794735f2020-02-11 21:01:37 -08001309
1310 }
kesavand7cf3a052020-08-28 12:49:18 +05301311 if onuInd.OperState == "down" && onuInd.FailReason != oop.OnuIndication_ONU_ACTIVATION_FAIL_REASON_NONE {
1312 if err := dh.eventMgr.onuActivationIndication(ctx, onuActivationFailEvent, onuInd, dh.device.Id, time.Now().UnixNano()); err != nil {
1313 logger.Warnw(ctx, "onu-activation-indication-reporting-failed", log.Fields{"error": err})
1314 }
1315 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001316 if err := dh.updateOnuStates(ctx, onuDevice, onuInd); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +00001317 return olterrors.NewErrCommunication("state-update-failed", errFields, err)
David K. Bainbridge794735f2020-02-11 21:01:37 -08001318 }
1319 return nil
cuilin20187b2a8c32019-03-26 19:52:28 -07001320}
1321
Neha Sharma96b7bf22020-06-15 10:37:32 +00001322func (dh *DeviceHandler) updateOnuStates(ctx context.Context, onuDevice *voltha.Device, onuInd *oop.OnuIndication) error {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001323 logger.Debugw(ctx, "onu-indication-for-state", log.Fields{"onuIndication": onuInd, "device-id": onuDevice.Id, "operStatus": onuDevice.OperStatus, "adminStatus": onuDevice.AdminState})
Girish Gowdra748de5c2020-07-01 10:27:52 -07001324 if onuInd.AdminState == "down" || onuInd.OperState == "down" {
1325 // The ONU has gone admin_state "down" or oper_state "down" - we expect the ONU to send discovery again
1326 // The ONU admin_state is "up" while "oper_state" is down in cases where ONU activation fails. In this case
1327 // the ONU sends Discovery again.
Girish Gowdra429f9502020-05-04 13:22:16 -07001328 dh.discOnus.Delete(onuDevice.SerialNumber)
Amit Ghosh9bbc5652020-02-17 13:37:32 +00001329 // Tests have shown that we sometimes get OperState as NOT down even if AdminState is down, forcing it
1330 if onuInd.OperState != "down" {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001331 logger.Warnw(ctx, "onu-admin-state-down", log.Fields{"operState": onuInd.OperState})
Amit Ghosh9bbc5652020-02-17 13:37:32 +00001332 onuInd.OperState = "down"
1333 }
1334 }
1335
David K. Bainbridge794735f2020-02-11 21:01:37 -08001336 switch onuInd.OperState {
1337 case "down":
Neha Sharma96b7bf22020-06-15 10:37:32 +00001338 logger.Debugw(ctx, "sending-interadapter-onu-indication", log.Fields{"onuIndication": onuInd, "device-id": onuDevice.Id, "operStatus": onuDevice.OperStatus, "adminStatus": onuDevice.AdminState})
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001339 // TODO NEW CORE do not hardcode adapter name. Handler needs Adapter reference
npujarec5762e2020-01-01 14:08:48 +05301340 err := dh.AdapterProxy.SendInterAdapterMessage(ctx, onuInd, ic.InterAdapterMessageType_ONU_IND_REQUEST,
serkant.uluderya4aff1862020-09-17 23:35:26 +03001341 dh.openOLT.config.Topic, onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "")
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001342 if err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301343 return olterrors.NewErrCommunication("inter-adapter-send-failed", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001344 "onu-indicator": onuInd,
serkant.uluderya4aff1862020-09-17 23:35:26 +03001345 "source": dh.openOLT.config.Topic,
David K. Bainbridge794735f2020-02-11 21:01:37 -08001346 "device-type": onuDevice.Type,
Girish Kumarf26e4882020-03-05 06:49:10 +00001347 "device-id": onuDevice.Id}, err)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001348 }
David K. Bainbridge794735f2020-02-11 21:01:37 -08001349 case "up":
Neha Sharma96b7bf22020-06-15 10:37:32 +00001350 logger.Debugw(ctx, "sending-interadapter-onu-indication", log.Fields{"onuIndication": onuInd, "device-id": onuDevice.Id, "operStatus": onuDevice.OperStatus, "adminStatus": onuDevice.AdminState})
Matt Jeanneret53539512019-07-20 14:47:02 -04001351 // TODO NEW CORE do not hardcode adapter name. Handler needs Adapter reference
npujarec5762e2020-01-01 14:08:48 +05301352 err := dh.AdapterProxy.SendInterAdapterMessage(ctx, onuInd, ic.InterAdapterMessageType_ONU_IND_REQUEST,
serkant.uluderya4aff1862020-09-17 23:35:26 +03001353 dh.openOLT.config.Topic, onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "")
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001354 if err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301355 return olterrors.NewErrCommunication("inter-adapter-send-failed", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001356 "onu-indicator": onuInd,
serkant.uluderya4aff1862020-09-17 23:35:26 +03001357 "source": dh.openOLT.config.Topic,
David K. Bainbridge794735f2020-02-11 21:01:37 -08001358 "device-type": onuDevice.Type,
Girish Kumarf26e4882020-03-05 06:49:10 +00001359 "device-id": onuDevice.Id}, err)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001360 }
David K. Bainbridge794735f2020-02-11 21:01:37 -08001361 default:
Girish Kumarf26e4882020-03-05 06:49:10 +00001362 return olterrors.NewErrInvalidValue(log.Fields{"oper-state": onuInd.OperState}, nil)
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001363 }
David K. Bainbridge794735f2020-02-11 21:01:37 -08001364 return nil
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001365}
1366
cuilin20187b2a8c32019-03-26 19:52:28 -07001367func (dh *DeviceHandler) stringifySerialNumber(serialNum *oop.SerialNumber) string {
1368 if serialNum != nil {
1369 return string(serialNum.VendorId) + dh.stringifyVendorSpecific(serialNum.VendorSpecific)
cuilin20187b2a8c32019-03-26 19:52:28 -07001370 }
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001371 return ""
cuilin20187b2a8c32019-03-26 19:52:28 -07001372}
Chaitrashree G S1a55b882020-02-04 17:35:35 -05001373func (dh *DeviceHandler) deStringifySerialNumber(serialNum string) (*oop.SerialNumber, error) {
1374 decodedStr, err := hex.DecodeString(serialNum[4:])
1375 if err != nil {
1376 return nil, err
1377 }
1378 return &oop.SerialNumber{
1379 VendorId: []byte(serialNum[:4]),
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001380 VendorSpecific: decodedStr,
Chaitrashree G S1a55b882020-02-04 17:35:35 -05001381 }, nil
1382}
cuilin20187b2a8c32019-03-26 19:52:28 -07001383
1384func (dh *DeviceHandler) stringifyVendorSpecific(vendorSpecific []byte) string {
1385 tmp := fmt.Sprintf("%x", (uint32(vendorSpecific[0])>>4)&0x0f) +
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001386 fmt.Sprintf("%x", uint32(vendorSpecific[0]&0x0f)) +
cuilin20187b2a8c32019-03-26 19:52:28 -07001387 fmt.Sprintf("%x", (uint32(vendorSpecific[1])>>4)&0x0f) +
1388 fmt.Sprintf("%x", (uint32(vendorSpecific[1]))&0x0f) +
1389 fmt.Sprintf("%x", (uint32(vendorSpecific[2])>>4)&0x0f) +
1390 fmt.Sprintf("%x", (uint32(vendorSpecific[2]))&0x0f) +
1391 fmt.Sprintf("%x", (uint32(vendorSpecific[3])>>4)&0x0f) +
1392 fmt.Sprintf("%x", (uint32(vendorSpecific[3]))&0x0f)
1393 return tmp
1394}
1395
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001396//UpdateFlowsBulk upates the bulk flow
1397func (dh *DeviceHandler) UpdateFlowsBulk() error {
Thomas Lee S94109f12020-03-03 16:39:29 +05301398 return olterrors.ErrNotImplemented
cuilin20187b2a8c32019-03-26 19:52:28 -07001399}
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001400
1401//GetChildDevice returns the child device for given parent port and onu id
Neha Sharma96b7bf22020-06-15 10:37:32 +00001402func (dh *DeviceHandler) GetChildDevice(ctx context.Context, parentPort, onuID uint32) (*voltha.Device, error) {
1403 logger.Debugw(ctx, "getchilddevice",
Shrey Baid807a2a02020-04-09 12:52:45 +05301404 log.Fields{"pon-port": parentPort,
Matteo Scandolo92186242020-06-12 10:54:18 -07001405 "onu-id": onuID,
Thomas Lee S985938d2020-05-04 11:40:41 +05301406 "device-id": dh.device.Id})
Girish Gowdru0c588b22019-04-23 23:24:56 -04001407 kwargs := make(map[string]interface{})
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001408 kwargs["onu_id"] = onuID
Girish Gowdru0c588b22019-04-23 23:24:56 -04001409 kwargs["parent_port_no"] = parentPort
Neha Sharma8f4e4322020-08-06 10:51:53 +00001410 onuDevice, err := dh.coreProxy.GetChildDevice(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, kwargs)
Girish Gowdru0c588b22019-04-23 23:24:56 -04001411 if err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +00001412 return nil, olterrors.NewErrNotFound("onu-device", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -07001413 "intf-id": parentPort,
1414 "onu-id": onuID}, err)
Girish Gowdru0c588b22019-04-23 23:24:56 -04001415 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001416 logger.Debugw(ctx, "successfully-received-child-device-from-core", log.Fields{"child-device-id": onuDevice.Id, "child-device-sn": onuDevice.SerialNumber})
David K. Bainbridge794735f2020-02-11 21:01:37 -08001417 return onuDevice, nil
manikkaraj kbf256be2019-03-25 00:13:48 +05301418}
1419
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001420// SendPacketInToCore sends packet-in to core
1421// For this, it calls SendPacketIn of the core-proxy which uses a device specific topic to send the request.
1422// The adapter handling the device creates a device specific topic
Neha Sharma96b7bf22020-06-15 10:37:32 +00001423func (dh *DeviceHandler) SendPacketInToCore(ctx context.Context, logicalPort uint32, packetPayload []byte) error {
Matteo Scandolo92186242020-06-12 10:54:18 -07001424 if logger.V(log.DebugLevel) {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001425 logger.Debugw(ctx, "send-packet-in-to-core", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -07001426 "port": logicalPort,
1427 "packet": hex.EncodeToString(packetPayload),
1428 "device-id": dh.device.Id,
1429 })
1430 }
Neha Sharma8f4e4322020-08-06 10:51:53 +00001431 if err := dh.coreProxy.SendPacketIn(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id, logicalPort, packetPayload); err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301432 return olterrors.NewErrCommunication("packet-send-failed", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001433 "source": "adapter",
1434 "destination": "core",
1435 "device-id": dh.device.Id,
1436 "logical-port": logicalPort,
Girish Kumarf26e4882020-03-05 06:49:10 +00001437 "packet": hex.EncodeToString(packetPayload)}, err)
manikkaraj k9eb6cac2019-05-09 12:32:03 -04001438 }
Matteo Scandolo92186242020-06-12 10:54:18 -07001439 if logger.V(log.DebugLevel) {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001440 logger.Debugw(ctx, "sent-packet-in-to-core-successfully", log.Fields{
Matteo Scandolo92186242020-06-12 10:54:18 -07001441 "packet": hex.EncodeToString(packetPayload),
1442 "device-id": dh.device.Id,
1443 })
1444 }
David K. Bainbridge794735f2020-02-11 21:01:37 -08001445 return nil
manikkaraj k9eb6cac2019-05-09 12:32:03 -04001446}
1447
Rohan Agrawalda5e0b22020-05-20 11:10:26 +00001448// UpdatePmConfig updates the pm metrics.
Neha Sharma96b7bf22020-06-15 10:37:32 +00001449func (dh *DeviceHandler) UpdatePmConfig(ctx context.Context, pmConfigs *voltha.PmConfigs) {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001450 logger.Infow(ctx, "update-pm-configs", log.Fields{"device-id": dh.device.Id, "pm-configs": pmConfigs})
Rohan Agrawalda5e0b22020-05-20 11:10:26 +00001451
1452 if pmConfigs.DefaultFreq != dh.metrics.ToPmConfigs().DefaultFreq {
1453 dh.metrics.UpdateFrequency(pmConfigs.DefaultFreq)
Neha Sharma96b7bf22020-06-15 10:37:32 +00001454 logger.Debugf(ctx, "frequency-updated")
Rohan Agrawalda5e0b22020-05-20 11:10:26 +00001455 }
1456
Kent Hagermane6ff1012020-07-14 15:07:53 -04001457 if !pmConfigs.Grouped {
Rohan Agrawalda5e0b22020-05-20 11:10:26 +00001458 metrics := dh.metrics.GetSubscriberMetrics()
1459 for _, m := range pmConfigs.Metrics {
1460 metrics[m.Name].Enabled = m.Enabled
1461
1462 }
1463 }
1464}
1465
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001466//UpdateFlowsIncrementally updates the device flow
npujarec5762e2020-01-01 14:08:48 +05301467func (dh *DeviceHandler) UpdateFlowsIncrementally(ctx context.Context, device *voltha.Device, flows *of.FlowChanges, groups *of.FlowGroupChanges, flowMetadata *voltha.FlowMetadata) error {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001468 logger.Debugw(ctx, "received-incremental-flowupdate-in-device-handler", log.Fields{"device-id": device.Id, "flows": flows, "groups": groups, "flowMetadata": flowMetadata})
Andrea Campanellac63bba92020-03-10 17:01:04 +01001469
Girish Gowdra491a9c62021-01-06 16:43:07 -08001470 var err error
Andrea Campanellac63bba92020-03-10 17:01:04 +01001471 var errorsList []error
1472
Girish Gowdru0c588b22019-04-23 23:24:56 -04001473 if flows != nil {
Manjunath Vanarajulu28c3e822019-05-16 11:14:28 -04001474 for _, flow := range flows.ToRemove.Items {
Girish Gowdrafb3d6102020-10-16 16:32:36 -07001475 ponIf := dh.getPonIfFromFlow(flow)
Girish Gowdracefae192020-03-19 18:14:10 -07001476
Neha Sharma96b7bf22020-06-15 10:37:32 +00001477 logger.Debugw(ctx, "removing-flow",
Shrey Baid807a2a02020-04-09 12:52:45 +05301478 log.Fields{"device-id": device.Id,
Girish Gowdra9602eb42020-09-09 15:50:39 -07001479 "ponIf": ponIf,
Shrey Baid807a2a02020-04-09 12:52:45 +05301480 "flowToRemove": flow})
Girish Gowdra491a9c62021-01-06 16:43:07 -08001481 if flow_utils.HasGroup(flow) {
1482 err = dh.RouteMcastFlowOrGroupMsgToChannel(ctx, flow, nil, McastFlowOrGroupRemove)
1483 } else {
1484 err = dh.flowMgr[ponIf].RouteFlowToOnuChannel(ctx, flow, false, nil)
1485 }
Girish Gowdracefae192020-03-19 18:14:10 -07001486 if err != nil {
1487 errorsList = append(errorsList, err)
1488 }
Manjunath Vanarajulu28c3e822019-05-16 11:14:28 -04001489 }
Girish Gowdra3d633032019-12-10 16:37:05 +05301490
1491 for _, flow := range flows.ToAdd.Items {
Girish Gowdrafb3d6102020-10-16 16:32:36 -07001492 ponIf := dh.getPonIfFromFlow(flow)
Neha Sharma96b7bf22020-06-15 10:37:32 +00001493 logger.Debugw(ctx, "adding-flow",
Shrey Baid807a2a02020-04-09 12:52:45 +05301494 log.Fields{"device-id": device.Id,
Girish Gowdra9602eb42020-09-09 15:50:39 -07001495 "ponIf": ponIf,
Shrey Baid807a2a02020-04-09 12:52:45 +05301496 "flowToAdd": flow})
Girish Gowdra491a9c62021-01-06 16:43:07 -08001497 if flow_utils.HasGroup(flow) {
1498 err = dh.RouteMcastFlowOrGroupMsgToChannel(ctx, flow, nil, McastFlowOrGroupAdd)
1499 } else {
1500 err = dh.flowMgr[ponIf].RouteFlowToOnuChannel(ctx, flow, true, flowMetadata)
1501 }
Andrea Campanellac63bba92020-03-10 17:01:04 +01001502 if err != nil {
1503 errorsList = append(errorsList, err)
1504 }
Girish Gowdra3d633032019-12-10 16:37:05 +05301505 }
Girish Gowdru0c588b22019-04-23 23:24:56 -04001506 }
Esin Karamanccb714b2019-11-29 15:02:06 +00001507
Girish Gowdracefae192020-03-19 18:14:10 -07001508 // Whether we need to synchronize multicast group adds and modifies like flow add and delete needs to be investigated
Esin Karamanccb714b2019-11-29 15:02:06 +00001509 if groups != nil {
1510 for _, group := range groups.ToAdd.Items {
Girish Gowdra491a9c62021-01-06 16:43:07 -08001511 // err = dh.groupMgr.AddGroup(ctx, group)
1512 err = dh.RouteMcastFlowOrGroupMsgToChannel(ctx, nil, group, McastFlowOrGroupAdd)
Andrea Campanellac63bba92020-03-10 17:01:04 +01001513 if err != nil {
1514 errorsList = append(errorsList, err)
1515 }
Esin Karamanccb714b2019-11-29 15:02:06 +00001516 }
1517 for _, group := range groups.ToUpdate.Items {
Girish Gowdra491a9c62021-01-06 16:43:07 -08001518 // err = dh.groupMgr.ModifyGroup(ctx, group)
1519 err = dh.RouteMcastFlowOrGroupMsgToChannel(ctx, nil, group, McastFlowOrGroupModify)
Andrea Campanellac63bba92020-03-10 17:01:04 +01001520 if err != nil {
1521 errorsList = append(errorsList, err)
1522 }
Esin Karamanccb714b2019-11-29 15:02:06 +00001523 }
Esin Karamand519bbf2020-07-01 11:16:03 +00001524 for _, group := range groups.ToRemove.Items {
Girish Gowdra491a9c62021-01-06 16:43:07 -08001525 // err = dh.groupMgr.DeleteGroup(ctx, group)
1526 err = dh.RouteMcastFlowOrGroupMsgToChannel(ctx, nil, group, McastFlowOrGroupRemove)
Esin Karamand519bbf2020-07-01 11:16:03 +00001527 if err != nil {
1528 errorsList = append(errorsList, err)
1529 }
Esin Karamanccb714b2019-11-29 15:02:06 +00001530 }
1531 }
Andrea Campanellac63bba92020-03-10 17:01:04 +01001532 if len(errorsList) > 0 {
1533 return fmt.Errorf("errors-installing-flows-groups, errors:%v", errorsList)
1534 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001535 logger.Debugw(ctx, "updated-flows-incrementally-successfully", log.Fields{"device-id": dh.device.Id})
Girish Gowdru0c588b22019-04-23 23:24:56 -04001536 return nil
manikkaraj kbf256be2019-03-25 00:13:48 +05301537}
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001538
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001539//DisableDevice disables the given device
1540//It marks the following for the given device:
1541//Device-Handler Admin-State : down
1542//Device Port-State: UNKNOWN
1543//Device Oper-State: UNKNOWN
Neha Sharma96b7bf22020-06-15 10:37:32 +00001544func (dh *DeviceHandler) DisableDevice(ctx context.Context, device *voltha.Device) error {
Chaitrashree G S44124192019-08-07 20:21:36 -04001545 /* On device disable ,admin state update has to be done prior sending request to agent since
1546 the indication thread may processes invalid indications of ONU and OLT*/
Serkant Uluderya89ff40c2019-10-17 16:02:25 -07001547 if dh.Client != nil {
Neha Sharma8f4e4322020-08-06 10:51:53 +00001548 if _, err := dh.Client.DisableOlt(log.WithSpanFromContext(context.Background(), ctx), new(oop.Empty)); err != nil {
Serkant Uluderya89ff40c2019-10-17 16:02:25 -07001549 if e, ok := status.FromError(err); ok && e.Code() == codes.Internal {
Girish Kumarf26e4882020-03-05 06:49:10 +00001550 return olterrors.NewErrAdapter("olt-disable-failed", log.Fields{"device-id": device.Id}, err)
Serkant Uluderya89ff40c2019-10-17 16:02:25 -07001551 }
Chaitrashree G S3b4c0352019-09-09 20:59:29 -04001552 }
Chaitrashree G S44124192019-08-07 20:21:36 -04001553 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001554 logger.Debugw(ctx, "olt-disabled", log.Fields{"device-id": device.Id})
Chaitrashree G S44124192019-08-07 20:21:36 -04001555 /* Discovered ONUs entries need to be cleared , since on device disable the child devices goes to
Serkant Uluderya89ff40c2019-10-17 16:02:25 -07001556 UNREACHABLE state which needs to be configured again*/
Naga Manjunatha8dc9372019-10-31 23:01:18 +05301557
1558 dh.discOnus = sync.Map{}
1559 dh.onus = sync.Map{}
1560
Thomas Lee S85f37312020-04-03 17:06:12 +05301561 //stopping the stats collector
1562 dh.stopCollector <- true
1563
Neha Sharma96b7bf22020-06-15 10:37:32 +00001564 go dh.notifyChildDevices(ctx, "unreachable")
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001565 cloned := proto.Clone(device).(*voltha.Device)
Thomas Lee S985938d2020-05-04 11:40:41 +05301566 //Update device Admin state
1567 dh.device = cloned
kdarapu1afeceb2020-02-12 01:38:09 -05001568 // Update the all pon ports state on that device to disable and NNI remains active as NNI remains active in openolt agent.
Neha Sharma8f4e4322020-08-06 10:51:53 +00001569 if err := dh.coreProxy.PortsStateUpdate(log.WithSpanFromContext(context.TODO(), ctx), cloned.Id, ^uint32(1<<voltha.Port_PON_OLT), voltha.OperStatus_UNKNOWN); err != nil {
Kent Hagermanf1db18b2020-07-08 13:38:15 -04001570 return olterrors.NewErrAdapter("ports-state-update-failed", log.Fields{"device-id": device.Id}, err)
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001571 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001572 logger.Debugw(ctx, "disable-device-end", log.Fields{"device-id": device.Id})
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001573 return nil
1574}
1575
Neha Sharma96b7bf22020-06-15 10:37:32 +00001576func (dh *DeviceHandler) notifyChildDevices(ctx context.Context, state string) {
Chaitrashree G S3b4c0352019-09-09 20:59:29 -04001577 // Update onu state as unreachable in onu adapter
1578 onuInd := oop.OnuIndication{}
Abhilash Laxmeshwarf9942e92020-01-07 15:32:44 +05301579 onuInd.OperState = state
Chaitrashree G S3b4c0352019-09-09 20:59:29 -04001580 //get the child device for the parent device
Neha Sharma8f4e4322020-08-06 10:51:53 +00001581 onuDevices, err := dh.coreProxy.GetChildDevices(log.WithSpanFromContext(context.TODO(), ctx), dh.device.Id)
Chaitrashree G S3b4c0352019-09-09 20:59:29 -04001582 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001583 logger.Errorw(ctx, "failed-to-get-child-devices-information", log.Fields{"device-id": dh.device.Id, "error": err})
Chaitrashree G S3b4c0352019-09-09 20:59:29 -04001584 }
1585 if onuDevices != nil {
1586 for _, onuDevice := range onuDevices.Items {
Neha Sharma8f4e4322020-08-06 10:51:53 +00001587 err := dh.AdapterProxy.SendInterAdapterMessage(log.WithSpanFromContext(context.TODO(), ctx), &onuInd, ic.InterAdapterMessageType_ONU_IND_REQUEST,
serkant.uluderya4aff1862020-09-17 23:35:26 +03001588 dh.openOLT.config.Topic, onuDevice.Type, onuDevice.Id, onuDevice.ProxyAddress.DeviceId, "")
Chaitrashree G S3b4c0352019-09-09 20:59:29 -04001589 if err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001590 logger.Errorw(ctx, "failed-to-send-inter-adapter-message", log.Fields{"OnuInd": onuInd,
serkant.uluderya4aff1862020-09-17 23:35:26 +03001591 "From Adapter": dh.openOLT.config.Topic, "DeviceType": onuDevice.Type, "device-id": onuDevice.Id})
Chaitrashree G S3b4c0352019-09-09 20:59:29 -04001592 }
1593
1594 }
1595 }
1596
1597}
1598
Girish Gowdru6a80bbd2019-07-02 07:36:09 -07001599//ReenableDevice re-enables the olt device after disable
1600//It marks the following for the given device:
1601//Device-Handler Admin-State : up
1602//Device Port-State: ACTIVE
1603//Device Oper-State: ACTIVE
Neha Sharma96b7bf22020-06-15 10:37:32 +00001604func (dh *DeviceHandler) ReenableDevice(ctx context.Context, device *voltha.Device) error {
Neha Sharma8f4e4322020-08-06 10:51:53 +00001605 if _, err := dh.Client.ReenableOlt(log.WithSpanFromContext(context.Background(), ctx), new(oop.Empty)); err != nil {
Abhilash Laxmeshwar5b302e12020-01-09 15:15:14 +05301606 if e, ok := status.FromError(err); ok && e.Code() == codes.Internal {
Girish Kumarf26e4882020-03-05 06:49:10 +00001607 return olterrors.NewErrAdapter("olt-reenable-failed", log.Fields{"device-id": dh.device.Id}, err)
Abhilash Laxmeshwar5b302e12020-01-09 15:15:14 +05301608 }
1609 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001610 logger.Debug(ctx, "olt-reenabled")
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001611
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001612 // Update the all ports state on that device to enable
kesavand39e0aa32020-01-28 20:58:50 -05001613
Kent Hagermanf1db18b2020-07-08 13:38:15 -04001614 ports, err := dh.coreProxy.ListDevicePorts(ctx, device.Id)
1615 if err != nil {
divyadesai3af43e12020-08-18 07:10:54 +00001616 return olterrors.NewErrAdapter("list-ports-failed", log.Fields{"device-id": device.Id}, err)
Kent Hagermanf1db18b2020-07-08 13:38:15 -04001617 }
1618 if err := dh.disableAdminDownPorts(ctx, ports); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +00001619 return olterrors.NewErrAdapter("port-status-update-failed-after-olt-reenable", log.Fields{"device": device}, err)
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001620 }
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001621 //Update the device oper status as ACTIVE
Kent Hagermanf1db18b2020-07-08 13:38:15 -04001622 device.OperStatus = voltha.OperStatus_ACTIVE
1623 dh.device = device
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001624
Neha Sharma8f4e4322020-08-06 10:51:53 +00001625 if err := dh.coreProxy.DeviceStateUpdate(log.WithSpanFromContext(context.TODO(), ctx), device.Id, device.ConnectStatus, device.OperStatus); err != nil {
Thomas Lee S94109f12020-03-03 16:39:29 +05301626 return olterrors.NewErrAdapter("state-update-failed", log.Fields{
David K. Bainbridge794735f2020-02-11 21:01:37 -08001627 "device-id": device.Id,
Kent Hagermanf1db18b2020-07-08 13:38:15 -04001628 "connect-status": device.ConnectStatus,
1629 "oper-status": device.OperStatus}, err)
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001630 }
kesavand39e0aa32020-01-28 20:58:50 -05001631
Neha Sharma96b7bf22020-06-15 10:37:32 +00001632 logger.Debugw(ctx, "reenabledevice-end", log.Fields{"device-id": device.Id})
Girish Gowdru5ba46c92019-04-25 05:00:05 -04001633
1634 return nil
1635}
manikkaraj k9eb6cac2019-05-09 12:32:03 -04001636
npujarec5762e2020-01-01 14:08:48 +05301637func (dh *DeviceHandler) clearUNIData(ctx context.Context, onu *rsrcMgr.OnuGemInfo) error {
Devmalya Paul495b94a2019-08-27 19:42:00 -04001638 var uniID uint32
1639 var err error
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301640 for _, port := range onu.UniPorts {
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001641 uniID = UniIDFromPortNum(port)
Neha Sharma96b7bf22020-06-15 10:37:32 +00001642 logger.Debugw(ctx, "clearing-resource-data-for-uni-port", log.Fields{"port": port, "uni-id": uniID})
A R Karthick1f85b802019-10-11 05:06:05 +00001643 /* Delete tech-profile instance from the KV store */
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001644 if err = dh.flowMgr[onu.IntfID].DeleteTechProfileInstances(ctx, onu.IntfID, onu.OnuID, uniID); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001645 logger.Debugw(ctx, "failed-to-remove-tech-profile-instance-for-onu", log.Fields{"onu-id": onu.OnuID})
Devmalya Paul495b94a2019-08-27 19:42:00 -04001646 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001647 logger.Debugw(ctx, "deleted-tech-profile-instance-for-onu", log.Fields{"onu-id": onu.OnuID})
npujarec5762e2020-01-01 14:08:48 +05301648 tpIDList := dh.resourceMgr.GetTechProfileIDForOnu(ctx, onu.IntfID, onu.OnuID, uniID)
Gamze Abakafee36392019-10-03 11:17:24 +00001649 for _, tpID := range tpIDList {
npujarec5762e2020-01-01 14:08:48 +05301650 if err = dh.resourceMgr.RemoveMeterIDForOnu(ctx, "upstream", onu.IntfID, onu.OnuID, uniID, tpID); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001651 logger.Debugw(ctx, "failed-to-remove-meter-id-for-onu-upstream", log.Fields{"onu-id": onu.OnuID})
Gamze Abakafee36392019-10-03 11:17:24 +00001652 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001653 logger.Debugw(ctx, "removed-meter-id-for-onu-upstream", log.Fields{"onu-id": onu.OnuID})
npujarec5762e2020-01-01 14:08:48 +05301654 if err = dh.resourceMgr.RemoveMeterIDForOnu(ctx, "downstream", onu.IntfID, onu.OnuID, uniID, tpID); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001655 logger.Debugw(ctx, "failed-to-remove-meter-id-for-onu-downstream", log.Fields{"onu-id": onu.OnuID})
Gamze Abakafee36392019-10-03 11:17:24 +00001656 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001657 logger.Debugw(ctx, "removed-meter-id-for-onu-downstream", log.Fields{"onu-id": onu.OnuID})
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301658 }
npujarec5762e2020-01-01 14:08:48 +05301659 dh.resourceMgr.FreePONResourcesForONU(ctx, onu.IntfID, onu.OnuID, uniID)
1660 if err = dh.resourceMgr.RemoveTechProfileIDsForOnu(ctx, onu.IntfID, onu.OnuID, uniID); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001661 logger.Debugw(ctx, "failed-to-remove-tech-profile-id-for-onu", log.Fields{"onu-id": onu.OnuID})
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301662 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001663 logger.Debugw(ctx, "removed-tech-profile-id-for-onu", log.Fields{"onu-id": onu.OnuID})
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001664 if err = dh.resourceMgr.DeletePacketInGemPortForOnu(ctx, onu.IntfID, onu.OnuID, port); err != nil {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001665 logger.Debugw(ctx, "failed-to-remove-gemport-pkt-in", log.Fields{"intfid": onu.IntfID, "onuid": onu.OnuID, "uniId": uniID})
A R Karthick1f85b802019-10-11 05:06:05 +00001666 }
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001667 if err = dh.resourceMgr.RemoveAllFlowsForIntfOnuUniKey(ctx, onu.IntfID, int32(onu.OnuID), int32(uniID)); err != nil {
1668 logger.Debugw(ctx, "failed-to-remove-flow-for", log.Fields{"intfid": onu.IntfID, "onuid": onu.OnuID, "uniId": uniID})
1669 }
Devmalya Paul495b94a2019-08-27 19:42:00 -04001670 }
1671 return nil
1672}
1673
npujarec5762e2020-01-01 14:08:48 +05301674func (dh *DeviceHandler) clearNNIData(ctx context.Context) error {
Devmalya Paul495b94a2019-08-27 19:42:00 -04001675 nniUniID := -1
1676 nniOnuID := -1
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301677
Serkant Uluderya89ff40c2019-10-17 16:02:25 -07001678 if dh.resourceMgr == nil {
Thomas Lee S985938d2020-05-04 11:40:41 +05301679 return olterrors.NewErrNotFound("resource-manager", log.Fields{"device-id": dh.device.Id}, nil)
Serkant Uluderya89ff40c2019-10-17 16:02:25 -07001680 }
Devmalya Paul495b94a2019-08-27 19:42:00 -04001681 //Free the flow-ids for the NNI port
npujarec5762e2020-01-01 14:08:48 +05301682 nni, err := dh.resourceMgr.GetNNIFromKVStore(ctx)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301683 if err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +00001684 return olterrors.NewErrPersistence("get", "nni", 0, nil, err)
Devmalya Paul495b94a2019-08-27 19:42:00 -04001685 }
Neha Sharma96b7bf22020-06-15 10:37:32 +00001686 logger.Debugw(ctx, "nni-", log.Fields{"nni": nni})
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301687 for _, nniIntfID := range nni {
npujarec5762e2020-01-01 14:08:48 +05301688 dh.resourceMgr.RemoveResourceMap(ctx, nniIntfID, int32(nniOnuID), int32(nniUniID))
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001689 _ = dh.resourceMgr.RemoveAllFlowsForIntfOnuUniKey(ctx, nniIntfID, -1, -1)
1690
Devmalya Paul495b94a2019-08-27 19:42:00 -04001691 }
npujarec5762e2020-01-01 14:08:48 +05301692 if err = dh.resourceMgr.DelNNiFromKVStore(ctx); err != nil {
Girish Kumarf26e4882020-03-05 06:49:10 +00001693 return olterrors.NewErrPersistence("clear", "nni", 0, nil, err)
Abhilash Laxmeshwarab0bd522019-10-21 15:05:15 +05301694 }
Girish Gowdraa09aeab2020-09-14 16:30:52 -07001695
David K. Bainbridge794735f2020-02-11 21:01:37 -08001696 return nil
Devmalya Paul495b94a2019-08-27 19:42:00 -04001697}
1698
1699// DeleteDevice deletes the device instance from openolt handler array. Also clears allocated resource manager resources. Also reboots the OLT hardware!
npujarec5762e2020-01-01 14:08:48 +05301700func (dh *DeviceHandler) DeleteDevice(ctx context.Context, device *voltha.Device) error {
Neha Sharma96b7bf22020-06-15 10:37:32 +00001701 logger.Debug(ctx, "function-entry-delete-device")
Devmalya Paul495b94a2019-08-27 19:42:00 -0400