sslobodr | 16e41bc | 2019-01-18 16:22:21 -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 | */ |
| 16 | |
| 17 | package main |
| 18 | |
| 19 | import ( |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 20 | "errors" |
David K. Bainbridge | f430cd5 | 2019-05-28 15:00:35 -0700 | [diff] [blame] | 21 | "flag" |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 22 | "fmt" |
| 23 | "math" |
| 24 | "os" |
David K. Bainbridge | f430cd5 | 2019-05-28 15:00:35 -0700 | [diff] [blame] | 25 | "path" |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 26 | "regexp" |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 27 | "strconv" |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 28 | "time" |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 29 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 30 | "github.com/golang/protobuf/ptypes" |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 31 | "github.com/golang/protobuf/ptypes/empty" |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 32 | "github.com/opencord/voltha-go/common/log" |
David K. Bainbridge | f430cd5 | 2019-05-28 15:00:35 -0700 | [diff] [blame] | 33 | "github.com/opencord/voltha-go/common/version" |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 34 | "github.com/opencord/voltha-go/kafka" |
William Kurkian | daa6bb2 | 2019-03-07 12:26:28 -0500 | [diff] [blame] | 35 | pb "github.com/opencord/voltha-protos/go/afrouter" |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 36 | cmn "github.com/opencord/voltha-protos/go/common" |
William Kurkian | daa6bb2 | 2019-03-07 12:26:28 -0500 | [diff] [blame] | 37 | ic "github.com/opencord/voltha-protos/go/inter_container" |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 38 | vpb "github.com/opencord/voltha-protos/go/voltha" |
| 39 | "golang.org/x/net/context" |
| 40 | "google.golang.org/grpc" |
| 41 | metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" |
| 42 | "k8s.io/client-go/kubernetes" |
| 43 | "k8s.io/client-go/rest" |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 44 | "k8s.io/client-go/tools/clientcmd" |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 45 | ) |
| 46 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 47 | type volthaPod struct { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 48 | name string |
| 49 | ipAddr string |
| 50 | node string |
| 51 | devIds map[string]struct{} |
| 52 | cluster string |
| 53 | backend string |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 54 | connection string |
| 55 | } |
| 56 | |
| 57 | type podTrack struct { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 58 | pod *volthaPod |
| 59 | dn bool |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 60 | } |
| 61 | |
David K. Bainbridge | f430cd5 | 2019-05-28 15:00:35 -0700 | [diff] [blame] | 62 | type Configuration struct { |
| 63 | DisplayVersionOnly *bool |
| 64 | } |
| 65 | |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 66 | var ( |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 67 | // if k8s variables are undefined, will attempt to use in-cluster config |
| 68 | k8sApiServer = getStrEnv("K8S_API_SERVER", "") |
| 69 | k8sKubeConfigPath = getStrEnv("K8S_KUBE_CONFIG_PATH", "") |
| 70 | |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 71 | podNamespace = getStrEnv("POD_NAMESPACE", "voltha") |
| 72 | podGrpcPort = uint64(getIntEnv("POD_GRPC_PORT", 0, math.MaxUint16, 50057)) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 73 | |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 74 | numRWPods = getIntEnv("NUM_RW_PODS", 1, math.MaxInt32, 6) |
| 75 | numROPods = getIntEnv("NUM_RO_PODS", 1, math.MaxInt32, 3) |
| 76 | |
| 77 | afrouterRouterName = getStrEnv("AFROUTER_ROUTER_NAME", "vcore") |
| 78 | afrouterRWClusterName = getStrEnv("AFROUTER_RW_CLUSTER_NAME", "vcore") |
| 79 | afrouterROClusterName = getStrEnv("AFROUTER_RO_CLUSTER_NAME", "ro_vcore") |
| 80 | |
| 81 | kafkaTopic = getStrEnv("KAFKA_TOPIC", "AffinityRouter") |
| 82 | kafkaClientType = getStrEnv("KAFKA_CLIENT_TYPE", "sarama") |
| 83 | kafkaHost = getStrEnv("KAFKA_HOST", "kafka") |
| 84 | kafkaPort = getIntEnv("KAFKA_PORT", 0, math.MaxUint16, 9092) |
| 85 | kafkaInstanceID = getStrEnv("KAFKA_INSTANCE_ID", "arouterd") |
| 86 | ) |
| 87 | |
| 88 | func getIntEnv(key string, min, max, defaultValue int) int { |
| 89 | if val, have := os.LookupEnv(key); have { |
| 90 | num, err := strconv.Atoi(val) |
| 91 | if err != nil || !(min <= num && num <= max) { |
| 92 | panic(fmt.Errorf("%s must be a number in the range [%d, %d]; default: %d", key, min, max, defaultValue)) |
| 93 | } |
| 94 | return num |
| 95 | } |
| 96 | return defaultValue |
| 97 | } |
| 98 | |
| 99 | func getStrEnv(key, defaultValue string) string { |
| 100 | if val, have := os.LookupEnv(key); have { |
| 101 | return val |
| 102 | } |
| 103 | return defaultValue |
| 104 | } |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 105 | |
| 106 | func newKafkaClient(clientType string, host string, port int, instanceID string) (kafka.Client, error) { |
| 107 | |
| 108 | log.Infow("kafka-client-type", log.Fields{"client": clientType}) |
| 109 | switch clientType { |
| 110 | case "sarama": |
| 111 | return kafka.NewSaramaClient( |
| 112 | kafka.Host(host), |
| 113 | kafka.Port(port), |
| 114 | kafka.ConsumerType(kafka.GroupCustomer), |
| 115 | kafka.ProducerReturnOnErrors(true), |
| 116 | kafka.ProducerReturnOnSuccess(true), |
| 117 | kafka.ProducerMaxRetries(6), |
| 118 | kafka.NumPartitions(3), |
| 119 | kafka.ConsumerGroupName(instanceID), |
| 120 | kafka.ConsumerGroupPrefix(instanceID), |
| 121 | kafka.AutoCreateTopic(false), |
| 122 | kafka.ProducerFlushFrequency(5), |
| 123 | kafka.ProducerRetryBackoff(time.Millisecond*30)), nil |
| 124 | } |
| 125 | return nil, errors.New("unsupported-client-type") |
| 126 | } |
| 127 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 128 | func k8sClientSet() *kubernetes.Clientset { |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 129 | var config *rest.Config |
| 130 | if k8sApiServer != "" || k8sKubeConfigPath != "" { |
| 131 | // use combination of URL & local kube-config file |
| 132 | c, err := clientcmd.BuildConfigFromFlags(k8sApiServer, k8sKubeConfigPath) |
| 133 | if err != nil { |
| 134 | panic(err) |
| 135 | } |
| 136 | config = c |
| 137 | } else { |
| 138 | // use in-cluster config |
| 139 | c, err := rest.InClusterConfig() |
| 140 | if err != nil { |
| 141 | log.Errorf("Unable to load in-cluster config. Try setting K8S_API_SERVER and K8S_KUBE_CONFIG_PATH?") |
| 142 | panic(err) |
| 143 | } |
| 144 | config = c |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 145 | } |
| 146 | // creates the clientset |
| 147 | clientset, err := kubernetes.NewForConfig(config) |
| 148 | if err != nil { |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 149 | panic(err) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 150 | } |
| 151 | |
| 152 | return clientset |
| 153 | } |
| 154 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 155 | func connect(addr string) (*grpc.ClientConn, error) { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 156 | for ctr := 0; ctr < 100; ctr++ { |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 157 | startTime := time.Now() |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 158 | log.Debugf("Trying to connect to %s", addr) |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 159 | ctx, _ := context.WithTimeout(context.Background(), time.Second*5) |
| 160 | conn, err := grpc.DialContext(ctx, addr, grpc.WithInsecure(), grpc.WithBlock()) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 161 | if err != nil { |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 162 | log.Debugf("Attempt to connect failed, retrying. (%v)", err) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 163 | } else { |
| 164 | log.Debugf("Connection succeeded") |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 165 | return conn, err |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 166 | } |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 167 | // 5s between attempts, whether or not if the connection fails immediately |
| 168 | time.Sleep(startTime.Add(time.Second * 5).Sub(time.Now())) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 169 | } |
| 170 | log.Debugf("Too many connection attempts, giving up!") |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 171 | return nil, errors.New("Timeout attempting to conect") |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 172 | } |
| 173 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 174 | func getVolthaPods(cs *kubernetes.Clientset, coreFilter *regexp.Regexp) []*volthaPod { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 175 | var rtrn []*volthaPod |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 176 | |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 177 | pods, err := cs.CoreV1().Pods(podNamespace).List(metav1.ListOptions{}) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 178 | if err != nil { |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 179 | panic(err) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 180 | } |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 181 | //log.Debugf("There are a total of %d pods in the cluster\n", len(pods.Items)) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 182 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 183 | for _, v := range pods.Items { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 184 | if coreFilter.MatchString(v.Name) { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 185 | log.Debugf("Namespace: %s, PodName: %s, PodIP: %s, Host: %s\n", v.Namespace, v.Name, |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 186 | v.Status.PodIP, v.Spec.NodeName) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 187 | // Only add the pod if it has an IP address. If it doesn't then it likely crashed and |
| 188 | // and is still in the process of getting re-started. |
| 189 | if v.Status.PodIP != "" { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 190 | rtrn = append(rtrn, &volthaPod{name: v.Name, ipAddr: v.Status.PodIP, node: v.Spec.NodeName, |
| 191 | devIds: make(map[string]struct{}), backend: "", connection: ""}) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 192 | } |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 193 | } |
| 194 | } |
| 195 | return rtrn |
| 196 | } |
| 197 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 198 | func reconcilePodDeviceIds(pod *volthaPod, ids map[string]struct{}) bool { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 199 | conn, err := connect(fmt.Sprintf("%s:%d", pod.ipAddr, podGrpcPort)) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 200 | defer conn.Close() |
sslobodr | 6c1689c | 2019-01-24 07:31:15 -0500 | [diff] [blame] | 201 | if err != nil { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 202 | log.Debugf("Could not query devices from %s, could not connect", pod.name) |
| 203 | return false |
| 204 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 205 | |
| 206 | var idList cmn.IDs |
| 207 | for k := range ids { |
| 208 | idList.Items = append(idList.Items, &cmn.ID{Id: k}) |
| 209 | } |
| 210 | |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 211 | client := vpb.NewVolthaServiceClient(conn) |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 212 | _, err = client.ReconcileDevices(context.Background(), &idList) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 213 | if err != nil { |
| 214 | log.Error(err) |
| 215 | return false |
| 216 | } |
| 217 | |
| 218 | return true |
| 219 | } |
| 220 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 221 | func queryPodDeviceIds(pod *volthaPod) map[string]struct{} { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 222 | var rtrn = make(map[string]struct{}) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 223 | // Open a connection to the pod |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 224 | conn, err := connect(fmt.Sprintf("%s:%d", pod.ipAddr, podGrpcPort)) |
sslobodr | 6c1689c | 2019-01-24 07:31:15 -0500 | [diff] [blame] | 225 | if err != nil { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 226 | log.Debugf("Could not query devices from %s, could not connect", pod.name) |
| 227 | return rtrn |
| 228 | } |
| 229 | defer conn.Close() |
| 230 | client := vpb.NewVolthaServiceClient(conn) |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 231 | devs, err := client.ListDeviceIds(context.Background(), &empty.Empty{}) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 232 | if err != nil { |
| 233 | log.Error(err) |
| 234 | return rtrn |
| 235 | } |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 236 | for _, dv := range devs.Items { |
| 237 | rtrn[dv.Id] = struct{}{} |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | return rtrn |
| 241 | } |
| 242 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 243 | func queryDeviceIds(pods []*volthaPod) { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 244 | for pk := range pods { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 245 | // Keep the old Id list if a new list is not returned |
| 246 | if idList := queryPodDeviceIds(pods[pk]); len(idList) != 0 { |
| 247 | pods[pk].devIds = idList |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 248 | } |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 249 | } |
| 250 | } |
| 251 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 252 | func allEmpty(pods []*volthaPod) bool { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 253 | for k := range pods { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 254 | if len(pods[k].devIds) != 0 { |
| 255 | return false |
| 256 | } |
| 257 | } |
| 258 | return true |
| 259 | } |
| 260 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 261 | func rmPod(pods []*volthaPod, idx int) []*volthaPod { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 262 | return append(pods[:idx], pods[idx+1:]...) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 263 | } |
| 264 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 265 | func groupIntersectingPods1(pods []*volthaPod, podCt int) ([][]*volthaPod, []*volthaPod) { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 266 | var rtrn [][]*volthaPod |
| 267 | var out []*volthaPod |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 268 | |
| 269 | for { |
| 270 | if len(pods) == 0 { |
| 271 | break |
| 272 | } |
| 273 | if len(pods[0].devIds) == 0 { // Ignore pods with no devices |
| 274 | ////log.Debugf("%s empty pod", pd[k].pod.name) |
| 275 | out = append(out, pods[0]) |
| 276 | pods = rmPod(pods, 0) |
| 277 | continue |
| 278 | } |
| 279 | // Start a pod group with this pod |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 280 | var grp []*volthaPod |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 281 | grp = append(grp, pods[0]) |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 282 | pods = rmPod(pods, 0) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 283 | //log.Debugf("Creating new group %s", pd[k].pod.name) |
| 284 | // Find the peer pod based on device overlap |
| 285 | // It's ok if one isn't found, an empty one will be used instead |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 286 | for k := range pods { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 287 | if len(pods[k].devIds) == 0 { // Skip pods with no devices |
| 288 | //log.Debugf("%s empty pod", pd[k1].pod.name) |
| 289 | continue |
| 290 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 291 | if intersect(grp[0].devIds, pods[k].devIds) { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 292 | //log.Debugf("intersection found %s:%s", pd[k].pod.name, pd[k1].pod.name) |
| 293 | if grp[0].node == pods[k].node { |
| 294 | // This should never happen |
| 295 | log.Errorf("pods %s and %s intersect and are on the same server!! Not pairing", |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 296 | grp[0].name, pods[k].name) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 297 | continue |
| 298 | } |
| 299 | grp = append(grp, pods[k]) |
| 300 | pods = rmPod(pods, k) |
| 301 | break |
| 302 | |
| 303 | } |
| 304 | } |
| 305 | rtrn = append(rtrn, grp) |
| 306 | //log.Debugf("Added group %s", grp[0].name) |
| 307 | // Check if the number of groups = half the pods, if so all groups are started. |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 308 | if len(rtrn) == podCt>>1 { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 309 | // Append any remaining pods to out |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 310 | out = append(out, pods[0:]...) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 311 | break |
| 312 | } |
| 313 | } |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 314 | return rtrn, out |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 315 | } |
| 316 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 317 | func unallocPodCount(pd []*podTrack) int { |
| 318 | var rtrn int = 0 |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 319 | for _, v := range pd { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 320 | if !v.dn { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 321 | rtrn++ |
| 322 | } |
| 323 | } |
| 324 | return rtrn |
| 325 | } |
| 326 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 327 | func sameNode(pod *volthaPod, grps [][]*volthaPod) bool { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 328 | for _, v := range grps { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 329 | if v[0].node == pod.node { |
| 330 | return true |
| 331 | } |
| 332 | if len(v) == 2 && v[1].node == pod.node { |
| 333 | return true |
| 334 | } |
| 335 | } |
| 336 | return false |
| 337 | } |
| 338 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 339 | func startRemainingGroups1(grps [][]*volthaPod, pods []*volthaPod, podCt int) ([][]*volthaPod, []*volthaPod) { |
| 340 | var grp []*volthaPod |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 341 | |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 342 | for k := range pods { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 343 | if sameNode(pods[k], grps) { |
| 344 | continue |
| 345 | } |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 346 | grp = []*volthaPod{} |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 347 | grp = append(grp, pods[k]) |
| 348 | pods = rmPod(pods, k) |
| 349 | grps = append(grps, grp) |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 350 | if len(grps) == podCt>>1 { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 351 | break |
| 352 | } |
| 353 | } |
| 354 | return grps, pods |
| 355 | } |
| 356 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 357 | func hasSingleSecondNode(grp []*volthaPod) bool { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 358 | var servers = make(map[string]struct{}) |
| 359 | for k := range grp { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 360 | if k == 0 { |
| 361 | continue // Ignore the first item |
| 362 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 363 | servers[grp[k].node] = struct{}{} |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 364 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 365 | if len(servers) == 1 { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 366 | return true |
| 367 | } |
| 368 | return false |
| 369 | } |
| 370 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 371 | func addNode(grps [][]*volthaPod, idx *volthaPod, item *volthaPod) [][]*volthaPod { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 372 | for k := range grps { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 373 | if grps[k][0].name == idx.name { |
| 374 | grps[k] = append(grps[k], item) |
| 375 | return grps |
| 376 | } |
| 377 | } |
| 378 | // TODO: Error checking required here. |
| 379 | return grps |
| 380 | } |
| 381 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 382 | func removeNode(grps [][]*volthaPod, item *volthaPod) [][]*volthaPod { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 383 | for k := range grps { |
| 384 | for k1 := range grps[k] { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 385 | if grps[k][k1].name == item.name { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 386 | grps[k] = append(grps[k][:k1], grps[k][k1+1:]...) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 387 | break |
| 388 | } |
| 389 | } |
| 390 | } |
| 391 | return grps |
| 392 | } |
| 393 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 394 | func groupRemainingPods1(grps [][]*volthaPod, pods []*volthaPod) [][]*volthaPod { |
| 395 | var lgrps [][]*volthaPod |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 396 | // All groups must be started when this function is called. |
| 397 | // Copy incomplete groups |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 398 | for k := range grps { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 399 | if len(grps[k]) != 2 { |
| 400 | lgrps = append(lgrps, grps[k]) |
| 401 | } |
| 402 | } |
| 403 | |
| 404 | // Add all pairing candidates to each started group. |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 405 | for k := range pods { |
| 406 | for k2 := range lgrps { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 407 | if lgrps[k2][0].node != pods[k].node { |
| 408 | lgrps[k2] = append(lgrps[k2], pods[k]) |
| 409 | } |
| 410 | } |
| 411 | } |
| 412 | |
| 413 | //TODO: If any member of lgrps doesn't have at least 2 |
| 414 | // nodes something is wrong. Check for that here |
| 415 | |
| 416 | for { |
| 417 | for { // Address groups with only a single server choice |
| 418 | var ssn bool = false |
| 419 | |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 420 | for k := range lgrps { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 421 | // Now if any of the groups only have a single |
| 422 | // node as the choice for the second member |
| 423 | // address that one first. |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 424 | if hasSingleSecondNode(lgrps[k]) { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 425 | ssn = true |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 426 | // Add this pairing to the groups |
| 427 | grps = addNode(grps, lgrps[k][0], lgrps[k][1]) |
| 428 | // Since this node is now used, remove it from all |
| 429 | // remaining tenative groups |
| 430 | lgrps = removeNode(lgrps, lgrps[k][1]) |
| 431 | // Now remove this group completely since |
| 432 | // it's been addressed |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 433 | lgrps = append(lgrps[:k], lgrps[k+1:]...) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 434 | break |
| 435 | } |
| 436 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 437 | if !ssn { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 438 | break |
| 439 | } |
| 440 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 441 | // Now address one of the remaining groups |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 442 | if len(lgrps) == 0 { |
| 443 | break // Nothing left to do, exit the loop |
| 444 | } |
| 445 | grps = addNode(grps, lgrps[0][0], lgrps[0][1]) |
| 446 | lgrps = removeNode(lgrps, lgrps[0][1]) |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 447 | lgrps = append(lgrps[:0], lgrps[1:]...) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 448 | } |
| 449 | return grps |
| 450 | } |
| 451 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 452 | func groupPods1(pods []*volthaPod) [][]*volthaPod { |
| 453 | var rtrn [][]*volthaPod |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 454 | var podCt int = len(pods) |
| 455 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 456 | rtrn, pods = groupIntersectingPods1(pods, podCt) |
| 457 | // There are several outcomes here |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 458 | // 1) All pods have been paired and we're done |
| 459 | // 2) Some un-allocated pods remain |
| 460 | // 2.a) All groups have been started |
| 461 | // 2.b) Not all groups have been started |
| 462 | if len(pods) == 0 { |
| 463 | return rtrn |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 464 | } else if len(rtrn) == podCt>>1 { // All groupings started |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 465 | // Allocate the remaining (presumably empty) pods to the started groups |
| 466 | return groupRemainingPods1(rtrn, pods) |
| 467 | } else { // Some groupings started |
| 468 | // Start empty groups with remaining pods |
| 469 | // each grouping is on a different server then |
| 470 | // allocate remaining pods. |
| 471 | rtrn, pods = startRemainingGroups1(rtrn, pods, podCt) |
| 472 | return groupRemainingPods1(rtrn, pods) |
| 473 | } |
| 474 | } |
| 475 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 476 | func intersect(d1 map[string]struct{}, d2 map[string]struct{}) bool { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 477 | for k := range d1 { |
| 478 | if _, ok := d2[k]; ok { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 479 | return true |
| 480 | } |
| 481 | } |
| 482 | return false |
| 483 | } |
| 484 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 485 | func setConnection(client pb.ConfigurationClient, cluster string, backend string, connection string, addr string, port uint64) { |
sslobodr | 360c8d7 | 2019-02-05 12:47:56 -0500 | [diff] [blame] | 486 | log.Debugf("Configuring backend %s : connection %s in cluster %s\n\n", |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 487 | backend, connection, cluster) |
| 488 | cnf := &pb.Conn{Server: "grpc_command", Cluster: cluster, Backend: backend, |
| 489 | Connection: connection, Addr: addr, |
| 490 | Port: port} |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 491 | if res, err := client.SetConnection(context.Background(), cnf); err != nil { |
| 492 | log.Debugf("failed SetConnection RPC call: %s", err) |
| 493 | } else { |
| 494 | log.Debugf("Result: %v", res) |
| 495 | } |
| 496 | } |
| 497 | |
| 498 | func setAffinity(client pb.ConfigurationClient, ids map[string]struct{}, backend string) { |
| 499 | log.Debugf("Configuring backend %s : affinities \n", backend) |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 500 | aff := &pb.Affinity{Router: afrouterRouterName, Route: "dev_manager", Cluster: afrouterRWClusterName, Backend: backend} |
| 501 | for k := range ids { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 502 | log.Debugf("Setting affinity for id %s", k) |
| 503 | aff.Id = k |
| 504 | if res, err := client.SetAffinity(context.Background(), aff); err != nil { |
| 505 | log.Debugf("failed affinity RPC call: %s", err) |
| 506 | } else { |
| 507 | log.Debugf("Result: %v", res) |
| 508 | } |
| 509 | } |
| 510 | } |
| 511 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 512 | func getBackendForCore(coreId string, coreGroups [][]*volthaPod) string { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 513 | for _, v := range coreGroups { |
| 514 | for _, v2 := range v { |
sslobodr | 38afd0d | 2019-01-21 12:31:46 -0500 | [diff] [blame] | 515 | if v2.name == coreId { |
| 516 | return v2.backend |
| 517 | } |
| 518 | } |
| 519 | } |
| 520 | log.Errorf("No backend found for core %s\n", coreId) |
| 521 | return "" |
| 522 | } |
| 523 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 524 | func monitorDiscovery(client pb.ConfigurationClient, |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 525 | ch <-chan *ic.InterContainerMessage, |
| 526 | coreGroups [][]*volthaPod) { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 527 | var id = make(map[string]struct{}) |
sslobodr | 38afd0d | 2019-01-21 12:31:46 -0500 | [diff] [blame] | 528 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 529 | select { |
| 530 | case msg := <-ch: |
| 531 | log.Debugf("Received a device discovery notification") |
sslobodr | 38afd0d | 2019-01-21 12:31:46 -0500 | [diff] [blame] | 532 | device := &ic.DeviceDiscovered{} |
| 533 | if err := ptypes.UnmarshalAny(msg.Body, device); err != nil { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 534 | log.Errorf("Could not unmarshal received notification %v", msg) |
| 535 | } else { |
sslobodr | 38afd0d | 2019-01-21 12:31:46 -0500 | [diff] [blame] | 536 | // Set the affinity of the discovered device. |
| 537 | if be := getBackendForCore(device.Id, coreGroups); be != "" { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 538 | id[device.Id] = struct{}{} |
sslobodr | 38afd0d | 2019-01-21 12:31:46 -0500 | [diff] [blame] | 539 | setAffinity(client, id, be) |
| 540 | } else { |
| 541 | log.Error("Cant use an empty string as a backend name") |
| 542 | } |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 543 | } |
| 544 | break |
| 545 | } |
| 546 | } |
| 547 | |
sslobodr | 38afd0d | 2019-01-21 12:31:46 -0500 | [diff] [blame] | 548 | func startDiscoveryMonitor(client pb.ConfigurationClient, |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 549 | coreGroups [][]*volthaPod) error { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 550 | var ch <-chan *ic.InterContainerMessage |
| 551 | // Connect to kafka for discovery events |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 552 | topic := &kafka.Topic{Name: kafkaTopic} |
| 553 | kc, err := newKafkaClient(kafkaClientType, kafkaHost, kafkaPort, kafkaInstanceID) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 554 | kc.Start() |
| 555 | |
| 556 | if ch, err = kc.Subscribe(topic); err != nil { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 557 | log.Errorf("Could not subscribe to the '%s' channel, discovery disabled", kafkaTopic) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 558 | return err |
| 559 | } |
sslobodr | 38afd0d | 2019-01-21 12:31:46 -0500 | [diff] [blame] | 560 | go monitorDiscovery(client, ch, coreGroups) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 561 | return nil |
| 562 | } |
| 563 | |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 564 | // Determines which items in core groups |
| 565 | // have changed based on the list provided |
| 566 | // and returns a coreGroup with only the changed |
| 567 | // items and a pod list with the new items |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 568 | func getAddrDiffs(coreGroups [][]*volthaPod, rwPods []*volthaPod) ([][]*volthaPod, []*volthaPod) { |
| 569 | var nList []*volthaPod |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 570 | var rtrn = make([][]*volthaPod, numRWPods>>1) |
| 571 | var ipAddrs = make(map[string]struct{}) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 572 | |
| 573 | log.Debug("Get addr diffs") |
| 574 | |
| 575 | // Start with an empty array |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 576 | for k := range rtrn { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 577 | rtrn[k] = make([]*volthaPod, 2) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 578 | } |
| 579 | |
| 580 | // Build a list with only the new items |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 581 | for _, v := range rwPods { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 582 | if !hasIpAddr(coreGroups, v.ipAddr) { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 583 | nList = append(nList, v) |
| 584 | } |
| 585 | ipAddrs[v.ipAddr] = struct{}{} // for the search below |
| 586 | } |
| 587 | |
| 588 | // Now build the coreGroups with only the changed items |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 589 | for k1, v1 := range coreGroups { |
| 590 | for k2, v2 := range v1 { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 591 | if _, ok := ipAddrs[v2.ipAddr]; !ok { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 592 | rtrn[k1][k2] = v2 |
| 593 | } |
| 594 | } |
| 595 | } |
| 596 | return rtrn, nList |
| 597 | } |
| 598 | |
| 599 | // Figure out where best to put the new pods |
| 600 | // in the coreGroup array based on the old |
| 601 | // pods being replaced. The criteria is that |
| 602 | // the new pod be on the same server as the |
| 603 | // old pod was. |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 604 | func reconcileAddrDiffs(coreGroupDiffs [][]*volthaPod, rwPodDiffs []*volthaPod) [][]*volthaPod { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 605 | var srvrs map[string][]*volthaPod = make(map[string][]*volthaPod) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 606 | |
| 607 | log.Debug("Reconciling diffs") |
| 608 | log.Debug("Building server list") |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 609 | for _, v := range rwPodDiffs { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 610 | log.Debugf("Adding %v to the server list", *v) |
| 611 | srvrs[v.node] = append(srvrs[v.node], v) |
| 612 | } |
| 613 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 614 | for k1, v1 := range coreGroupDiffs { |
| 615 | log.Debugf("k1:%v, v1:%v", k1, v1) |
| 616 | for k2, v2 := range v1 { |
| 617 | log.Debugf("k2:%v, v2:%v", k2, v2) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 618 | if v2 == nil { // Nothing to do here |
| 619 | continue |
| 620 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 621 | if _, ok := srvrs[v2.node]; ok { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 622 | coreGroupDiffs[k1][k2] = srvrs[v2.node][0] |
| 623 | if len(srvrs[v2.node]) > 1 { // remove one entry from the list |
| 624 | srvrs[v2.node] = append(srvrs[v2.node][:0], srvrs[v2.node][1:]...) |
| 625 | } else { // Delete the endtry from the map |
| 626 | delete(srvrs, v2.node) |
| 627 | } |
| 628 | } else { |
| 629 | log.Error("This should never happen, node appears to have changed names") |
| 630 | // attempt to limp along by keeping this old entry |
| 631 | } |
| 632 | } |
| 633 | } |
| 634 | |
| 635 | return coreGroupDiffs |
| 636 | } |
| 637 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 638 | func applyAddrDiffs(client pb.ConfigurationClient, coreList interface{}, nPods []*volthaPod) { |
| 639 | var newEntries [][]*volthaPod |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 640 | |
| 641 | log.Debug("Applying diffs") |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 642 | switch cores := coreList.(type) { |
| 643 | case [][]*volthaPod: |
| 644 | newEntries = reconcileAddrDiffs(getAddrDiffs(cores, nPods)) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 645 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 646 | // Now replace the information in coreGropus with the new |
| 647 | // entries and then reconcile the device ids on the core |
| 648 | // that's in the new entry with the device ids of it's |
| 649 | // active-active peer. |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 650 | for k1, v1 := range cores { |
| 651 | for k2, v2 := range v1 { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 652 | if newEntries[k1][k2] != nil { |
| 653 | // TODO: Missing is the case where bothe the primary |
| 654 | // and the secondary core crash and come back. |
| 655 | // Pull the device ids from the active-active peer |
| 656 | ids := queryPodDeviceIds(cores[k1][k2^1]) |
| 657 | if len(ids) != 0 { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 658 | if !reconcilePodDeviceIds(newEntries[k1][k2], ids) { |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 659 | log.Errorf("Attempt to reconcile ids on pod %v failed", newEntries[k1][k2]) |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 660 | } |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 661 | } |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 662 | // Send the affininty router new connection information |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 663 | setConnection(client, afrouterRWClusterName, v2.backend, v2.connection, newEntries[k1][k2].ipAddr, podGrpcPort) |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 664 | // Copy the new entry information over |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 665 | cores[k1][k2].ipAddr = newEntries[k1][k2].ipAddr |
| 666 | cores[k1][k2].name = newEntries[k1][k2].name |
| 667 | cores[k1][k2].devIds = ids |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 668 | } |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 669 | } |
| 670 | } |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 671 | case []*volthaPod: |
| 672 | var mia []*volthaPod |
| 673 | var found bool |
| 674 | // TODO: Break this using functions to simplify |
| 675 | // reading of the code. |
| 676 | // Find the core(s) that have changed addresses |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 677 | for k1, v1 := range cores { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 678 | found = false |
| 679 | for _, v2 := range nPods { |
| 680 | if v1.ipAddr == v2.ipAddr { |
| 681 | found = true |
| 682 | break |
| 683 | } |
| 684 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 685 | if !found { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 686 | mia = append(mia, cores[k1]) |
| 687 | } |
| 688 | } |
| 689 | // Now plug in the new addresses and set the connection |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 690 | for _, v1 := range nPods { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 691 | found = false |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 692 | for _, v2 := range cores { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 693 | if v1.ipAddr == v2.ipAddr { |
| 694 | found = true |
| 695 | break |
| 696 | } |
| 697 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 698 | if found { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 699 | continue |
| 700 | } |
| 701 | mia[0].ipAddr = v1.ipAddr |
| 702 | mia[0].name = v1.name |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 703 | setConnection(client, afrouterROClusterName, mia[0].backend, mia[0].connection, v1.ipAddr, podGrpcPort) |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 704 | // Now get rid of the mia entry just processed |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 705 | mia = append(mia[:0], mia[1:]...) |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 706 | } |
| 707 | default: |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 708 | log.Error("Internal: Unexpected type in call to applyAddrDiffs") |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 709 | } |
| 710 | } |
| 711 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 712 | func updateDeviceIds(coreGroups [][]*volthaPod, rwPods []*volthaPod) { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 713 | var byName = make(map[string]*volthaPod) |
sslobodr | cd37bc5 | 2019-01-24 11:47:16 -0500 | [diff] [blame] | 714 | |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 715 | // Convenience |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 716 | for _, v := range rwPods { |
sslobodr | cd37bc5 | 2019-01-24 11:47:16 -0500 | [diff] [blame] | 717 | byName[v.name] = v |
| 718 | } |
| 719 | |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 720 | for k1, v1 := range coreGroups { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 721 | for k2 := range v1 { |
sslobodr | cd37bc5 | 2019-01-24 11:47:16 -0500 | [diff] [blame] | 722 | coreGroups[k1][k2].devIds = byName[v1[k2].name].devIds |
| 723 | } |
| 724 | } |
| 725 | } |
| 726 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 727 | func startCoreMonitor(client pb.ConfigurationClient, |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 728 | clientset *kubernetes.Clientset, |
| 729 | rwCoreFltr *regexp.Regexp, |
| 730 | roCoreFltr *regexp.Regexp, |
| 731 | coreGroups [][]*volthaPod, |
| 732 | oRoPods []*volthaPod) error { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 733 | // Now that initial allocation has been completed, monitor the pods |
| 734 | // for IP changes |
| 735 | // The main loop needs to do the following: |
| 736 | // 1) Periodically query the pods and filter out |
| 737 | // the vcore ones |
| 738 | // 2) Validate that the pods running are the same |
| 739 | // as the previous check |
| 740 | // 3) Validate that the IP addresses are the same |
| 741 | // as the last check. |
| 742 | // If the pod name(s) ha(s/ve) changed then remove |
| 743 | // the unused pod names and add in the new pod names |
| 744 | // maintaining the cluster/backend information. |
| 745 | // If an IP address has changed (which shouldn't |
| 746 | // happen unless a pod is re-started) it should get |
| 747 | // caught by the pod name change. |
| 748 | for { |
| 749 | time.Sleep(10 * time.Second) // Wait a while |
| 750 | // Get the rw core list from k8s |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 751 | rwPods := getVolthaPods(clientset, rwCoreFltr) |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 752 | queryDeviceIds(rwPods) |
sslobodr | cd37bc5 | 2019-01-24 11:47:16 -0500 | [diff] [blame] | 753 | updateDeviceIds(coreGroups, rwPods) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 754 | // If we didn't get 2n+1 pods then wait since |
| 755 | // something is down and will hopefully come |
| 756 | // back up at some point. |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 757 | if len(rwPods) != numRWPods { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 758 | continue |
| 759 | } |
| 760 | // We have all pods, check if any IP addresses |
| 761 | // have changed. |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 762 | for _, v := range rwPods { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 763 | if !hasIpAddr(coreGroups, v.ipAddr) { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 764 | log.Debug("Address has changed...") |
| 765 | applyAddrDiffs(client, coreGroups, rwPods) |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 766 | break |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 767 | } |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 768 | } |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 769 | |
| 770 | roPods := getVolthaPods(clientset, roCoreFltr) |
| 771 | |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 772 | if len(roPods) != numROPods { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 773 | continue |
| 774 | } |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 775 | for _, v := range roPods { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 776 | if !hasIpAddr(oRoPods, v.ipAddr) { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 777 | applyAddrDiffs(client, oRoPods, roPods) |
| 778 | break |
| 779 | } |
| 780 | } |
| 781 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 782 | } |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 783 | } |
| 784 | |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 785 | func hasIpAddr(coreList interface{}, ipAddr string) bool { |
| 786 | switch cores := coreList.(type) { |
| 787 | case []*volthaPod: |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 788 | for _, v := range cores { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 789 | if v.ipAddr == ipAddr { |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 790 | return true |
| 791 | } |
| 792 | } |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 793 | case [][]*volthaPod: |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 794 | for _, v1 := range cores { |
| 795 | for _, v2 := range v1 { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 796 | if v2.ipAddr == ipAddr { |
| 797 | return true |
| 798 | } |
| 799 | } |
| 800 | } |
| 801 | default: |
| 802 | log.Error("Internal: Unexpected type in call to hasIpAddr") |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 803 | } |
| 804 | return false |
| 805 | } |
| 806 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 807 | func main() { |
| 808 | // This is currently hard coded to a cluster with 3 servers |
| 809 | //var connections map[string]configConn = make(map[string]configConn) |
| 810 | //var rwCorePodsPrev map[string]rwPod = make(map[string]rwPod) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 811 | var err error |
| 812 | var conn *grpc.ClientConn |
| 813 | |
David K. Bainbridge | f430cd5 | 2019-05-28 15:00:35 -0700 | [diff] [blame] | 814 | config := &Configuration{} |
| 815 | cmdParse := flag.NewFlagSet(path.Base(os.Args[0]), flag.ContinueOnError) |
| 816 | config.DisplayVersionOnly = cmdParse.Bool("version", false, "Print version information and exit") |
| 817 | |
| 818 | err = cmdParse.Parse(os.Args[1:]) |
| 819 | if err != nil { |
| 820 | fmt.Printf("Error: %v\n", err) |
| 821 | os.Exit(1) |
| 822 | } |
| 823 | |
| 824 | if *config.DisplayVersionOnly { |
| 825 | fmt.Println("VOLTHA API Server (afrouterd)") |
| 826 | fmt.Println(version.VersionInfo.String(" ")) |
| 827 | return |
| 828 | } |
| 829 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 830 | // Set up the regular expression to identify the voltha cores |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 831 | rwCoreFltr := regexp.MustCompile(`rw-core[0-9]-`) |
| 832 | roCoreFltr := regexp.MustCompile(`ro-core-`) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 833 | |
| 834 | // Set up logging |
| 835 | if _, err := log.SetDefaultLogger(log.JSON, 0, nil); err != nil { |
| 836 | log.With(log.Fields{"error": err}).Fatal("Cannot setup logging") |
| 837 | } |
| 838 | |
| 839 | // Set up kubernetes api |
| 840 | clientset := k8sClientSet() |
| 841 | |
| 842 | // Connect to the affinity router and set up the client |
| 843 | conn, err = connect("localhost:55554") // This is a sidecar container so communicating over localhost |
| 844 | if err != nil { |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 845 | panic(err) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 846 | } |
Kent Hagerman | e566c2e | 2019-06-03 17:56:42 -0400 | [diff] [blame^] | 847 | defer conn.Close() |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 848 | client := pb.NewConfigurationClient(conn) |
| 849 | |
| 850 | // Get the voltha rw-core podes |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 851 | rwPods := getVolthaPods(clientset, rwCoreFltr) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 852 | |
| 853 | // Fetch the devices held by each running core |
sslobodr | e7ce71d | 2019-01-22 16:21:45 -0500 | [diff] [blame] | 854 | queryDeviceIds(rwPods) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 855 | |
| 856 | // For debugging... comment out l8r |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 857 | for _, v := range rwPods { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 858 | log.Debugf("Pod list %v", *v) |
| 859 | } |
| 860 | |
| 861 | coreGroups := groupPods1(rwPods) |
| 862 | |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 863 | // Assign the groupings to the the backends and connections |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 864 | for k := range coreGroups { |
| 865 | for k1 := range coreGroups[k] { |
| 866 | coreGroups[k][k1].cluster = afrouterRWClusterName |
| 867 | coreGroups[k][k1].backend = afrouterRWClusterName + strconv.Itoa(k+1) |
| 868 | coreGroups[k][k1].connection = afrouterRWClusterName + strconv.Itoa(k+1) + strconv.Itoa(k1+1) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 869 | } |
| 870 | } |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 871 | log.Info("Core grouping completed") |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 872 | |
| 873 | // TODO: Debugging code, comment out for production |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 874 | for k, v := range coreGroups { |
| 875 | for k2, v2 := range v { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 876 | log.Debugf("Core group %d,%d: %v", k, k2, v2) |
| 877 | } |
| 878 | } |
sslobodr | cd37bc5 | 2019-01-24 11:47:16 -0500 | [diff] [blame] | 879 | log.Info("Setting affinities") |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 880 | // Now set the affinities for exising devices in the cores |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 881 | for _, v := range coreGroups { |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 882 | setAffinity(client, v[0].devIds, v[0].backend) |
| 883 | setAffinity(client, v[1].devIds, v[1].backend) |
| 884 | } |
sslobodr | cd37bc5 | 2019-01-24 11:47:16 -0500 | [diff] [blame] | 885 | log.Info("Setting connections") |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 886 | // Configure the backeds based on the calculated core groups |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 887 | for _, v := range coreGroups { |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 888 | setConnection(client, afrouterRWClusterName, v[0].backend, v[0].connection, v[0].ipAddr, podGrpcPort) |
| 889 | setConnection(client, afrouterRWClusterName, v[1].backend, v[1].connection, v[1].ipAddr, podGrpcPort) |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 890 | } |
| 891 | |
| 892 | // Process the read only pods |
| 893 | roPods := getVolthaPods(clientset, roCoreFltr) |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 894 | for k, v := range roPods { |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 895 | log.Debugf("Processing ro_pod %v", v) |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 896 | vN := afrouterROClusterName + strconv.Itoa(k+1) |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 897 | log.Debugf("Setting connection %s, %s, %s", vN, vN+"1", v.ipAddr) |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 898 | roPods[k].cluster = afrouterROClusterName |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 899 | roPods[k].backend = vN |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 900 | roPods[k].connection = vN + "1" |
Kent Hagerman | 334a8ce | 2019-05-16 16:50:33 -0400 | [diff] [blame] | 901 | setConnection(client, afrouterROClusterName, v.backend, v.connection, v.ipAddr, podGrpcPort) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 902 | } |
| 903 | |
sslobodr | cd37bc5 | 2019-01-24 11:47:16 -0500 | [diff] [blame] | 904 | log.Info("Starting discovery monitoring") |
sslobodr | 38afd0d | 2019-01-21 12:31:46 -0500 | [diff] [blame] | 905 | startDiscoveryMonitor(client, coreGroups) |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 906 | |
sslobodr | cd37bc5 | 2019-01-24 11:47:16 -0500 | [diff] [blame] | 907 | log.Info("Starting core monitoring") |
sslobodr | 8e2ccb5 | 2019-02-05 09:21:47 -0500 | [diff] [blame] | 908 | startCoreMonitor(client, clientset, rwCoreFltr, |
Kent Hagerman | 0ab4cb2 | 2019-04-24 13:13:35 -0400 | [diff] [blame] | 909 | roCoreFltr, coreGroups, roPods) // Never returns |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 910 | return |
sslobodr | 16e41bc | 2019-01-18 16:22:21 -0500 | [diff] [blame] | 911 | } |