func()

in cmd/schema.go [88:192]

• 93 lines of code
• 16 McCabe index (conditional complexity)

func (cmd *SchemaCmd) Execute(ctx context.Context, f *flag.FlagSet, _ ...interface{}) subcommands.ExitStatus {
	// Cleanup smt tmp data directory in case residuals remain from prev runs.
	os.RemoveAll(filepath.Join(os.TempDir(), constants.SMT_TMP_DIR))
	var err error
	defer func() {
		if err != nil {
			logger.Log.Fatal("FATAL error", zap.Error(err))
		}
	}()
	err = logger.InitializeLogger(cmd.logLevel)
	if err != nil {
		fmt.Println("Error initialising logger, did you specify a valid log-level? [DEBUG, INFO, WARN, ERROR, FATAL]", err)
		return subcommands.ExitFailure
	}
	defer logger.Log.Sync()
	// validate and parse source-profile, target-profile and source
	sourceProfile, targetProfile, ioHelper, dbName, err := PrepareMigrationPrerequisites(cmd.sourceProfile, cmd.targetProfile, cmd.source)
	if err != nil {
		err = fmt.Errorf("error while preparing prerequisites for migration: %v", err)
		return subcommands.ExitUsageError
	}
	if cmd.project == "" {
		getInfo := &utils.GetUtilInfoImpl{}
		cmd.project, err = getInfo.GetProject()
		if err != nil {
			logger.Log.Error("Could not get project id from gcloud environment or --project flag. Either pass the projectId in the --project flag or configure in gcloud CLI using gcloud config set", zap.Error(err))
			return subcommands.ExitUsageError
		}
	}

	if cmd.validate {
		return subcommands.ExitSuccess
	}

	// If filePrefix not explicitly set, use generated dbName.
	if cmd.filePrefix == "" {
		cmd.filePrefix = dbName
	}

	schemaConversionStartTime := time.Now()
	var conv *internal.Conv
	convImpl := &conversion.ConvImpl{}
	if cmd.sessionJSON != "" {
		logger.Log.Info("Loading the conversion context from session file."+
			" The source profile will not be used for the schema conversion.", zap.String("sessionFile", cmd.sessionJSON))
		conv = internal.MakeConv()
		err = conversion.ReadSessionFile(conv, cmd.sessionJSON)
		if err != nil {
			return subcommands.ExitFailure
		}
		expressionVerificationAccessor, _ := expressions_api.NewExpressionVerificationAccessorImpl(context.Background(), targetProfile.Conn.Sp.Project, targetProfile.Conn.Sp.Instance)
		schemaToSpanner := common.SchemaToSpannerImpl{
			ExpressionVerificationAccessor: expressionVerificationAccessor,
		}
		err := schemaToSpanner.VerifyExpressions(conv)

		if err != nil {
			logger.Log.Error(fmt.Sprintf("Error while verifying the expressions %v", err))
			return subcommands.ExitFailure
		}
	} else {
		ctx := context.Background()
		ddlVerifier, err := expressions_api.NewDDLVerifierImpl(ctx, "", "")
		if err != nil {
			logger.Log.Error(fmt.Sprintf("error trying create ddl verifier: %v", err))
			return subcommands.ExitFailure
		}
		sfs := &conversion.SchemaFromSourceImpl{
			DdlVerifier: ddlVerifier,
		}
		conv, err = convImpl.SchemaConv(cmd.project, sourceProfile, targetProfile, &ioHelper, sfs)
		if err != nil {
			return subcommands.ExitFailure
		}
	}
	if conv == nil {
		logger.Log.Error("Could not initialize conversion context from")
		return subcommands.ExitFailure
	}
	conversion.WriteSchemaFile(conv, schemaConversionStartTime, cmd.filePrefix+schemaFile, ioHelper.Out, sourceProfile.Driver)
	// We always write the session file to accommodate for a re-run that might change anything.
	conversion.WriteSessionFile(conv, cmd.filePrefix+sessionFile, ioHelper.Out)

	// Populate migration request id and migration type in conv object.
	conv.Audit.MigrationRequestId, _ = utils.GenerateName("smt-job")
	conv.Audit.MigrationRequestId = strings.Replace(conv.Audit.MigrationRequestId, "_", "-", -1)
	conv.Audit.MigrationType = migration.MigrationData_SCHEMA_ONLY.Enum()
	conv.Audit.SkipMetricsPopulation = os.Getenv("SKIP_METRICS_POPULATION") == "true"
	if !cmd.dryRun {
		_, err = MigrateDatabase(ctx, cmd.project, targetProfile, sourceProfile, dbName, &ioHelper, cmd, conv, nil)
		if err != nil {
			err = fmt.Errorf("can't finish database migration for db %s: %v", dbName, err)
			return subcommands.ExitFailure
		}
	}

	schemaCoversionEndTime := time.Now()
	conv.Audit.SchemaConversionDuration = schemaCoversionEndTime.Sub(schemaConversionStartTime)
	banner := utils.GetBanner(schemaConversionStartTime, dbName)
	reportImpl := conversion.ReportImpl{}
	reportImpl.GenerateReport(sourceProfile.Driver, nil, ioHelper.BytesRead, banner, conv, cmd.filePrefix, dbName, ioHelper.Out)
	// Cleanup smt tmp data directory.
	os.RemoveAll(filepath.Join(os.TempDir(), constants.SMT_TMP_DIR))
	return subcommands.ExitSuccess
}