func()

in controllers/autoneg.go [197:296]

• 84 lines of code
• 25 McCabe index (conditional complexity)

func (b *ProdBackendController) ReconcileBackends(actual, intended AutonegStatus) (err error) {
	removes, upserts := ReconcileStatus(b.project, actual, intended)

	var forceCapacity map[int]bool = make(map[int]bool, 0)
	for port, _removes := range removes {
		for idx, remove := range _removes {
			var oldSvc *compute.BackendService
			oldSvc, err = b.getBackendService(remove.name, remove.region)
			var svcUpdated = false
			var e *errNotFound
			if errors.As(err, &e) {
				// If the backend service is gone, we construct a BackendService with the same name
				// and an empty list of backends.
				err = nil
				oldSvc = &compute.BackendService{
					Name:     remove.name,
					Backends: make([]*compute.Backend, 0),
				}
			} else if err != nil {
				return
			}

			var newSvc *compute.BackendService
			upsert := upserts[port][idx]

			if upsert.name != remove.name {
				if newSvc, err = b.getBackendService(upsert.name, upsert.region); err != nil {
					return
				}
			} else {
				newSvc = oldSvc
			}

			// Remove backends in the list to be deleted
			for _, d := range remove.backends {
				for i, be := range oldSvc.Backends {
					if d.Group == be.Group {
						svcUpdated = true
						copy(oldSvc.Backends[i:], oldSvc.Backends[i+1:])
						oldSvc.Backends = oldSvc.Backends[:len(oldSvc.Backends)-1]
						break
					}
				}
			}

			// If we are changing backend services, save the old service
			if upsert.name != remove.name && svcUpdated {
				if err = b.updateBackends(remove.name, remove.region, oldSvc, forceCapacity); err != nil {
					return
				}
			}

			// Add or update any new backends to the list
			for _, u := range upsert.backends {
				copy := true
				for beidx, be := range newSvc.Backends {
					if u.Group == be.Group {
						// TODO: copy fields explicitly
						be.MaxRatePerEndpoint = u.MaxRatePerEndpoint
						be.MaxConnectionsPerEndpoint = u.MaxConnectionsPerEndpoint
						if intended.AutonegSyncConfig != nil {
							var syncConfig AutonegSyncConfig = *intended.AutonegSyncConfig
							if syncConfig.CapacityScaler != nil && *syncConfig.CapacityScaler == true {
								be.CapacityScaler = u.CapacityScaler
								forceCapacity[beidx] = true
							}
						} else {
							// Force CapacityScaler to an "empty value"
							u.CapacityScaler = 0
							// Check if existing capacity scaler is zero
							if be.CapacityScaler == 0 {
								forceCapacity[beidx] = true
							}
						}
						copy = false
						break
					}
				}
				if copy {
					// It's a new backend to be added
					newBackend := u
					if _, ok := intended.AutonegConfig.BackendServices[port][idx]; ok {
						if intended.AutonegConfig.BackendServices[port][idx].InitialCapacity != nil {
							forceCapacity[len(newSvc.Backends)] = true
						}
					}
					newSvc.Backends = append(newSvc.Backends, &newBackend)
				}
			}
			if len(upsert.backends) > 0 {
				err = b.updateBackends(upsert.name, upsert.region, newSvc, forceCapacity)
			}
			if err != nil {
				return err
			}
		}
	}

	return nil
}