Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 1 | /* |
| 2 | Copyright 2020 the original author or authors. |
| 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 | */ |
| 16 | |
| 17 | package openflow |
| 18 | |
| 19 | import ( |
| 20 | "context" |
Andrea Campanella | 22aa3ed | 2021-03-04 15:58:55 +0100 | [diff] [blame] | 21 | "fmt" |
David K. Bainbridge | e05cf0c | 2021-08-19 03:16:50 +0000 | [diff] [blame] | 22 | |
Jonathan Hart | 828908c | 2020-04-15 14:23:45 -0700 | [diff] [blame] | 23 | "github.com/opencord/goloxi" |
| 24 | ofp "github.com/opencord/goloxi/of13" |
David K. Bainbridge | e05cf0c | 2021-08-19 03:16:50 +0000 | [diff] [blame] | 25 | "github.com/opencord/voltha-lib-go/v7/pkg/log" |
| 26 | "github.com/opencord/voltha-protos/v5/go/openflow_13" |
| 27 | "github.com/opencord/voltha-protos/v5/go/voltha" |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 28 | ) |
| 29 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 30 | func (ofc *OFConnection) handleGroupMod(ctx context.Context, groupMod ofp.IGroupMod) { |
Girish Kumar | 01e0c63 | 2020-08-10 16:48:56 +0000 | [diff] [blame] | 31 | span, ctx := log.CreateChildSpan(ctx, "openflow-group-modification") |
| 32 | defer span.Finish() |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 33 | |
| 34 | volthaClient := ofc.VolthaClient.Get() |
| 35 | if volthaClient == nil { |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 36 | logger.Errorw(ctx, "no-voltha-connection", |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 37 | log.Fields{"device-id": ofc.DeviceID}) |
| 38 | return |
| 39 | } |
| 40 | |
| 41 | groupUpdate := &openflow_13.FlowGroupTableUpdate{ |
| 42 | Id: ofc.DeviceID, |
| 43 | GroupMod: &voltha.OfpGroupMod{ |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 44 | Command: openflowGroupModCommandToVoltha(ctx, groupMod.GetCommand()), |
| 45 | Type: openflowGroupTypeToVoltha(ctx, groupMod.GetGroupType()), |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 46 | GroupId: groupMod.GetGroupId(), |
| 47 | Buckets: openflowBucketsToVoltha(groupMod.GetBuckets()), |
| 48 | }, |
| 49 | } |
| 50 | |
Girish Kumar | 01e0c63 | 2020-08-10 16:48:56 +0000 | [diff] [blame] | 51 | _, err := volthaClient.UpdateLogicalDeviceFlowGroupTable(log.WithSpanFromContext(context.Background(), ctx), groupUpdate) |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 52 | if err != nil { |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 53 | logger.Errorw(ctx, "Error updating group table", |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 54 | log.Fields{"device-id": ofc.DeviceID, "error": err}) |
| 55 | } |
| 56 | |
| 57 | } |
| 58 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 59 | func openflowGroupModCommandToVoltha(ctx context.Context, command ofp.GroupModCommand) openflow_13.OfpGroupModCommand { |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 60 | switch command { |
| 61 | case ofp.OFPGCAdd: |
| 62 | return openflow_13.OfpGroupModCommand_OFPGC_ADD |
| 63 | case ofp.OFPGCModify: |
| 64 | return openflow_13.OfpGroupModCommand_OFPGC_MODIFY |
| 65 | case ofp.OFPGCDelete: |
| 66 | return openflow_13.OfpGroupModCommand_OFPGC_DELETE |
| 67 | } |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 68 | logger.Errorw(ctx, "Unknown group mod command", log.Fields{"command": command}) |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 69 | return 0 |
| 70 | } |
| 71 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 72 | func openflowGroupTypeToVoltha(ctx context.Context, t ofp.GroupType) openflow_13.OfpGroupType { |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 73 | switch t { |
| 74 | case ofp.OFPGTAll: |
| 75 | return openflow_13.OfpGroupType_OFPGT_ALL |
| 76 | case ofp.OFPGTSelect: |
| 77 | return openflow_13.OfpGroupType_OFPGT_SELECT |
| 78 | case ofp.OFPGTIndirect: |
| 79 | return openflow_13.OfpGroupType_OFPGT_INDIRECT |
| 80 | case ofp.OFPGTFf: |
| 81 | return openflow_13.OfpGroupType_OFPGT_FF |
| 82 | } |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 83 | logger.Errorw(ctx, "Unknown openflow group type", log.Fields{"type": t}) |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 84 | return 0 |
| 85 | } |
| 86 | |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 87 | func volthaGroupTypeToOpenflow(ctx context.Context, t openflow_13.OfpGroupType) ofp.GroupType { |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 88 | switch t { |
| 89 | case openflow_13.OfpGroupType_OFPGT_ALL: |
| 90 | return ofp.OFPGTAll |
| 91 | case openflow_13.OfpGroupType_OFPGT_SELECT: |
| 92 | return ofp.OFPGTSelect |
| 93 | case openflow_13.OfpGroupType_OFPGT_INDIRECT: |
| 94 | return ofp.OFPGTIndirect |
| 95 | case openflow_13.OfpGroupType_OFPGT_FF: |
| 96 | return ofp.OFPGTFf |
| 97 | } |
Rohan Agrawal | c32d993 | 2020-06-15 11:01:47 +0000 | [diff] [blame] | 98 | logger.Errorw(ctx, "Unknown voltha group type", log.Fields{"type": t}) |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 99 | return 0 |
| 100 | } |
| 101 | |
| 102 | func openflowBucketsToVoltha(buckets []*ofp.Bucket) []*openflow_13.OfpBucket { |
| 103 | outBuckets := make([]*openflow_13.OfpBucket, len(buckets)) |
| 104 | |
| 105 | for i, bucket := range buckets { |
| 106 | b := &openflow_13.OfpBucket{ |
| 107 | Weight: uint32(bucket.Weight), |
| 108 | WatchPort: uint32(bucket.WatchPort), |
| 109 | WatchGroup: bucket.WatchGroup, |
| 110 | Actions: openflowActionsToVoltha(bucket.Actions), |
| 111 | } |
| 112 | outBuckets[i] = b |
| 113 | } |
| 114 | |
| 115 | return outBuckets |
| 116 | } |
| 117 | |
| 118 | func openflowActionsToVoltha(actions []goloxi.IAction) []*openflow_13.OfpAction { |
| 119 | outActions := make([]*openflow_13.OfpAction, len(actions)) |
| 120 | |
| 121 | for i, action := range actions { |
| 122 | outActions[i] = extractAction(action) |
| 123 | } |
| 124 | |
| 125 | return outActions |
| 126 | } |
| 127 | |
Andrea Campanella | 22aa3ed | 2021-03-04 15:58:55 +0100 | [diff] [blame] | 128 | func volthaBucketsToOpenflow(ctx context.Context, buckets []*openflow_13.OfpBucket) ([]*ofp.Bucket, error) { |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 129 | outBuckets := make([]*ofp.Bucket, len(buckets)) |
| 130 | |
| 131 | for i, bucket := range buckets { |
Andrea Campanella | 22aa3ed | 2021-03-04 15:58:55 +0100 | [diff] [blame] | 132 | actions, err := volthaActionsToOpenflow(ctx, bucket.Actions) |
| 133 | if err != nil { |
| 134 | return nil, err |
| 135 | } |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 136 | b := &ofp.Bucket{ |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 137 | Weight: uint16(bucket.Weight), |
| 138 | WatchPort: ofp.Port(bucket.WatchPort), |
| 139 | WatchGroup: bucket.WatchGroup, |
| 140 | Actions: actions, |
| 141 | } |
| 142 | outBuckets[i] = b |
| 143 | } |
| 144 | |
Andrea Campanella | 22aa3ed | 2021-03-04 15:58:55 +0100 | [diff] [blame] | 145 | return outBuckets, nil |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 146 | } |
| 147 | |
Andrea Campanella | 22aa3ed | 2021-03-04 15:58:55 +0100 | [diff] [blame] | 148 | func volthaActionsToOpenflow(ctx context.Context, actions []*openflow_13.OfpAction) ([]goloxi.IAction, error) { |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 149 | outActions := make([]goloxi.IAction, len(actions)) |
| 150 | |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 151 | for i, action := range actions { |
Andrea Campanella | 22aa3ed | 2021-03-04 15:58:55 +0100 | [diff] [blame] | 152 | outAction, err := parseAction(ctx, action) |
| 153 | if err == nil { |
| 154 | outActions[i] = outAction |
| 155 | } else { |
| 156 | return nil, fmt.Errorf("can't-parse-action %v", err) |
| 157 | } |
| 158 | |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 159 | } |
| 160 | |
Andrea Campanella | 22aa3ed | 2021-03-04 15:58:55 +0100 | [diff] [blame] | 161 | return outActions, nil |
Jonathan Hart | 60c5d77 | 2020-03-30 18:28:40 -0700 | [diff] [blame] | 162 | } |