sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 1 | /* |
| 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 | */ |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 16 | |
| 17 | package afrouter |
| 18 | |
| 19 | import ( |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 20 | "errors" |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 21 | "fmt" |
| 22 | "github.com/opencord/voltha-go/common/log" |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 23 | "google.golang.org/grpc" |
| 24 | "google.golang.org/grpc/metadata" |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 25 | ) |
| 26 | |
| 27 | type BindingRouter struct { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 28 | name string |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 29 | association associationType |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 30 | //routingField string |
| 31 | grpcService string |
| 32 | //protoDescriptor *pb.FileDescriptorSet |
| 33 | //methodMap map[string]byte |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 34 | beCluster *cluster |
| 35 | bindings map[string]*backend |
| 36 | bindingType string |
| 37 | bindingField string |
| 38 | bindingMethod string |
| 39 | currentBackend **backend |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 40 | } |
| 41 | |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 42 | func (br BindingRouter) BackendCluster(s string, metaKey string) (*cluster, error) { |
| 43 | return br.beCluster, nil |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 44 | //return nil,errors.New("Not implemented yet") |
| 45 | } |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 46 | func (br BindingRouter) Name() string { |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 47 | return br.name |
| 48 | } |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 49 | func (br BindingRouter) Service() string { |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 50 | return br.grpcService |
| 51 | } |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 52 | func (br BindingRouter) GetMetaKeyVal(serverStream grpc.ServerStream) (string, string, error) { |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 53 | var rtrnK = "" |
| 54 | var rtrnV = "" |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 55 | |
| 56 | // Get the metadata from the server stream |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 57 | md, ok := metadata.FromIncomingContext(serverStream.Context()) |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 58 | if !ok { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 59 | return rtrnK, rtrnV, errors.New("Could not get a server stream metadata") |
| 60 | } |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 61 | |
| 62 | // Determine if one of the method routing keys exists in the metadata |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 63 | if _, ok := md[br.bindingField]; ok == true { |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 64 | rtrnV = md[br.bindingField][0] |
| 65 | rtrnK = br.bindingField |
| 66 | } |
| 67 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 68 | return rtrnK, rtrnV, nil |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 69 | } |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 70 | func (br BindingRouter) FindBackendCluster(becName string) *cluster { |
| 71 | if becName == br.beCluster.name { |
| 72 | return br.beCluster |
sslobodr | 360c8d7 | 2019-02-05 12:47:56 -0500 | [diff] [blame] | 73 | } |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 74 | return nil |
| 75 | } |
| 76 | func (br BindingRouter) ReplyHandler(v interface{}) error { |
| 77 | return nil |
| 78 | } |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 79 | func (br BindingRouter) Route(sel interface{}) *backend { |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 80 | var err error |
| 81 | switch sl := sel.(type) { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 82 | case *nbFrame: |
| 83 | if b, ok := br.bindings[sl.metaVal]; ok == true { // binding exists, just return it |
| 84 | return b |
| 85 | } else { // establish a new binding or error. |
| 86 | if sl.metaVal != "" { |
| 87 | err = errors.New(fmt.Sprintf("Attempt to route on non-existent metadata value '%s' in key '%s'", |
| 88 | sl.metaVal, sl.metaKey)) |
| 89 | log.Error(err) |
| 90 | sl.err = err |
| 91 | return nil |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 92 | } |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 93 | if sl.methodInfo.method != br.bindingMethod { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 94 | err = errors.New(fmt.Sprintf("Binding must occur with method %s but attempted with method %s", |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 95 | br.bindingMethod, sl.methodInfo.method)) |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 96 | log.Error(err) |
| 97 | sl.err = err |
| 98 | return nil |
| 99 | } |
| 100 | log.Debugf("MUST CREATE A NEW BINDING MAP ENTRY!!") |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 101 | if len(br.bindings) < len(br.beCluster.backends) { |
| 102 | if *br.currentBackend, err = br.beCluster.nextBackend(*br.currentBackend, BackendSequenceRoundRobin); err == nil { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 103 | // Use the name of the backend as the metaVal for this new binding |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 104 | br.bindings[(*br.currentBackend).name] = *br.currentBackend |
| 105 | return *br.currentBackend |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 106 | } else { |
| 107 | log.Error(err) |
| 108 | sl.err = err |
| 109 | return nil |
| 110 | } |
| 111 | } else { |
| 112 | err = errors.New(fmt.Sprintf("Backends exhausted in attempt to bind for metakey '%s' with value '%s'", |
| 113 | sl.metaKey, sl.metaVal)) |
| 114 | log.Error(err) |
| 115 | sl.err = err |
| 116 | } |
| 117 | } |
| 118 | return nil |
| 119 | default: |
| 120 | return nil |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 121 | } |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 122 | } |
| 123 | |
sslobodr | cd37bc5 | 2019-01-24 11:47:16 -0500 | [diff] [blame] | 124 | func newBindingRouter(rconf *RouterConfig, config *RouteConfig) (Router, error) { |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 125 | var rtrn_err = false |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 126 | var err error = nil |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 127 | log.Debugf("Creating binding router %s", config.Name) |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 128 | // A name must exist |
| 129 | if config.Name == "" { |
| 130 | log.Error("A router 'name' must be specified") |
| 131 | rtrn_err = true |
| 132 | } |
| 133 | |
| 134 | if rconf.ProtoPackage == "" { |
| 135 | log.Error("A 'package' must be specified") |
| 136 | rtrn_err = true |
| 137 | } |
| 138 | |
| 139 | if rconf.ProtoService == "" { |
| 140 | log.Error("A 'service' must be specified") |
| 141 | rtrn_err = true |
| 142 | } |
| 143 | |
| 144 | //if config.RouteField == "" { |
| 145 | // log.Error("A 'routing_field' must be specified") |
| 146 | // rtrn_err = true |
| 147 | //} |
| 148 | |
| 149 | // TODO: Using the specified service, the imported proto |
| 150 | // descriptor file should be scanned for all methods provided |
| 151 | // for this router to ensure that this field exists in |
| 152 | // the message(s) passed to the method. This will avoid run |
| 153 | // time failures that might not be detected for long periods |
| 154 | // of time. |
| 155 | |
| 156 | // TODO The routes section is currently not being used |
| 157 | // so the router will route all methods based on the |
| 158 | // routing_field. This needs to be done. |
| 159 | var bptr *backend |
| 160 | bptr = nil |
| 161 | br := BindingRouter{ |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 162 | name: config.Name, |
| 163 | grpcService: rconf.ProtoService, |
| 164 | bindings: make(map[string]*backend), |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 165 | //methodMap:make(map[string]byte), |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 166 | currentBackend: &bptr, |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 167 | //serialNo:0, |
| 168 | } |
| 169 | |
| 170 | // A binding association must exist |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 171 | br.association = config.Binding.Association |
| 172 | if br.association == AssociationUndefined { |
| 173 | log.Error("An binding association must be specified") |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 174 | rtrn_err = true |
| 175 | } |
| 176 | // A binding type must exist |
| 177 | // TODO: This is parsed but ignored and a header based type is used. |
| 178 | if config.Binding.Type != "header" { |
| 179 | log.Error("The binding type must be set to header") |
| 180 | rtrn_err = true |
| 181 | } else { |
| 182 | br.bindingType = config.Binding.Type |
| 183 | } |
| 184 | // A binding method must exist |
| 185 | if config.Binding.Method == "" { |
| 186 | log.Error("The binding method must be specified") |
| 187 | rtrn_err = true |
| 188 | } else { |
| 189 | br.bindingMethod = config.Binding.Method |
| 190 | } |
| 191 | // A binding field must exxist |
| 192 | if config.Binding.Field == "" { |
| 193 | log.Error("The binding field must be specified") |
| 194 | rtrn_err = true |
| 195 | } else { |
| 196 | br.bindingField = config.Binding.Field |
| 197 | } |
| 198 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 199 | // Create the backend cluster or link to an existing one |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 200 | ok := true |
Kent Hagerman | 1e9061e | 2019-05-21 16:01:21 -0400 | [diff] [blame^] | 201 | if br.beCluster, ok = clusters[config.backendCluster.Name]; ok == false { |
| 202 | if br.beCluster, err = newBackendCluster(config.backendCluster); err != nil { |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 203 | log.Errorf("Could not create a backend for router %s", config.Name) |
| 204 | rtrn_err = true |
| 205 | } |
| 206 | } |
| 207 | |
| 208 | // HERE HERE HERE |
| 209 | |
| 210 | if rtrn_err { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 211 | return br, errors.New(fmt.Sprintf("Failed to create a new router '%s'", br.name)) |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 212 | } |
| 213 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 214 | return br, nil |
sslobodr | 392ebd5 | 2019-01-18 12:41:49 -0500 | [diff] [blame] | 215 | } |