func main()

in traffic_ops/app/db/traffic_vault_migrate/traffic_vault_migrate.go [114:299]
160 lines of code
40 McCabe index (conditional complexity)

func main() {
	getopt.ParseV2()

	initConfig()

	var fromSrv TVBackend
	var toSrv TVBackend

	importData := keyFile != ""
	toSrvUsed := !dump && !dry || keyFile != ""

	if !importData {
		log.Infof("Initiating fromSrv %s...\n", fromType)
		if !validateType(fromType) {
			log.Errorln("Unknown fromType " + fromType)
			os.Exit(1)
		}
		fromSrv = getBackendFromType(fromType)
		if err := fromSrv.ReadConfigFile(fromCfgPath); err != nil {
			log.Errorf("Unable to read fromSrv cfg: %v", err)
			os.Exit(1)
		}

		if err := fromSrv.Start(); err != nil {
			log.Errorf("issue starting fromSrv: %v", err)
			os.Exit(1)
		}
		defer log.Close(fromSrv, "closing fromSrv")

		if err := fromSrv.Ping(); err != nil {
			log.Errorf("Unable to ping fromSrv: %v", err)
			os.Exit(1)
		}
	}

	if toSrvUsed {
		log.Infof("Initiating toSrv %s...\n", toType)
		if !validateType(toType) {
			log.Errorln("Unknown toType " + toType)
			os.Exit(1)
		}
		toSrv = getBackendFromType(toType)

		if err := toSrv.ReadConfigFile(toCfgPath); err != nil {
			log.Errorf("Unable to read toSrv cfg: %v", err)
			os.Exit(1)
		}

		if err := toSrv.Start(); err != nil {
			log.Errorf("issue starting toSrv: %v", err)
			os.Exit(1)
		}
		defer log.Close(toSrv, "closing toSrv")

		if err := toSrv.Ping(); err != nil {
			log.Errorf("Unable to ping toSrv: %v", err)
			os.Exit(1)
		}
	}

	var fromSecret Secrets
	if !importData {
		var err error
		log.Infof("Fetching data from %s...\n", fromSrv.Name())
		if err = fromSrv.Fetch(); err != nil {
			log.Errorf("Unable to fetch fromSrv data: %v", err)
			os.Exit(1)
		}

		if fromSecret, err = GetKeys(fromSrv); err != nil {
			log.Errorln(err)
			os.Exit(1)
		}

		if err := Validate(fromSrv); err != nil {
			log.Errorln(err)
			os.Exit(1)
		}

	} else {
		err := fromSecret.fill(keyFile)
		if err != nil {
			log.Errorln("error reading " + keyFile + ": " + err.Error())
			os.Exit(1)
		}
	}

	if dump {
		log.Infof("Dumping data from %s...\n", fromSrv.Name())
		fromSecret.dump("dump")
		return
	}

	if compare {
		log.Infof("Fetching data from %s...\n", toSrv.Name())
		if err := toSrv.Fetch(); err != nil {
			log.Errorf("Unable to fetch toSrv data: %v\n", err)
			os.Exit(1)
		}

		toSecret, err := GetKeys(toSrv)
		if err != nil {
			log.Errorln(err)
			os.Exit(1)
		}
		log.Infoln("Validating " + toSrv.Name())
		if err := toSrv.ValidateKey(); err != nil && len(err) > 0 {
			log.Errorln(strings.Join(err, "\n"))
			os.Exit(1)
		}

		fromSecret.sort()
		toSecret.sort()

		if !importData {
			log.Infoln(fromSrv.String())
		} else {
			log.Infof("Disk backup:\n\tSSL Keys: %d\n\tDNSSec Keys: %d\n\tURI Keys: %d\n\tURL Keys: %d\n", len(fromSecret.sslkeys), len(fromSecret.dnssecKeys), len(fromSecret.uriKeys), len(fromSecret.urlKeys))
		}
		log.Infoln(toSrv.String())

		if !reflect.DeepEqual(fromSecret.sslkeys, toSecret.sslkeys) {
			log.Errorln("from sslkeys and to sslkeys don't match")
			os.Exit(1)
		}
		if !reflect.DeepEqual(fromSecret.dnssecKeys, toSecret.dnssecKeys) {
			log.Errorln("from dnssec and to dnssec don't match")
			os.Exit(1)
		}
		if !reflect.DeepEqual(fromSecret.uriKeys, toSecret.uriKeys) {
			log.Errorln("from uri and to uri don't match")
			os.Exit(1)
		}
		if !reflect.DeepEqual(fromSecret.urlKeys, toSecret.urlKeys) {
			log.Errorln("from url and to url don't match")
			os.Exit(1)
		}
		log.Infoln("Both data sources have the same keys")
		return
	}

	if toSrvUsed {
		log.Infof("Setting %s keys...\n", toSrv.Name())
		if err := SetKeys(toSrv, fromSecret); err != nil {
			log.Errorln(err)
			os.Exit(1)
		}

		if err := Validate(toSrv); err != nil {
			log.Errorln(err)
			os.Exit(1)
		}
	}

	if !importData {
		log.Infoln(fromSrv.String())
	} else {
		log.Infof("Disk backup:\n\tSSL Keys: %d\n\tDNSSec Keys: %d\n\tURI Keys: %d\n\tURL Keys: %d\n", len(fromSecret.sslkeys), len(fromSecret.dnssecKeys), len(fromSecret.uriKeys), len(fromSecret.urlKeys))
	}

	if dry {
		return
	}

	if !noConfirm {
		ans := "q"
		for {
			fmt.Print("Confirm data insertion (y/n): ")
			if _, err := fmt.Scanln(&ans); err != nil {
				log.Errorln("unable to get user input")
				os.Exit(1)
			}

			if ans == "y" {
				break
			} else if ans == "n" {
				return
			}
		}
	}
	log.Infof("Inserting data into %s...\n", toSrv.Name())
	if err := toSrv.Insert(); err != nil {
		log.Errorln(err)
		os.Exit(1)
	}
}