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