blob: 4ae8841bf8a092fa0f18ff2a100a10de618ba37a [file] [log] [blame]
Matteo Scandolo8df63df2019-09-12 10:34:32 -07001/*
2 * Portions copyright 2019-present Open Networking Foundation
3 * Original copyright 2019-present Ciena Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18package commands
19
20import (
21 "context"
Matteo Scandolo10f965c2019-09-24 10:40:46 -070022 "fmt"
Anand S Katti09541352020-01-29 15:54:01 +053023 "os"
24 "strconv"
25 "strings"
26
Matteo Scandolo8df63df2019-09-12 10:34:32 -070027 "github.com/jessevdk/go-flags"
Anand S Katti09541352020-01-29 15:54:01 +053028 "github.com/olekukonko/tablewriter"
Matteo Scandolo8df63df2019-09-12 10:34:32 -070029 pb "github.com/opencord/bbsim/api/bbsim"
30 "github.com/opencord/bbsim/internal/bbsimctl/config"
31 "github.com/opencord/cordctl/pkg/format"
32 log "github.com/sirupsen/logrus"
Matteo Scandolo8df63df2019-09-12 10:34:32 -070033)
34
35const (
Matteo Scandolo8a574812021-05-20 15:18:53 -070036 DEFAULT_ONU_DEVICE_HEADER_FORMAT = "table{{ .PonPortID }}\t{{ .ID }}\t{{ .SerialNumber }}\t{{ .OperState }}\t{{ .InternalState }}\t{{ .ImageSoftwareExpectedSections }}\t{{ .ImageSoftwareReceivedSections }}\t{{ .ActiveImageEntityId }}\t{{ .CommittedImageEntityId }}"
37 DEFAULT_ONU_DEVICE_HEADER_FORMAT_WITH_SERVICES = "table{{ .PonPortID }}\t{{ .ID }}\t{{ .SerialNumber }}\t{{ .OperState }}\t{{ .InternalState }}\t{{ .ImageSoftwareExpectedSections }}\t{{ .ImageSoftwareReceivedSections }}\t{{ .ActiveImageEntityId }}\t{{ .CommittedImageEntityId }}\t{{ .Unis }}"
Matteo Scandolo8df63df2019-09-12 10:34:32 -070038)
39
Matteo Scandolo10f965c2019-09-24 10:40:46 -070040type OnuSnString string
Arjun E K57a7fcb2020-01-30 06:44:45 +000041type IgmpSubAction string
Onur Kalinagac9f9faca2021-01-21 14:04:34 +000042type GroupAddress string
Arjun E K57a7fcb2020-01-30 06:44:45 +000043
44const IgmpJoinKey string = "join"
45const IgmpLeaveKey string = "leave"
Arjun E Kdd443f02020-02-07 15:24:01 +000046const IgmpJoinKeyV3 string = "joinv3"
Arjun E K57a7fcb2020-01-30 06:44:45 +000047
Matteo Scandolo618a6582020-09-09 12:21:29 -070048var IgmpAllowedActions = []string{IgmpJoinKey, IgmpLeaveKey, IgmpJoinKeyV3}
49
Matteo Scandolo4a036262020-08-17 15:56:13 -070050type ONUList struct {
51 Verbose bool `short:"v" long:"verbose" description:"Print all the informations we have about ONUs"`
52}
Matteo Scandolod2ca2c72019-10-04 16:50:22 -070053
54type ONUGet struct {
Matteo Scandolo4a036262020-08-17 15:56:13 -070055 Verbose bool `short:"v" long:"verbose" description:"Print all the informations we have about ONUs"`
56 Args struct {
57 OnuSn OnuSnString
58 } `positional-args:"yes" required:"yes"`
59}
60
Matteo Scandoloef4e8f82021-05-17 11:20:49 -070061type ONUUnis struct {
Matteo Scandolo8a574812021-05-20 15:18:53 -070062 Verbose bool `short:"v" long:"verbose" description:"Print all the informations we have about UNIs"`
63 Args struct {
Matteo Scandoloef4e8f82021-05-17 11:20:49 -070064 OnuSn OnuSnString
65 } `positional-args:"yes" required:"yes"`
66}
67
Matteo Scandolo10f965c2019-09-24 10:40:46 -070068type ONUShutDown struct {
69 Args struct {
70 OnuSn OnuSnString
71 } `positional-args:"yes" required:"yes"`
Matteo Scandolo8df63df2019-09-12 10:34:32 -070072}
73
Matteo Scandolo10f965c2019-09-24 10:40:46 -070074type ONUPowerOn struct {
75 Args struct {
76 OnuSn OnuSnString
77 } `positional-args:"yes" required:"yes"`
78}
79
Matteo Scandoloe383d5d2019-10-25 14:47:27 -070080type ONUEapolRestart struct {
81 Args struct {
82 OnuSn OnuSnString
83 } `positional-args:"yes" required:"yes"`
84}
85
86type ONUDhcpRestart struct {
87 Args struct {
88 OnuSn OnuSnString
89 } `positional-args:"yes" required:"yes"`
90}
91
Arjun E K57a7fcb2020-01-30 06:44:45 +000092type ONUIgmp struct {
93 Args struct {
Onur Kalinagac9f9faca2021-01-21 14:04:34 +000094 OnuSn OnuSnString
95 SubAction IgmpSubAction
96 GroupAddress GroupAddress
Arjun E K57a7fcb2020-01-30 06:44:45 +000097 } `positional-args:"yes" required:"yes"`
98}
99
Pragya Arya8bdb4532020-03-02 17:08:09 +0530100type ONUTrafficSchedulers struct {
101 Args struct {
102 OnuSn OnuSnString
103 } `positional-args:"yes" required:"yes"`
104}
105
106type ONUFlows struct {
107 Args struct {
108 OnuSn OnuSnString
109 } `positional-args:"yes" required:"yes"`
110}
111
Nitin Subramanianb0a333a2021-07-08 15:01:41 -0700112type ONUServices struct {
113 Args struct {
114 OnuSn OnuSnString
115 } `positional-args:"yes"`
116}
117
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700118type ONUOptions struct {
Anand S Katti09541352020-01-29 15:54:01 +0530119 List ONUList `command:"list"`
120 Get ONUGet `command:"get"`
121 ShutDown ONUShutDown `command:"shutdown"`
122 PowerOn ONUPowerOn `command:"poweron"`
123 RestartEapol ONUEapolRestart `command:"auth_restart"`
124 RestartDchp ONUDhcpRestart `command:"dhcp_restart"`
125 Igmp ONUIgmp `command:"igmp"`
126 TrafficSchedulers ONUTrafficSchedulers `command:"traffic_schedulers"`
Anand S Katti86552f92020-03-03 21:56:32 +0530127 Alarms AlarmOptions `command:"alarms"`
Pragya Arya8bdb4532020-03-02 17:08:09 +0530128 Flows ONUFlows `command:"flows"`
Nitin Subramanianb0a333a2021-07-08 15:01:41 -0700129 Services ONUServices `command:"services"`
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700130}
131
132func RegisterONUCommands(parser *flags.Parser) {
Shrey Baid688b4242020-07-10 20:40:10 +0530133 _, _ = parser.AddCommand("onu", "ONU Commands", "Commands to query and manipulate ONU devices", &ONUOptions{})
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700134}
135
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700136func getONUs() *pb.ONUs {
137
138 client, conn := connect()
Matteo Scandolo8df63df2019-09-12 10:34:32 -0700139 defer conn.Close()
Matteo Scandolo8df63df2019-09-12 10:34:32 -0700140
141 // Contact the server and print out its response.
Matteo Scandolo8df63df2019-09-12 10:34:32 -0700142 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
143 defer cancel()
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700144
145 onus, err := client.GetONUs(ctx, &pb.Empty{})
Matteo Scandolo8df63df2019-09-12 10:34:32 -0700146 if err != nil {
Matteo Scandolo2bf742a2019-10-01 11:33:34 -0700147 log.Fatalf("could not get OLT: %v", err)
Matteo Scandolo8df63df2019-09-12 10:34:32 -0700148 return nil
149 }
150 return onus
151}
152
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700153func (options *ONUList) Execute(args []string) error {
Matteo Scandolo8df63df2019-09-12 10:34:32 -0700154 onus := getONUs()
155
156 // print out
Matteo Scandolo4a036262020-08-17 15:56:13 -0700157 var tableFormat format.Format
158 if options.Verbose {
159 tableFormat = format.Format(DEFAULT_ONU_DEVICE_HEADER_FORMAT_WITH_SERVICES)
160 } else {
161 tableFormat = format.Format(DEFAULT_ONU_DEVICE_HEADER_FORMAT)
162 }
Matteo Scandolo8df63df2019-09-12 10:34:32 -0700163 if err := tableFormat.Execute(os.Stdout, true, onus.Items); err != nil {
164 log.Fatalf("Error while formatting ONUs table: %s", err)
165 }
166
167 return nil
168}
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700169
Matteo Scandolod2ca2c72019-10-04 16:50:22 -0700170func (options *ONUGet) Execute(args []string) error {
171 client, conn := connect()
172 defer conn.Close()
173
174 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
175 defer cancel()
176 req := pb.ONURequest{
177 SerialNumber: string(options.Args.OnuSn),
178 }
179 res, err := client.GetONU(ctx, &req)
180
181 if err != nil {
Matteo Scandolo4a036262020-08-17 15:56:13 -0700182 log.Fatalf("Cannot not get ONU %s: %v", options.Args.OnuSn, err)
Matteo Scandolod2ca2c72019-10-04 16:50:22 -0700183 return err
184 }
185
Matteo Scandolo4a036262020-08-17 15:56:13 -0700186 var tableFormat format.Format
187 if options.Verbose {
188 tableFormat = format.Format(DEFAULT_ONU_DEVICE_HEADER_FORMAT_WITH_SERVICES)
189 } else {
190 tableFormat = format.Format(DEFAULT_ONU_DEVICE_HEADER_FORMAT)
191 }
Matteo Scandolod2ca2c72019-10-04 16:50:22 -0700192 if err := tableFormat.Execute(os.Stdout, true, []*pb.ONU{res}); err != nil {
193 log.Fatalf("Error while formatting ONUs table: %s", err)
194 }
195
196 return nil
197}
198
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700199func (options *ONUShutDown) Execute(args []string) error {
200
201 client, conn := connect()
202 defer conn.Close()
203
204 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
205 defer cancel()
206 req := pb.ONURequest{
207 SerialNumber: string(options.Args.OnuSn),
208 }
209 res, err := client.ShutdownONU(ctx, &req)
210
211 if err != nil {
Matteo Scandoloe383d5d2019-10-25 14:47:27 -0700212 log.Fatalf("Cannot shutdown ONU %s: %v", options.Args.OnuSn, err)
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700213 return err
214 }
215
216 fmt.Println(fmt.Sprintf("[Status: %d] %s", res.StatusCode, res.Message))
217
218 return nil
219}
220
221func (options *ONUPowerOn) Execute(args []string) error {
222 client, conn := connect()
223 defer conn.Close()
224
225 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
226 defer cancel()
227 req := pb.ONURequest{
228 SerialNumber: string(options.Args.OnuSn),
229 }
230 res, err := client.PoweronONU(ctx, &req)
231
232 if err != nil {
Matteo Scandoloe383d5d2019-10-25 14:47:27 -0700233 log.Fatalf("Cannot power on ONU %s: %v", options.Args.OnuSn, err)
234 return err
235 }
236
237 fmt.Println(fmt.Sprintf("[Status: %d] %s", res.StatusCode, res.Message))
238
239 return nil
240}
241
242func (options *ONUEapolRestart) Execute(args []string) error {
243 client, conn := connect()
244 defer conn.Close()
245
246 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
247 defer cancel()
248 req := pb.ONURequest{
249 SerialNumber: string(options.Args.OnuSn),
250 }
251 res, err := client.RestartEapol(ctx, &req)
252
253 if err != nil {
254 log.Fatalf("Cannot restart EAPOL for ONU %s: %v", options.Args.OnuSn, err)
255 return err
256 }
257
258 fmt.Println(fmt.Sprintf("[Status: %d] %s", res.StatusCode, res.Message))
259
260 return nil
261}
262
263func (options *ONUDhcpRestart) Execute(args []string) error {
264 client, conn := connect()
265 defer conn.Close()
266
267 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
268 defer cancel()
269 req := pb.ONURequest{
270 SerialNumber: string(options.Args.OnuSn),
271 }
272 res, err := client.RestartDhcp(ctx, &req)
273
274 if err != nil {
275 log.Fatalf("Cannot restart DHCP for ONU %s: %v", options.Args.OnuSn, err)
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700276 return err
277 }
278
279 fmt.Println(fmt.Sprintf("[Status: %d] %s", res.StatusCode, res.Message))
280
281 return nil
282}
283
Arjun E K57a7fcb2020-01-30 06:44:45 +0000284func (options *ONUIgmp) Execute(args []string) error {
285 client, conn := connect()
286 defer conn.Close()
287
288 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
289 defer cancel()
290
291 req := pb.ONURequest{
292 SerialNumber: string(options.Args.OnuSn),
293 }
294
295 var subActionVal pb.SubActionTypes
296 if string(options.Args.SubAction) == IgmpJoinKey {
297 subActionVal = pb.SubActionTypes_JOIN
298 } else if string(options.Args.SubAction) == IgmpLeaveKey {
299 subActionVal = pb.SubActionTypes_LEAVE
Anand S Katti09541352020-01-29 15:54:01 +0530300 } else if string(options.Args.SubAction) == IgmpJoinKeyV3 {
301 subActionVal = pb.SubActionTypes_JOINV3
302 }
Arjun E K57a7fcb2020-01-30 06:44:45 +0000303
304 igmpReq := pb.IgmpRequest{
305 OnuReq: &req,
306 SubActionVal: subActionVal,
Onur Kalinagac9f9faca2021-01-21 14:04:34 +0000307 GroupAddress: string(options.Args.GroupAddress),
Arjun E K57a7fcb2020-01-30 06:44:45 +0000308 }
309 res, err := client.GetONU(ctx, igmpReq.OnuReq)
310 if err != nil {
311 log.WithFields(log.Fields{
312 "SerialNumber": options.Args.OnuSn,
313 }).Errorf("Cannot not get details on ONU error: %v", err)
314 }
315 log.WithFields(log.Fields{
316 "SerialNumber": igmpReq.OnuReq.SerialNumber,
Onur Kalinagac9f9faca2021-01-21 14:04:34 +0000317 }).Debugf("ONU has identified : %s", res)
Arjun E K57a7fcb2020-01-30 06:44:45 +0000318
319 igmpRes, igmpErr := client.ChangeIgmpState(ctx, &igmpReq)
320 if igmpErr != nil {
321 log.WithFields(log.Fields{
322 "SubAction": options.Args.SubAction,
323 }).Errorf("Could not process Action: error: %v", igmpErr)
324 } else {
325 log.WithFields(log.Fields{
326 "SubAction": options.Args.SubAction,
327 }).Debugf("igmp state has been changed with response: %s",
328 igmpRes.Message)
329 }
330
331 return nil
332}
333
Pragya Arya8bdb4532020-03-02 17:08:09 +0530334func (options *ONUFlows) Execute(args []string) error {
335 client, conn := connect()
336 defer conn.Close()
337
338 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
339 defer cancel()
340 req := pb.ONURequest{
341 SerialNumber: string(options.Args.OnuSn),
342 }
343 res, err := client.GetFlows(ctx, &req)
344 if err != nil {
345 log.Errorf("Cannot get flows for ONU %s: %v", options.Args.OnuSn, err)
346 return err
347 }
348
349 if res.Flows == nil {
350 fmt.Println(fmt.Sprintf("ONU %s has no flows", options.Args.OnuSn))
351 return nil
352 }
353
354 flowHeader := []string{
355 "access_intf_id",
356 "onu_id",
357 "uni_id",
358 "flow_id",
359 "flow_type",
360 "eth_type",
361 "alloc_id",
362 "network_intf_id",
363 "gemport_id",
364 "classifier",
365 "action",
366 "priority",
367 "cookie",
368 "port_no",
369 }
370
371 tableFlow := tablewriter.NewWriter(os.Stdout)
372 tableFlow.SetRowLine(true)
373 fmt.Fprintf(os.Stdout, "ONU Flows:\n")
374 tableFlow.SetHeader(flowHeader)
375
376 for _, flow := range res.Flows {
377 flowInfo := []string{}
378 flowInfo = append(flowInfo,
379 strconv.Itoa(int(flow.AccessIntfId)),
380 strconv.Itoa(int(flow.OnuId)),
381 strconv.Itoa(int(flow.UniId)),
382 strconv.Itoa(int(flow.FlowId)),
383 flow.FlowType,
384 fmt.Sprintf("%x", flow.Classifier.EthType),
385 strconv.Itoa(int(flow.AllocId)),
386 strconv.Itoa(int(flow.NetworkIntfId)),
387 strconv.Itoa(int(flow.GemportId)),
388 flow.Classifier.String(),
389 flow.Action.String(),
390 strconv.Itoa(int(flow.Priority)),
391 strconv.Itoa(int(flow.Cookie)),
392 strconv.Itoa(int(flow.PortNo)),
393 )
394 tableFlow.Append(flowInfo)
395 }
396 tableFlow.Render()
397 tableFlow.SetNewLine("")
398 return nil
399}
400
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700401func (onuSn *OnuSnString) Complete(match string) []flags.Completion {
402 client, conn := connect()
403 defer conn.Close()
404
405 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
406 defer cancel()
407
408 onus, err := client.GetONUs(ctx, &pb.Empty{})
409 if err != nil {
Matteo Scandolo86e8ce62019-10-11 12:03:10 -0700410 log.Fatalf("could not get ONUs: %v", err)
Matteo Scandolo10f965c2019-09-24 10:40:46 -0700411 return nil
412 }
413
414 list := make([]flags.Completion, 0)
415 for _, k := range onus.Items {
416 if strings.HasPrefix(k.SerialNumber, match) {
417 list = append(list, flags.Completion{Item: k.SerialNumber})
418 }
419 }
420
421 return list
422}
Anand S Katti09541352020-01-29 15:54:01 +0530423
Matteo Scandolo618a6582020-09-09 12:21:29 -0700424func (onuSn *IgmpSubAction) Complete(match string) []flags.Completion {
425 list := make([]flags.Completion, 0)
426 for _, k := range IgmpAllowedActions {
427 if strings.HasPrefix(k, match) {
428 list = append(list, flags.Completion{Item: k})
429 }
430 }
431 return list
432}
433
Anand S Katti09541352020-01-29 15:54:01 +0530434func (options *ONUTrafficSchedulers) Execute(args []string) error {
435 client, conn := connect()
436 defer conn.Close()
437
438 ctx, cancel := context.WithTimeout(context.Background(), config.GlobalConfig.Grpc.Timeout)
439 defer cancel()
440 req := pb.ONURequest{
441 SerialNumber: string(options.Args.OnuSn),
442 }
443 res, err := client.GetOnuTrafficSchedulers(ctx, &req)
444 if err != nil {
445 log.Fatalf("Cannot get traffic schedulers for ONU %s: %v", options.Args.OnuSn, err)
446 return err
447 }
448
449 if res.TraffSchedulers == nil {
450 log.Fatalf("Cannot get traffic schedulers for ONU: %s (unavailable)", options.Args.OnuSn)
451 return nil
452 }
453
454 SchedulerHeader := []string{"Direction",
455 "AllocId",
456 "Scheduler.Direction",
457 "Scheduler.AdditionalBw",
458 "Scheduler.Priority",
459 "Scheduler.Weight",
460 "Scheduler.SchedPolicy",
461 }
462
463 ShapingInfoHeader := []string{"InferredAdditionBwIndication",
464 "Cbs",
465 "Cir",
466 "Gir",
467 "Pbs",
468 "Pir",
469 }
470
471 SchedulerVals := []string{}
472 ShapingInfoVals := []string{}
473 for _, v := range res.TraffSchedulers.TrafficScheds {
474 SchedulerVals = append(SchedulerVals,
475 v.GetDirection().String(),
476 strconv.Itoa(int(v.GetAllocId())),
477 v.Scheduler.GetDirection().String(),
478 v.Scheduler.GetAdditionalBw().String(),
479 strconv.Itoa(int(v.Scheduler.GetPriority())),
480 strconv.Itoa(int(v.Scheduler.GetWeight())),
481 v.GetScheduler().GetSchedPolicy().String(),
482 )
483
484 ShapingInfoVals = append(ShapingInfoVals,
485 v.TrafficShapingInfo.GetAddBwInd().String(),
486 strconv.Itoa(int(v.TrafficShapingInfo.GetCbs())),
487 strconv.Itoa(int(v.TrafficShapingInfo.GetCir())),
488 strconv.Itoa(int(v.TrafficShapingInfo.GetGir())),
489 strconv.Itoa(int(v.TrafficShapingInfo.GetPbs())),
490 strconv.Itoa(int(v.TrafficShapingInfo.GetPir())),
491 )
492 }
493
494 fmt.Fprintf(os.Stdout, "OnuId: %d \n", int(res.TraffSchedulers.OnuId))
495 fmt.Fprintf(os.Stdout, "IntfId: %d \n", int(res.TraffSchedulers.IntfId))
496 fmt.Fprintf(os.Stdout, "UniId: %d \n", int(res.TraffSchedulers.UniId))
497 fmt.Fprintf(os.Stdout, "OnuPortNo: %d \n", int(res.TraffSchedulers.PortNo))
498
499 tableSched := tablewriter.NewWriter(os.Stdout)
500 tableSched.SetRowLine(true)
501 fmt.Fprintf(os.Stdout, "Traffic Schedulers Info:\n")
502 tableSched.SetHeader(SchedulerHeader)
503 tableSched.Append(SchedulerVals)
504 tableSched.Render()
505 tableSched.SetNewLine("")
506
507 tableShap := tablewriter.NewWriter(os.Stdout)
508 tableShap.SetRowLine(true)
509 fmt.Fprintf(os.Stdout, "Traffic Shaping Info:\n")
510 tableShap.SetHeader(ShapingInfoHeader)
511 tableShap.Append(ShapingInfoVals)
512 tableShap.Render()
513
514 return nil
515}
Nitin Subramanianb0a333a2021-07-08 15:01:41 -0700516
517func (options *ONUServices) Execute(args []string) error {
518 services, err := getServices(string(options.Args.OnuSn), "")
519
520 if err != nil {
521 log.Errorf("Cannot get services for ONU %s: %v", options.Args.OnuSn, err)
522 return err
523 }
524
525 // print out
526 tableFormat := format.Format(DEFAULT_SERVICE_HEADER_FORMAT)
527 if err := tableFormat.Execute(os.Stdout, true, services.Items); err != nil {
528 log.Fatalf("Error while formatting ONUs table: %s", err)
529 }
530
531 return nil
532}