command/meta: Skip the GetProviderSchema cache on upgrade

Author: SarahFrench

internal/command/meta_backend.go

@@ -69,6 +69,8 @@ type BackendOpts struct {
 	// during upgrade-triggered migrations.
 	PreviousLocks *depsfile.Locks
 
+	SkipGetProviderSchemaCache bool
+
 	// ConfigOverride is an hcl.Body that, if non-nil, will be used with
 	// configs.MergeBodies to override the type-specific backend configuration
 	// arguments in Config.
@@ -374,7 +376,7 @@ func (m *Meta) BackendForLocalPlan(plan *plans.Plan) (backendrun.OperationsBacke
 			return nil, diags
 		}
 
-		factories, err := m.ProviderFactoriesFromLocks(locks)
+		factories, err := m.ProviderFactoriesFromLocks(locks, false)
 		if err != nil {
 			// This may happen if the provider isn't present in the provider cache.
 			// This should be caught earlier by logic that diffs the config against the backend state file.
@@ -1224,7 +1226,7 @@ func (m *Meta) backendFromConfig(opts *BackendOpts) (backend.Backend, tfdiags.Di
 		// AND we're not providing any overrides. An override can mean a change overriding an unchanged backend block (indicated by the hash value).
 		if (uint64(cHash) == s.StateStore.Hash) && (!opts.Init || opts.ConfigOverride == nil) {
 			log.Printf("[TRACE] Meta.Backend: using already-initialized, unchanged %q state_store configuration", stateStoreConfig.Type)
-			savedStateStore, sssDiags := m.savedStateStore(sMgr, opts.Locks)
+			savedStateStore, sssDiags := m.savedStateStore(sMgr, opts.Locks, false)
 			diags = diags.Append(sssDiags)
 			// Verify that selected workspace exist. Otherwise prompt user to create one
 			if opts.Init && savedStateStore != nil {
@@ -1242,7 +1244,7 @@ func (m *Meta) backendFromConfig(opts *BackendOpts) (backend.Backend, tfdiags.Di
 		// don't need to migrate, we update the state store cache hash value.
 		if !m.stateStoreConfigNeedsMigration(stateStoreConfig, s.StateStore, opts) {
 			log.Printf("[TRACE] Meta.Backend: using already-initialized %q state store configuration", stateStoreConfig.Type)
-			savedStateStore, moreDiags := m.savedStateStore(sMgr, opts.Locks)
+			savedStateStore, moreDiags := m.savedStateStore(sMgr, opts.Locks, false)
 			diags = diags.Append(moreDiags)
 			if moreDiags.HasErrors() {
 				return nil, diags
@@ -1309,6 +1311,20 @@ func (m *Meta) backendFromConfig(opts *BackendOpts) (backend.Backend, tfdiags.Di
 			return nil, diags
 		}
 
+		pLock := opts.Locks.Provider(stateStoreConfig.ProviderAddr)
+		lockVersion, err := providerreqs.GoVersionFromVersion(pLock.Version())
+		if err != nil {
+			diags = diags.Append(tfdiags.Sourceless(
+				tfdiags.Warning,
+				"Unable to determine version of the state store provider",
+				fmt.Sprintf("Failed to parse version of %s from the lock file: %s", stateStoreConfig.ProviderAddr.ForDisplay(), err),
+			))
+			return nil, diags
+		}
+		if !lockVersion.Equal(s.StateStore.Provider.Version) {
+			opts.SkipGetProviderSchemaCache = true
+		}
+
 		return m.stateStore_changed(stateStoreConfig, cHash, sMgr, opts, initReason)
 
 	default:
@@ -1497,7 +1513,7 @@ func (m *Meta) backendFromState(_ context.Context, locks *depsfile.Locks) (backe
 		// state_store
 		log.Printf("[TRACE] Meta.Backend: working directory was previously initialized for %q state store", s.StateStore.Type)
 		var ssDiags tfdiags.Diagnostics
-		b, ssDiags = m.savedStateStore(sMgr, locks) // Relies on the state manager's internal state being refreshed above.
+		b, ssDiags = m.savedStateStore(sMgr, locks, false) // Relies on the state manager's internal state being refreshed above.
 		diags = diags.Append(ssDiags)
 		if ssDiags.HasErrors() {
 			return nil, diags
@@ -2545,7 +2561,7 @@ func (m *Meta) stateStore_to_backend(ssSMgr *clistate.LocalState, dstBackendType
 	view.Output(views.StateMigrateLocalMessage, stateStoreType)
 
 	// Initialize the configured state store
-	ss, moreDiags := m.savedStateStore(ssSMgr, opts.Locks)
+	ss, moreDiags := m.savedStateStore(ssSMgr, opts.Locks, false)
 	diags = diags.Append(moreDiags)
 	if moreDiags.HasErrors() {
 		return nil, diags
@@ -2672,7 +2688,7 @@ func (m *Meta) stateStore_changed(cfg *configs.StateStore, cfgHash int, sMgr *cl
 	}
 
 	// Grab the source state store
-	srcB, srcBDiags := m.savedStateStore(sMgr, opts.PreviousLocks)
+	srcB, srcBDiags := m.savedStateStore(sMgr, opts.PreviousLocks, opts.SkipGetProviderSchemaCache)
 	diags = diags.Append(srcBDiags)
 	if srcBDiags.HasErrors() {
 		return nil, diags
@@ -2689,11 +2705,12 @@ func (m *Meta) stateStore_changed(cfg *configs.StateStore, cfgHash int, sMgr *cl
 
 	// Perform the migration
 	err := m.backendMigrateState(&backendMigrateOpts{
-		SourceType:      s.StateStore.Type,
-		DestinationType: cfg.Type,
-		Source:          srcB,
-		Destination:     dstB,
-		ViewType:        vt,
+		SkipGetProviderSchemaCache: opts.SkipGetProviderSchemaCache,
+		SourceType:                 s.StateStore.Type,
+		DestinationType:            cfg.Type,
+		Source:                     srcB,
+		Destination:                dstB,
+		ViewType:                   vt,
 	})
 	if err != nil {
 		diags = diags.Append(err)
@@ -2826,7 +2843,7 @@ To make the initial dependency selections that will initialize the dependency lo
 }
 
 // Initializing a saved state store from the backend state file (aka 'cache file', aka 'legacy state file')
-func (m *Meta) savedStateStore(sMgr *clistate.LocalState, locks *depsfile.Locks) (backend.Backend, tfdiags.Diagnostics) {
+func (m *Meta) savedStateStore(sMgr *clistate.LocalState, locks *depsfile.Locks, skipCache bool) (backend.Backend, tfdiags.Diagnostics) {
 	// We're preparing a state_store version of backend.Backend.
 	//
 	// The provider and state store will be configured using the backend state file.
@@ -2835,7 +2852,7 @@ func (m *Meta) savedStateStore(sMgr *clistate.LocalState, locks *depsfile.Locks)
 
 	s := sMgr.State()
 
-	factory, pDiags := m.StateStoreProviderFactoryFromConfigState(s.StateStore, locks)
+	factory, pDiags := m.StateStoreProviderFactoryFromConfigState(s.StateStore, locks, skipCache)
 	diags = diags.Append(pDiags)
 	if pDiags.HasErrors() {
 		return nil, diags
@@ -3317,7 +3334,7 @@ func (m *Meta) StateStoreProviderFactoryFromConfig(config *configs.StateStore, l
 		})
 	}
 
-	factories, err := m.ProviderFactoriesFromLocks(locks)
+	factories, err := m.ProviderFactoriesFromLocks(locks, false)
 	if err != nil {
 		// This may happen if the provider isn't present in the provider cache.
 		// This should be caught earlier by logic that diffs the config against the backend state file.
@@ -3350,7 +3367,7 @@ func (m *Meta) StateStoreProviderFactoryFromConfig(config *configs.StateStore, l
 	return factory, diags
 }
 
-func (m *Meta) StateStoreProviderFactoryFromConfigState(cfgState *workdir.StateStoreConfigState, locks *depsfile.Locks) (providers.Factory, tfdiags.Diagnostics) {
+func (m *Meta) StateStoreProviderFactoryFromConfigState(cfgState *workdir.StateStoreConfigState, locks *depsfile.Locks, skipCache bool) (providers.Factory, tfdiags.Diagnostics) {
 	var diags tfdiags.Diagnostics
 
 	if cfgState == nil {
@@ -3366,7 +3383,7 @@ func (m *Meta) StateStoreProviderFactoryFromConfigState(cfgState *workdir.StateS
 		})
 	}
 
-	factories, err := m.providerFactoriesFromLocks(locks)
+	factories, err := m.providerFactoriesFromLocks(locks, skipCache)
 	if err != nil {
 		// This may happen if the provider isn't present in the provider cache.
 		// This should be caught earlier by logic that diffs the config against the backend state file.

internal/command/meta_backend_migrate.go

@@ -28,6 +28,7 @@ import (
 
 type backendMigrateOpts struct {
 	SourceType, DestinationType string
+	SkipGetProviderSchemaCache  bool
 	Source, Destination         backend.Backend
 	ViewType                    arguments.ViewType
 
@@ -496,7 +497,8 @@ func (m *Meta) backendMigrateEmptyConfirm(source, destination statemgr.Full, opt
 }
 
 func (m *Meta) backendMigrateNonEmptyConfirm(
-	sourceState, destinationState statemgr.Full, opts *backendMigrateOpts) (bool, error) {
+	sourceState, destinationState statemgr.Full, opts *backendMigrateOpts,
+) (bool, error) {
 	// We need to grab both states so we can write them to a file
 	source := sourceState.State()
 	destination := destinationState.State()
@@ -580,7 +582,7 @@ func (m *Meta) backendMigrateTFC(opts *backendMigrateOpts) error {
 	if err != nil {
 		return err
 	}
-	//to be used below, not yet implamented
+	// to be used below, not yet implamented
 	// destinationWorkspaces, destinationSingleState
 	_, _, err = retrieveWorkspaces(opts.Destination, opts.SourceType)
 	if err != nil {
@@ -639,7 +641,7 @@ func (m *Meta) backendMigrateTFC(opts *backendMigrateOpts) error {
 		if migrate, err := m.promptSingleToCloudSingleStateMigration(opts); err != nil {
 			return err
 		} else if !migrate {
-			return nil //skip migrating but return successfully
+			return nil // skip migrating but return successfully
 		}
 
 		return m.backendMigrateState_s_s(opts)

internal/command/meta_backend_test.go

@@ -2430,7 +2430,7 @@ func TestSavedStateStore(t *testing.T) {
 		}
 
 		// Code under test
-		b, diags := m.savedStateStore(sMgr, locks)
+		b, diags := m.savedStateStore(sMgr, locks, false)
 		if diags.HasErrors() {
 			t.Fatalf("unexpected errors: %s", diags.Err())
 		}
@@ -2474,7 +2474,7 @@ func TestSavedStateStore(t *testing.T) {
 			t.Fatal(dDiags.Err())
 		}
 
-		_, diags := m.savedStateStore(sMgr, locks)
+		_, diags := m.savedStateStore(sMgr, locks, false)
 		if !diags.HasErrors() {
 			t.Fatal("expected errors but got none")
 		}
@@ -2516,7 +2516,7 @@ func TestSavedStateStore(t *testing.T) {
 			t.Fatal(dDiags.Err())
 		}
 
-		_, diags := m.savedStateStore(sMgr, locks)
+		_, diags := m.savedStateStore(sMgr, locks, false)
 		if !diags.HasErrors() {
 			t.Fatal("expected errors but got none")
 		}

internal/command/meta_providers.go

@@ -280,7 +280,9 @@ func (m *Meta) ProviderFactories() (map[addrs.Provider]providers.Factory, error)
 		return nil, fmt.Errorf("failed to read dependency lock file: %s", diags.Err())
 	}
 
-	return m.providerFactoriesFromLocks(locks)
+	// Pass false as skipCache because this function is not used to launch 'old' versions of a provider
+	// during a state migration using state_store
+	return m.providerFactoriesFromLocks(locks, false)
 }
 
 // ProviderFactoriesFromLocks receives in memory locks and uses them to produce a map
@@ -290,12 +292,12 @@ func (m *Meta) ProviderFactories() (map[addrs.Provider]providers.Factory, error)
 // ProviderFactoriesFromLocks should only be used if the calling code relies on locks
 // that have not yet been persisted to a dependency lock file on disk. Realistically, this
 // means only code in the init command should use this method.
-func (m *Meta) ProviderFactoriesFromLocks(configLocks *depsfile.Locks) (map[addrs.Provider]providers.Factory, error) {
+func (m *Meta) ProviderFactoriesFromLocks(configLocks *depsfile.Locks, skipCache bool) (map[addrs.Provider]providers.Factory, error) {
 	// Ensure overrides and unmanaged providers are reflected in the returned list of factories,
 	// while avoiding mutating the in-memory
 	locks := m.annotateDependencyLocksWithOverrides(configLocks.DeepCopy())
 
-	return m.providerFactoriesFromLocks(locks)
+	return m.providerFactoriesFromLocks(locks, skipCache)
 }
 
 // providerFactoriesFromLocks returns a map of provider factories from a given set of locks.
@@ -304,7 +306,7 @@ func (m *Meta) ProviderFactoriesFromLocks(configLocks *depsfile.Locks) (map[addr
 // Instead, use:
 // * `ProviderFactoriesFromLocks` - for use when locks aren't yet persisted to a dependency lock file.
 // * `ProviderFactories` - for use when Terraform is guaranteed to read all necessary locks from a dependency lock file.
-func (m *Meta) providerFactoriesFromLocks(locks *depsfile.Locks) (map[addrs.Provider]providers.Factory, error) {
+func (m *Meta) providerFactoriesFromLocks(locks *depsfile.Locks, skipCache bool) (map[addrs.Provider]providers.Factory, error) {
 	// We'll always run through all of our providers, even if one of them
 	// encounters an error, so that we can potentially report multiple errors
 	// where appropriate and so that callers can potentially make use of the
@@ -390,7 +392,7 @@ func (m *Meta) providerFactoriesFromLocks(locks *depsfile.Locks) (map[addrs.Prov
 				continue
 			}
 		}
-		factories[provider] = providerFactory(cached)
+		factories[provider] = providerFactory(cached, skipCache)
 	}
 	for provider, localDir := range devOverrideProviders {
 		factories[provider] = devOverrideProviderFactory(provider, localDir)
@@ -419,7 +421,7 @@ func (m *Meta) internalProviders() map[string]providers.Factory {
 // providerFactory produces a provider factory that runs up the executable
 // file in the given cache package and uses go-plugin to implement
 // providers.Interface against it.
-func providerFactory(meta *providercache.CachedProvider) providers.Factory {
+func providerFactory(meta *providercache.CachedProvider, skipCache bool) providers.Factory {
 	return func() (providers.Interface, error) {
 		execFile, err := meta.ExecutableFile()
 		if err != nil {
@@ -451,23 +453,25 @@ func providerFactory(meta *providercache.CachedProvider) providers.Factory {
 
 		// store the client so that the plugin can kill the child process
 		protoVer := client.NegotiatedVersion()
-		return finalizeFactoryPlugin(raw, protoVer, meta.Provider, client), nil
+		return finalizeFactoryPlugin(raw, protoVer, meta.Provider, skipCache, client), nil
 	}
 }
 
 // finalizeFactoryPlugin completes the setup of a plugin dispensed by the rpc
 // client to be returned by the plugin factory.
-func finalizeFactoryPlugin(rawPlugin any, protoVersion int, addr addrs.Provider, client *plugin.Client) providers.Interface {
+func finalizeFactoryPlugin(rawPlugin any, protoVersion int, addr addrs.Provider, skipCache bool, client *plugin.Client) providers.Interface {
 	switch protoVersion {
 	case 5:
 		p := rawPlugin.(*tfplugin.GRPCProvider)
 		p.PluginClient = client
 		p.Addr = addr
+		p.SkipCache = skipCache
 		return p
 	case 6:
 		p := rawPlugin.(*tfplugin6.GRPCProvider)
 		p.PluginClient = client
 		p.Addr = addr
+		p.SkipCache = skipCache
 		return p
 	default:
 		panic("unsupported protocol version")
@@ -480,11 +484,12 @@ func devOverrideProviderFactory(provider addrs.Provider, localDir getproviders.P
 	// doesn't actually care about the version, so we can leave it
 	// unspecified: overridden providers are not explicitly versioned.
 	log.Printf("[DEBUG] Provider %s is overridden to load from %s", provider, localDir)
+	skipCache := false
 	return providerFactory(&providercache.CachedProvider{
 		Provider:   provider,
 		Version:    getproviders.UnspecifiedVersion,
 		PackageDir: string(localDir),
-	})
+	}, skipCache)
 }
 
 // unmanagedProviderFactory produces a provider factory that uses the passed
@@ -532,16 +537,17 @@ func unmanagedProviderFactory(provider addrs.Provider, reattach *plugin.Reattach
 
 		// store the client so that the plugin can kill the child process
 		protoVer := client.NegotiatedVersion()
+		skipCache := false
 		switch protoVer {
 		case 0, 5:
 			// As of the 0.15 release, sdk.v2 doesn't include the protocol
 			// version in the ReattachConfig (only recently added to
 			// go-plugin), so client.NegotiatedVersion() always returns 0. We
 			// assume that an unmanaged provider reporting protocol version 0 is
 			// actually using proto v5 for backwards compatibility.
-			return finalizeFactoryPlugin(raw, 5, provider, client), nil
+			return finalizeFactoryPlugin(raw, 5, provider, skipCache, client), nil
 		case 6:
-			return finalizeFactoryPlugin(raw, 6, provider, client), nil
+			return finalizeFactoryPlugin(raw, 6, provider, skipCache, client), nil
 		default:
 			return nil, fmt.Errorf("unsupported protocol version %d", protoVer)
 		}

internal/plugin/grpc_provider.go

@@ -64,6 +64,9 @@ type GRPCProvider struct {
 	// but it may not always be available for alternative execute modes.
 	Addr addrs.Provider
 
+	// SkipCache WIP
+	SkipCache bool
+
 	// Proto client use to make the grpc service calls.
 	client proto.ProviderClient
 
@@ -83,7 +86,7 @@ func (p *GRPCProvider) GetProviderSchema() providers.GetProviderSchemaResponse {
 	defer p.mu.Unlock()
 
 	// check the global cache if we can
-	if !p.Addr.IsZero() {
+	if !p.Addr.IsZero() && !p.SkipCache {
 		if resp, ok := providers.SchemaCache.Get(p.Addr); ok && resp.ServerCapabilities.GetProviderSchemaOptional {
 			logger.Trace("GRPCProvider: returning cached schema", p.Addr.String())
 			return resp

internal/plugin6/grpc_provider.go

@@ -71,6 +71,9 @@ type GRPCProvider struct {
 	// but it may not always be available for alternative execute modes.
 	Addr addrs.Provider
 
+	// SkipCache WIP
+	SkipCache bool
+
 	// Proto client use to make the grpc service calls.
 	client proto6.ProviderClient
 
@@ -93,7 +96,7 @@ func (p *GRPCProvider) GetProviderSchema() providers.GetProviderSchemaResponse {
 	defer p.mu.Unlock()
 
 	// check the global cache if we can
-	if !p.Addr.IsZero() {
+	if !p.Addr.IsZero() && !p.SkipCache {
 		if resp, ok := providers.SchemaCache.Get(p.Addr); ok && resp.ServerCapabilities.GetProviderSchemaOptional {
 			logger.Trace("GRPCProvider.v6: returning cached schema", p.Addr.String())
 			return resp
@@ -208,7 +211,7 @@ func (p *GRPCProvider) GetProviderSchema() providers.GetProviderSchemaResponse {
 	}
 
 	// set the global cache if we can
-	if !p.Addr.IsZero() {
+	if !p.Addr.IsZero() && !p.SkipCache {
 		providers.SchemaCache.Set(p.Addr, resp)
 	}
 

internal/rpcapi/dependencies.go

@@ -717,11 +717,13 @@ func providerFactoriesForLocks(locks *depsfile.Locks, pluginsDir *providercache.
 				p := raw.(*tfplugin.GRPCProvider)
 				p.PluginClient = client
 				p.Addr = addr
+				p.SkipCache = false
 				return p, nil
 			case 6:
 				p := raw.(*tfplugin6.GRPCProvider)
 				p.PluginClient = client
 				p.Addr = addr
+				p.SkipCache = false
 				return p, nil
 			default:
 				panic("unsupported protocol version")