func()

in tools/cli/domain_migration_command.go [323:482]
130 lines of code
22 McCabe index (conditional complexity)

func (d *domainMigrationCLIImpl) DynamicConfigCheck(c *cli.Context) DomainMigrationRow {
	var mismatchedConfigs []MismatchedDynamicConfig
	check := true

	resp := dynamicconfig.ListAllProductionKeys()

	currDomain := c.GlobalString(FlagDomain)
	newDomain := c.String(FlagDestinationDomain)

	ctx, cancel := newContext(c)
	defer cancel()

	currentDomainID := getDomainID(ctx, currDomain, d.frontendClient)
	destinationDomainID := getDomainID(ctx, newDomain, d.destinationClient)
	if currentDomainID == "" {
		ErrorAndExit("Failed to get domainID for the current domain.", nil)
	}

	if destinationDomainID == "" {
		ErrorAndExit("Failed to get domainID for the destination domain.", nil)
	}

	for _, configKey := range resp {
		if len(configKey.Filters()) == 1 && configKey.Filters()[0] == dc.DomainName {
			// Validate dynamic configs with only domainName filter
			currRequest := dynamicconfig.ToGetDynamicConfigFilterRequest(configKey.String(), []dynamicconfig.FilterOption{
				dynamicconfig.DomainFilter(currDomain),
			})

			newRequest := dynamicconfig.ToGetDynamicConfigFilterRequest(configKey.String(), []dynamicconfig.FilterOption{
				dynamicconfig.DomainFilter(newDomain),
			})

			currResp, err := d.frontendAdminClient.GetDynamicConfig(ctx, currRequest)
			if err != nil {
				// empty to indicate N/A
				currResp = emptyGetDynamicConfigRequest
			}
			newResp, err := d.destinationAdminClient.GetDynamicConfig(ctx, newRequest)
			if err != nil {
				// empty to indicate N/A
				newResp = emptyGetDynamicConfigRequest
			}

			if !reflect.DeepEqual(currResp.Value, newResp.Value) {
				check = false
				mismatchedConfigs = append(mismatchedConfigs, MismatchedDynamicConfig{
					Key: configKey,
					CurrValues: []*types.DynamicConfigValue{
						toDynamicConfigValue(currResp.Value, map[dc.Filter]interface{}{
							dynamicconfig.DomainName: currDomain,
						}),
					},
					NewValues: []*types.DynamicConfigValue{
						toDynamicConfigValue(newResp.Value, map[dc.Filter]interface{}{
							dynamicconfig.DomainName: newDomain,
						}),
					},
				})
			}

		} else if len(configKey.Filters()) == 1 && configKey.Filters()[0] == dc.DomainID {
			// Validate dynamic configs with only domainID filter
			currRequest := dynamicconfig.ToGetDynamicConfigFilterRequest(configKey.String(), []dynamicconfig.FilterOption{
				dynamicconfig.DomainIDFilter(currentDomainID),
			})

			newRequest := dynamicconfig.ToGetDynamicConfigFilterRequest(configKey.String(), []dynamicconfig.FilterOption{
				dynamicconfig.DomainIDFilter(destinationDomainID),
			})

			currResp, err := d.frontendAdminClient.GetDynamicConfig(ctx, currRequest)
			if err != nil {
				// empty to indicate N/A
				currResp = emptyGetDynamicConfigRequest
			}
			newResp, err := d.destinationAdminClient.GetDynamicConfig(ctx, newRequest)
			if err != nil {
				// empty to indicate N/A
				newResp = emptyGetDynamicConfigRequest
			}

			if !reflect.DeepEqual(currResp.Value, newResp.Value) {
				check = false
				mismatchedConfigs = append(mismatchedConfigs, MismatchedDynamicConfig{
					Key: configKey,
					CurrValues: []*types.DynamicConfigValue{
						toDynamicConfigValue(currResp.Value, map[dc.Filter]interface{}{
							dynamicconfig.DomainID: currentDomainID,
						}),
					},
					NewValues: []*types.DynamicConfigValue{
						toDynamicConfigValue(newResp.Value, map[dc.Filter]interface{}{
							dynamicconfig.DomainID: destinationDomainID,
						}),
					},
				})
			}

		} else if containsFilter(configKey, dc.DomainName.String()) && containsFilter(configKey, dc.TaskListName.String()) {
			// Validate dynamic configs with only domainName and TaskList filters
			taskLists := c.StringSlice(FlagTaskList)
			var mismatchedCurValues []*types.DynamicConfigValue
			var mismatchedNewValues []*types.DynamicConfigValue
			for _, taskList := range taskLists {

				currRequest := dynamicconfig.ToGetDynamicConfigFilterRequest(configKey.String(), []dynamicconfig.FilterOption{
					dynamicconfig.DomainFilter(currDomain),
					dynamicconfig.TaskListFilter(taskList),
				})

				newRequest := dynamicconfig.ToGetDynamicConfigFilterRequest(configKey.String(), []dynamicconfig.FilterOption{
					dynamicconfig.DomainFilter(newDomain),
					dynamicconfig.TaskListFilter(taskList),
				})

				currResp, err := d.frontendAdminClient.GetDynamicConfig(ctx, currRequest)
				if err != nil {
					// empty to indicate N/A
					currResp = emptyGetDynamicConfigRequest
				}
				newResp, err := d.destinationAdminClient.GetDynamicConfig(ctx, newRequest)
				if err != nil {
					// empty to indicate N/A
					newResp = emptyGetDynamicConfigRequest
				}

				if !reflect.DeepEqual(currResp.Value, newResp.Value) {
					check = false
					mismatchedCurValues = append(mismatchedCurValues, toDynamicConfigValue(currResp.Value, map[dc.Filter]interface{}{
						dynamicconfig.DomainName:   currDomain,
						dynamicconfig.TaskListName: taskLists,
					}))
					mismatchedNewValues = append(mismatchedNewValues, toDynamicConfigValue(newResp.Value, map[dc.Filter]interface{}{
						dynamicconfig.DomainName:   newDomain,
						dynamicconfig.TaskListName: taskLists,
					}))

				}
			}
			if len(mismatchedCurValues) > 0 && len(mismatchedNewValues) > 0 {
				mismatchedConfigs = append(mismatchedConfigs, MismatchedDynamicConfig{
					Key:        configKey,
					CurrValues: mismatchedCurValues,
					NewValues:  mismatchedNewValues,
				})
			}
		}
	}

	validationRow := DomainMigrationRow{
		ValidationCheck:  "Dynamic Config Check",
		ValidationResult: check,
		ValidationDetails: ValidationDetails{
			MismatchedDynamicConfig: mismatchedConfigs,
		},
	}

	return validationRow
}