upstream/terraform
1
0
Fork 0
mirror of https://github.com/hashicorp/terraform.git synced 2026-02-03 20:50:59 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

stacks: split the terraform1 RPC package into per-service packages (#35513)

Browse source 
* stacks: split the terraform1 RPC package into per-service packages

* pull latest changes
This commit is contained in:
Liam Cervante 2024-08-07 17:33:51 +02:00 committed by GitHub
parent 6d4436d355
commit 915b174da3
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
39 changed files with 17935 additions and 17352 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
internal/rpcapi/convert.go
View file

@ -12,6 +12,7 @@ import (
"github.com/hashicorp/terraform/internal/lang/marks"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
"github.com/hashicorp/terraform/internal/stacks/stackruntime"
"github.com/hashicorp/terraform/internal/tfdiags"
@ -92,7 +93,7 @@ func sourcePosFromProto(protoPos *terraform1.SourcePos) tfdiags.SourcePos {
}
}
func dynamicTypedValueFromProto(protoVal *terraform1.DynamicValue) (cty.Value, error) {
func dynamicTypedValueFromProto(protoVal *stacks.DynamicValue) (cty.Value, error) {
if len(protoVal.Msgpack) == 0 {
return cty.DynamicVal, fmt.Errorf("uses unsupported serialization format (only MessagePack is supported)")
}
@ -110,7 +111,7 @@ func dynamicTypedValueFromProto(protoVal *terraform1.DynamicValue) (cty.Value, e
return v, nil
}
func externalInputValuesFromProto(protoVals map[string]*terraform1.DynamicValueWithSource) (map[stackaddrs.InputVariable]stackruntime.ExternalInputValue, error) {
func externalInputValuesFromProto(protoVals map[string]*stacks.DynamicValueWithSource) (map[stackaddrs.InputVariable]stackruntime.ExternalInputValue, error) {
if len(protoVals) == 0 {
return nil, nil
}
@ -126,7 +127,7 @@ func externalInputValuesFromProto(protoVals map[string]*terraform1.DynamicValueW
return ret, err
}
func externalInputValueFromProto(protoVal *terraform1.DynamicValueWithSource) (stackruntime.ExternalInputValue, error) {
func externalInputValueFromProto(protoVal *stacks.DynamicValueWithSource) (stackruntime.ExternalInputValue, error) {
v, err := dynamicTypedValueFromProto(protoVal.Value)
if err != nil {
return stackruntime.ExternalInputValue{}, nil

135
internal/rpcapi/dependencies.go
View file

@ -30,12 +30,13 @@ import (
"github.com/hashicorp/terraform/internal/providercache"
"github.com/hashicorp/terraform/internal/providers"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies"
"github.com/hashicorp/terraform/internal/tfdiags"
"github.com/hashicorp/terraform/version"
)
type dependenciesServer struct {
terraform1.UnimplementedDependenciesServer
dependencies.UnimplementedDependenciesServer
handles *handleTable
services *disco.Disco
@ -48,28 +49,28 @@ func newDependenciesServer(handles *handleTable, services *disco.Disco) *depende
}
}
func (s *dependenciesServer) OpenSourceBundle(ctx context.Context, req *terraform1.OpenSourceBundle_Request) (*terraform1.OpenSourceBundle_Response, error) {
func (s *dependenciesServer) OpenSourceBundle(ctx context.Context, req *dependencies.OpenSourceBundle_Request) (*dependencies.OpenSourceBundle_Response, error) {
localDir := filepath.Clean(req.LocalPath)
sources, err := sourcebundle.OpenDir(localDir)
if err != nil {
return nil, status.Error(codes.Unknown, err.Error())
}
hnd := s.handles.NewSourceBundle(sources)
return &terraform1.OpenSourceBundle_Response{
return &dependencies.OpenSourceBundle_Response{
SourceBundleHandle: hnd.ForProtobuf(),
}, err
}
func (s *dependenciesServer) CloseSourceBundle(ctx context.Context, req *terraform1.CloseSourceBundle_Request) (*terraform1.CloseSourceBundle_Response, error) {
func (s *dependenciesServer) CloseSourceBundle(ctx context.Context, req *dependencies.CloseSourceBundle_Request) (*dependencies.CloseSourceBundle_Response, error) {
hnd := handle[*sourcebundle.Bundle](req.SourceBundleHandle)
err := s.handles.CloseSourceBundle(hnd)
if err != nil {
return nil, status.Error(codes.InvalidArgument, err.Error())
}
return &terraform1.CloseSourceBundle_Response{}, nil
return &dependencies.CloseSourceBundle_Response{}, nil
}
func (s *dependenciesServer) OpenDependencyLockFile(ctx context.Context, req *terraform1.OpenDependencyLockFile_Request) (*terraform1.OpenDependencyLockFile_Response, error) {
func (s *dependenciesServer) OpenDependencyLockFile(ctx context.Context, req *dependencies.OpenDependencyLockFile_Request) (*dependencies.OpenDependencyLockFile_Response, error) {
sourcesHnd := handle[*sourcebundle.Bundle](req.SourceBundleHandle)
sources := s.handles.SourceBundle(sourcesHnd)
if sources == nil {
@ -88,19 +89,19 @@ func (s *dependenciesServer) OpenDependencyLockFile(ctx context.Context, req *te
locks, diags := depsfile.LoadLocksFromFile(lockFilePath)
if diags.HasErrors() {
return &terraform1.OpenDependencyLockFile_Response{
return &dependencies.OpenDependencyLockFile_Response{
Diagnostics: diagnosticsToProto(diags),
}, nil
}
locksHnd := s.handles.NewDependencyLocks(locks)
return &terraform1.OpenDependencyLockFile_Response{
return &dependencies.OpenDependencyLockFile_Response{
DependencyLocksHandle: locksHnd.ForProtobuf(),
Diagnostics: diagnosticsToProto(diags),
}, nil
}
func (s *dependenciesServer) CreateDependencyLocks(ctx context.Context, req *terraform1.CreateDependencyLocks_Request) (*terraform1.CreateDependencyLocks_Response, error) {
func (s *dependenciesServer) CreateDependencyLocks(ctx context.Context, req *dependencies.CreateDependencyLocks_Request) (*dependencies.CreateDependencyLocks_Response, error) {
locks := depsfile.NewLocks()
for _, provider := range req.ProviderSelections {
addr, diags := addrs.ParseProviderSourceString(provider.SourceAddr)
@ -138,21 +139,21 @@ func (s *dependenciesServer) CreateDependencyLocks(ctx context.Context, req *ter
}
locksHnd := s.handles.NewDependencyLocks(locks)
return &terraform1.CreateDependencyLocks_Response{
return &dependencies.CreateDependencyLocks_Response{
DependencyLocksHandle: locksHnd.ForProtobuf(),
}, nil
}
func (s *dependenciesServer) CloseDependencyLocks(ctx context.Context, req *terraform1.CloseDependencyLocks_Request) (*terraform1.CloseDependencyLocks_Response, error) {
func (s *dependenciesServer) CloseDependencyLocks(ctx context.Context, req *dependencies.CloseDependencyLocks_Request) (*dependencies.CloseDependencyLocks_Response, error) {
hnd := handle[*depsfile.Locks](req.DependencyLocksHandle)
err := s.handles.CloseDependencyLocks(hnd)
if err != nil {
return nil, status.Error(codes.InvalidArgument, "invalid dependency locks handle")
}
return &terraform1.CloseDependencyLocks_Response{}, nil
return &dependencies.CloseDependencyLocks_Response{}, nil
}
func (s *dependenciesServer) GetLockedProviderDependencies(ctx context.Context, req *terraform1.GetLockedProviderDependencies_Request) (*terraform1.GetLockedProviderDependencies_Response, error) {
func (s *dependenciesServer) GetLockedProviderDependencies(ctx context.Context, req *dependencies.GetLockedProviderDependencies_Request) (*dependencies.GetLockedProviderDependencies_Response, error) {
hnd := handle[*depsfile.Locks](req.DependencyLocksHandle)
locks := s.handles.DependencyLocks(hnd)
if locks == nil {
@ -183,12 +184,12 @@ func (s *dependenciesServer) GetLockedProviderDependencies(ctx context.Context,
return protoProviders[i].SourceAddr < protoProviders[j].SourceAddr
})
return &terraform1.GetLockedProviderDependencies_Response{
return &dependencies.GetLockedProviderDependencies_Response{
SelectedProviders: protoProviders,
}, nil
}
func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProviderPluginCache_Request, evts terraform1.Dependencies_BuildProviderPluginCacheServer) error {
func (s *dependenciesServer) BuildProviderPluginCache(req *dependencies.BuildProviderPluginCache_Request, evts dependencies.Dependencies_BuildProviderPluginCacheServer) error {
ctx := evts.Context()
hnd := handle[*depsfile.Locks](req.DependencyLocksHandle)
@ -201,11 +202,11 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
for _, protoMethod := range req.InstallationMethods {
var source getproviders.Source
switch arg := protoMethod.Source.(type) {
case *terraform1.BuildProviderPluginCache_Request_InstallMethod_Direct:
case *dependencies.BuildProviderPluginCache_Request_InstallMethod_Direct:
source = getproviders.NewRegistrySource(s.services)
case *terraform1.BuildProviderPluginCache_Request_InstallMethod_LocalMirrorDir:
case *dependencies.BuildProviderPluginCache_Request_InstallMethod_LocalMirrorDir:
source = getproviders.NewFilesystemMirrorSource(arg.LocalMirrorDir)
case *terraform1.BuildProviderPluginCache_Request_InstallMethod_NetworkMirrorUrl:
case *dependencies.BuildProviderPluginCache_Request_InstallMethod_NetworkMirrorUrl:
u, err := url.Parse(arg.NetworkMirrorUrl)
if err != nil {
return status.Errorf(codes.InvalidArgument, "invalid network mirror URL %q", arg.NetworkMirrorUrl)
@ -263,25 +264,25 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
// which could potentially help drive a percentage-based progress
// bar or similar in the UI by correlating with the "FetchSuccess"
// events.
protoConstraints := make([]*terraform1.BuildProviderPluginCache_Event_ProviderConstraints, 0, len(reqs))
protoConstraints := make([]*dependencies.BuildProviderPluginCache_Event_ProviderConstraints, 0, len(reqs))
for addr, constraints := range reqs {
protoConstraints = append(protoConstraints, &terraform1.BuildProviderPluginCache_Event_ProviderConstraints{
protoConstraints = append(protoConstraints, &dependencies.BuildProviderPluginCache_Event_ProviderConstraints{
SourceAddr: addr.ForDisplay(),
Versions: getproviders.VersionConstraintsString(constraints),
})
}
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_Pending_{
Pending: &terraform1.BuildProviderPluginCache_Event_Pending{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_Pending_{
Pending: &dependencies.BuildProviderPluginCache_Event_Pending{
Expected: protoConstraints,
},
},
})
},
ProviderAlreadyInstalled: func(provider addrs.Provider, selectedVersion getproviders.Version) {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_AlreadyInstalled{
AlreadyInstalled: &terraform1.BuildProviderPluginCache_Event_ProviderVersion{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_AlreadyInstalled{
AlreadyInstalled: &dependencies.BuildProviderPluginCache_Event_ProviderVersion{
SourceAddr: provider.ForDisplay(),
Version: selectedVersion.String(),
},
@ -289,17 +290,17 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
})
},
BuiltInProviderAvailable: func(provider addrs.Provider) {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_BuiltIn{
BuiltIn: &terraform1.BuildProviderPluginCache_Event_ProviderVersion{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_BuiltIn{
BuiltIn: &dependencies.BuildProviderPluginCache_Event_ProviderVersion{
SourceAddr: provider.ForDisplay(),
},
},
})
},
BuiltInProviderFailure: func(provider addrs.Provider, err error) {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_Diagnostic{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_Diagnostic{
Diagnostic: diagnosticToProto(tfdiags.Sourceless(
tfdiags.Error,
"Built-in provider unavailable",
@ -313,9 +314,9 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
sentErrorDiags = true
},
QueryPackagesBegin: func(provider addrs.Provider, versionConstraints getproviders.VersionConstraints, locked bool) {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_QueryBegin{
QueryBegin: &terraform1.BuildProviderPluginCache_Event_ProviderConstraints{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_QueryBegin{
QueryBegin: &dependencies.BuildProviderPluginCache_Event_ProviderConstraints{
SourceAddr: provider.ForDisplay(),
Versions: getproviders.VersionConstraintsString(versionConstraints),
},
@ -323,9 +324,9 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
})
},
QueryPackagesSuccess: func(provider addrs.Provider, selectedVersion getproviders.Version) {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_QuerySuccess{
QuerySuccess: &terraform1.BuildProviderPluginCache_Event_ProviderVersion{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_QuerySuccess{
QuerySuccess: &dependencies.BuildProviderPluginCache_Event_ProviderVersion{
SourceAddr: provider.ForDisplay(),
Version: selectedVersion.String(),
},
@ -333,9 +334,9 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
})
},
QueryPackagesWarning: func(provider addrs.Provider, warn []string) {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_QueryWarnings{
QueryWarnings: &terraform1.BuildProviderPluginCache_Event_ProviderWarnings{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_QueryWarnings{
QueryWarnings: &dependencies.BuildProviderPluginCache_Event_ProviderWarnings{
SourceAddr: provider.ForDisplay(),
Warnings: warn,
},
@ -343,8 +344,8 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
})
},
QueryPackagesFailure: func(provider addrs.Provider, err error) {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_Diagnostic{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_Diagnostic{
Diagnostic: diagnosticToProto(tfdiags.Sourceless(
tfdiags.Error,
"Provider is unavailable",
@ -359,10 +360,10 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
sentErrorDiags = true
},
FetchPackageBegin: func(provider addrs.Provider, version getproviders.Version, location getproviders.PackageLocation) {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_FetchBegin_{
FetchBegin: &terraform1.BuildProviderPluginCache_Event_FetchBegin{
ProviderVersion: &terraform1.BuildProviderPluginCache_Event_ProviderVersion{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_FetchBegin_{
FetchBegin: &dependencies.BuildProviderPluginCache_Event_FetchBegin{
ProviderVersion: &dependencies.BuildProviderPluginCache_Event_ProviderVersion{
SourceAddr: provider.ForDisplay(),
Version: version.String(),
},
@ -372,13 +373,13 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
})
},
FetchPackageSuccess: func(provider addrs.Provider, version getproviders.Version, localDir string, authResult *getproviders.PackageAuthenticationResult) {
var protoAuthResult terraform1.BuildProviderPluginCache_Event_FetchComplete_AuthResult
var protoAuthResult dependencies.BuildProviderPluginCache_Event_FetchComplete_AuthResult
var keyID string
if authResult != nil {
keyID = authResult.KeyID
switch {
case authResult.SignedByHashiCorp():
protoAuthResult = terraform1.BuildProviderPluginCache_Event_FetchComplete_OFFICIAL_SIGNED
protoAuthResult = dependencies.BuildProviderPluginCache_Event_FetchComplete_OFFICIAL_SIGNED
default:
// TODO: The getproviders.PackageAuthenticationResult type
// only exposes the full detail of the signing outcome as
@ -386,13 +387,13 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
// means we can't populate this in full detail. For now
// we'll treat anything signed by a non-HashiCorp key as
// "unknown" and then rationalize this later.
protoAuthResult = terraform1.BuildProviderPluginCache_Event_FetchComplete_UNKNOWN
protoAuthResult = dependencies.BuildProviderPluginCache_Event_FetchComplete_UNKNOWN
}
}
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_FetchComplete_{
FetchComplete: &terraform1.BuildProviderPluginCache_Event_FetchComplete{
ProviderVersion: &terraform1.BuildProviderPluginCache_Event_ProviderVersion{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_FetchComplete_{
FetchComplete: &dependencies.BuildProviderPluginCache_Event_FetchComplete{
ProviderVersion: &dependencies.BuildProviderPluginCache_Event_ProviderVersion{
SourceAddr: provider.ForDisplay(),
Version: version.String(),
},
@ -403,8 +404,8 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
})
},
FetchPackageFailure: func(provider addrs.Provider, version getproviders.Version, err error) {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_Diagnostic{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_Diagnostic{
Diagnostic: diagnosticToProto(tfdiags.Sourceless(
tfdiags.Error,
"Failed to fetch provider package",
@ -427,8 +428,8 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
// err will typically just duplicate them, so we'll skip emitting
// another diagnostic in that case.
if !sentErrorDiags {
evts.Send(&terraform1.BuildProviderPluginCache_Event{
Event: &terraform1.BuildProviderPluginCache_Event_Diagnostic{
evts.Send(&dependencies.BuildProviderPluginCache_Event{
Event: &dependencies.BuildProviderPluginCache_Event_Diagnostic{
Diagnostic: diagnosticToProto(tfdiags.Sourceless(
tfdiags.Error,
"Failed to install providers",
@ -450,7 +451,7 @@ func (s *dependenciesServer) BuildProviderPluginCache(req *terraform1.BuildProvi
return nil
}
func (s *dependenciesServer) OpenProviderPluginCache(ctx context.Context, req *terraform1.OpenProviderPluginCache_Request) (*terraform1.OpenProviderPluginCache_Response, error) {
func (s *dependenciesServer) OpenProviderPluginCache(ctx context.Context, req *dependencies.OpenProviderPluginCache_Request) (*dependencies.OpenProviderPluginCache_Response, error) {
var cacheDir *providercache.Dir
if req.OverridePlatform == "" {
cacheDir = providercache.NewDir(req.CacheDir)
@ -463,21 +464,21 @@ func (s *dependenciesServer) OpenProviderPluginCache(ctx context.Context, req *t
}
hnd := s.handles.NewProviderPluginCache(cacheDir)
return &terraform1.OpenProviderPluginCache_Response{
return &dependencies.OpenProviderPluginCache_Response{
ProviderCacheHandle: hnd.ForProtobuf(),
}, nil
}
func (s *dependenciesServer) CloseProviderPluginCache(ctx context.Context, req *terraform1.CloseProviderPluginCache_Request) (*terraform1.CloseProviderPluginCache_Response, error) {
func (s *dependenciesServer) CloseProviderPluginCache(ctx context.Context, req *dependencies.CloseProviderPluginCache_Request) (*dependencies.CloseProviderPluginCache_Response, error) {
hnd := handle[*providercache.Dir](req.ProviderCacheHandle)
err := s.handles.CloseProviderPluginCache(hnd)
if err != nil {
return nil, status.Error(codes.InvalidArgument, "invalid provider plugin cache handle")
}
return &terraform1.CloseProviderPluginCache_Response{}, nil
return &dependencies.CloseProviderPluginCache_Response{}, nil
}
func (s *dependenciesServer) GetCachedProviders(ctx context.Context, req *terraform1.GetCachedProviders_Request) (*terraform1.GetCachedProviders_Response, error) {
func (s *dependenciesServer) GetCachedProviders(ctx context.Context, req *dependencies.GetCachedProviders_Request) (*dependencies.GetCachedProviders_Response, error) {
hnd := handle[*providercache.Dir](req.ProviderCacheHandle)
cacheDir := s.handles.ProviderPluginCache(hnd)
if cacheDir == nil {
@ -507,12 +508,12 @@ func (s *dependenciesServer) GetCachedProviders(ctx context.Context, req *terraf
}
}
return &terraform1.GetCachedProviders_Response{
return &dependencies.GetCachedProviders_Response{
AvailableProviders: ret,
}, nil
}
func (s *dependenciesServer) GetBuiltInProviders(ctx context.Context, req *terraform1.GetBuiltInProviders_Request) (*terraform1.GetBuiltInProviders_Response, error) {
func (s *dependenciesServer) GetBuiltInProviders(ctx context.Context, req *dependencies.GetBuiltInProviders_Request) (*dependencies.GetBuiltInProviders_Response, error) {
ret := make([]*terraform1.ProviderPackage, 0, len(builtinProviders))
for typeName := range builtinProviders {
ret = append(ret, &terraform1.ProviderPackage{
@ -522,12 +523,12 @@ func (s *dependenciesServer) GetBuiltInProviders(ctx context.Context, req *terra
sort.Slice(ret, func(i, j int) bool {
return ret[i].SourceAddr < ret[j].SourceAddr
})
return &terraform1.GetBuiltInProviders_Response{
return &dependencies.GetBuiltInProviders_Response{
AvailableProviders: ret,
}, nil
}
func (s *dependenciesServer) GetProviderSchema(ctx context.Context, req *terraform1.GetProviderSchema_Request) (*terraform1.GetProviderSchema_Response, error) {
func (s *dependenciesServer) GetProviderSchema(ctx context.Context, req *dependencies.GetProviderSchema_Request) (*dependencies.GetProviderSchema_Response, error) {
var cacheHnd handle[*providercache.Dir]
var cacheDir *providercache.Dir
if req.GetProviderCacheHandle() != 0 {
@ -568,7 +569,7 @@ func (s *dependenciesServer) GetProviderSchema(ctx context.Context, req *terrafo
return nil, status.Errorf(codes.Internal, err.Error())
}
return &terraform1.GetProviderSchema_Response{
return &dependencies.GetProviderSchema_Response{
Schema: providerSchemaToProto(schemaResp),
}, nil
}

73
internal/rpcapi/dependencies_provider_schema.go
View file

@ -10,6 +10,7 @@ import (
"github.com/apparentlymart/go-versions/versions"
"github.com/hashicorp/go-plugin"
"github.com/hashicorp/terraform/internal/addrs"
"github.com/hashicorp/terraform/internal/configs/configschema"
"github.com/hashicorp/terraform/internal/getproviders"
@ -18,7 +19,7 @@ import (
tfplugin6 "github.com/hashicorp/terraform/internal/plugin6"
"github.com/hashicorp/terraform/internal/providercache"
"github.com/hashicorp/terraform/internal/providers"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies"
)
// This file contains helper functions and supporting logic for
@ -120,7 +121,7 @@ func unconfiguredBuiltinProviderInstance(addr addrs.Provider) (providers.Interfa
return factory(), nil
}
func providerSchemaToProto(schemaResp providers.GetProviderSchemaResponse) *terraform1.ProviderSchema {
func providerSchemaToProto(schemaResp providers.GetProviderSchemaResponse) *dependencies.ProviderSchema {
// Due to some historical poor design planning, the provider protocol uses
// different terminology than the user-facing terminology for Terraform
// Core and the Terraform language, and so part of our job here is to
@ -138,8 +139,8 @@ func providerSchemaToProto(schemaResp providers.GetProviderSchemaResponse) *terr
// probably not want to make a new rpcapi protocol major version each time
// a new provider protocol version is added or removed.
mrtSchemas := make(map[string]*terraform1.Schema, len(schemaResp.ResourceTypes))
drtSchemas := make(map[string]*terraform1.Schema, len(schemaResp.DataSources))
mrtSchemas := make(map[string]*dependencies.Schema, len(schemaResp.ResourceTypes))
drtSchemas := make(map[string]*dependencies.Schema, len(schemaResp.DataSources))
for name, elem := range schemaResp.ResourceTypes {
mrtSchemas[name] = schemaElementToProto(elem)
@ -148,38 +149,38 @@ func providerSchemaToProto(schemaResp providers.GetProviderSchemaResponse) *terr
drtSchemas[name] = schemaElementToProto(elem)
}
return &terraform1.ProviderSchema{
return &dependencies.ProviderSchema{
ProviderConfig: schemaElementToProto(schemaResp.Provider),
ManagedResourceTypes: mrtSchemas,
DataResourceTypes: drtSchemas,
}
}
func schemaElementToProto(elem providers.Schema) *terraform1.Schema {
return &terraform1.Schema{
func schemaElementToProto(elem providers.Schema) *dependencies.Schema {
return &dependencies.Schema{
Block: schemaBlockToProto(elem.Block),
}
}
func schemaBlockToProto(block *configschema.Block) *terraform1.Schema_Block {
func schemaBlockToProto(block *configschema.Block) *dependencies.Schema_Block {
if block == nil {
return &terraform1.Schema_Block{}
return &dependencies.Schema_Block{}
}
attributes := make([]*terraform1.Schema_Attribute, 0, len(block.Attributes))
attributes := make([]*dependencies.Schema_Attribute, 0, len(block.Attributes))
for name, attr := range block.Attributes {
attributes = append(attributes, schemaAttributeToProto(name, attr))
}
sort.Slice(attributes, func(i, j int) bool {
return attributes[i].Name < attributes[j].Name
})
blockTypes := make([]*terraform1.Schema_NestedBlock, 0, len(block.BlockTypes))
blockTypes := make([]*dependencies.Schema_NestedBlock, 0, len(block.BlockTypes))
for typeName, blockType := range block.BlockTypes {
blockTypes = append(blockTypes, schemaNestedBlockToProto(typeName, blockType))
}
sort.Slice(blockTypes, func(i, j int) bool {
return blockTypes[i].TypeName < blockTypes[j].TypeName
})
return &terraform1.Schema_Block{
return &dependencies.Schema_Block{
Deprecated: block.Deprecated,
Description: schemaDocstringToProto(block.Description, block.DescriptionKind),
Attributes: attributes,
@ -187,10 +188,10 @@ func schemaBlockToProto(block *configschema.Block) *terraform1.Schema_Block {
}
}
func schemaAttributeToProto(name string, attr *configschema.Attribute) *terraform1.Schema_Attribute {
func schemaAttributeToProto(name string, attr *configschema.Attribute) *dependencies.Schema_Attribute {
var err error
var typeBytes []byte
var objectType *terraform1.Schema_Object
var objectType *dependencies.Schema_Object
if attr.NestedType != nil {
objectType = schemaNestedObjectTypeToProto(attr.NestedType)
} else {
@ -203,7 +204,7 @@ func schemaAttributeToProto(name string, attr *configschema.Attribute) *terrafor
}
}
return &terraform1.Schema_Attribute{
return &dependencies.Schema_Attribute{
Name: name,
Type: typeBytes,
NestedType: objectType,
@ -216,48 +217,48 @@ func schemaAttributeToProto(name string, attr *configschema.Attribute) *terrafor
}
}
func schemaNestedBlockToProto(typeName string, blockType *configschema.NestedBlock) *terraform1.Schema_NestedBlock {
var protoNesting terraform1.Schema_NestedBlock_NestingMode
func schemaNestedBlockToProto(typeName string, blockType *configschema.NestedBlock) *dependencies.Schema_NestedBlock {
var protoNesting dependencies.Schema_NestedBlock_NestingMode
switch blockType.Nesting {
case configschema.NestingSingle:
protoNesting = terraform1.Schema_NestedBlock_SINGLE
protoNesting = dependencies.Schema_NestedBlock_SINGLE
case configschema.NestingGroup:
protoNesting = terraform1.Schema_NestedBlock_GROUP
protoNesting = dependencies.Schema_NestedBlock_GROUP
case configschema.NestingList:
protoNesting = terraform1.Schema_NestedBlock_LIST
protoNesting = dependencies.Schema_NestedBlock_LIST
case configschema.NestingSet:
protoNesting = terraform1.Schema_NestedBlock_SET
protoNesting = dependencies.Schema_NestedBlock_SET
case configschema.NestingMap:
protoNesting = terraform1.Schema_NestedBlock_MAP
protoNesting = dependencies.Schema_NestedBlock_MAP
default:
// The above should be exhaustive for all configschema.NestingMode variants
panic(fmt.Sprintf("invalid structural attribute nesting mode %s", blockType.Nesting))
}
return &terraform1.Schema_NestedBlock{
return &dependencies.Schema_NestedBlock{
TypeName: typeName,
Block: schemaBlockToProto(&blockType.Block),
Nesting: protoNesting,
}
}
func schemaNestedObjectTypeToProto(objType *configschema.Object) *terraform1.Schema_Object {
var protoNesting terraform1.Schema_Object_NestingMode
func schemaNestedObjectTypeToProto(objType *configschema.Object) *dependencies.Schema_Object {
var protoNesting dependencies.Schema_Object_NestingMode
switch objType.Nesting {
case configschema.NestingSingle:
protoNesting = terraform1.Schema_Object_SINGLE
protoNesting = dependencies.Schema_Object_SINGLE
case configschema.NestingList:
protoNesting = terraform1.Schema_Object_LIST
protoNesting = dependencies.Schema_Object_LIST
case configschema.NestingSet:
protoNesting = terraform1.Schema_Object_SET
protoNesting = dependencies.Schema_Object_SET
case configschema.NestingMap:
protoNesting = terraform1.Schema_Object_MAP
protoNesting = dependencies.Schema_Object_MAP
default:
// The above should be exhaustive for all configschema.NestingMode variants
panic(fmt.Sprintf("invalid structural attribute nesting mode %s", objType.Nesting))
}
attributes := make([]*terraform1.Schema_Attribute, 0, len(objType.Attributes))
attributes := make([]*dependencies.Schema_Attribute, 0, len(objType.Attributes))
for name, attr := range objType.Attributes {
attributes = append(attributes, schemaAttributeToProto(name, attr))
}
@ -265,28 +266,28 @@ func schemaNestedObjectTypeToProto(objType *configschema.Object) *terraform1.Sch
return attributes[i].Name < attributes[j].Name
})
return &terraform1.Schema_Object{
return &dependencies.Schema_Object{
Nesting: protoNesting,
Attributes: attributes,
}
}
func schemaDocstringToProto(doc string, format configschema.StringKind) *terraform1.Schema_DocString {
func schemaDocstringToProto(doc string, format configschema.StringKind) *dependencies.Schema_DocString {
if doc == "" {
return nil
}
var protoFormat terraform1.Schema_DocString_Format
var protoFormat dependencies.Schema_DocString_Format
switch format {
case configschema.StringPlain:
protoFormat = terraform1.Schema_DocString_PLAIN
protoFormat = dependencies.Schema_DocString_PLAIN
case configschema.StringMarkdown:
protoFormat = terraform1.Schema_DocString_MARKDOWN
protoFormat = dependencies.Schema_DocString_MARKDOWN
default:
// We'll ignore strings in unsupported formats, although we should
// try to keep the above exhaustive if we add new formats in future.
return nil
}
return &terraform1.Schema_DocString{
return &dependencies.Schema_DocString{
Description: doc,
Format: protoFormat,
}

93
internal/rpcapi/dependencies_test.go
View file

@ -13,10 +13,13 @@ import (
"github.com/hashicorp/go-slug/sourceaddrs"
"github.com/hashicorp/go-slug/sourcebundle"
"github.com/hashicorp/terraform-svchost/disco"
"github.com/hashicorp/terraform/internal/addrs"
"github.com/hashicorp/terraform/internal/depsfile"
"github.com/hashicorp/terraform/internal/getproviders"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies"
"google.golang.org/grpc"
"google.golang.org/protobuf/testing/protocmp"
@ -29,7 +32,7 @@ func TestDependenciesOpenCloseSourceBundle(t *testing.T) {
handles := newHandleTable()
depsServer := newDependenciesServer(handles, disco.New())
openResp, err := depsServer.OpenSourceBundle(ctx, &terraform1.OpenSourceBundle_Request{
openResp, err := depsServer.OpenSourceBundle(ctx, &dependencies.OpenSourceBundle_Request{
LocalPath: "testdata/sourcebundle",
})
if err != nil {
@ -58,7 +61,7 @@ func TestDependenciesOpenCloseSourceBundle(t *testing.T) {
}
}
_, err = depsServer.CloseSourceBundle(ctx, &terraform1.CloseSourceBundle_Request{
_, err = depsServer.CloseSourceBundle(ctx, &dependencies.CloseSourceBundle_Request{
SourceBundleHandle: openResp.SourceBundleHandle,
})
if err != nil {
@ -72,19 +75,19 @@ func TestDependencyLocks(t *testing.T) {
handles := newHandleTable()
depsServer := newDependenciesServer(handles, disco.New())
openSourcesResp, err := depsServer.OpenSourceBundle(ctx, &terraform1.OpenSourceBundle_Request{
openSourcesResp, err := depsServer.OpenSourceBundle(ctx, &dependencies.OpenSourceBundle_Request{
LocalPath: "testdata/sourcebundle",
})
if err != nil {
t.Fatal(err)
}
defer func() {
depsServer.CloseSourceBundle(ctx, &terraform1.CloseSourceBundle_Request{
depsServer.CloseSourceBundle(ctx, &dependencies.CloseSourceBundle_Request{
SourceBundleHandle: openSourcesResp.SourceBundleHandle,
})
}()
openLocksResp, err := depsServer.OpenDependencyLockFile(ctx, &terraform1.OpenDependencyLockFile_Request{
openLocksResp, err := depsServer.OpenDependencyLockFile(ctx, &dependencies.OpenDependencyLockFile_Request{
SourceBundleHandle: openSourcesResp.SourceBundleHandle,
SourceAddress: &terraform1.SourceAddress{
Source: "git::https://example.com/foo.git//.terraform.lock.hcl",
@ -125,7 +128,7 @@ func TestDependencyLocks(t *testing.T) {
}
}
getProvidersResp, err := depsServer.GetLockedProviderDependencies(ctx, &terraform1.GetLockedProviderDependencies_Request{
getProvidersResp, err := depsServer.GetLockedProviderDependencies(ctx, &dependencies.GetLockedProviderDependencies_Request{
DependencyLocksHandle: openLocksResp.DependencyLocksHandle,
})
if err != nil {
@ -144,7 +147,7 @@ func TestDependencyLocks(t *testing.T) {
t.Errorf("wrong GetLockedProviderDependencies result\n%s", diff)
}
_, err = depsServer.CloseDependencyLocks(ctx, &terraform1.CloseDependencyLocks_Request{
_, err = depsServer.CloseDependencyLocks(ctx, &dependencies.CloseDependencyLocks_Request{
DependencyLocksHandle: openLocksResp.DependencyLocksHandle,
})
if err != nil {
@ -154,14 +157,14 @@ func TestDependencyLocks(t *testing.T) {
// We should now be able to create a new locks handle referring to the
// same providers as the one we just closed. This simulates a caller
// propagating its provider locks between separate instances of rpcapi.
newLocksResp, err := depsServer.CreateDependencyLocks(ctx, &terraform1.CreateDependencyLocks_Request{
newLocksResp, err := depsServer.CreateDependencyLocks(ctx, &dependencies.CreateDependencyLocks_Request{
ProviderSelections: getProvidersResp.SelectedProviders,
})
if err != nil {
t.Fatal(err)
}
getProvidersResp, err = depsServer.GetLockedProviderDependencies(ctx, &terraform1.GetLockedProviderDependencies_Request{
getProvidersResp, err = depsServer.GetLockedProviderDependencies(ctx, &dependencies.GetLockedProviderDependencies_Request{
DependencyLocksHandle: newLocksResp.DependencyLocksHandle,
})
if err != nil {
@ -182,19 +185,19 @@ func TestDependenciesProviderCache(t *testing.T) {
// a real in-memory gRPC connection to exercise it concisely so that
// we can work with the client API rather than the server API.
grpcClient, close := grpcClientForTesting(ctx, t, func(srv *grpc.Server) {
terraform1.RegisterDependenciesServer(srv, depsServer)
dependencies.RegisterDependenciesServer(srv, depsServer)
})
defer close()
depsClient := terraform1.NewDependenciesClient(grpcClient)
depsClient := dependencies.NewDependenciesClient(grpcClient)
openSourcesResp, err := depsClient.OpenSourceBundle(ctx, &terraform1.OpenSourceBundle_Request{
openSourcesResp, err := depsClient.OpenSourceBundle(ctx, &dependencies.OpenSourceBundle_Request{
LocalPath: "testdata/sourcebundle",
})
if err != nil {
t.Fatal(err)
}
defer func() {
_, err := depsClient.CloseSourceBundle(ctx, &terraform1.CloseSourceBundle_Request{
_, err := depsClient.CloseSourceBundle(ctx, &dependencies.CloseSourceBundle_Request{
SourceBundleHandle: openSourcesResp.SourceBundleHandle,
})
if err != nil {
@ -202,7 +205,7 @@ func TestDependenciesProviderCache(t *testing.T) {
}
}()
openLocksResp, err := depsClient.OpenDependencyLockFile(ctx, &terraform1.OpenDependencyLockFile_Request{
openLocksResp, err := depsClient.OpenDependencyLockFile(ctx, &dependencies.OpenDependencyLockFile_Request{
SourceBundleHandle: openSourcesResp.SourceBundleHandle,
SourceAddress: &terraform1.SourceAddress{
Source: "git::https://example.com/foo.git//.terraform.lock.hcl",
@ -218,7 +221,7 @@ func TestDependenciesProviderCache(t *testing.T) {
tmpDir := t.TempDir()
cacheDir := filepath.Join(tmpDir, "pc")
evts, err := depsClient.BuildProviderPluginCache(ctx, &terraform1.BuildProviderPluginCache_Request{
evts, err := depsClient.BuildProviderPluginCache(ctx, &dependencies.BuildProviderPluginCache_Request{
DependencyLocksHandle: openLocksResp.DependencyLocksHandle,
CacheDir: cacheDir,
@ -229,9 +232,9 @@ func TestDependenciesProviderCache(t *testing.T) {
// (A real client of this API would typically just specify the "direct"
// installation method, which retrieves packages from their origin
// registries.)
InstallationMethods: []*terraform1.BuildProviderPluginCache_Request_InstallMethod{
InstallationMethods: []*dependencies.BuildProviderPluginCache_Request_InstallMethod{
{
Source: &terraform1.BuildProviderPluginCache_Request_InstallMethod_LocalMirrorDir{
Source: &dependencies.BuildProviderPluginCache_Request_InstallMethod_LocalMirrorDir{
LocalMirrorDir: "testdata/provider-fs-mirror",
},
},
@ -258,9 +261,9 @@ func TestDependenciesProviderCache(t *testing.T) {
// for UI purposes we ought to add more coverage here for the other
// event types.
switch evt := msg.Event.(type) {
case *terraform1.BuildProviderPluginCache_Event_Diagnostic:
case *dependencies.BuildProviderPluginCache_Event_Diagnostic:
t.Errorf("unexpected diagnostic:\n\n%s\n\n%s", evt.Diagnostic.Summary, evt.Diagnostic.Detail)
case *terraform1.BuildProviderPluginCache_Event_FetchComplete_:
case *dependencies.BuildProviderPluginCache_Event_FetchComplete_:
if evt.FetchComplete.ProviderVersion.SourceAddr == "example.com/foo/bar" {
seenFakeProvider = true
if got, want := evt.FetchComplete.ProviderVersion.Version, "1.2.3"; got != want {
@ -275,7 +278,7 @@ func TestDependenciesProviderCache(t *testing.T) {
t.Error("no 'fetch complete' event for example.com/foo/bar")
}
openCacheResp, err := depsClient.OpenProviderPluginCache(ctx, &terraform1.OpenProviderPluginCache_Request{
openCacheResp, err := depsClient.OpenProviderPluginCache(ctx, &dependencies.OpenProviderPluginCache_Request{
CacheDir: cacheDir,
OverridePlatform: "os_arch",
})
@ -283,14 +286,14 @@ func TestDependenciesProviderCache(t *testing.T) {
t.Fatal(err)
}
defer func() {
_, err := depsClient.CloseProviderPluginCache(ctx, &terraform1.CloseProviderPluginCache_Request{
_, err := depsClient.CloseProviderPluginCache(ctx, &dependencies.CloseProviderPluginCache_Request{
ProviderCacheHandle: openCacheResp.ProviderCacheHandle,
})
if err != nil {
t.Error(err)
}
}()
pkgsResp, err := depsClient.GetCachedProviders(ctx, &terraform1.GetCachedProviders_Request{
pkgsResp, err := depsClient.GetCachedProviders(ctx, &dependencies.GetCachedProviders_Request{
ProviderCacheHandle: openCacheResp.ProviderCacheHandle,
})
if err != nil {
@ -320,7 +323,7 @@ func TestDependenciesProviderSchema(t *testing.T) {
handles := newHandleTable()
depsServer := newDependenciesServer(handles, disco.New())
providersResp, err := depsServer.GetBuiltInProviders(ctx, &terraform1.GetBuiltInProviders_Request{})
providersResp, err := depsServer.GetBuiltInProviders(ctx, &dependencies.GetBuiltInProviders_Request{})
if err != nil {
t.Fatal(err)
}
@ -336,7 +339,7 @@ func TestDependenciesProviderSchema(t *testing.T) {
}
}
schemaResp, err := depsServer.GetProviderSchema(ctx, &terraform1.GetProviderSchema_Request{
schemaResp, err := depsServer.GetProviderSchema(ctx, &dependencies.GetProviderSchema_Request{
ProviderAddr: "terraform.io/builtin/terraform",
})
if err != nil {
@ -344,69 +347,69 @@ func TestDependenciesProviderSchema(t *testing.T) {
}
{
got := schemaResp.Schema
want := &terraform1.ProviderSchema{
ProviderConfig: &terraform1.Schema{
Block: &terraform1.Schema_Block{
want := &dependencies.ProviderSchema{
ProviderConfig: &dependencies.Schema{
Block: &dependencies.Schema_Block{
// This provider has no configuration arguments
},
},
DataResourceTypes: map[string]*terraform1.Schema{
"terraform_remote_state": &terraform1.Schema{
Block: &terraform1.Schema_Block{
Attributes: []*terraform1.Schema_Attribute{
DataResourceTypes: map[string]*dependencies.Schema{
"terraform_remote_state": &dependencies.Schema{
Block: &dependencies.Schema_Block{
Attributes: []*dependencies.Schema_Attribute{
{
Name: "backend",
Type: []byte(`"string"`),
Required: true,
Description: &terraform1.Schema_DocString{
Description: &dependencies.Schema_DocString{
Description: "The remote backend to use, e.g. `remote` or `http`.",
Format: terraform1.Schema_DocString_MARKDOWN,
Format: dependencies.Schema_DocString_MARKDOWN,
},
},
{
Name: "config",
Type: []byte(`"dynamic"`),
Optional: true,
Description: &terraform1.Schema_DocString{
Description: &dependencies.Schema_DocString{
Description: "The configuration of the remote backend. Although this is optional, most backends require some configuration.\n\nThe object can use any arguments that would be valid in the equivalent `terraform { backend \"<TYPE>\" { ... } }` block.",
Format: terraform1.Schema_DocString_MARKDOWN,
Format: dependencies.Schema_DocString_MARKDOWN,
},
},
{
Name: "defaults",
Type: []byte(`"dynamic"`),
Optional: true,
Description: &terraform1.Schema_DocString{
Description: &dependencies.Schema_DocString{
Description: "Default values for outputs, in case the state file is empty or lacks a required output.",
Format: terraform1.Schema_DocString_MARKDOWN,
Format: dependencies.Schema_DocString_MARKDOWN,
},
},
{
Name: "outputs",
Type: []byte(`"dynamic"`),
Computed: true,
Description: &terraform1.Schema_DocString{
Description: &dependencies.Schema_DocString{
Description: "An object containing every root-level output in the remote state.",
Format: terraform1.Schema_DocString_MARKDOWN,
Format: dependencies.Schema_DocString_MARKDOWN,
},
},
{
Name: "workspace",
Type: []byte(`"string"`),
Optional: true,
Description: &terraform1.Schema_DocString{
Description: &dependencies.Schema_DocString{
Description: "The Terraform workspace to use, if the backend supports workspaces.",
Format: terraform1.Schema_DocString_MARKDOWN,
Format: dependencies.Schema_DocString_MARKDOWN,
},
},
},
},
},
},
ManagedResourceTypes: map[string]*terraform1.Schema{
"terraform_data": &terraform1.Schema{
Block: &terraform1.Schema_Block{
Attributes: []*terraform1.Schema_Attribute{
ManagedResourceTypes: map[string]*dependencies.Schema{
"terraform_data": &dependencies.Schema{
Block: &dependencies.Schema_Block{
Attributes: []*dependencies.Schema_Attribute{
{
Name: "id",
Type: []byte(`"string"`),

34
internal/rpcapi/dynrpcserver/dependencies.go
View file

@ -8,21 +8,21 @@ import (
"context"
"sync"
tf1 "github.com/hashicorp/terraform/internal/rpcapi/terraform1"
dependencies "github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies"
)
type Dependencies struct {
impl tf1.DependenciesServer
impl dependencies.DependenciesServer
mu sync.RWMutex
}
var _ tf1.DependenciesServer = (*Dependencies)(nil)
var _ dependencies.DependenciesServer = (*Dependencies)(nil)
func NewDependenciesStub() *Dependencies {
return &Dependencies{}
}
func (s *Dependencies) BuildProviderPluginCache(a0 *tf1.BuildProviderPluginCache_Request, a1 tf1.Dependencies_BuildProviderPluginCacheServer) error {
func (s *Dependencies) BuildProviderPluginCache(a0 *dependencies.BuildProviderPluginCache_Request, a1 dependencies.Dependencies_BuildProviderPluginCacheServer) error {
impl, err := s.realRPCServer()
if err != nil {
return err
@ -30,7 +30,7 @@ func (s *Dependencies) BuildProviderPluginCache(a0 *tf1.BuildProviderPluginCache
return impl.BuildProviderPluginCache(a0, a1)
}
func (s *Dependencies) CloseDependencyLocks(a0 context.Context, a1 *tf1.CloseDependencyLocks_Request) (*tf1.CloseDependencyLocks_Response, error) {
func (s *Dependencies) CloseDependencyLocks(a0 context.Context, a1 *dependencies.CloseDependencyLocks_Request) (*dependencies.CloseDependencyLocks_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -38,7 +38,7 @@ func (s *Dependencies) CloseDependencyLocks(a0 context.Context, a1 *tf1.CloseDep
return impl.CloseDependencyLocks(a0, a1)
}
func (s *Dependencies) CloseProviderPluginCache(a0 context.Context, a1 *tf1.CloseProviderPluginCache_Request) (*tf1.CloseProviderPluginCache_Response, error) {
func (s *Dependencies) CloseProviderPluginCache(a0 context.Context, a1 *dependencies.CloseProviderPluginCache_Request) (*dependencies.CloseProviderPluginCache_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -46,7 +46,7 @@ func (s *Dependencies) CloseProviderPluginCache(a0 context.Context, a1 *tf1.Clos
return impl.CloseProviderPluginCache(a0, a1)
}
func (s *Dependencies) CloseSourceBundle(a0 context.Context, a1 *tf1.CloseSourceBundle_Request) (*tf1.CloseSourceBundle_Response, error) {
func (s *Dependencies) CloseSourceBundle(a0 context.Context, a1 *dependencies.CloseSourceBundle_Request) (*dependencies.CloseSourceBundle_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -54,7 +54,7 @@ func (s *Dependencies) CloseSourceBundle(a0 context.Context, a1 *tf1.CloseSource
return impl.CloseSourceBundle(a0, a1)
}
func (s *Dependencies) CreateDependencyLocks(a0 context.Context, a1 *tf1.CreateDependencyLocks_Request) (*tf1.CreateDependencyLocks_Response, error) {
func (s *Dependencies) CreateDependencyLocks(a0 context.Context, a1 *dependencies.CreateDependencyLocks_Request) (*dependencies.CreateDependencyLocks_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -62,7 +62,7 @@ func (s *Dependencies) CreateDependencyLocks(a0 context.Context, a1 *tf1.CreateD
return impl.CreateDependencyLocks(a0, a1)
}
func (s *Dependencies) GetBuiltInProviders(a0 context.Context, a1 *tf1.GetBuiltInProviders_Request) (*tf1.GetBuiltInProviders_Response, error) {
func (s *Dependencies) GetBuiltInProviders(a0 context.Context, a1 *dependencies.GetBuiltInProviders_Request) (*dependencies.GetBuiltInProviders_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -70,7 +70,7 @@ func (s *Dependencies) GetBuiltInProviders(a0 context.Context, a1 *tf1.GetBuiltI
return impl.GetBuiltInProviders(a0, a1)
}
func (s *Dependencies) GetCachedProviders(a0 context.Context, a1 *tf1.GetCachedProviders_Request) (*tf1.GetCachedProviders_Response, error) {
func (s *Dependencies) GetCachedProviders(a0 context.Context, a1 *dependencies.GetCachedProviders_Request) (*dependencies.GetCachedProviders_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -78,7 +78,7 @@ func (s *Dependencies) GetCachedProviders(a0 context.Context, a1 *tf1.GetCachedP
return impl.GetCachedProviders(a0, a1)
}
func (s *Dependencies) GetLockedProviderDependencies(a0 context.Context, a1 *tf1.GetLockedProviderDependencies_Request) (*tf1.GetLockedProviderDependencies_Response, error) {
func (s *Dependencies) GetLockedProviderDependencies(a0 context.Context, a1 *dependencies.GetLockedProviderDependencies_Request) (*dependencies.GetLockedProviderDependencies_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -86,7 +86,7 @@ func (s *Dependencies) GetLockedProviderDependencies(a0 context.Context, a1 *tf1
return impl.GetLockedProviderDependencies(a0, a1)
}
func (s *Dependencies) GetProviderSchema(a0 context.Context, a1 *tf1.GetProviderSchema_Request) (*tf1.GetProviderSchema_Response, error) {
func (s *Dependencies) GetProviderSchema(a0 context.Context, a1 *dependencies.GetProviderSchema_Request) (*dependencies.GetProviderSchema_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -94,7 +94,7 @@ func (s *Dependencies) GetProviderSchema(a0 context.Context, a1 *tf1.GetProvider
return impl.GetProviderSchema(a0, a1)
}
func (s *Dependencies) OpenDependencyLockFile(a0 context.Context, a1 *tf1.OpenDependencyLockFile_Request) (*tf1.OpenDependencyLockFile_Response, error) {
func (s *Dependencies) OpenDependencyLockFile(a0 context.Context, a1 *dependencies.OpenDependencyLockFile_Request) (*dependencies.OpenDependencyLockFile_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -102,7 +102,7 @@ func (s *Dependencies) OpenDependencyLockFile(a0 context.Context, a1 *tf1.OpenDe
return impl.OpenDependencyLockFile(a0, a1)
}
func (s *Dependencies) OpenProviderPluginCache(a0 context.Context, a1 *tf1.OpenProviderPluginCache_Request) (*tf1.OpenProviderPluginCache_Response, error) {
func (s *Dependencies) OpenProviderPluginCache(a0 context.Context, a1 *dependencies.OpenProviderPluginCache_Request) (*dependencies.OpenProviderPluginCache_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -110,7 +110,7 @@ func (s *Dependencies) OpenProviderPluginCache(a0 context.Context, a1 *tf1.OpenP
return impl.OpenProviderPluginCache(a0, a1)
}
func (s *Dependencies) OpenSourceBundle(a0 context.Context, a1 *tf1.OpenSourceBundle_Request) (*tf1.OpenSourceBundle_Response, error) {
func (s *Dependencies) OpenSourceBundle(a0 context.Context, a1 *dependencies.OpenSourceBundle_Request) (*dependencies.OpenSourceBundle_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -118,13 +118,13 @@ func (s *Dependencies) OpenSourceBundle(a0 context.Context, a1 *tf1.OpenSourceBu
return impl.OpenSourceBundle(a0, a1)
}
func (s *Dependencies) ActivateRPCServer(impl tf1.DependenciesServer) {
func (s *Dependencies) ActivateRPCServer(impl dependencies.DependenciesServer) {
s.mu.Lock()
s.impl = impl
s.mu.Unlock()
}
func (s *Dependencies) realRPCServer() (tf1.DependenciesServer, error) {
func (s *Dependencies) realRPCServer() (dependencies.DependenciesServer, error) {
s.mu.RLock()
impl := s.impl
s.mu.RUnlock()

272
internal/rpcapi/dynrpcserver/generator/main.go
View file

@ -23,172 +23,177 @@ import (
"golang.org/x/tools/go/packages"
)
const protobufPkg = "github.com/hashicorp/terraform/internal/rpcapi/terraform1"
var protobufPkgs = map[string]string{
"dependencies": "github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies",
"stacks": "github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks",
"packages": "github.com/hashicorp/terraform/internal/rpcapi/terraform1/packages",
}
func main() {
cfg := &packages.Config{
Mode: packages.NeedTypes | packages.NeedTypesInfo | packages.NeedFiles,
}
pkgs, err := packages.Load(cfg, protobufPkg)
if err != nil {
log.Fatalf("can't load the protobuf/gRPC proxy package: %s", err)
}
if len(pkgs) != 1 {
log.Fatalf("wrong number of packages found")
}
pkg := pkgs[0]
if pkg.TypesInfo == nil {
log.Fatalf("types info not available")
}
if len(pkg.GoFiles) < 1 {
log.Fatalf("no files included in package")
}
// We assume that our output directory is sibling to the directory
// containing the protobuf specification.
outDir := filepath.Join(filepath.Dir(pkg.GoFiles[0]), "../dynrpcserver")
Types:
for _, obj := range pkg.TypesInfo.Defs {
typ, ok := obj.(*types.TypeName)
if !ok {
continue
for shortName, pkgName := range protobufPkgs {
cfg := &packages.Config{
Mode: packages.NeedTypes | packages.NeedTypesInfo | packages.NeedFiles,
}
underTyp := typ.Type().Underlying()
iface, ok := underTyp.(*types.Interface)
if !ok {
continue
pkgs, err := packages.Load(cfg, pkgName)
if err != nil {
log.Fatalf("can't load the protobuf/gRPC proxy package: %s", err)
}
if !strings.HasSuffix(typ.Name(), "Server") || typ.Name() == "SetupServer" {
// Doesn't look like a generated gRPC server interface
continue
if len(pkgs) != 1 {
log.Fatalf("wrong number of packages found")
}
pkg := pkgs[0]
if pkg.TypesInfo == nil {
log.Fatalf("types info not available")
}
if len(pkg.GoFiles) < 1 {
log.Fatalf("no files included in package")
}
// The interfaces used for streaming requests/responses unfortunately
// also have a "Server" suffix in the generated Go code, and so
// we need to detect those more surgically by noticing that they
// have grpc.ServerStream embedded inside.
for i := 0; i < iface.NumEmbeddeds(); i++ {
emb, ok := iface.EmbeddedType(i).(*types.Named)
// We assume that our output directory is sibling to the directory
// containing the protobuf specification.
outDir := filepath.Join(filepath.Dir(pkg.GoFiles[0]), "../../dynrpcserver")
Types:
for _, obj := range pkg.TypesInfo.Defs {
typ, ok := obj.(*types.TypeName)
if !ok {
continue
}
pkg := emb.Obj().Pkg().Path()
name := emb.Obj().Name()
if pkg == "google.golang.org/grpc" && name == "ServerStream" {
continue Types
underTyp := typ.Type().Underlying()
iface, ok := underTyp.(*types.Interface)
if !ok {
continue
}
if !strings.HasSuffix(typ.Name(), "Server") || typ.Name() == "SetupServer" {
// Doesn't look like a generated gRPC server interface
continue
}
}
// If we get here then what we're holding _seems_ to be a gRPC
// server interface, and so we'll generate a dynamic initialization
// wrapper for it.
// The interfaces used for streaming requests/responses unfortunately
// also have a "Server" suffix in the generated Go code, and so
// we need to detect those more surgically by noticing that they
// have grpc.ServerStream embedded inside.
for i := 0; i < iface.NumEmbeddeds(); i++ {
emb, ok := iface.EmbeddedType(i).(*types.Named)
if !ok {
continue
}
pkg := emb.Obj().Pkg().Path()
name := emb.Obj().Name()
if pkg == "google.golang.org/grpc" && name == "ServerStream" {
continue Types
}
}
ifaceName := typ.Name()
baseName := strings.TrimSuffix(ifaceName, "Server")
filename := toFilenameCase(baseName) + ".go"
absFilename := filepath.Join(outDir, filename)
// If we get here then what we're holding _seems_ to be a gRPC
// server interface, and so we'll generate a dynamic initialization
// wrapper for it.
var buf bytes.Buffer
ifaceName := typ.Name()
baseName := strings.TrimSuffix(ifaceName, "Server")
filename := toFilenameCase(baseName) + ".go"
absFilename := filepath.Join(outDir, filename)
fmt.Fprintf(&buf, `// Copyright (c) HashiCorp, Inc.
var buf bytes.Buffer
fmt.Fprintf(&buf, `// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
// Code generated by ./generator. DO NOT EDIT.
`)
fmt.Fprintf(&buf, `package dynrpcserver
fmt.Fprintf(&buf, `package dynrpcserver
import (
"context"
"sync"
tf1 %q
%s %q
)
`, protobufPkg)
fmt.Fprintf(&buf, "type %s struct {\n", baseName)
fmt.Fprintf(&buf, "impl tf1.%s\n", ifaceName)
fmt.Fprintln(&buf, "mu sync.RWMutex")
buf.WriteString("}\n\n")
`, shortName, pkg)
fmt.Fprintf(&buf, "type %s struct {\n", baseName)
fmt.Fprintf(&buf, "impl %s.%s\n", shortName, ifaceName)
fmt.Fprintln(&buf, "mu sync.RWMutex")
buf.WriteString("}\n\n")
fmt.Fprintf(&buf, "var _ tf1.%s = (*%s)(nil)\n\n", ifaceName, baseName)
fmt.Fprintf(&buf, "var _ %s.%s = (*%s)(nil)\n\n", shortName, ifaceName, baseName)
fmt.Fprintf(&buf, "func New%sStub() *%s {\n", baseName, baseName)
fmt.Fprintf(&buf, "return &%s{}\n", baseName)
fmt.Fprintf(&buf, "}\n\n")
fmt.Fprintf(&buf, "func New%sStub() *%s {\n", baseName, baseName)
fmt.Fprintf(&buf, "return &%s{}\n", baseName)
fmt.Fprintf(&buf, "}\n\n")
for i := 0; i < iface.NumMethods(); i++ {
method := iface.Method(i)
sig := method.Type().(*types.Signature)
for i := 0; i < iface.NumMethods(); i++ {
method := iface.Method(i)
sig := method.Type().(*types.Signature)
fmt.Fprintf(&buf, "func (s *%s) %s(", baseName, method.Name())
for i := 0; i < sig.Params().Len(); i++ {
param := sig.Params().At(i)
fmt.Fprintf(&buf, "func (s *%s) %s(", baseName, method.Name())
for i := 0; i < sig.Params().Len(); i++ {
param := sig.Params().At(i)
// The generated interface types don't include parameter names
// and so we just use synthetic parameter names here.
name := fmt.Sprintf("a%d", i)
genType := typeRef(param.Type().String())
// The generated interface types don't include parameter names
// and so we just use synthetic parameter names here.
name := fmt.Sprintf("a%d", i)
genType := typeRef(param.Type().String(), shortName, pkgName)
if i > 0 {
buf.WriteString(", ")
if i > 0 {
buf.WriteString(", ")
}
buf.WriteString(name)
buf.WriteString(" ")
buf.WriteString(genType)
}
buf.WriteString(name)
buf.WriteString(" ")
buf.WriteString(genType)
}
fmt.Fprintf(&buf, ")")
if sig.Results().Len() > 1 {
buf.WriteString("(")
}
for i := 0; i < sig.Results().Len(); i++ {
result := sig.Results().At(i)
genType := typeRef(result.Type().String())
if i > 0 {
buf.WriteString(", ")
fmt.Fprintf(&buf, ")")
if sig.Results().Len() > 1 {
buf.WriteString("(")
}
buf.WriteString(genType)
}
if sig.Results().Len() > 1 {
buf.WriteString(")")
}
switch n := sig.Results().Len(); n {
case 1:
fmt.Fprintf(&buf, ` {
for i := 0; i < sig.Results().Len(); i++ {
result := sig.Results().At(i)
genType := typeRef(result.Type().String(), shortName, pkgName)
if i > 0 {
buf.WriteString(", ")
}
buf.WriteString(genType)
}
if sig.Results().Len() > 1 {
buf.WriteString(")")
}
switch n := sig.Results().Len(); n {
case 1:
fmt.Fprintf(&buf, ` {
impl, err := s.realRPCServer()
if err != nil {
return err
}
`)
case 2:
fmt.Fprintf(&buf, ` {
case 2:
fmt.Fprintf(&buf, ` {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
}
`)
default:
log.Fatalf("don't know how to make a stub for method with %d results", n)
}
fmt.Fprintf(&buf, "return impl.%s(", method.Name())
for i := 0; i < sig.Params().Len(); i++ {
if i > 0 {
buf.WriteString(", ")
default:
log.Fatalf("don't know how to make a stub for method with %d results", n)
}
fmt.Fprintf(&buf, "a%d", i)
fmt.Fprintf(&buf, "return impl.%s(", method.Name())
for i := 0; i < sig.Params().Len(); i++ {
if i > 0 {
buf.WriteString(", ")
}
fmt.Fprintf(&buf, "a%d", i)
}
fmt.Fprintf(&buf, ")\n}\n\n")
}
fmt.Fprintf(&buf, ")\n}\n\n")
}
fmt.Fprintf(&buf, `
func (s *%s) ActivateRPCServer(impl tf1.%s) {
fmt.Fprintf(&buf, `
func (s *%s) ActivateRPCServer(impl %s.%s) {
s.mu.Lock()
s.impl = impl
s.mu.Unlock()
}
func (s *%s) realRPCServer() (tf1.%s, error) {
func (s *%s) realRPCServer() (%s.%s, error) {
s.mu.RLock()
impl := s.impl
s.mu.RUnlock()
@ -197,26 +202,27 @@ Types:
}
return impl, nil
}
`, baseName, ifaceName, baseName, ifaceName)
`, baseName, shortName, ifaceName, baseName, shortName, ifaceName)
src, err := format.Source(buf.Bytes())
if err != nil {
//log.Fatalf("formatting %s: %s", filename, err)
src = buf.Bytes()
}
f, err := os.Create(absFilename)
if err != nil {
log.Fatal(err)
}
_, err = f.Write(src)
if err != nil {
log.Fatalf("writing %s: %s", filename, err)
}
src, err := format.Source(buf.Bytes())
if err != nil {
//log.Fatalf("formatting %s: %s", filename, err)
src = buf.Bytes()
}
f, err := os.Create(absFilename)
if err != nil {
log.Fatal(err)
}
_, err = f.Write(src)
if err != nil {
log.Fatalf("writing %s: %s", filename, err)
}
}
}
}
func typeRef(fullType string) string {
func typeRef(fullType, name, pkg string) string {
// The following is specialized to only the parameter types
// we typically expect to see in a server interface. This
// might need extra rules if we step outside the design idiom
@ -226,10 +232,10 @@ func typeRef(fullType string) string {
return fullType
case fullType == "interface{}" || fullType == "any":
return "any"
case strings.HasPrefix(fullType, "*"+protobufPkg+"."):
return "*tf1." + fullType[len(protobufPkg)+2:]
case strings.HasPrefix(fullType, protobufPkg+"."):
return "tf1." + fullType[len(protobufPkg)+1:]
case strings.HasPrefix(fullType, "*"+pkg+"."):
return "*" + name + "." + fullType[len(pkg)+2:]
case strings.HasPrefix(fullType, pkg+"."):
return name + "." + fullType[len(pkg)+1:]
default:
log.Fatalf("don't know what to do with parameter type %s", fullType)
return ""

20
internal/rpcapi/dynrpcserver/packages.go
View file

@ -8,21 +8,21 @@ import (
"context"
"sync"
tf1 "github.com/hashicorp/terraform/internal/rpcapi/terraform1"
packages "github.com/hashicorp/terraform/internal/rpcapi/terraform1/packages"
)
type Packages struct {
impl tf1.PackagesServer
impl packages.PackagesServer
mu sync.RWMutex
}
var _ tf1.PackagesServer = (*Packages)(nil)
var _ packages.PackagesServer = (*Packages)(nil)
func NewPackagesStub() *Packages {
return &Packages{}
}
func (s *Packages) FetchModulePackage(a0 context.Context, a1 *tf1.FetchModulePackage_Request) (*tf1.FetchModulePackage_Response, error) {
func (s *Packages) FetchModulePackage(a0 context.Context, a1 *packages.FetchModulePackage_Request) (*packages.FetchModulePackage_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -30,7 +30,7 @@ func (s *Packages) FetchModulePackage(a0 context.Context, a1 *tf1.FetchModulePac
return impl.FetchModulePackage(a0, a1)
}
func (s *Packages) FetchProviderPackage(a0 context.Context, a1 *tf1.FetchProviderPackage_Request) (*tf1.FetchProviderPackage_Response, error) {
func (s *Packages) FetchProviderPackage(a0 context.Context, a1 *packages.FetchProviderPackage_Request) (*packages.FetchProviderPackage_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -38,7 +38,7 @@ func (s *Packages) FetchProviderPackage(a0 context.Context, a1 *tf1.FetchProvide
return impl.FetchProviderPackage(a0, a1)
}
func (s *Packages) ModulePackageSourceAddr(a0 context.Context, a1 *tf1.ModulePackageSourceAddr_Request) (*tf1.ModulePackageSourceAddr_Response, error) {
func (s *Packages) ModulePackageSourceAddr(a0 context.Context, a1 *packages.ModulePackageSourceAddr_Request) (*packages.ModulePackageSourceAddr_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -46,7 +46,7 @@ func (s *Packages) ModulePackageSourceAddr(a0 context.Context, a1 *tf1.ModulePac
return impl.ModulePackageSourceAddr(a0, a1)
}
func (s *Packages) ModulePackageVersions(a0 context.Context, a1 *tf1.ModulePackageVersions_Request) (*tf1.ModulePackageVersions_Response, error) {
func (s *Packages) ModulePackageVersions(a0 context.Context, a1 *packages.ModulePackageVersions_Request) (*packages.ModulePackageVersions_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -54,7 +54,7 @@ func (s *Packages) ModulePackageVersions(a0 context.Context, a1 *tf1.ModulePacka
return impl.ModulePackageVersions(a0, a1)
}
func (s *Packages) ProviderPackageVersions(a0 context.Context, a1 *tf1.ProviderPackageVersions_Request) (*tf1.ProviderPackageVersions_Response, error) {
func (s *Packages) ProviderPackageVersions(a0 context.Context, a1 *packages.ProviderPackageVersions_Request) (*packages.ProviderPackageVersions_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -62,13 +62,13 @@ func (s *Packages) ProviderPackageVersions(a0 context.Context, a1 *tf1.ProviderP
return impl.ProviderPackageVersions(a0, a1)
}
func (s *Packages) ActivateRPCServer(impl tf1.PackagesServer) {
func (s *Packages) ActivateRPCServer(impl packages.PackagesServer) {
s.mu.Lock()
s.impl = impl
s.mu.Unlock()
}
func (s *Packages) realRPCServer() (tf1.PackagesServer, error) {
func (s *Packages) realRPCServer() (packages.PackagesServer, error) {
s.mu.RLock()
impl := s.impl
s.mu.RUnlock()

34
internal/rpcapi/dynrpcserver/stacks.go
View file

@ -8,21 +8,21 @@ import (
"context"
"sync"
tf1 "github.com/hashicorp/terraform/internal/rpcapi/terraform1"
stacks "github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
)
type Stacks struct {
impl tf1.StacksServer
impl stacks.StacksServer
mu sync.RWMutex
}
var _ tf1.StacksServer = (*Stacks)(nil)
var _ stacks.StacksServer = (*Stacks)(nil)
func NewStacksStub() *Stacks {
return &Stacks{}
}
func (s *Stacks) ApplyStackChanges(a0 *tf1.ApplyStackChanges_Request, a1 tf1.Stacks_ApplyStackChangesServer) error {
func (s *Stacks) ApplyStackChanges(a0 *stacks.ApplyStackChanges_Request, a1 stacks.Stacks_ApplyStackChangesServer) error {
impl, err := s.realRPCServer()
if err != nil {
return err
@ -30,7 +30,7 @@ func (s *Stacks) ApplyStackChanges(a0 *tf1.ApplyStackChanges_Request, a1 tf1.Sta
return impl.ApplyStackChanges(a0, a1)
}
func (s *Stacks) ClosePlan(a0 context.Context, a1 *tf1.CloseStackPlan_Request) (*tf1.CloseStackPlan_Response, error) {
func (s *Stacks) ClosePlan(a0 context.Context, a1 *stacks.CloseStackPlan_Request) (*stacks.CloseStackPlan_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -38,7 +38,7 @@ func (s *Stacks) ClosePlan(a0 context.Context, a1 *tf1.CloseStackPlan_Request) (
return impl.ClosePlan(a0, a1)
}
func (s *Stacks) CloseStackConfiguration(a0 context.Context, a1 *tf1.CloseStackConfiguration_Request) (*tf1.CloseStackConfiguration_Response, error) {
func (s *Stacks) CloseStackConfiguration(a0 context.Context, a1 *stacks.CloseStackConfiguration_Request) (*stacks.CloseStackConfiguration_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -46,7 +46,7 @@ func (s *Stacks) CloseStackConfiguration(a0 context.Context, a1 *tf1.CloseStackC
return impl.CloseStackConfiguration(a0, a1)
}
func (s *Stacks) CloseState(a0 context.Context, a1 *tf1.CloseStackState_Request) (*tf1.CloseStackState_Response, error) {
func (s *Stacks) CloseState(a0 context.Context, a1 *stacks.CloseStackState_Request) (*stacks.CloseStackState_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -54,7 +54,7 @@ func (s *Stacks) CloseState(a0 context.Context, a1 *tf1.CloseStackState_Request)
return impl.CloseState(a0, a1)
}
func (s *Stacks) FindStackConfigurationComponents(a0 context.Context, a1 *tf1.FindStackConfigurationComponents_Request) (*tf1.FindStackConfigurationComponents_Response, error) {
func (s *Stacks) FindStackConfigurationComponents(a0 context.Context, a1 *stacks.FindStackConfigurationComponents_Request) (*stacks.FindStackConfigurationComponents_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -62,7 +62,7 @@ func (s *Stacks) FindStackConfigurationComponents(a0 context.Context, a1 *tf1.Fi
return impl.FindStackConfigurationComponents(a0, a1)
}
func (s *Stacks) InspectExpressionResult(a0 context.Context, a1 *tf1.InspectExpressionResult_Request) (*tf1.InspectExpressionResult_Response, error) {
func (s *Stacks) InspectExpressionResult(a0 context.Context, a1 *stacks.InspectExpressionResult_Request) (*stacks.InspectExpressionResult_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -70,7 +70,7 @@ func (s *Stacks) InspectExpressionResult(a0 context.Context, a1 *tf1.InspectExpr
return impl.InspectExpressionResult(a0, a1)
}
func (s *Stacks) OpenPlan(a0 tf1.Stacks_OpenPlanServer) error {
func (s *Stacks) OpenPlan(a0 stacks.Stacks_OpenPlanServer) error {
impl, err := s.realRPCServer()
if err != nil {
return err
@ -78,7 +78,7 @@ func (s *Stacks) OpenPlan(a0 tf1.Stacks_OpenPlanServer) error {
return impl.OpenPlan(a0)
}
func (s *Stacks) OpenStackConfiguration(a0 context.Context, a1 *tf1.OpenStackConfiguration_Request) (*tf1.OpenStackConfiguration_Response, error) {
func (s *Stacks) OpenStackConfiguration(a0 context.Context, a1 *stacks.OpenStackConfiguration_Request) (*stacks.OpenStackConfiguration_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -86,7 +86,7 @@ func (s *Stacks) OpenStackConfiguration(a0 context.Context, a1 *tf1.OpenStackCon
return impl.OpenStackConfiguration(a0, a1)
}
func (s *Stacks) OpenStackInspector(a0 context.Context, a1 *tf1.OpenStackInspector_Request) (*tf1.OpenStackInspector_Response, error) {
func (s *Stacks) OpenStackInspector(a0 context.Context, a1 *stacks.OpenStackInspector_Request) (*stacks.OpenStackInspector_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -94,7 +94,7 @@ func (s *Stacks) OpenStackInspector(a0 context.Context, a1 *tf1.OpenStackInspect
return impl.OpenStackInspector(a0, a1)
}
func (s *Stacks) OpenState(a0 tf1.Stacks_OpenStateServer) error {
func (s *Stacks) OpenState(a0 stacks.Stacks_OpenStateServer) error {
impl, err := s.realRPCServer()
if err != nil {
return err
@ -102,7 +102,7 @@ func (s *Stacks) OpenState(a0 tf1.Stacks_OpenStateServer) error {
return impl.OpenState(a0)
}
func (s *Stacks) PlanStackChanges(a0 *tf1.PlanStackChanges_Request, a1 tf1.Stacks_PlanStackChangesServer) error {
func (s *Stacks) PlanStackChanges(a0 *stacks.PlanStackChanges_Request, a1 stacks.Stacks_PlanStackChangesServer) error {
impl, err := s.realRPCServer()
if err != nil {
return err
@ -110,7 +110,7 @@ func (s *Stacks) PlanStackChanges(a0 *tf1.PlanStackChanges_Request, a1 tf1.Stack
return impl.PlanStackChanges(a0, a1)
}
func (s *Stacks) ValidateStackConfiguration(a0 context.Context, a1 *tf1.ValidateStackConfiguration_Request) (*tf1.ValidateStackConfiguration_Response, error) {
func (s *Stacks) ValidateStackConfiguration(a0 context.Context, a1 *stacks.ValidateStackConfiguration_Request) (*stacks.ValidateStackConfiguration_Response, error) {
impl, err := s.realRPCServer()
if err != nil {
return nil, err
@ -118,13 +118,13 @@ func (s *Stacks) ValidateStackConfiguration(a0 context.Context, a1 *tf1.Validate
return impl.ValidateStackConfiguration(a0, a1)
}
func (s *Stacks) ActivateRPCServer(impl tf1.StacksServer) {
func (s *Stacks) ActivateRPCServer(impl stacks.StacksServer) {
s.mu.Lock()
s.impl = impl
s.mu.Unlock()
}
func (s *Stacks) realRPCServer() (tf1.StacksServer, error) {
func (s *Stacks) realRPCServer() (stacks.StacksServer, error) {
s.mu.RLock()
impl := s.impl
s.mu.RUnlock()

28
internal/rpcapi/internal_client.go
View file

@ -8,10 +8,14 @@ import (
"fmt"
"net"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/test/bufconn"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/packages"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/setup"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
)
// Client is a client for the RPC API.
@ -24,7 +28,7 @@ type Client struct {
conn *grpc.ClientConn
// serverCaps should be from the result of the Setup.Handshake call
// previously made to the server that conn is connected to.
serverCaps *terraform1.ServerCapabilities
serverCaps *setup.ServerCapabilities
close func(context.Context) error
}
@ -39,7 +43,7 @@ type Client struct {
//
// Callers should call the Close method of the returned client once they are
// done using it, or else they will leak goroutines.
func NewInternalClient(ctx context.Context, clientCaps *terraform1.ClientCapabilities) (*Client, error) {
func NewInternalClient(ctx context.Context, clientCaps *setup.ClientCapabilities) (*Client, error) {
fakeListener := bufconn.Listen(4 * 1024 * 1024 /* buffer size */)
srv := grpc.NewServer()
registerGRPCServices(srv, &serviceOpts{})
@ -68,8 +72,8 @@ func NewInternalClient(ctx context.Context, clientCaps *terraform1.ClientCapabil
// immediately use the main services. (The caller would otherwise need
// to do this immediately on return anyway, or the result would be
// useless.)
setupClient := terraform1.NewSetupClient(clientConn)
setupResp, err := setupClient.Handshake(ctx, &terraform1.Handshake_Request{
setupClient := setup.NewSetupClient(clientConn)
setupResp, err := setupClient.Handshake(ctx, &setup.Handshake_Request{
Capabilities: clientCaps,
})
if err != nil {
@ -108,21 +112,21 @@ func (c *Client) Close(ctx context.Context) error {
// ServerCapabilities returns the server's response to capability negotiation.
//
// Callers must not modify anything reachable through the returned pointer.
func (c *Client) ServerCapabilities() *terraform1.ServerCapabilities {
func (c *Client) ServerCapabilities() *setup.ServerCapabilities {
return c.serverCaps
}
// Dependencies returns a client for the Dependencies service of the RPC API.
func (c *Client) Dependencies() terraform1.DependenciesClient {
return terraform1.NewDependenciesClient(c.conn)
func (c *Client) Dependencies() dependencies.DependenciesClient {
return dependencies.NewDependenciesClient(c.conn)
}
// Packages returns a client for the Packages service of the RPC API.
func (c *Client) Packages() terraform1.PackagesClient {
return terraform1.NewPackagesClient(c.conn)
func (c *Client) Packages() packages.PackagesClient {
return packages.NewPackagesClient(c.conn)
}
// Stacks returns a client for the Stacks service of the RPC API.
func (c *Client) Stacks() terraform1.StacksClient {
return terraform1.NewStacksClient(c.conn)
func (c *Client) Stacks() stacks.StacksClient {
return stacks.NewStacksClient(c.conn)
}

5
internal/rpcapi/internal_client_test.go
View file

@ -8,13 +8,14 @@ import (
"testing"
"github.com/davecgh/go-spew/spew"
"github.com/hashicorp/terraform/internal/rpcapi"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/setup"
)
func TestInternalClientOpenClose(t *testing.T) {
ctx := context.Background()
client, err := rpcapi.NewInternalClient(ctx, &terraform1.ClientCapabilities{})
client, err := rpcapi.NewInternalClient(ctx, &setup.ClientCapabilities{})
if err != nil {
t.Error(err)
}

27
internal/rpcapi/packages.go
View file

@ -18,9 +18,10 @@ import (
"github.com/hashicorp/terraform/internal/registry"
"github.com/hashicorp/terraform/internal/registry/regsrc"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/packages"
)
var _ terraform1.PackagesServer = (*packagesServer)(nil)
var _ packages.PackagesServer = (*packagesServer)(nil)
func newPackagesServer(services *disco.Disco) *packagesServer {
return &packagesServer{
@ -38,14 +39,14 @@ func newPackagesServer(services *disco.Disco) *packagesServer {
type providerSourceFn func(services *disco.Disco) getproviders.Source
type packagesServer struct {
terraform1.UnimplementedPackagesServer
packages.UnimplementedPackagesServer
services *disco.Disco
providerSourceFn providerSourceFn
}
func (p *packagesServer) ProviderPackageVersions(ctx context.Context, request *terraform1.ProviderPackageVersions_Request) (*terraform1.ProviderPackageVersions_Response, error) {
response := new(terraform1.ProviderPackageVersions_Response)
func (p *packagesServer) ProviderPackageVersions(ctx context.Context, request *packages.ProviderPackageVersions_Request) (*packages.ProviderPackageVersions_Response, error) {
response := new(packages.ProviderPackageVersions_Response)
source := p.providerSourceFn(p.services)
provider, diags := addrs.ParseProviderSourceString(request.SourceAddr)
@ -85,9 +86,9 @@ func (p *packagesServer) ProviderPackageVersions(ctx context.Context, request *t
return response, nil
}
func (p *packagesServer) FetchProviderPackage(ctx context.Context, request *terraform1.FetchProviderPackage_Request) (*terraform1.FetchProviderPackage_Response, error) {
func (p *packagesServer) FetchProviderPackage(ctx context.Context, request *packages.FetchProviderPackage_Request) (*packages.FetchProviderPackage_Response, error) {
response := new(terraform1.FetchProviderPackage_Response)
response := new(packages.FetchProviderPackage_Response)
version, err := versions.ParseVersion(request.Version)
if err != nil {
@ -112,7 +113,7 @@ func (p *packagesServer) FetchProviderPackage(ctx context.Context, request *terr
}
for _, requestPlatform := range request.Platforms {
result := new(terraform1.FetchProviderPackage_PlatformResult)
result := new(packages.FetchProviderPackage_PlatformResult)
response.Results = append(response.Results, result)
platform, err := getproviders.ParsePlatform(requestPlatform)
@ -178,8 +179,8 @@ func (p *packagesServer) FetchProviderPackage(ctx context.Context, request *terr
return response, nil
}
func (p *packagesServer) ModulePackageVersions(ctx context.Context, request *terraform1.ModulePackageVersions_Request) (*terraform1.ModulePackageVersions_Response, error) {
response := new(terraform1.ModulePackageVersions_Response)
func (p *packagesServer) ModulePackageVersions(ctx context.Context, request *packages.ModulePackageVersions_Request) (*packages.ModulePackageVersions_Response, error) {
response := new(packages.ModulePackageVersions_Response)
module, err := regsrc.ParseModuleSource(request.SourceAddr)
if err != nil {
@ -211,8 +212,8 @@ func (p *packagesServer) ModulePackageVersions(ctx context.Context, request *ter
return response, nil
}
func (p *packagesServer) ModulePackageSourceAddr(ctx context.Context, request *terraform1.ModulePackageSourceAddr_Request) (*terraform1.ModulePackageSourceAddr_Response, error) {
response := new(terraform1.ModulePackageSourceAddr_Response)
func (p *packagesServer) ModulePackageSourceAddr(ctx context.Context, request *packages.ModulePackageSourceAddr_Request) (*packages.ModulePackageSourceAddr_Response, error) {
response := new(packages.ModulePackageSourceAddr_Response)
module, err := regsrc.ParseModuleSource(request.SourceAddr)
if err != nil {
@ -239,8 +240,8 @@ func (p *packagesServer) ModulePackageSourceAddr(ctx context.Context, request *t
return response, nil
}
func (p *packagesServer) FetchModulePackage(ctx context.Context, request *terraform1.FetchModulePackage_Request) (*terraform1.FetchModulePackage_Response, error) {
response := new(terraform1.FetchModulePackage_Response)
func (p *packagesServer) FetchModulePackage(ctx context.Context, request *packages.FetchModulePackage_Request) (*packages.FetchModulePackage_Response, error) {
response := new(packages.FetchModulePackage_Response)
fetcher := getmodules.NewPackageFetcher()
if err := fetcher.FetchPackage(ctx, request.CacheDir, request.Url); err != nil {

5
internal/rpcapi/packages_test.go
View file

@ -19,6 +19,7 @@ import (
"github.com/hashicorp/terraform/internal/addrs"
"github.com/hashicorp/terraform/internal/getproviders"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/packages"
)
func TestPackagesServer_ProviderPackageVersions(t *testing.T) {
@ -86,7 +87,7 @@ func TestPackagesServer_ProviderPackageVersions(t *testing.T) {
providerSourceFn: tc.sourceFn,
}
response, err := service.ProviderPackageVersions(context.Background(), &terraform1.ProviderPackageVersions_Request{
response, err := service.ProviderPackageVersions(context.Background(), &packages.ProviderPackageVersions_Request{
SourceAddr: tc.source,
})
if err != nil {
@ -230,7 +231,7 @@ func TestPackagesServer_FetchProviderPackage(t *testing.T) {
}
cacheDir := t.TempDir()
response, err := service.FetchProviderPackage(context.Background(), &terraform1.FetchProviderPackage_Request{
response, err := service.FetchProviderPackage(context.Background(), &packages.FetchProviderPackage_Request{
CacheDir: cacheDir,
SourceAddr: tc.source,
Version: tc.version,

37
internal/rpcapi/plugin.go
View file

@ -14,7 +14,10 @@ import (
"google.golang.org/grpc"
"github.com/hashicorp/terraform/internal/rpcapi/dynrpcserver"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/packages"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/setup"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
)
type corePlugin struct {
@ -41,19 +44,19 @@ func registerGRPCServices(s *grpc.Server, opts *serviceOpts) {
// We initially only register the setup server, because the registration
// of other services can vary depending on the capabilities negotiated
// during handshake.
setup := newSetupServer(serverHandshake(s, opts))
terraform1.RegisterSetupServer(s, setup)
server := newSetupServer(serverHandshake(s, opts))
setup.RegisterSetupServer(s, server)
}
func serverHandshake(s *grpc.Server, opts *serviceOpts) func(context.Context, *terraform1.Handshake_Request, *stopper) (*terraform1.ServerCapabilities, error) {
dependencies := dynrpcserver.NewDependenciesStub()
terraform1.RegisterDependenciesServer(s, dependencies)
stacks := dynrpcserver.NewStacksStub()
terraform1.RegisterStacksServer(s, stacks)
packages := dynrpcserver.NewPackagesStub()
terraform1.RegisterPackagesServer(s, packages)
func serverHandshake(s *grpc.Server, opts *serviceOpts) func(context.Context, *setup.Handshake_Request, *stopper) (*setup.ServerCapabilities, error) {
dependenciesStub := dynrpcserver.NewDependenciesStub()
dependencies.RegisterDependenciesServer(s, dependenciesStub)
stacksStub := dynrpcserver.NewStacksStub()
stacks.RegisterStacksServer(s, stacksStub)
packagesStub := dynrpcserver.NewPackagesStub()
packages.RegisterPackagesServer(s, packagesStub)
return func(ctx context.Context, request *terraform1.Handshake_Request, stopper *stopper) (*terraform1.ServerCapabilities, error) {
return func(ctx context.Context, request *setup.Handshake_Request, stopper *stopper) (*setup.ServerCapabilities, error) {
// All of our servers will share a common handles table so that objects
// can be passed from one service to another.
handles := newHandleTable()
@ -70,7 +73,7 @@ func serverHandshake(s *grpc.Server, opts *serviceOpts) func(context.Context, *t
// CLI configuration.
services, err := newServiceDisco(request.GetConfig())
if err != nil {
return &terraform1.ServerCapabilities{}, err
return &setup.ServerCapabilities{}, err
}
// If handshaking is successful (which it currently always is, because
@ -78,13 +81,13 @@ func serverHandshake(s *grpc.Server, opts *serviceOpts) func(context.Context, *t
// will initialize all of the other services so the client can begin
// doing real work. In future the details of what we register here
// might vary based on the negotiated capabilities.
dependencies.ActivateRPCServer(newDependenciesServer(handles, services))
stacks.ActivateRPCServer(newStacksServer(stopper, handles, opts))
packages.ActivateRPCServer(newPackagesServer(services))
dependenciesStub.ActivateRPCServer(newDependenciesServer(handles, services))
stacksStub.ActivateRPCServer(newStacksServer(stopper, handles, opts))
packagesStub.ActivateRPCServer(newPackagesServer(services))
// If the client requested any extra capabililties that we're going
// to honor then we should announce them in this result.
return &terraform1.ServerCapabilities{}, nil
return &setup.ServerCapabilities{}, nil
}
}
@ -97,7 +100,7 @@ type serviceOpts struct {
experimentsAllowed bool
}
func newServiceDisco(config *terraform1.Config) (*disco.Disco, error) {
func newServiceDisco(config *setup.Config) (*disco.Disco, error) {
services := disco.New()
credSrc := newCredentialsSource()

18
internal/rpcapi/setup.go
View file

@ -7,7 +7,7 @@ import (
"context"
"sync"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/setup"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
@ -20,12 +20,12 @@ import (
// must call to negotiate access to any other services. This is really just
// an adapter around a handshake function implemented on [corePlugin].
type setupServer struct {
terraform1.UnimplementedSetupServer
setup.UnimplementedSetupServer
// initOthers is the callback used to perform the capability negotiation
// step and initialize all of the other API services based on what was
// negotiated.
initOthers func(context.Context, *terraform1.Handshake_Request, *stopper) (*terraform1.ServerCapabilities, error)
initOthers func(context.Context, *setup.Handshake_Request, *stopper) (*setup.ServerCapabilities, error)
// stopper is used to track and stop long-running operations when the Stop
// RPC is called.
@ -34,14 +34,14 @@ type setupServer struct {
mu sync.Mutex
}
func newSetupServer(initOthers func(context.Context, *terraform1.Handshake_Request, *stopper) (*terraform1.ServerCapabilities, error)) terraform1.SetupServer {
func newSetupServer(initOthers func(context.Context, *setup.Handshake_Request, *stopper) (*setup.ServerCapabilities, error)) setup.SetupServer {
return &setupServer{
initOthers: initOthers,
stopper: newStopper(),
}
}
func (s *setupServer) Handshake(ctx context.Context, req *terraform1.Handshake_Request) (*terraform1.Handshake_Response, error) {
func (s *setupServer) Handshake(ctx context.Context, req *setup.Handshake_Request) (*setup.Handshake_Response, error) {
s.mu.Lock()
defer s.mu.Unlock()
@ -49,7 +49,7 @@ func (s *setupServer) Handshake(ctx context.Context, req *terraform1.Handshake_R
return nil, status.Error(codes.FailedPrecondition, "handshake already completed")
}
var serverCaps *terraform1.ServerCapabilities
var serverCaps *setup.ServerCapabilities
var err error
{
ctx, span := tracer.Start(ctx, "initialize RPC services")
@ -60,16 +60,16 @@ func (s *setupServer) Handshake(ctx context.Context, req *terraform1.Handshake_R
if err != nil {
return nil, err
}
return &terraform1.Handshake_Response{
return &setup.Handshake_Response{
Capabilities: serverCaps,
}, nil
}
func (s *setupServer) Stop(ctx context.Context, req *terraform1.Stop_Request) (*terraform1.Stop_Response, error) {
func (s *setupServer) Stop(ctx context.Context, req *setup.Stop_Request) (*setup.Stop_Response, error) {
s.mu.Lock()
defer s.mu.Unlock()
s.stopper.stop()
return &terraform1.Stop_Response{}, nil
return &setup.Stop_Response{}, nil
}

18
internal/rpcapi/setup_test.go
View file

@ -9,23 +9,23 @@ import (
"sync"
"testing"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/setup"
)
func TestSetupServer_Handshake(t *testing.T) {
called := 0
server := newSetupServer(func(ctx context.Context, req *terraform1.Handshake_Request, stopper *stopper) (*terraform1.ServerCapabilities, error) {
server := newSetupServer(func(ctx context.Context, req *setup.Handshake_Request, stopper *stopper) (*setup.ServerCapabilities, error) {
called++
if got, want := req.Config.Credentials["localterraform.com"].Token, "boop"; got != want {
t.Fatalf("incorrect token. got %q, want %q", got, want)
}
return &terraform1.ServerCapabilities{}, nil
return &setup.ServerCapabilities{}, nil
})
req := &terraform1.Handshake_Request{
Capabilities: &terraform1.ClientCapabilities{},
Config: &terraform1.Config{
Credentials: map[string]*terraform1.HostCredential{
req := &setup.Handshake_Request{
Capabilities: &setup.ClientCapabilities{},
Config: &setup.Config{
Credentials: map[string]*setup.HostCredential{
"localterraform.com": {
Token: "boop",
},
@ -51,9 +51,9 @@ func TestSetupServer_Handshake(t *testing.T) {
func TestSetupServer_Stop(t *testing.T) {
var s *stopper
server := newSetupServer(func(ctx context.Context, req *terraform1.Handshake_Request, stopper *stopper) (*terraform1.ServerCapabilities, error) {
server := newSetupServer(func(ctx context.Context, req *setup.Handshake_Request, stopper *stopper) (*setup.ServerCapabilities, error) {
s = stopper
return &terraform1.ServerCapabilities{}, nil
return &setup.ServerCapabilities{}, nil
})
_, err := server.Handshake(context.Background(), nil)
if err != nil {

190
internal/rpcapi/stacks.go
View file

@ -22,7 +22,7 @@ import (
"github.com/hashicorp/terraform/internal/plans"
"github.com/hashicorp/terraform/internal/providercache"
"github.com/hashicorp/terraform/internal/providers"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
"github.com/hashicorp/terraform/internal/stacks/stackconfig"
"github.com/hashicorp/terraform/internal/stacks/stackplan"
@ -33,7 +33,7 @@ import (
)
type stacksServer struct {
terraform1.UnimplementedStacksServer
stacks.UnimplementedStacksServer
stopper *stopper
handles *handleTable
@ -53,7 +53,7 @@ type stacksServer struct {
planTimestampOverride *time.Time
}
var _ terraform1.StacksServer = (*stacksServer)(nil)
var _ stacks.StacksServer = (*stacksServer)(nil)
func newStacksServer(stopper *stopper, handles *handleTable, opts *serviceOpts) *stacksServer {
return &stacksServer{
@ -63,7 +63,7 @@ func newStacksServer(stopper *stopper, handles *handleTable, opts *serviceOpts)
}
}
func (s *stacksServer) OpenStackConfiguration(ctx context.Context, req *terraform1.OpenStackConfiguration_Request) (*terraform1.OpenStackConfiguration_Response, error) {
func (s *stacksServer) OpenStackConfiguration(ctx context.Context, req *stacks.OpenStackConfiguration_Request) (*stacks.OpenStackConfiguration_Response, error) {
sourcesHnd := handle[*sourcebundle.Bundle](req.SourceBundleHandle)
sources := s.handles.SourceBundle(sourcesHnd)
if sources == nil {
@ -80,7 +80,7 @@ func (s *stacksServer) OpenStackConfiguration(ctx context.Context, req *terrafor
// For errors in the configuration itself we treat that as a successful
// result from OpenStackConfiguration but with diagnostics in the
// response and no source handle.
return &terraform1.OpenStackConfiguration_Response{
return &stacks.OpenStackConfiguration_Response{
Diagnostics: diagnosticsToProto(diags),
}, nil
}
@ -102,22 +102,22 @@ func (s *stacksServer) OpenStackConfiguration(ctx context.Context, req *terrafor
// handle. (The caller is required to ensure that the source bundle files
// on disk are not modified for as long as the source bundle handle remains
// open, and its lifetime will necessarily exceed the config handle.)
return &terraform1.OpenStackConfiguration_Response{
return &stacks.OpenStackConfiguration_Response{
StackConfigHandle: configHnd.ForProtobuf(),
Diagnostics: diagnosticsToProto(diags),
}, nil
}
func (s *stacksServer) CloseStackConfiguration(ctx context.Context, req *terraform1.CloseStackConfiguration_Request) (*terraform1.CloseStackConfiguration_Response, error) {
func (s *stacksServer) CloseStackConfiguration(ctx context.Context, req *stacks.CloseStackConfiguration_Request) (*stacks.CloseStackConfiguration_Response, error) {
hnd := handle[*stackconfig.Config](req.StackConfigHandle)
err := s.handles.CloseStackConfig(hnd)
if err != nil {
return nil, status.Error(codes.InvalidArgument, err.Error())
}
return &terraform1.CloseStackConfiguration_Response{}, nil
return &stacks.CloseStackConfiguration_Response{}, nil
}
func (s *stacksServer) ValidateStackConfiguration(ctx context.Context, req *terraform1.ValidateStackConfiguration_Request) (*terraform1.ValidateStackConfiguration_Response, error) {
func (s *stacksServer) ValidateStackConfiguration(ctx context.Context, req *stacks.ValidateStackConfiguration_Request) (*stacks.ValidateStackConfiguration_Response, error) {
cfgHnd := handle[*stackconfig.Config](req.StackConfigHandle)
cfg := s.handles.StackConfig(cfgHnd)
if cfg == nil {
@ -154,62 +154,62 @@ func (s *stacksServer) ValidateStackConfiguration(ctx context.Context, req *terr
ProviderFactories: providerFactories,
DependencyLocks: *deps,
})
return &terraform1.ValidateStackConfiguration_Response{
return &stacks.ValidateStackConfiguration_Response{
Diagnostics: diagnosticsToProto(diags),
}, nil
}
func (s *stacksServer) FindStackConfigurationComponents(ctx context.Context, req *terraform1.FindStackConfigurationComponents_Request) (*terraform1.FindStackConfigurationComponents_Response, error) {
func (s *stacksServer) FindStackConfigurationComponents(ctx context.Context, req *stacks.FindStackConfigurationComponents_Request) (*stacks.FindStackConfigurationComponents_Response, error) {
cfgHnd := handle[*stackconfig.Config](req.StackConfigHandle)
cfg := s.handles.StackConfig(cfgHnd)
if cfg == nil {
return nil, status.Error(codes.InvalidArgument, "the given stack configuration handle is invalid")
}
return &terraform1.FindStackConfigurationComponents_Response{
return &stacks.FindStackConfigurationComponents_Response{
Config: stackConfigMetaforProto(cfg.Root, stackaddrs.RootStack),
}, nil
}
func stackConfigMetaforProto(cfgNode *stackconfig.ConfigNode, stackAddr stackaddrs.Stack) *terraform1.FindStackConfigurationComponents_StackConfig {
ret := &terraform1.FindStackConfigurationComponents_StackConfig{
Components: make(map[string]*terraform1.FindStackConfigurationComponents_Component),
EmbeddedStacks: make(map[string]*terraform1.FindStackConfigurationComponents_EmbeddedStack),
InputVariables: make(map[string]*terraform1.FindStackConfigurationComponents_InputVariable),
OutputValues: make(map[string]*terraform1.FindStackConfigurationComponents_OutputValue),
func stackConfigMetaforProto(cfgNode *stackconfig.ConfigNode, stackAddr stackaddrs.Stack) *stacks.FindStackConfigurationComponents_StackConfig {
ret := &stacks.FindStackConfigurationComponents_StackConfig{
Components: make(map[string]*stacks.FindStackConfigurationComponents_Component),
EmbeddedStacks: make(map[string]*stacks.FindStackConfigurationComponents_EmbeddedStack),
InputVariables: make(map[string]*stacks.FindStackConfigurationComponents_InputVariable),
OutputValues: make(map[string]*stacks.FindStackConfigurationComponents_OutputValue),
}
for name, cc := range cfgNode.Stack.Components {
cProto := &terraform1.FindStackConfigurationComponents_Component{
cProto := &stacks.FindStackConfigurationComponents_Component{
SourceAddr: cc.FinalSourceAddr.String(),
ComponentAddr: stackaddrs.Config(stackAddr, stackaddrs.Component{Name: cc.Name}).String(),
}
switch {
case cc.ForEach != nil:
cProto.Instances = terraform1.FindStackConfigurationComponents_FOR_EACH
cProto.Instances = stacks.FindStackConfigurationComponents_FOR_EACH
default:
cProto.Instances = terraform1.FindStackConfigurationComponents_SINGLE
cProto.Instances = stacks.FindStackConfigurationComponents_SINGLE
}
ret.Components[name] = cProto
}
for name, sn := range cfgNode.Children {
sc := cfgNode.Stack.EmbeddedStacks[name]
sProto := &terraform1.FindStackConfigurationComponents_EmbeddedStack{
sProto := &stacks.FindStackConfigurationComponents_EmbeddedStack{
SourceAddr: sn.Stack.SourceAddr.String(),
Config: stackConfigMetaforProto(sn, stackAddr.Child(name)),
}
switch {
case sc.ForEach != nil:
sProto.Instances = terraform1.FindStackConfigurationComponents_FOR_EACH
sProto.Instances = stacks.FindStackConfigurationComponents_FOR_EACH
default:
sProto.Instances = terraform1.FindStackConfigurationComponents_SINGLE
sProto.Instances = stacks.FindStackConfigurationComponents_SINGLE
}
ret.EmbeddedStacks[name] = sProto
}
for name, vc := range cfgNode.Stack.InputVariables {
vProto := &terraform1.FindStackConfigurationComponents_InputVariable{
vProto := &stacks.FindStackConfigurationComponents_InputVariable{
Optional: !vc.DefaultValue.IsNull(),
Sensitive: vc.Sensitive,
Ephemeral: vc.Ephemeral,
@ -218,7 +218,7 @@ func stackConfigMetaforProto(cfgNode *stackconfig.ConfigNode, stackAddr stackadd
}
for name, oc := range cfgNode.Stack.OutputValues {
oProto := &terraform1.FindStackConfigurationComponents_OutputValue{
oProto := &stacks.FindStackConfigurationComponents_OutputValue{
Sensitive: oc.Sensitive,
Ephemeral: oc.Ephemeral,
}
@ -228,7 +228,7 @@ func stackConfigMetaforProto(cfgNode *stackconfig.ConfigNode, stackAddr stackadd
return ret
}
func (s *stacksServer) OpenState(stream terraform1.Stacks_OpenStateServer) error {
func (s *stacksServer) OpenState(stream stacks.Stacks_OpenStateServer) error {
loader := stackstate.NewLoader()
for {
item, err := stream.Recv()
@ -244,21 +244,21 @@ func (s *stacksServer) OpenState(stream terraform1.Stacks_OpenStateServer) error
}
hnd := s.handles.NewStackState(loader.State())
return stream.SendAndClose(&terraform1.OpenStackState_Response{
return stream.SendAndClose(&stacks.OpenStackState_Response{
StateHandle: hnd.ForProtobuf(),
})
}
func (s *stacksServer) CloseState(ctx context.Context, req *terraform1.CloseStackState_Request) (*terraform1.CloseStackState_Response, error) {
func (s *stacksServer) CloseState(ctx context.Context, req *stacks.CloseStackState_Request) (*stacks.CloseStackState_Response, error) {
hnd := handle[*stackstate.State](req.StateHandle)
err := s.handles.CloseStackState(hnd)
if err != nil {
return nil, status.Error(codes.InvalidArgument, err.Error())
}
return &terraform1.CloseStackState_Response{}, nil
return &stacks.CloseStackState_Response{}, nil
}
func (s *stacksServer) PlanStackChanges(req *terraform1.PlanStackChanges_Request, evts terraform1.Stacks_PlanStackChangesServer) error {
func (s *stacksServer) PlanStackChanges(req *stacks.PlanStackChanges_Request, evts stacks.Stacks_PlanStackChangesServer) error {
ctx := evts.Context()
syncEvts := newSyncStreamingRPCSender(evts)
evts = nil // Prevent accidental unsynchronized usage of this server
@ -323,11 +323,11 @@ func (s *stacksServer) PlanStackChanges(req *terraform1.PlanStackChanges_Request
var planMode plans.Mode
switch req.PlanMode {
case terraform1.PlanMode_NORMAL:
case stacks.PlanMode_NORMAL:
planMode = plans.NormalMode
case terraform1.PlanMode_REFRESH_ONLY:
case stacks.PlanMode_REFRESH_ONLY:
planMode = plans.RefreshOnlyMode
case terraform1.PlanMode_DESTROY:
case stacks.PlanMode_DESTROY:
planMode = plans.DestroyMode
default:
return status.Errorf(codes.InvalidArgument, "unsupported planning mode %d", req.PlanMode)
@ -390,8 +390,8 @@ func (s *stacksServer) PlanStackChanges(req *terraform1.PlanStackChanges_Request
diags := tfdiags.Diagnostics{diag}
protoDiags := diagnosticsToProto(diags)
for _, protoDiag := range protoDiags {
syncEvts.Send(&terraform1.PlanStackChanges_Event{
Event: &terraform1.PlanStackChanges_Event_Diagnostic{
syncEvts.Send(&stacks.PlanStackChanges_Event{
Event: &stacks.PlanStackChanges_Event_Diagnostic{
Diagnostic: protoDiag,
},
})
@ -439,8 +439,8 @@ Events:
continue
}
syncEvts.Send(&terraform1.PlanStackChanges_Event{
Event: &terraform1.PlanStackChanges_Event_PlannedChange{
syncEvts.Send(&stacks.PlanStackChanges_Event{
Event: &stacks.PlanStackChanges_Event_PlannedChange{
PlannedChange: protoChange,
},
})
@ -467,7 +467,7 @@ Events:
return nil
}
func (s *stacksServer) OpenPlan(stream terraform1.Stacks_OpenPlanServer) error {
func (s *stacksServer) OpenPlan(stream stacks.Stacks_OpenPlanServer) error {
loader := stackplan.NewLoader()
for {
item, err := stream.Recv()
@ -487,21 +487,21 @@ func (s *stacksServer) OpenPlan(stream terraform1.Stacks_OpenPlanServer) error {
return status.Errorf(codes.InvalidArgument, "invalid raw plan: %s", err)
}
hnd := s.handles.NewStackPlan(plan)
return stream.SendAndClose(&terraform1.OpenStackPlan_Response{
return stream.SendAndClose(&stacks.OpenStackPlan_Response{
PlanHandle: hnd.ForProtobuf(),
})
}
func (s *stacksServer) ClosePlan(ctx context.Context, req *terraform1.CloseStackPlan_Request) (*terraform1.CloseStackPlan_Response, error) {
func (s *stacksServer) ClosePlan(ctx context.Context, req *stacks.CloseStackPlan_Request) (*stacks.CloseStackPlan_Response, error) {
hnd := handle[*stackplan.Plan](req.PlanHandle)
err := s.handles.CloseStackPlan(hnd)
if err != nil {
return nil, status.Error(codes.InvalidArgument, err.Error())
}
return &terraform1.CloseStackPlan_Response{}, nil
return &stacks.CloseStackPlan_Response{}, nil
}
func (s *stacksServer) ApplyStackChanges(req *terraform1.ApplyStackChanges_Request, evts terraform1.Stacks_ApplyStackChangesServer) error {
func (s *stacksServer) ApplyStackChanges(req *stacks.ApplyStackChanges_Request, evts stacks.Stacks_ApplyStackChangesServer) error {
ctx := evts.Context()
syncEvts := newSyncStreamingRPCSender(evts)
evts = nil // Prevent accidental unsynchronized usage of this server
@ -612,8 +612,8 @@ func (s *stacksServer) ApplyStackChanges(req *terraform1.ApplyStackChanges_Reque
diags := tfdiags.Diagnostics{diag}
protoDiags := diagnosticsToProto(diags)
for _, protoDiag := range protoDiags {
syncEvts.Send(&terraform1.ApplyStackChanges_Event{
Event: &terraform1.ApplyStackChanges_Event_Diagnostic{
syncEvts.Send(&stacks.ApplyStackChanges_Event{
Event: &stacks.ApplyStackChanges_Event_Diagnostic{
Diagnostic: protoDiag,
},
})
@ -664,8 +664,8 @@ Events:
continue
}
syncEvts.Send(&terraform1.ApplyStackChanges_Event{
Event: &terraform1.ApplyStackChanges_Event_AppliedChange{
syncEvts.Send(&stacks.ApplyStackChanges_Event{
Event: &stacks.ApplyStackChanges_Event_AppliedChange{
AppliedChange: protoChange,
},
})
@ -693,7 +693,7 @@ Events:
return nil
}
func (s *stacksServer) OpenStackInspector(ctx context.Context, req *terraform1.OpenStackInspector_Request) (*terraform1.OpenStackInspector_Response, error) {
func (s *stacksServer) OpenStackInspector(ctx context.Context, req *stacks.OpenStackInspector_Request) (*stacks.OpenStackInspector_Response, error) {
cfgHnd := handle[*stackconfig.Config](req.StackConfigHandle)
cfg := s.handles.StackConfig(cfgHnd)
if cfg == nil {
@ -743,14 +743,14 @@ func (s *stacksServer) OpenStackInspector(ctx context.Context, req *terraform1.O
ExperimentsAllowed: s.experimentsAllowed,
})
return &terraform1.OpenStackInspector_Response{
return &stacks.OpenStackInspector_Response{
StackInspectorHandle: hnd.ForProtobuf(),
// There are currently no situations that return diagnostics, but
// we reserve the right to add some later.
}, nil
}
func (s *stacksServer) InspectExpressionResult(ctx context.Context, req *terraform1.InspectExpressionResult_Request) (*terraform1.InspectExpressionResult_Response, error) {
func (s *stacksServer) InspectExpressionResult(ctx context.Context, req *stacks.InspectExpressionResult_Request) (*stacks.InspectExpressionResult_Response, error) {
hnd := handle[*stacksInspector](req.StackInspectorHandle)
insp := s.handles.StackInspector(hnd)
if insp == nil {
@ -761,9 +761,9 @@ func (s *stacksServer) InspectExpressionResult(ctx context.Context, req *terrafo
func stackPlanHooks(evts *syncPlanStackChangesServer, mainStackSource sourceaddrs.FinalSource) *stackruntime.Hooks {
return stackChangeHooks(
func(scp *terraform1.StackChangeProgress) error {
return evts.Send(&terraform1.PlanStackChanges_Event{
Event: &terraform1.PlanStackChanges_Event_Progress{
func(scp *stacks.StackChangeProgress) error {
return evts.Send(&stacks.PlanStackChanges_Event{
Event: &stacks.PlanStackChanges_Event_Progress{
Progress: scp,
},
})
@ -774,9 +774,9 @@ func stackPlanHooks(evts *syncPlanStackChangesServer, mainStackSource sourceaddr
func stackApplyHooks(evts *syncApplyStackChangesServer, mainStackSource sourceaddrs.FinalSource) *stackruntime.Hooks {
return stackChangeHooks(
func(scp *terraform1.StackChangeProgress) error {
return evts.Send(&terraform1.ApplyStackChanges_Event{
Event: &terraform1.ApplyStackChanges_Event_Progress{
func(scp *stacks.StackChangeProgress) error {
return evts.Send(&stacks.ApplyStackChanges_Event{
Event: &stacks.ApplyStackChanges_Event_Progress{
Progress: scp,
},
})
@ -788,7 +788,7 @@ func stackApplyHooks(evts *syncApplyStackChangesServer, mainStackSource sourcead
// stackChangeHooks is the shared hook-handling logic for both [stackPlanHooks]
// and [stackApplyHooks]. Each phase emits a different subset of the events
// handled here.
func stackChangeHooks(send func(*terraform1.StackChangeProgress) error, mainStackSource sourceaddrs.FinalSource) *stackruntime.Hooks {
func stackChangeHooks(send func(*stacks.StackChangeProgress) error, mainStackSource sourceaddrs.FinalSource) *stackruntime.Hooks {
return &stackruntime.Hooks{
// For any BeginFunc-shaped hook that returns an OpenTelemetry tracing
// span, we'll wrap it in a context so that the runtime's downstream
@ -839,9 +839,9 @@ func stackChangeHooks(send func(*terraform1.StackChangeProgress) error, mainStac
for _, ia := range ce.InstanceAddrs {
ias = append(ias, ia.String())
}
send(&terraform1.StackChangeProgress{
Event: &terraform1.StackChangeProgress_ComponentInstances_{
ComponentInstances: &terraform1.StackChangeProgress_ComponentInstances{
send(&stacks.StackChangeProgress{
Event: &stacks.StackChangeProgress_ComponentInstances_{
ComponentInstances: &stacks.StackChangeProgress_ComponentInstances{
ComponentAddr: ce.ComponentAddr.String(),
InstanceAddrs: ias,
},
@ -914,10 +914,10 @@ func stackChangeHooks(send func(*terraform1.StackChangeProgress) error, mainStac
if !rihd.ProviderAddr.IsZero() {
providerAddr = rihd.ProviderAddr.String()
}
send(&terraform1.StackChangeProgress{
Event: &terraform1.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &terraform1.StackChangeProgress_ResourceInstanceStatus{
Addr: terraform1.NewResourceInstanceObjectInStackAddr(rihd.Addr),
send(&stacks.StackChangeProgress{
Event: &stacks.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &stacks.StackChangeProgress_ResourceInstanceStatus{
Addr: stacks.NewResourceInstanceObjectInStackAddr(rihd.Addr),
Status: rihd.Status.ForProtobuf(),
ProviderAddr: providerAddr,
},
@ -939,8 +939,8 @@ func stackChangeHooks(send func(*terraform1.StackChangeProgress) error, mainStac
return span
}
send(&terraform1.StackChangeProgress{
Event: &terraform1.StackChangeProgress_ResourceInstancePlannedChange_{
send(&stacks.StackChangeProgress{
Event: &stacks.StackChangeProgress_ResourceInstancePlannedChange_{
ResourceInstancePlannedChange: ripc,
},
})
@ -960,9 +960,9 @@ func stackChangeHooks(send func(*terraform1.StackChangeProgress) error, mainStac
deferred := stackplan.EncodeDeferred(change.Reason)
send(&terraform1.StackChangeProgress{
Event: &terraform1.StackChangeProgress_DeferredResourceInstancePlannedChange_{
DeferredResourceInstancePlannedChange: &terraform1.StackChangeProgress_DeferredResourceInstancePlannedChange{
send(&stacks.StackChangeProgress{
Event: &stacks.StackChangeProgress_DeferredResourceInstancePlannedChange_{
DeferredResourceInstancePlannedChange: &stacks.StackChangeProgress_DeferredResourceInstancePlannedChange{
Change: ripc,
Deferred: deferred,
},
@ -974,10 +974,10 @@ func stackChangeHooks(send func(*terraform1.StackChangeProgress) error, mainStac
// We also report a roll-up of planned resource action counts after each
// component instance plan or apply completes.
ReportComponentInstancePlanned: func(ctx context.Context, span any, cic *hooks.ComponentInstanceChange) any {
send(&terraform1.StackChangeProgress{
Event: &terraform1.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &terraform1.StackChangeProgress_ComponentInstanceChanges{
Addr: &terraform1.ComponentInstanceInStackAddr{
send(&stacks.StackChangeProgress{
Event: &stacks.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &stacks.StackChangeProgress_ComponentInstanceChanges{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: stackaddrs.ConfigComponentForAbsInstance(cic.Addr).String(),
ComponentInstanceAddr: cic.Addr.String(),
},
@ -1001,10 +1001,10 @@ func stackChangeHooks(send func(*terraform1.StackChangeProgress) error, mainStac
// version of the agent than the plan phase which has support for
// a different set of possible change types.
ReportComponentInstanceApplied: func(ctx context.Context, span any, cic *hooks.ComponentInstanceChange) any {
send(&terraform1.StackChangeProgress{
Event: &terraform1.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &terraform1.StackChangeProgress_ComponentInstanceChanges{
Addr: &terraform1.ComponentInstanceInStackAddr{
send(&stacks.StackChangeProgress{
Event: &stacks.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &stacks.StackChangeProgress_ComponentInstanceChanges{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: stackaddrs.ConfigComponentForAbsInstance(cic.Addr).String(),
ComponentInstanceAddr: cic.Addr.String(),
},
@ -1024,32 +1024,32 @@ func stackChangeHooks(send func(*terraform1.StackChangeProgress) error, mainStac
}
}
func resourceInstancePlanned(ric *hooks.ResourceInstanceChange) (*terraform1.StackChangeProgress_ResourceInstancePlannedChange, error) {
actions, err := terraform1.ChangeTypesForPlanAction(ric.Change.Action)
func resourceInstancePlanned(ric *hooks.ResourceInstanceChange) (*stacks.StackChangeProgress_ResourceInstancePlannedChange, error) {
actions, err := stacks.ChangeTypesForPlanAction(ric.Change.Action)
if err != nil {
return nil, err
}
var moved *terraform1.StackChangeProgress_ResourceInstancePlannedChange_Moved
var moved *stacks.StackChangeProgress_ResourceInstancePlannedChange_Moved
if !ric.Change.PrevRunAddr.Equal(ric.Change.Addr) {
moved = &terraform1.StackChangeProgress_ResourceInstancePlannedChange_Moved{
PrevAddr: &terraform1.ResourceInstanceInStackAddr{
moved = &stacks.StackChangeProgress_ResourceInstancePlannedChange_Moved{
PrevAddr: &stacks.ResourceInstanceInStackAddr{
ComponentInstanceAddr: ric.Addr.Component.String(),
ResourceInstanceAddr: ric.Change.PrevRunAddr.String(),
},
}
}
var imported *terraform1.StackChangeProgress_ResourceInstancePlannedChange_Imported
var imported *stacks.StackChangeProgress_ResourceInstancePlannedChange_Imported
if ric.Change.Importing != nil {
imported = &terraform1.StackChangeProgress_ResourceInstancePlannedChange_Imported{
imported = &stacks.StackChangeProgress_ResourceInstancePlannedChange_Imported{
ImportId: ric.Change.Importing.ID,
Unknown: ric.Change.Importing.Unknown,
}
}
return &terraform1.StackChangeProgress_ResourceInstancePlannedChange{
Addr: terraform1.NewResourceInstanceObjectInStackAddr(ric.Addr),
return &stacks.StackChangeProgress_ResourceInstancePlannedChange{
Addr: stacks.NewResourceInstanceObjectInStackAddr(ric.Addr),
Actions: actions,
Moved: moved,
Imported: imported,
@ -1057,11 +1057,11 @@ func resourceInstancePlanned(ric *hooks.ResourceInstanceChange) (*terraform1.Sta
}, nil
}
func evtComponentInstanceStatus(ci stackaddrs.AbsComponentInstance, status hooks.ComponentInstanceStatus) *terraform1.StackChangeProgress {
return &terraform1.StackChangeProgress{
Event: &terraform1.StackChangeProgress_ComponentInstanceStatus_{
ComponentInstanceStatus: &terraform1.StackChangeProgress_ComponentInstanceStatus{
Addr: &terraform1.ComponentInstanceInStackAddr{
func evtComponentInstanceStatus(ci stackaddrs.AbsComponentInstance, status hooks.ComponentInstanceStatus) *stacks.StackChangeProgress {
return &stacks.StackChangeProgress{
Event: &stacks.StackChangeProgress_ComponentInstanceStatus_{
ComponentInstanceStatus: &stacks.StackChangeProgress_ComponentInstanceStatus{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: stackaddrs.ConfigComponentForAbsInstance(ci).String(),
ComponentInstanceAddr: ci.String(),
},
@ -1072,13 +1072,13 @@ func evtComponentInstanceStatus(ci stackaddrs.AbsComponentInstance, status hooks
}
// syncPlanStackChangesServer is a wrapper around a
// terraform1.Stacks_PlanStackChangesServer implementation that makes the
// stacks.Stacks_PlanStackChangesServer implementation that makes the
// Send method concurrency-safe by holding a mutex throughout the underlying
// call.
type syncPlanStackChangesServer = syncStreamingRPCSender[terraform1.Stacks_PlanStackChangesServer, *terraform1.PlanStackChanges_Event]
type syncPlanStackChangesServer = syncStreamingRPCSender[stacks.Stacks_PlanStackChangesServer, *stacks.PlanStackChanges_Event]
// syncApplyStackChangesServer is a wrapper around a
// terraform1.Stacks_ApplyStackChangesServer implementation that makes the
// stacks.Stacks_ApplyStackChangesServer implementation that makes the
// Send method concurrency-safe by holding a mutex throughout the underlying
// call.
type syncApplyStackChangesServer = syncStreamingRPCSender[terraform1.Stacks_ApplyStackChangesServer, *terraform1.ApplyStackChanges_Event]
type syncApplyStackChangesServer = syncStreamingRPCSender[stacks.Stacks_ApplyStackChangesServer, *stacks.ApplyStackChanges_Event]

14
internal/rpcapi/stacks_inspector.go
View file

@ -17,7 +17,7 @@ import (
"github.com/hashicorp/terraform/internal/lang/marks"
"github.com/hashicorp/terraform/internal/plans"
"github.com/hashicorp/terraform/internal/providers"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
"github.com/hashicorp/terraform/internal/stacks/stackconfig"
"github.com/hashicorp/terraform/internal/stacks/stackruntime"
@ -39,13 +39,13 @@ type stacksInspector struct {
// InspectExpressionResult evaluates a given expression string in the
// inspection environment represented by the receiver.
func (i *stacksInspector) InspectExpressionResult(ctx context.Context, req *terraform1.InspectExpressionResult_Request) (*terraform1.InspectExpressionResult_Response, error) {
func (i *stacksInspector) InspectExpressionResult(ctx context.Context, req *stacks.InspectExpressionResult_Request) (*stacks.InspectExpressionResult_Response, error) {
var diags tfdiags.Diagnostics
expr, hclDiags := hclsyntax.ParseExpression(req.ExpressionSrc, "<external expression>", hcl.InitialPos)
diags = diags.Append(hclDiags)
if diags.HasErrors() {
return &terraform1.InspectExpressionResult_Response{
return &stacks.InspectExpressionResult_Response{
Diagnostics: diagnosticsToProto(diags),
}, nil
}
@ -69,7 +69,7 @@ func (i *stacksInspector) InspectExpressionResult(ctx context.Context, req *terr
diags = diags.Append(moreDiags)
if val == cty.NilVal {
// Too invalid to return any value at all, then.
return &terraform1.InspectExpressionResult_Response{
return &stacks.InspectExpressionResult_Response{
Diagnostics: diagnosticsToProto(diags),
}, nil
}
@ -94,13 +94,13 @@ func (i *stacksInspector) InspectExpressionResult(ctx context.Context, req *terr
"Result is not serializable",
fmt.Sprintf("Cannot return the result of the given expression: %s.", err),
))
return &terraform1.InspectExpressionResult_Response{
return &stacks.InspectExpressionResult_Response{
Diagnostics: diagnosticsToProto(diags),
}, nil
}
return &terraform1.InspectExpressionResult_Response{
Result: terraform1.NewDynamicValue(valRaw, sensitivePaths),
return &stacks.InspectExpressionResult_Response{
Result: stacks.NewDynamicValue(valRaw, sensitivePaths),
Diagnostics: diagnosticsToProto(diags),
}, nil
}

294
internal/rpcapi/stacks_test.go
View file

@ -27,6 +27,8 @@ import (
"github.com/hashicorp/terraform/internal/getproviders/providerreqs"
"github.com/hashicorp/terraform/internal/providers"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
"github.com/hashicorp/terraform/internal/stacks/stackconfig"
"github.com/hashicorp/terraform/internal/stacks/stackplan"
@ -55,7 +57,7 @@ func TestStacksOpenCloseStackConfiguration(t *testing.T) {
sourcesHnd = handles.NewSourceBundle(sources)
}
openResp, err := stacksServer.OpenStackConfiguration(ctx, &terraform1.OpenStackConfiguration_Request{
openResp, err := stacksServer.OpenStackConfiguration(ctx, &stacks.OpenStackConfiguration_Request{
SourceBundleHandle: sourcesHnd.ForProtobuf(),
SourceAddress: &terraform1.SourceAddress{
Source: "git::https://example.com/foo.git",
@ -81,7 +83,7 @@ func TestStacksOpenCloseStackConfiguration(t *testing.T) {
{
depsServer := newDependenciesServer(handles, disco.New())
_, err := depsServer.CloseSourceBundle(ctx, &terraform1.CloseSourceBundle_Request{
_, err := depsServer.CloseSourceBundle(ctx, &dependencies.CloseSourceBundle_Request{
SourceBundleHandle: sourcesHnd.ForProtobuf(),
})
if err == nil {
@ -99,7 +101,7 @@ func TestStacksOpenCloseStackConfiguration(t *testing.T) {
}
}
_, err = stacksServer.CloseStackConfiguration(ctx, &terraform1.CloseStackConfiguration_Request{
_, err = stacksServer.CloseStackConfiguration(ctx, &stacks.CloseStackConfiguration_Request{
StackConfigHandle: openResp.StackConfigHandle,
})
if err != nil {
@ -110,7 +112,7 @@ func TestStacksOpenCloseStackConfiguration(t *testing.T) {
{
depsServer := newDependenciesServer(handles, disco.New())
_, err := depsServer.CloseSourceBundle(ctx, &terraform1.CloseSourceBundle_Request{
_, err := depsServer.CloseSourceBundle(ctx, &dependencies.CloseSourceBundle_Request{
SourceBundleHandle: sourcesHnd.ForProtobuf(),
})
if err != nil {
@ -138,7 +140,7 @@ func TestStacksFindStackConfigurationComponents(t *testing.T) {
}
t.Run("empty config", func(t *testing.T) {
openResp, err := stacksServer.OpenStackConfiguration(ctx, &terraform1.OpenStackConfiguration_Request{
openResp, err := stacksServer.OpenStackConfiguration(ctx, &stacks.OpenStackConfiguration_Request{
SourceBundleHandle: sourcesHnd.ForProtobuf(),
SourceAddress: &terraform1.SourceAddress{
Source: "git::https://example.com/foo.git",
@ -154,7 +156,7 @@ func TestStacksFindStackConfigurationComponents(t *testing.T) {
}
}
cmpntResp, err := stacksServer.FindStackConfigurationComponents(ctx, &terraform1.FindStackConfigurationComponents_Request{
cmpntResp, err := stacksServer.FindStackConfigurationComponents(ctx, &stacks.FindStackConfigurationComponents_Request{
StackConfigHandle: openResp.StackConfigHandle,
})
if err != nil {
@ -162,7 +164,7 @@ func TestStacksFindStackConfigurationComponents(t *testing.T) {
}
got := cmpntResp.Config
want := &terraform1.FindStackConfigurationComponents_StackConfig{
want := &stacks.FindStackConfigurationComponents_StackConfig{
// Intentionally empty, because the configuration we've loaded
// is itself empty.
}
@ -171,7 +173,7 @@ func TestStacksFindStackConfigurationComponents(t *testing.T) {
}
})
t.Run("non-empty config", func(t *testing.T) {
openResp, err := stacksServer.OpenStackConfiguration(ctx, &terraform1.OpenStackConfiguration_Request{
openResp, err := stacksServer.OpenStackConfiguration(ctx, &stacks.OpenStackConfiguration_Request{
SourceBundleHandle: sourcesHnd.ForProtobuf(),
SourceAddress: &terraform1.SourceAddress{
Source: "git::https://example.com/foo.git//non-empty-stack",
@ -187,7 +189,7 @@ func TestStacksFindStackConfigurationComponents(t *testing.T) {
}
}
cmpntResp, err := stacksServer.FindStackConfigurationComponents(ctx, &terraform1.FindStackConfigurationComponents_Request{
cmpntResp, err := stacksServer.FindStackConfigurationComponents(ctx, &stacks.FindStackConfigurationComponents_Request{
StackConfigHandle: openResp.StackConfigHandle,
})
if err != nil {
@ -195,23 +197,23 @@ func TestStacksFindStackConfigurationComponents(t *testing.T) {
}
got := cmpntResp.Config
want := &terraform1.FindStackConfigurationComponents_StackConfig{
Components: map[string]*terraform1.FindStackConfigurationComponents_Component{
want := &stacks.FindStackConfigurationComponents_StackConfig{
Components: map[string]*stacks.FindStackConfigurationComponents_Component{
"single": {
SourceAddr: "git::https://example.com/foo.git//non-empty-stack/empty-module",
ComponentAddr: "component.single",
},
"for_each": {
SourceAddr: "git::https://example.com/foo.git//non-empty-stack/empty-module",
Instances: terraform1.FindStackConfigurationComponents_FOR_EACH,
Instances: stacks.FindStackConfigurationComponents_FOR_EACH,
ComponentAddr: "component.for_each",
},
},
EmbeddedStacks: map[string]*terraform1.FindStackConfigurationComponents_EmbeddedStack{
EmbeddedStacks: map[string]*stacks.FindStackConfigurationComponents_EmbeddedStack{
"single": {
SourceAddr: "git::https://example.com/foo.git//non-empty-stack/child",
Config: &terraform1.FindStackConfigurationComponents_StackConfig{
Components: map[string]*terraform1.FindStackConfigurationComponents_Component{
Config: &stacks.FindStackConfigurationComponents_StackConfig{
Components: map[string]*stacks.FindStackConfigurationComponents_Component{
"foo": {
SourceAddr: "git::https://example.com/foo.git//non-empty-stack/empty-module",
ComponentAddr: "stack.single.component.foo",
@ -221,9 +223,9 @@ func TestStacksFindStackConfigurationComponents(t *testing.T) {
},
"for_each": {
SourceAddr: "git::https://example.com/foo.git//non-empty-stack/child",
Instances: terraform1.FindStackConfigurationComponents_FOR_EACH,
Config: &terraform1.FindStackConfigurationComponents_StackConfig{
Components: map[string]*terraform1.FindStackConfigurationComponents_Component{
Instances: stacks.FindStackConfigurationComponents_FOR_EACH,
Config: &stacks.FindStackConfigurationComponents_StackConfig{
Components: map[string]*stacks.FindStackConfigurationComponents_Component{
"foo": {
SourceAddr: "git::https://example.com/foo.git//non-empty-stack/empty-module",
ComponentAddr: "stack.for_each.component.foo",
@ -232,13 +234,13 @@ func TestStacksFindStackConfigurationComponents(t *testing.T) {
},
},
},
InputVariables: map[string]*terraform1.FindStackConfigurationComponents_InputVariable{
InputVariables: map[string]*stacks.FindStackConfigurationComponents_InputVariable{
"unused": {Optional: false},
"unused_with_default": {Optional: true},
"sensitive": {Sensitive: true},
"ephemeral": {Ephemeral: true},
},
OutputValues: map[string]*terraform1.FindStackConfigurationComponents_OutputValue{
OutputValues: map[string]*stacks.FindStackConfigurationComponents_OutputValue{
"normal": {},
"sensitive": {Sensitive: true},
"ephemeral": {Ephemeral: true},
@ -257,11 +259,11 @@ func TestStacksOpenState(t *testing.T) {
stacksServer := newStacksServer(newStopper(), handles, &serviceOpts{})
grpcClient, close := grpcClientForTesting(ctx, t, func(srv *grpc.Server) {
terraform1.RegisterStacksServer(srv, stacksServer)
stacks.RegisterStacksServer(srv, stacksServer)
})
defer close()
stacksClient := terraform1.NewStacksClient(grpcClient)
stacksClient := stacks.NewStacksClient(grpcClient)
stream, err := stacksClient.OpenState(ctx)
if err != nil {
t.Fatal(err)
@ -272,8 +274,8 @@ func TestStacksOpenState(t *testing.T) {
if err != nil {
t.Fatalf("failed to encode %T message %q: %s", msg, key, err)
}
err = stream.Send(&terraform1.OpenStackState_RequestItem{
Raw: &terraform1.AppliedChange_RawChange{
err = stream.Send(&stacks.OpenStackState_RequestItem{
Raw: &stacks.AppliedChange_RawChange{
Key: key,
Value: rawMsg,
},
@ -307,7 +309,7 @@ func TestStacksOpenState(t *testing.T) {
t.Errorf("state does not track %s", wantComponentInstAddr)
}
_, err = stacksClient.CloseState(ctx, &terraform1.CloseStackState_Request{
_, err = stacksClient.CloseState(ctx, &stacks.CloseStackState_Request{
StateHandle: resp.StateHandle,
})
if err != nil {
@ -322,11 +324,11 @@ func TestStacksOpenPlan(t *testing.T) {
stacksServer := newStacksServer(newStopper(), handles, &serviceOpts{})
grpcClient, close := grpcClientForTesting(ctx, t, func(srv *grpc.Server) {
terraform1.RegisterStacksServer(srv, stacksServer)
stacks.RegisterStacksServer(srv, stacksServer)
})
defer close()
stacksClient := terraform1.NewStacksClient(grpcClient)
stacksClient := stacks.NewStacksClient(grpcClient)
stream, err := stacksClient.OpenPlan(ctx)
if err != nil {
t.Fatal(err)
@ -337,7 +339,7 @@ func TestStacksOpenPlan(t *testing.T) {
if err != nil {
t.Fatalf("failed to encode %T message: %s", msg, err)
}
err = stream.Send(&terraform1.OpenStackPlan_RequestItem{
err = stream.Send(&stacks.OpenStackPlan_RequestItem{
Raw: rawMsg,
})
if err != nil {
@ -373,7 +375,7 @@ func TestStacksOpenPlan(t *testing.T) {
t.Error("plan is missing the raw state entry for 'test-foo'")
}
_, err = stacksClient.ClosePlan(ctx, &terraform1.CloseStackPlan_Request{
_, err = stacksClient.ClosePlan(ctx, &stacks.CloseStackPlan_Request{
PlanHandle: resp.PlanHandle,
})
if err != nil {
@ -408,23 +410,23 @@ func TestStacksPlanStackChanges(t *testing.T) {
}
grpcClient, close := grpcClientForTesting(ctx, t, func(srv *grpc.Server) {
terraform1.RegisterStacksServer(srv, stacksServer)
stacks.RegisterStacksServer(srv, stacksServer)
})
defer close()
stacksClient := terraform1.NewStacksClient(grpcClient)
events, err := stacksClient.PlanStackChanges(ctx, &terraform1.PlanStackChanges_Request{
PlanMode: terraform1.PlanMode_NORMAL,
stacksClient := stacks.NewStacksClient(grpcClient)
events, err := stacksClient.PlanStackChanges(ctx, &stacks.PlanStackChanges_Request{
PlanMode: stacks.PlanMode_NORMAL,
StackConfigHandle: configHnd.ForProtobuf(),
})
if err != nil {
t.Fatalf("unexpected error: %s", err)
}
wantEvents := splitStackOperationEvents([]*terraform1.PlanStackChanges_Event{
wantEvents := splitStackOperationEvents([]*stacks.PlanStackChanges_Event{
{
Event: &terraform1.PlanStackChanges_Event_PlannedChange{
PlannedChange: &terraform1.PlannedChange{
Event: &stacks.PlanStackChanges_Event_PlannedChange{
PlannedChange: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanHeader{
TerraformVersion: version.SemVer.String(),
@ -434,8 +436,8 @@ func TestStacksPlanStackChanges(t *testing.T) {
},
},
{
Event: &terraform1.PlanStackChanges_Event_PlannedChange{
PlannedChange: &terraform1.PlannedChange{
Event: &stacks.PlanStackChanges_Event_PlannedChange{
PlannedChange: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanTimestamp{
PlanTimestamp: fakePlanTimestamp.Format(time.RFC3339),
@ -445,16 +447,16 @@ func TestStacksPlanStackChanges(t *testing.T) {
},
},
{
Event: &terraform1.PlanStackChanges_Event_PlannedChange{
PlannedChange: &terraform1.PlannedChange{
Event: &stacks.PlanStackChanges_Event_PlannedChange{
PlannedChange: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanApplyable{
Applyable: true,
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_PlanApplyable{
Description: &stacks.PlannedChange_ChangeDescription_PlanApplyable{
PlanApplyable: true,
},
},
@ -463,7 +465,7 @@ func TestStacksPlanStackChanges(t *testing.T) {
},
},
})
var gotEventsAll []*terraform1.PlanStackChanges_Event
var gotEventsAll []*stacks.PlanStackChanges_Event
for {
event, err := events.Recv()
if err == io.EOF {
@ -487,16 +489,16 @@ func TestStackChangeProgress(t *testing.T) {
store *stacks_testing_provider.ResourceStore
state []stackstate.AppliedChange
inputs map[string]cty.Value
want []*terraform1.StackChangeProgress
want []*stacks.StackChangeProgress
diagnostics []*terraform1.Diagnostic
}{
"deferred_changes": {
source: "git::https://example.com/bar.git",
want: []*terraform1.StackChangeProgress{
want: []*stacks.StackChangeProgress{
{
Event: &terraform1.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &terraform1.StackChangeProgress_ComponentInstanceChanges{
Addr: &terraform1.ComponentInstanceInStackAddr{
Event: &stacks.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &stacks.StackChangeProgress_ComponentInstanceChanges{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: "component.deferred",
ComponentInstanceAddr: "component.deferred",
},
@ -506,54 +508,54 @@ func TestStackChangeProgress(t *testing.T) {
},
},
{
Event: &terraform1.StackChangeProgress_DeferredResourceInstancePlannedChange_{
DeferredResourceInstancePlannedChange: &terraform1.StackChangeProgress_DeferredResourceInstancePlannedChange{
Deferred: &terraform1.Deferred{
Reason: terraform1.Deferred_RESOURCE_CONFIG_UNKNOWN,
Event: &stacks.StackChangeProgress_DeferredResourceInstancePlannedChange_{
DeferredResourceInstancePlannedChange: &stacks.StackChangeProgress_DeferredResourceInstancePlannedChange{
Deferred: &stacks.Deferred{
Reason: stacks.Deferred_RESOURCE_CONFIG_UNKNOWN,
},
Change: &terraform1.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Change: &stacks.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.deferred",
ResourceInstanceAddr: "testing_deferred_resource.resource",
},
Actions: []terraform1.ChangeType{terraform1.ChangeType_CREATE},
Actions: []stacks.ChangeType{stacks.ChangeType_CREATE},
ProviderAddr: "registry.terraform.io/hashicorp/testing",
},
},
},
},
{
Event: &terraform1.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &terraform1.StackChangeProgress_ResourceInstanceStatus{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Event: &stacks.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &stacks.StackChangeProgress_ResourceInstanceStatus{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.deferred",
ResourceInstanceAddr: "testing_deferred_resource.resource",
},
Status: terraform1.StackChangeProgress_ResourceInstanceStatus_PLANNING,
Status: stacks.StackChangeProgress_ResourceInstanceStatus_PLANNING,
ProviderAddr: "registry.terraform.io/hashicorp/testing",
},
},
},
{
Event: &terraform1.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &terraform1.StackChangeProgress_ResourceInstanceStatus{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Event: &stacks.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &stacks.StackChangeProgress_ResourceInstanceStatus{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.deferred",
ResourceInstanceAddr: "testing_deferred_resource.resource",
},
Status: terraform1.StackChangeProgress_ResourceInstanceStatus_PLANNED,
Status: stacks.StackChangeProgress_ResourceInstanceStatus_PLANNED,
ProviderAddr: "registry.terraform.io/hashicorp/testing",
},
},
},
{
Event: &terraform1.StackChangeProgress_ComponentInstanceStatus_{
ComponentInstanceStatus: &terraform1.StackChangeProgress_ComponentInstanceStatus{
Addr: &terraform1.ComponentInstanceInStackAddr{
Event: &stacks.StackChangeProgress_ComponentInstanceStatus_{
ComponentInstanceStatus: &stacks.StackChangeProgress_ComponentInstanceStatus{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: "component.deferred",
ComponentInstanceAddr: "component.deferred",
},
Status: terraform1.StackChangeProgress_ComponentInstanceStatus_DEFERRED,
Status: stacks.StackChangeProgress_ComponentInstanceStatus_DEFERRED,
},
},
},
@ -585,19 +587,19 @@ func TestStackChangeProgress(t *testing.T) {
Schema: stacks_testing_provider.TestingResourceSchema,
},
},
want: []*terraform1.StackChangeProgress{
want: []*stacks.StackChangeProgress{
{
Event: &terraform1.StackChangeProgress_ResourceInstancePlannedChange_{
ResourceInstancePlannedChange: &terraform1.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Event: &stacks.StackChangeProgress_ResourceInstancePlannedChange_{
ResourceInstancePlannedChange: &stacks.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.self",
ResourceInstanceAddr: "testing_resource.after",
},
Actions: []terraform1.ChangeType{
terraform1.ChangeType_NOOP,
Actions: []stacks.ChangeType{
stacks.ChangeType_NOOP,
},
Moved: &terraform1.StackChangeProgress_ResourceInstancePlannedChange_Moved{
PrevAddr: &terraform1.ResourceInstanceInStackAddr{
Moved: &stacks.StackChangeProgress_ResourceInstancePlannedChange_Moved{
PrevAddr: &stacks.ResourceInstanceInStackAddr{
ComponentInstanceAddr: "component.self",
ResourceInstanceAddr: "testing_resource.before",
},
@ -607,9 +609,9 @@ func TestStackChangeProgress(t *testing.T) {
},
},
{
Event: &terraform1.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &terraform1.StackChangeProgress_ComponentInstanceChanges{
Addr: &terraform1.ComponentInstanceInStackAddr{
Event: &stacks.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &stacks.StackChangeProgress_ComponentInstanceChanges{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: "component.self",
ComponentInstanceAddr: "component.self",
},
@ -631,12 +633,12 @@ func TestStackChangeProgress(t *testing.T) {
inputs: map[string]cty.Value{
"unknown": cty.UnknownVal(cty.String),
},
want: []*terraform1.StackChangeProgress{
want: []*stacks.StackChangeProgress{
{
Event: &terraform1.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &terraform1.StackChangeProgress_ComponentInstanceChanges{
Addr: &terraform1.ComponentInstanceInStackAddr{
Event: &stacks.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &stacks.StackChangeProgress_ComponentInstanceChanges{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: "component.unknown",
ComponentInstanceAddr: "component.unknown",
},
@ -646,18 +648,18 @@ func TestStackChangeProgress(t *testing.T) {
},
},
{
Event: &terraform1.StackChangeProgress_DeferredResourceInstancePlannedChange_{
DeferredResourceInstancePlannedChange: &terraform1.StackChangeProgress_DeferredResourceInstancePlannedChange{
Deferred: &terraform1.Deferred{
Reason: terraform1.Deferred_RESOURCE_CONFIG_UNKNOWN,
Event: &stacks.StackChangeProgress_DeferredResourceInstancePlannedChange_{
DeferredResourceInstancePlannedChange: &stacks.StackChangeProgress_DeferredResourceInstancePlannedChange{
Deferred: &stacks.Deferred{
Reason: stacks.Deferred_RESOURCE_CONFIG_UNKNOWN,
},
Change: &terraform1.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Change: &stacks.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.unknown",
ResourceInstanceAddr: "testing_resource.resource",
},
Actions: []terraform1.ChangeType{terraform1.ChangeType_CREATE},
Imported: &terraform1.StackChangeProgress_ResourceInstancePlannedChange_Imported{
Actions: []stacks.ChangeType{stacks.ChangeType_CREATE},
Imported: &stacks.StackChangeProgress_ResourceInstancePlannedChange_Imported{
Unknown: true,
},
ProviderAddr: "registry.terraform.io/hashicorp/testing",
@ -666,32 +668,32 @@ func TestStackChangeProgress(t *testing.T) {
},
},
{
Event: &terraform1.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &terraform1.StackChangeProgress_ResourceInstanceStatus{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Event: &stacks.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &stacks.StackChangeProgress_ResourceInstanceStatus{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.unknown",
ResourceInstanceAddr: "testing_resource.resource",
},
Status: terraform1.StackChangeProgress_ResourceInstanceStatus_PLANNING,
Status: stacks.StackChangeProgress_ResourceInstanceStatus_PLANNING,
ProviderAddr: "registry.terraform.io/hashicorp/testing",
},
},
},
{
Event: &terraform1.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &terraform1.StackChangeProgress_ResourceInstanceStatus{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Event: &stacks.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &stacks.StackChangeProgress_ResourceInstanceStatus{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.unknown",
ResourceInstanceAddr: "testing_resource.resource",
},
Status: terraform1.StackChangeProgress_ResourceInstanceStatus_PLANNED,
Status: stacks.StackChangeProgress_ResourceInstanceStatus_PLANNED,
ProviderAddr: "registry.terraform.io/hashicorp/testing",
},
},
}, {
Event: &terraform1.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &terraform1.StackChangeProgress_ComponentInstanceChanges{
Addr: &terraform1.ComponentInstanceInStackAddr{
Event: &stacks.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &stacks.StackChangeProgress_ComponentInstanceChanges{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: "component.self",
ComponentInstanceAddr: "component.self",
},
@ -701,14 +703,14 @@ func TestStackChangeProgress(t *testing.T) {
},
},
{
Event: &terraform1.StackChangeProgress_ResourceInstancePlannedChange_{
ResourceInstancePlannedChange: &terraform1.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Event: &stacks.StackChangeProgress_ResourceInstancePlannedChange_{
ResourceInstancePlannedChange: &stacks.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.self",
ResourceInstanceAddr: "testing_resource.resource",
},
Actions: []terraform1.ChangeType{terraform1.ChangeType_NOOP},
Imported: &terraform1.StackChangeProgress_ResourceInstancePlannedChange_Imported{
Actions: []stacks.ChangeType{stacks.ChangeType_NOOP},
Imported: &stacks.StackChangeProgress_ResourceInstancePlannedChange_Imported{
ImportId: "self",
},
ProviderAddr: "registry.terraform.io/hashicorp/testing",
@ -716,25 +718,25 @@ func TestStackChangeProgress(t *testing.T) {
},
},
{
Event: &terraform1.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &terraform1.StackChangeProgress_ResourceInstanceStatus{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Event: &stacks.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &stacks.StackChangeProgress_ResourceInstanceStatus{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.self",
ResourceInstanceAddr: "testing_resource.resource",
},
Status: terraform1.StackChangeProgress_ResourceInstanceStatus_PLANNING,
Status: stacks.StackChangeProgress_ResourceInstanceStatus_PLANNING,
ProviderAddr: "registry.terraform.io/hashicorp/testing",
},
},
},
{
Event: &terraform1.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &terraform1.StackChangeProgress_ResourceInstanceStatus{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Event: &stacks.StackChangeProgress_ResourceInstanceStatus_{
ResourceInstanceStatus: &stacks.StackChangeProgress_ResourceInstanceStatus{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.self",
ResourceInstanceAddr: "testing_resource.resource",
},
Status: terraform1.StackChangeProgress_ResourceInstanceStatus_PLANNED,
Status: stacks.StackChangeProgress_ResourceInstanceStatus_PLANNED,
ProviderAddr: "registry.terraform.io/hashicorp/testing",
},
},
@ -767,25 +769,25 @@ func TestStackChangeProgress(t *testing.T) {
Schema: stacks_testing_provider.TestingResourceSchema,
},
},
want: []*terraform1.StackChangeProgress{
want: []*stacks.StackChangeProgress{
{
Event: &terraform1.StackChangeProgress_ResourceInstancePlannedChange_{
ResourceInstancePlannedChange: &terraform1.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Event: &stacks.StackChangeProgress_ResourceInstancePlannedChange_{
ResourceInstancePlannedChange: &stacks.StackChangeProgress_ResourceInstancePlannedChange{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: "component.self",
ResourceInstanceAddr: "testing_resource.resource",
},
Actions: []terraform1.ChangeType{
terraform1.ChangeType_FORGET,
Actions: []stacks.ChangeType{
stacks.ChangeType_FORGET,
},
ProviderAddr: "registry.terraform.io/hashicorp/testing",
},
},
},
{
Event: &terraform1.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &terraform1.StackChangeProgress_ComponentInstanceChanges{
Addr: &terraform1.ComponentInstanceInStackAddr{
Event: &stacks.StackChangeProgress_ComponentInstanceChanges_{
ComponentInstanceChanges: &stacks.StackChangeProgress_ComponentInstanceChanges{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: "component.self",
ComponentInstanceAddr: "component.self",
},
@ -834,13 +836,13 @@ func TestStackChangeProgress(t *testing.T) {
hnd := handles.NewSourceBundle(sb)
client, close := grpcClientForTesting(ctx, t, func(srv *grpc.Server) {
terraform1.RegisterStacksServer(srv, stacksServer)
stacks.RegisterStacksServer(srv, stacksServer)
})
defer close()
stacks := terraform1.NewStacksClient(client)
stacksClient := stacks.NewStacksClient(client)
open, err := stacks.OpenStackConfiguration(ctx, &terraform1.OpenStackConfiguration_Request{
open, err := stacksClient.OpenStackConfiguration(ctx, &stacks.OpenStackConfiguration_Request{
SourceBundleHandle: hnd.ForProtobuf(),
SourceAddress: &terraform1.SourceAddress{
Source: tc.source,
@ -849,19 +851,19 @@ func TestStackChangeProgress(t *testing.T) {
if err != nil {
t.Fatalf("unexpected error: %s", err)
}
defer stacks.CloseStackConfiguration(ctx, &terraform1.CloseStackConfiguration_Request{
defer stacksClient.CloseStackConfiguration(ctx, &stacks.CloseStackConfiguration_Request{
StackConfigHandle: open.StackConfigHandle,
})
resp, err := stacks.PlanStackChanges(ctx, &terraform1.PlanStackChanges_Request{
PlanMode: terraform1.PlanMode_NORMAL,
resp, err := stacksClient.PlanStackChanges(ctx, &stacks.PlanStackChanges_Request{
PlanMode: stacks.PlanMode_NORMAL,
StackConfigHandle: open.StackConfigHandle,
PreviousState: appliedChangeToRawState(t, tc.state),
InputValues: func() map[string]*terraform1.DynamicValueWithSource {
values := make(map[string]*terraform1.DynamicValueWithSource)
InputValues: func() map[string]*stacks.DynamicValueWithSource {
values := make(map[string]*stacks.DynamicValueWithSource)
for name, value := range tc.inputs {
values[name] = &terraform1.DynamicValueWithSource{
Value: &terraform1.DynamicValue{
values[name] = &stacks.DynamicValueWithSource{
Value: &stacks.DynamicValue{
Msgpack: mustMsgpack(t, value, value.Type()),
},
SourceRange: &terraform1.SourceRange{
@ -877,11 +879,11 @@ func TestStackChangeProgress(t *testing.T) {
t.Fatalf("unexpected error: %s", err)
}
wantEvents := splitStackOperationEvents(func() []*terraform1.PlanStackChanges_Event {
events := make([]*terraform1.PlanStackChanges_Event, 0, len(tc.want))
wantEvents := splitStackOperationEvents(func() []*stacks.PlanStackChanges_Event {
events := make([]*stacks.PlanStackChanges_Event, 0, len(tc.want))
for _, want := range tc.want {
events = append(events, &terraform1.PlanStackChanges_Event{
Event: &terraform1.PlanStackChanges_Event_Progress{
events = append(events, &stacks.PlanStackChanges_Event{
Event: &stacks.PlanStackChanges_Event_Progress{
Progress: want,
},
})
@ -889,8 +891,8 @@ func TestStackChangeProgress(t *testing.T) {
return events
}())
gotEvents := splitStackOperationEvents(func() []*terraform1.PlanStackChanges_Event {
var events []*terraform1.PlanStackChanges_Event
gotEvents := splitStackOperationEvents(func() []*stacks.PlanStackChanges_Event {
var events []*stacks.PlanStackChanges_Event
for {
event, err := resp.Recv()
if err == io.EOF {
@ -915,7 +917,7 @@ func TestStackChangeProgress(t *testing.T) {
t.Errorf("missing expected diagnostic: %v", tc.diagnostics[diagIx])
continue
}
diag := gotEvents.Diagnostics[diagIx].Event.(*terraform1.PlanStackChanges_Event_Diagnostic).Diagnostic
diag := gotEvents.Diagnostics[diagIx].Event.(*stacks.PlanStackChanges_Event_Diagnostic).Diagnostic
if diff := cmp.Diff(tc.diagnostics[diagIx], diag, protocmp.Transform()); diff != "" {
// Then we have a diagnostic that doesn't match what we
// expected.
@ -980,21 +982,21 @@ func TestStackChangeProgress(t *testing.T) {
// interest, which will also avoid the need to update every test whenever we
// add something entirely new to the even stream.
type stackOperationEventStreams struct {
PlannedChanges []*terraform1.PlanStackChanges_Event
Diagnostics []*terraform1.PlanStackChanges_Event
PlannedChanges []*stacks.PlanStackChanges_Event
Diagnostics []*stacks.PlanStackChanges_Event
// MiscHooks is the "everything else" category where the detailed begin/end
// events for individual Terraform Core operations appear.
MiscHooks []*terraform1.PlanStackChanges_Event
MiscHooks []*stacks.PlanStackChanges_Event
}
func splitStackOperationEvents(all []*terraform1.PlanStackChanges_Event) stackOperationEventStreams {
func splitStackOperationEvents(all []*stacks.PlanStackChanges_Event) stackOperationEventStreams {
ret := stackOperationEventStreams{}
for _, evt := range all {
switch evt.Event.(type) {
case *terraform1.PlanStackChanges_Event_PlannedChange:
case *stacks.PlanStackChanges_Event_PlannedChange:
ret.PlannedChanges = append(ret.PlannedChanges, evt)
case *terraform1.PlanStackChanges_Event_Diagnostic:
case *stacks.PlanStackChanges_Event_Diagnostic:
ret.Diagnostics = append(ret.Diagnostics, evt)
default:
ret.MiscHooks = append(ret.MiscHooks, evt)

26
internal/rpcapi/telemetry_test.go
View file

@ -12,7 +12,9 @@ import (
"github.com/davecgh/go-spew/spew"
"github.com/google/go-cmp/cmp"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/setup"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
"go.opentelemetry.io/otel/codes"
@ -224,20 +226,20 @@ func TestTelemetryInTestsGRPC(t *testing.T) {
)
client, close := grpcClientForTesting(ctx, t, func(srv *grpc.Server) {
setup := &setupServer{
initOthers: func(ctx context.Context, cc *terraform1.Handshake_Request, stopper *stopper) (*terraform1.ServerCapabilities, error) {
return &terraform1.ServerCapabilities{}, nil
server := &setupServer{
initOthers: func(ctx context.Context, cc *setup.Handshake_Request, stopper *stopper) (*setup.ServerCapabilities, error) {
return &setup.ServerCapabilities{}, nil
},
}
terraform1.RegisterSetupServer(srv, setup)
setup.RegisterSetupServer(srv, server)
})
defer close()
setupClient := terraform1.NewSetupClient(client)
setupClient := setup.NewSetupClient(client)
{
ctx, span := otel.Tracer("TestTelemetryInTestsGRPC").Start(ctx, "root")
_, err := setupClient.Handshake(ctx, &terraform1.Handshake_Request{
Capabilities: &terraform1.ClientCapabilities{},
_, err := setupClient.Handshake(ctx, &setup.Handshake_Request{
Capabilities: &setup.ClientCapabilities{},
})
if err != nil {
t.Fatal(err)
@ -254,14 +256,14 @@ func TestTelemetryInTestsGRPC(t *testing.T) {
t.Run("client span", func(t *testing.T) {
span := clientSpan
t.Logf("client span: %s", spew.Sdump(span))
if got, want := span.Name, "terraform1.Setup/Handshake"; got != want {
if got, want := span.Name, "terraform1.setup.Setup/Handshake"; got != want {
t.Errorf("wrong name\ngot: %s\nwant: %s", got, want)
}
attrs := otelAttributesMap(span.Attributes)
if got, want := attrs["rpc.system"], "grpc"; got != want {
t.Errorf("wrong rpc.system\ngot: %s\nwant: %s", got, want)
}
if got, want := attrs["rpc.service"], "terraform1.Setup"; got != want {
if got, want := attrs["rpc.service"], "terraform1.setup.Setup"; got != want {
t.Errorf("wrong rpc.service\ngot: %s\nwant: %s", got, want)
}
if got, want := attrs["rpc.method"], "Handshake"; got != want {
@ -271,7 +273,7 @@ func TestTelemetryInTestsGRPC(t *testing.T) {
t.Run("server span", func(t *testing.T) {
span := serverSpan
t.Logf("server span: %s", spew.Sdump(span))
if got, want := span.Name, "terraform1.Setup/Handshake"; got != want {
if got, want := span.Name, "terraform1.setup.Setup/Handshake"; got != want {
t.Errorf("wrong name\ngot: %s\nwant: %s", got, want)
}
if got, want := span.Parent.SpanID(), clientSpan.SpanContext.SpanID(); got != want {
@ -284,7 +286,7 @@ func TestTelemetryInTestsGRPC(t *testing.T) {
if got, want := attrs["rpc.system"], "grpc"; got != want {
t.Errorf("wrong rpc.system\ngot: %s\nwant: %s", got, want)
}
if got, want := attrs["rpc.service"], "terraform1.Setup"; got != want {
if got, want := attrs["rpc.service"], "terraform1.setup.Setup"; got != want {
t.Errorf("wrong rpc.service\ngot: %s\nwant: %s", got, want)
}
if got, want := attrs["rpc.method"], "Handshake"; got != want {

4833
internal/rpcapi/terraform1/dependencies/dependencies.pb.go Normal file
View file

File diff suppressed because it is too large Load diff

379
internal/rpcapi/terraform1/dependencies/dependencies.proto Normal file
View file

@ -0,0 +1,379 @@
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
syntax = "proto3";
package terraform1.dependencies;
import "terraform1.proto";
service Dependencies {
// Opens a source bundle that was already extracted into the filesystem
// somewhere, returning an opaque source bundle handle that can be used for
// subsequent operations.
rpc OpenSourceBundle(OpenSourceBundle.Request) returns (OpenSourceBundle.Response);
// Closes a previously-opened source bundle, invalidating the given handle
// and therefore making it safe to delete or modify the bundle directory
// on disk.
rpc CloseSourceBundle(CloseSourceBundle.Request) returns (CloseSourceBundle.Response);
// Reads and parses an existing dependency lock file from the filesystem,
// returning a dependency locks handle.
//
// This function parses a user-provided source file, and so invalid content
// in that file is treated as diagnostics in a successful response rather
// than as an RPC error. Callers must check whether the dependency locks
// handle in the response is set (non-zero) before using it, and treat
// an unset handle as indicating a user error which is described in the
// accompanying diagnostics. Diagnostics can also be returned along with
// a valid handle, e.g. if there are non-blocking warning diagnostics.
rpc OpenDependencyLockFile(OpenDependencyLockFile.Request) returns (OpenDependencyLockFile.Response);
// Creates an in-memory-only dependency locks handle with a fixed set of
// dependency selections provided as arguments.
rpc CreateDependencyLocks(CreateDependencyLocks.Request) returns (CreateDependencyLocks.Response);
rpc CloseDependencyLocks(CloseDependencyLocks.Request) returns (CloseDependencyLocks.Response);
// Returns information about the provider version selections in a
// dependency locks object.
rpc GetLockedProviderDependencies(GetLockedProviderDependencies.Request) returns (GetLockedProviderDependencies.Response);
// Populates a new provider plugin cache directory in the local filesystem
// based on the provider version selections in a given dependency locks
// object.
//
// This particular RPC can only install already-selected provider packages
// recorded in a dependency locks object; it does not support "upgrading"
// provider selections to newer versions as a CLI user would do with
// "terraform init -upgrade", because there would be no way to then
// commit the updated locks to disk as a lock file.
rpc BuildProviderPluginCache(BuildProviderPluginCache.Request) returns (stream BuildProviderPluginCache.Event);
// Opens an existing local filesystem directory as a provider plugin cache
// directory, returning a plugin cache handle that can be used with other
// RPC operations.
rpc OpenProviderPluginCache(OpenProviderPluginCache.Request) returns (OpenProviderPluginCache.Response);
rpc CloseProviderPluginCache(CloseProviderPluginCache.Request) returns (CloseProviderPluginCache.Response);
// Returns information about the specific provider packages that are
// available in the given provider plugin cache.
rpc GetCachedProviders(GetCachedProviders.Request) returns (GetCachedProviders.Response);
// Returns information about the built-in providers that are compiled in
// to this Terraform Core server.
rpc GetBuiltInProviders(GetBuiltInProviders.Request) returns (GetBuiltInProviders.Response);
// Returns a description of the schema for a particular provider in a
// given provider plugin cache, or of a particular built-in provider
// known to this version of Terraform Core.
//
// WARNING: This operation requires executing the selected provider plugin,
// which therefore allows it to run arbitrary code as a child process of
// this Terraform Core server, with access to all of the same resources.
// This should typically be used only with providers explicitly selected
// in a dependency lock file, so users can control what external code
// has the potential to run in a context that probably has access to
// private source code and other sensitive information.
rpc GetProviderSchema(GetProviderSchema.Request) returns (GetProviderSchema.Response);
}
message OpenSourceBundle {
message Request {
string local_path = 1;
}
message Response {
int64 source_bundle_handle = 1;
}
}
message CloseSourceBundle {
message Request {
int64 source_bundle_handle = 1;
}
message Response {
}
}
message OpenDependencyLockFile {
message Request {
int64 source_bundle_handle = 1;
terraform1.SourceAddress source_address = 2;
}
message Response {
int64 dependency_locks_handle = 1;
repeated terraform1.Diagnostic diagnostics = 2;
}
}
message CreateDependencyLocks {
message Request {
// The provider selections to include in the locks object.
//
// A typical value would be the result of an earlier call to
// GetLockedProviderDependencies on some other locks object,
// e.g. if a caller needs to propagate a set of locks from one
// Terraform Core RPC server to another.
repeated terraform1.ProviderPackage provider_selections = 1;
}
message Response {
int64 dependency_locks_handle = 1;
}
}
message CloseDependencyLocks {
message Request {
int64 dependency_locks_handle = 1;
}
message Response {
}
}
message GetLockedProviderDependencies {
message Request {
int64 dependency_locks_handle = 1;
}
message Response {
repeated terraform1.ProviderPackage selected_providers = 1;
}
}
message BuildProviderPluginCache {
message Request {
string cache_dir = 1;
int64 dependency_locks_handle = 2;
repeated InstallMethod installation_methods = 3;
// If set, this populates the cache with plugins for a different
// platform than the one the Terraform Core RPC server is running on.
// If unset (empty) then the cache will be populated with packages
// for the same platform as Terraform Core was built for, if available.
//
// If this is set to a different platform than the Terraform Core RPC
// server's then the generated cache directory will appear empty to
// other operations on this server.
string override_platform = 4;
message InstallMethod {
oneof source {
bool direct = 1;
string local_mirror_dir = 2;
string network_mirror_url = 3;
}
repeated string include = 4;
repeated string exclude = 5;
}
}
message Event {
oneof event {
Pending pending = 1;
ProviderVersion already_installed = 2;
ProviderVersion built_in = 3;
ProviderConstraints query_begin = 4;
ProviderVersion query_success = 5;
ProviderWarnings query_warnings = 6;
FetchBegin fetch_begin = 7;
FetchComplete fetch_complete = 8;
terraform1.Diagnostic diagnostic = 9;
}
message Pending {
repeated ProviderConstraints expected = 1;
}
message ProviderConstraints {
string source_addr = 1;
string versions = 2;
}
message ProviderVersion {
string source_addr = 1;
string version = 2;
}
message ProviderWarnings {
string source_addr = 1;
repeated string warnings = 2;
}
message FetchBegin {
ProviderVersion provider_version = 1;
string location = 2;
}
message FetchComplete {
ProviderVersion provider_version = 1;
AuthResult auth_result = 2;
// If auth_result is one of the "_SIGNED" variants then this
// might contain a UI-oriented identifier for the key that
// signed the package. The exact format of this string is not
// guaranteed; do not attempt to parse it or make automated
// decisions based on it.
string key_id_for_display = 3;
enum AuthResult {
UNKNOWN = 0;
VERIFIED_CHECKSUM = 1;
OFFICIAL_SIGNED = 2;
PARTNER_SIGNED = 3;
SELF_SIGNED = 4;
}
}
}
}
message OpenProviderPluginCache {
message Request {
string cache_dir = 1;
// As with the field of the same name in BuildProviderPluginCache.Request.
//
// If this is set to anything other than this RPC server's native
// platform then any operations that require executing the provider
// plugin are likely to fail due to executable format errors or
// similar. However, it's valid to use the returned handle with
// GetCachedProviders, since it only analyzes the cache metadata
// and doesn't actually run the plugins inside.
string override_platform = 2;
}
message Response {
int64 provider_cache_handle = 1;
}
}
message CloseProviderPluginCache {
message Request {
int64 provider_cache_handle = 1;
}
message Response {
}
}
message GetCachedProviders {
message Request {
int64 provider_cache_handle = 1;
}
message Response {
repeated terraform1.ProviderPackage available_providers = 1;
}
}
message GetBuiltInProviders {
message Request {
}
message Response {
// The built-in providers that are compiled in to this Terraform Core
// server.
//
// This uses terraform1.ProviderPackage messages for consistency with the other
// operations which list providers, but built-in providers do not
// have version numbers nor hashes so those fields will always be
// unset in the result.
repeated terraform1.ProviderPackage available_providers = 1;
}
}
message GetProviderSchema {
message Request {
// The address of the provider to retrieve schema for, using the
// typical provider source address syntax.
//
// When requesting schema based on a terraform1.ProviderPackage message, populate
// this with its "source_addr" field.
string provider_addr = 1;
// The version number of the given provider to retrieve the schema
// of, which must have already been populated into the cache directory.
//
// Not supported for built-in providers because we can only access the
// single "version" of the provider that's compiled into this Terraform
// Core server, and so must be left unset or empty for those.
//
// When requesting schema based on a terraform1.ProviderPackage message, populate
// this with its "version" field.
string provider_version = 2;
// The handle for the previously-opened provider plugin cache to
// load the provider plugin from.
//
// Optional for built-in providers, but can still be specified in that
// case if desired so that callers can safely just send the handle they
// have in all cases and be naive about which providers are and are
// not built in.
int64 provider_cache_handle = 3;
}
message Response {
ProviderSchema schema = 1;
}
}
// ProviderSchema describes the full schema for a particular provider.
message ProviderSchema {
Schema provider_config = 1;
map<string, Schema> managed_resource_types = 2;
map<string, Schema> data_resource_types = 3;
}
// Schema describes a schema for an instance of a particular object, such as
// a resource type or a provider's overall configuration.
message Schema {
// Block is the top level configuration block for this schema.
Block block = 1;
message Block {
repeated Attribute attributes = 1;
repeated NestedBlock block_types = 2;
DocString description = 3;
bool deprecated = 4;
}
message Attribute {
string name = 1;
bytes type = 2;
Object nested_type = 10;
DocString description = 3;
bool required = 4;
bool optional = 5;
bool computed = 6;
bool sensitive = 7;
bool deprecated = 8;
}
message NestedBlock {
enum NestingMode {
INVALID = 0;
SINGLE = 1;
LIST = 2;
SET = 3;
MAP = 4;
GROUP = 5;
}
string type_name = 1;
Block block = 2;
NestingMode nesting = 3;
}
message Object {
enum NestingMode {
INVALID = 0;
SINGLE = 1;
LIST = 2;
SET = 3;
MAP = 4;
}
repeated Attribute attributes = 1;
NestingMode nesting = 3;
}
message DocString {
string description = 1;
Format format = 2;
enum Format {
PLAIN = 0;
MARKDOWN = 1;
}
}
}

1453
internal/rpcapi/terraform1/packages/packages.pb.go Normal file
View file

File diff suppressed because it is too large Load diff

91
internal/rpcapi/terraform1/packages/packages.proto Normal file
View file

@ -0,0 +1,91 @@
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
syntax = "proto3";
package terraform1.packages;
import "terraform1.proto";
// The Packages service provides helper functions for retrieving Terraform
// modules and providers.
//
// Unlike the Dependencies service, the Packages service does not require any
// existing configuration or sourcebundle to function.
//
// This service is designed for use with a specific command-line tool, and is
// currently experimental. It can be changed and removed without warning, even
// in patch releases.
service Packages {
rpc ProviderPackageVersions(ProviderPackageVersions.Request) returns (ProviderPackageVersions.Response);
rpc FetchProviderPackage(FetchProviderPackage.Request) returns (FetchProviderPackage.Response);
rpc ModulePackageVersions(ModulePackageVersions.Request) returns (ModulePackageVersions.Response);
rpc ModulePackageSourceAddr(ModulePackageSourceAddr.Request) returns (ModulePackageSourceAddr.Response);
rpc FetchModulePackage(FetchModulePackage.Request) returns (FetchModulePackage.Response);
}
message ProviderPackageVersions {
message Request {
string source_addr = 1;
}
message Response {
repeated string versions = 1;
repeated terraform1.Diagnostic diagnostics = 2;
}
}
message FetchProviderPackage {
message Request {
string cache_dir = 1;
string source_addr = 2;
string version = 3;
repeated string platforms = 4;
repeated string hashes = 5;
}
message Response {
// Each requested platform will return a result in this list. The order
// of the returned results will match the order of the requested
// platforms. If the binary for a given platform could not be downloaded
// there will still be an entry in the results with diagnostics
// explaining why.
repeated FetchProviderPackage.PlatformResult results = 1;
repeated terraform1.Diagnostic diagnostics = 2;
}
message PlatformResult {
terraform1.ProviderPackage provider = 1;
repeated terraform1.Diagnostic diagnostics = 2;
}
}
message ModulePackageVersions {
message Request {
string source_addr = 2;
}
message Response {
repeated string versions = 1;
repeated terraform1.Diagnostic diagnostics = 2;
}
}
message ModulePackageSourceAddr {
message Request {
string source_addr = 1;
string version = 2;
}
message Response {
string url = 1;
repeated terraform1.Diagnostic diagnostics = 2;
}
}
message FetchModulePackage {
message Request {
string cache_dir = 1;
string url = 2;
}
message Response {
repeated terraform1.Diagnostic diagnostics = 1;
}
}

831
internal/rpcapi/terraform1/setup/setup.pb.go Normal file
View file

@ -0,0 +1,831 @@
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.33.0
// protoc v3.15.6
// source: setup.proto
package setup
import (
context "context"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
type Handshake struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *Handshake) Reset() {
*x = Handshake{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Handshake) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Handshake) ProtoMessage() {}
func (x *Handshake) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[0]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Handshake.ProtoReflect.Descriptor instead.
func (*Handshake) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{0}
}
type Stop struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *Stop) Reset() {
*x = Stop{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[1]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Stop) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Stop) ProtoMessage() {}
func (x *Stop) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[1]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Stop.ProtoReflect.Descriptor instead.
func (*Stop) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{1}
}
type Config struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Credentials map[string]*HostCredential `protobuf:"bytes,1,rep,name=credentials,proto3" json:"credentials,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}
func (x *Config) Reset() {
*x = Config{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[2]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[2]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{2}
}
func (x *Config) GetCredentials() map[string]*HostCredential {
if x != nil {
return x.Credentials
}
return nil
}
type HostCredential struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
}
func (x *HostCredential) Reset() {
*x = HostCredential{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[3]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *HostCredential) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*HostCredential) ProtoMessage() {}
func (x *HostCredential) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[3]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use HostCredential.ProtoReflect.Descriptor instead.
func (*HostCredential) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{3}
}
func (x *HostCredential) GetToken() string {
if x != nil {
return x.Token
}
return ""
}
// The capabilities that the client wishes to advertise to the server during
// handshake.
type ClientCapabilities struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *ClientCapabilities) Reset() {
*x = ClientCapabilities{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[4]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ClientCapabilities) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ClientCapabilities) ProtoMessage() {}
func (x *ClientCapabilities) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[4]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ClientCapabilities.ProtoReflect.Descriptor instead.
func (*ClientCapabilities) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{4}
}
// The capabilities that the server wishes to advertise to the client during
// handshake. Fields in this message can also be used to acknowledge and
// confirm support for client capabilities advertised in ClientCapabilities,
// in situations where the client must vary its behavior based on the server's
// level of support.
type ServerCapabilities struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *ServerCapabilities) Reset() {
*x = ServerCapabilities{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[5]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *ServerCapabilities) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*ServerCapabilities) ProtoMessage() {}
func (x *ServerCapabilities) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[5]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use ServerCapabilities.ProtoReflect.Descriptor instead.
func (*ServerCapabilities) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{5}
}
type Handshake_Request struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Capabilities *ClientCapabilities `protobuf:"bytes,1,opt,name=capabilities,proto3" json:"capabilities,omitempty"`
Config *Config `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
}
func (x *Handshake_Request) Reset() {
*x = Handshake_Request{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[6]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Handshake_Request) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Handshake_Request) ProtoMessage() {}
func (x *Handshake_Request) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[6]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Handshake_Request.ProtoReflect.Descriptor instead.
func (*Handshake_Request) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{0, 0}
}
func (x *Handshake_Request) GetCapabilities() *ClientCapabilities {
if x != nil {
return x.Capabilities
}
return nil
}
func (x *Handshake_Request) GetConfig() *Config {
if x != nil {
return x.Config
}
return nil
}
type Handshake_Response struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
Capabilities *ServerCapabilities `protobuf:"bytes,2,opt,name=capabilities,proto3" json:"capabilities,omitempty"`
}
func (x *Handshake_Response) Reset() {
*x = Handshake_Response{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[7]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Handshake_Response) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Handshake_Response) ProtoMessage() {}
func (x *Handshake_Response) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[7]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Handshake_Response.ProtoReflect.Descriptor instead.
func (*Handshake_Response) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{0, 1}
}
func (x *Handshake_Response) GetCapabilities() *ServerCapabilities {
if x != nil {
return x.Capabilities
}
return nil
}
type Stop_Request struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *Stop_Request) Reset() {
*x = Stop_Request{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[8]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Stop_Request) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Stop_Request) ProtoMessage() {}
func (x *Stop_Request) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[8]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Stop_Request.ProtoReflect.Descriptor instead.
func (*Stop_Request) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{1, 0}
}
type Stop_Response struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
}
func (x *Stop_Response) Reset() {
*x = Stop_Response{}
if protoimpl.UnsafeEnabled {
mi := &file_setup_proto_msgTypes[9]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *Stop_Response) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Stop_Response) ProtoMessage() {}
func (x *Stop_Response) ProtoReflect() protoreflect.Message {
mi := &file_setup_proto_msgTypes[9]
if protoimpl.UnsafeEnabled && x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Stop_Response.ProtoReflect.Descriptor instead.
func (*Stop_Response) Descriptor() ([]byte, []int) {
return file_setup_proto_rawDescGZIP(), []int{1, 1}
}
var File_setup_proto protoreflect.FileDescriptor
var file_setup_proto_rawDesc = []byte{
0x0a, 0x0b, 0x73, 0x65, 0x74, 0x75, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x74,
0x65, 0x72, 0x72, 0x61, 0x66, 0x6f, 0x72, 0x6d, 0x31, 0x2e, 0x73, 0x65, 0x74, 0x75, 0x70, 0x22,
0xe9, 0x01, 0x0a, 0x09, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x1a, 0x85, 0x01,
0x0a, 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x48, 0x0a, 0x0c, 0x63, 0x61, 0x70,
0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
0x24, 0x2e, 0x74, 0x65, 0x72, 0x72, 0x61, 0x66, 0x6f, 0x72, 0x6d, 0x31, 0x2e, 0x73, 0x65, 0x74,
0x75, 0x70, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c,
0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
0x69, 0x65, 0x73, 0x12, 0x30, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20,
0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x74, 0x65, 0x72, 0x72, 0x61, 0x66, 0x6f, 0x72, 0x6d, 0x31,
0x2e, 0x73, 0x65, 0x74, 0x75, 0x70, 0x2e, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x06, 0x63,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x1a, 0x54, 0x0a, 0x08, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
0x65, 0x12, 0x48, 0x0a, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65,
0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x74, 0x65, 0x72, 0x72, 0x61, 0x66,
0x6f, 0x72, 0x6d, 0x31, 0x2e, 0x73, 0x65, 0x74, 0x75, 0x70, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x65,
0x72, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x52, 0x0c, 0x63,
0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0x1d, 0x0a, 0x04, 0x53,
0x74, 0x6f, 0x70, 0x1a, 0x09, 0x0a, 0x07, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x0a,
0x0a, 0x08, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0xb7, 0x01, 0x0a, 0x06, 0x43,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x4b, 0x0a, 0x0b, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74,
0x69, 0x61, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x74, 0x65, 0x72,
0x72, 0x61, 0x66, 0x6f, 0x72, 0x6d, 0x31, 0x2e, 0x73, 0x65, 0x74, 0x75, 0x70, 0x2e, 0x43, 0x6f,
0x6e, 0x66, 0x69, 0x67, 0x2e, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x73,
0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x63, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61,
0x6c, 0x73, 0x1a, 0x60, 0x0a, 0x10, 0x43, 0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c,
0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20,
0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x36, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75,
0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x65, 0x72, 0x72, 0x61, 0x66,
0x6f, 0x72, 0x6d, 0x31, 0x2e, 0x73, 0x65, 0x74, 0x75, 0x70, 0x2e, 0x48, 0x6f, 0x73, 0x74, 0x43,
0x72, 0x65, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65,
0x3a, 0x02, 0x38, 0x01, 0x22, 0x26, 0x0a, 0x0e, 0x48, 0x6f, 0x73, 0x74, 0x43, 0x72, 0x65, 0x64,
0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x14, 0x0a, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x18,
0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x22, 0x14, 0x0a, 0x12,
0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69,
0x65, 0x73, 0x22, 0x14, 0x0a, 0x12, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x43, 0x61, 0x70, 0x61,
0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x32, 0xa8, 0x01, 0x0a, 0x05, 0x53, 0x65, 0x74,
0x75, 0x70, 0x12, 0x56, 0x0a, 0x09, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x12,
0x23, 0x2e, 0x74, 0x65, 0x72, 0x72, 0x61, 0x66, 0x6f, 0x72, 0x6d, 0x31, 0x2e, 0x73, 0x65, 0x74,
0x75, 0x70, 0x2e, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b, 0x65, 0x2e, 0x52, 0x65, 0x71,
0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x74, 0x65, 0x72, 0x72, 0x61, 0x66, 0x6f, 0x72, 0x6d,
0x31, 0x2e, 0x73, 0x65, 0x74, 0x75, 0x70, 0x2e, 0x48, 0x61, 0x6e, 0x64, 0x73, 0x68, 0x61, 0x6b,
0x65, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x04, 0x53, 0x74,
0x6f, 0x70, 0x12, 0x1e, 0x2e, 0x74, 0x65, 0x72, 0x72, 0x61, 0x66, 0x6f, 0x72, 0x6d, 0x31, 0x2e,
0x73, 0x65, 0x74, 0x75, 0x70, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x2e, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x74, 0x65, 0x72, 0x72, 0x61, 0x66, 0x6f, 0x72, 0x6d, 0x31, 0x2e,
0x73, 0x65, 0x74, 0x75, 0x70, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x2e, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}
var (
file_setup_proto_rawDescOnce sync.Once
file_setup_proto_rawDescData = file_setup_proto_rawDesc
)
func file_setup_proto_rawDescGZIP() []byte {
file_setup_proto_rawDescOnce.Do(func() {
file_setup_proto_rawDescData = protoimpl.X.CompressGZIP(file_setup_proto_rawDescData)
})
return file_setup_proto_rawDescData
}
var file_setup_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
var file_setup_proto_goTypes = []interface{}{
(*Handshake)(nil), // 0: terraform1.setup.Handshake
(*Stop)(nil), // 1: terraform1.setup.Stop
(*Config)(nil), // 2: terraform1.setup.Config
(*HostCredential)(nil), // 3: terraform1.setup.HostCredential
(*ClientCapabilities)(nil), // 4: terraform1.setup.ClientCapabilities
(*ServerCapabilities)(nil), // 5: terraform1.setup.ServerCapabilities
(*Handshake_Request)(nil), // 6: terraform1.setup.Handshake.Request
(*Handshake_Response)(nil), // 7: terraform1.setup.Handshake.Response
(*Stop_Request)(nil), // 8: terraform1.setup.Stop.Request
(*Stop_Response)(nil), // 9: terraform1.setup.Stop.Response
nil, // 10: terraform1.setup.Config.CredentialsEntry
}
var file_setup_proto_depIdxs = []int32{
10, // 0: terraform1.setup.Config.credentials:type_name -> terraform1.setup.Config.CredentialsEntry
4, // 1: terraform1.setup.Handshake.Request.capabilities:type_name -> terraform1.setup.ClientCapabilities
2, // 2: terraform1.setup.Handshake.Request.config:type_name -> terraform1.setup.Config
5, // 3: terraform1.setup.Handshake.Response.capabilities:type_name -> terraform1.setup.ServerCapabilities
3, // 4: terraform1.setup.Config.CredentialsEntry.value:type_name -> terraform1.setup.HostCredential
6, // 5: terraform1.setup.Setup.Handshake:input_type -> terraform1.setup.Handshake.Request
8, // 6: terraform1.setup.Setup.Stop:input_type -> terraform1.setup.Stop.Request
7, // 7: terraform1.setup.Setup.Handshake:output_type -> terraform1.setup.Handshake.Response
9, // 8: terraform1.setup.Setup.Stop:output_type -> terraform1.setup.Stop.Response
7, // [7:9] is the sub-list for method output_type
5, // [5:7] is the sub-list for method input_type
5, // [5:5] is the sub-list for extension type_name
5, // [5:5] is the sub-list for extension extendee
0, // [0:5] is the sub-list for field type_name
}
func init() { file_setup_proto_init() }
func file_setup_proto_init() {
if File_setup_proto != nil {
return
}
if !protoimpl.UnsafeEnabled {
file_setup_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Handshake); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_setup_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Stop); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_setup_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Config); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_setup_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*HostCredential); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_setup_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ClientCapabilities); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_setup_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*ServerCapabilities); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_setup_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Handshake_Request); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_setup_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Handshake_Response); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_setup_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Stop_Request); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_setup_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*Stop_Response); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_setup_proto_rawDesc,
NumEnums: 0,
NumMessages: 11,
NumExtensions: 0,
NumServices: 1,
},
GoTypes: file_setup_proto_goTypes,
DependencyIndexes: file_setup_proto_depIdxs,
MessageInfos: file_setup_proto_msgTypes,
}.Build()
File_setup_proto = out.File
file_setup_proto_rawDesc = nil
file_setup_proto_goTypes = nil
file_setup_proto_depIdxs = nil
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6
// SetupClient is the client API for Setup service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SetupClient interface {
// Clients must call Handshake before any other function of any other
// service, to complete the capability negotiation step that may
// then affect the behaviors of subsequent operations.
//
// This function can be called only once per RPC server.
Handshake(ctx context.Context, in *Handshake_Request, opts ...grpc.CallOption) (*Handshake_Response, error)
// At any time after handshaking, clients may call Stop to initiate a
// graceful shutdown of the server.
Stop(ctx context.Context, in *Stop_Request, opts ...grpc.CallOption) (*Stop_Response, error)
}
type setupClient struct {
cc grpc.ClientConnInterface
}
func NewSetupClient(cc grpc.ClientConnInterface) SetupClient {
return &setupClient{cc}
}
func (c *setupClient) Handshake(ctx context.Context, in *Handshake_Request, opts ...grpc.CallOption) (*Handshake_Response, error) {
out := new(Handshake_Response)
err := c.cc.Invoke(ctx, "/terraform1.setup.Setup/Handshake", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *setupClient) Stop(ctx context.Context, in *Stop_Request, opts ...grpc.CallOption) (*Stop_Response, error) {
out := new(Stop_Response)
err := c.cc.Invoke(ctx, "/terraform1.setup.Setup/Stop", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// SetupServer is the server API for Setup service.
type SetupServer interface {
// Clients must call Handshake before any other function of any other
// service, to complete the capability negotiation step that may
// then affect the behaviors of subsequent operations.
//
// This function can be called only once per RPC server.
Handshake(context.Context, *Handshake_Request) (*Handshake_Response, error)
// At any time after handshaking, clients may call Stop to initiate a
// graceful shutdown of the server.
Stop(context.Context, *Stop_Request) (*Stop_Response, error)
}
// UnimplementedSetupServer can be embedded to have forward compatible implementations.
type UnimplementedSetupServer struct {
}
func (*UnimplementedSetupServer) Handshake(context.Context, *Handshake_Request) (*Handshake_Response, error) {
return nil, status.Errorf(codes.Unimplemented, "method Handshake not implemented")
}
func (*UnimplementedSetupServer) Stop(context.Context, *Stop_Request) (*Stop_Response, error) {
return nil, status.Errorf(codes.Unimplemented, "method Stop not implemented")
}
func RegisterSetupServer(s *grpc.Server, srv SetupServer) {
s.RegisterService(&_Setup_serviceDesc, srv)
}
func _Setup_Handshake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(Handshake_Request)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SetupServer).Handshake(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/terraform1.setup.Setup/Handshake",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SetupServer).Handshake(ctx, req.(*Handshake_Request))
}
return interceptor(ctx, in, info, handler)
}
func _Setup_Stop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(Stop_Request)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(SetupServer).Stop(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/terraform1.setup.Setup/Stop",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(SetupServer).Stop(ctx, req.(*Stop_Request))
}
return interceptor(ctx, in, info, handler)
}
var _Setup_serviceDesc = grpc.ServiceDesc{
ServiceName: "terraform1.setup.Setup",
HandlerType: (*SetupServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Handshake",
Handler: _Setup_Handshake_Handler,
},
{
MethodName: "Stop",
Handler: _Setup_Stop_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "setup.proto",
}

58
internal/rpcapi/terraform1/setup/setup.proto Normal file
View file

@ -0,0 +1,58 @@
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
syntax = "proto3";
package terraform1.setup;
service Setup {
// Clients must call Handshake before any other function of any other
// service, to complete the capability negotiation step that may
// then affect the behaviors of subsequent operations.
//
// This function can be called only once per RPC server.
rpc Handshake(Handshake.Request) returns (Handshake.Response);
// At any time after handshaking, clients may call Stop to initiate a
// graceful shutdown of the server.
rpc Stop(Stop.Request) returns (Stop.Response);
}
message Handshake {
message Request {
ClientCapabilities capabilities = 1;
Config config = 2;
}
message Response {
ServerCapabilities capabilities = 2;
}
}
message Stop {
message Request {
}
message Response {
}
}
message Config {
map<string, HostCredential> credentials = 1;
}
message HostCredential {
string token = 1;
}
// The capabilities that the client wishes to advertise to the server during
// handshake.
message ClientCapabilities {
// There are not yet any negotiatable capabilities.
}
// The capabilities that the server wishes to advertise to the client during
// handshake. Fields in this message can also be used to acknowledge and
// confirm support for client capabilities advertised in ClientCapabilities,
// in situations where the client must vary its behavior based on the server's
// level of support.
message ServerCapabilities {
// There are not yet any negotiatable capabilities.
}

2
internal/rpcapi/terraform1/conversion.go → internal/rpcapi/terraform1/stacks/conversion.go
View file

@ -1,7 +1,7 @@
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
package terraform1
package stacks
import (
"fmt"

8396
internal/rpcapi/terraform1/stacks/stacks.pb.go Normal file
View file

File diff suppressed because it is too large Load diff

802
internal/rpcapi/terraform1/stacks/stacks.proto Normal file
View file

@ -0,0 +1,802 @@
// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: BUSL-1.1
syntax = "proto3";
package terraform1.stacks;
import "google/protobuf/any.proto";
import "terraform1.proto";
service Stacks {
// Load and perform initial static validation of a stack configuration
// in a previously-opened source bundle. If successful, returns a
// stack configuration handle that can be used with other operations.
rpc OpenStackConfiguration(OpenStackConfiguration.Request)
returns (OpenStackConfiguration.Response);
// Close a previously-opened stack configuration using its handle.
rpc CloseStackConfiguration(CloseStackConfiguration.Request)
returns (CloseStackConfiguration.Response);
// Validate an open stack configuration.
rpc ValidateStackConfiguration(ValidateStackConfiguration.Request)
returns (ValidateStackConfiguration.Response);
// Analyze a stack configuration to find all of the components it declares.
// This is static analysis only, so it cannot produce dynamic information
// such as the number of instances of each component.
rpc FindStackConfigurationComponents(FindStackConfigurationComponents.Request)
returns (FindStackConfigurationComponents.Response);
// Load a stack state by sending a stream of raw state objects that were
// streamed from a previous ApplyStackChanges response.
rpc OpenState(stream OpenStackState.RequestItem) returns (OpenStackState.Response);
// Close a stack state handle, discarding the associated state.
rpc CloseState(CloseStackState.Request) returns (CloseStackState.Response);
// Calculate a desired state from the given configuration and compare it
// with the current state to propose a set of changes to converge the
// current state with the desired state, at least in part.
rpc PlanStackChanges(PlanStackChanges.Request)
returns (stream PlanStackChanges.Event);
// Load a previously-created plan by sending a stream of raw change objects
// that were streamed from a previous PlanStackChanges response.
rpc OpenPlan(stream OpenStackPlan.RequestItem) returns (OpenStackPlan.Response);
// Close a saved plan handle, discarding the associated saved plan.
rpc ClosePlan(CloseStackPlan.Request) returns (CloseStackPlan.Response);
// Execute the changes proposed by an earlier call to PlanStackChanges.
rpc ApplyStackChanges(ApplyStackChanges.Request)
returns (stream ApplyStackChanges.Event);
// OpenStackInspector creates a stack inspector handle that can be used
// with subsequent calls to the "Inspect"-prefixed functions.
rpc OpenStackInspector(OpenStackInspector.Request)
returns (OpenStackInspector.Response);
// InspectExpressionResult evaluates an arbitrary expression in the context
// of a stack inspector handle.
rpc InspectExpressionResult(InspectExpressionResult.Request)
returns (InspectExpressionResult.Response);
}
message OpenStackConfiguration {
message Request {
int64 source_bundle_handle = 1;
terraform1.SourceAddress source_address = 2;
}
message Response {
int64 stack_config_handle = 1;
repeated terraform1.Diagnostic diagnostics = 2;
}
}
message CloseStackConfiguration {
message Request {
int64 stack_config_handle = 1;
}
message Response {
}
}
message ValidateStackConfiguration {
message Request {
int64 stack_config_handle = 1;
int64 dependency_locks_handle = 2;
int64 provider_cache_handle = 3;
}
message Response {
repeated terraform1.Diagnostic diagnostics = 1;
}
}
message FindStackConfigurationComponents {
message Request {
int64 stack_config_handle = 1;
}
message Response {
StackConfig config = 1;
}
enum Instances {
SINGLE = 0;
COUNT = 1;
FOR_EACH = 2;
}
message StackConfig {
map<string, Component> components = 1;
map<string, EmbeddedStack> embedded_stacks = 2;
map<string, InputVariable> input_variables = 3;
map<string, OutputValue> output_values = 4;
}
message EmbeddedStack {
string source_addr = 1;
Instances instances = 2;
StackConfig config = 3;
}
message Component {
string source_addr = 1;
Instances instances = 2;
string component_addr = 3;
}
message InputVariable {
bool optional = 1;
bool sensitive = 2;
bool ephemeral = 3;
}
message OutputValue {
bool sensitive = 1;
bool ephemeral = 2;
}
}
message OpenStackState {
message RequestItem {
AppliedChange.RawChange raw = 1;
}
message Response {
int64 state_handle = 1;
}
}
message CloseStackState {
message Request {
int64 state_handle = 1;
}
message Response {
}
}
message PlanStackChanges {
message Request {
PlanMode plan_mode = 1;
int64 stack_config_handle = 2;
int64 previous_state_handle = 7;
map<string, google.protobuf.Any> previous_state = 3 [deprecated = true];
int64 dependency_locks_handle = 4;
int64 provider_cache_handle = 5;
map<string, DynamicValueWithSource> input_values = 6;
// TODO: Various other planning options
}
message Event {
oneof event {
PlannedChange planned_change = 1;
terraform1.Diagnostic diagnostic = 2;
StackChangeProgress progress = 10;
}
reserved 3 to 9; // formerly used for individual progress events
}
}
message OpenStackPlan {
message RequestItem {
google.protobuf.Any raw = 1;
}
message Response {
int64 plan_handle = 1;
}
}
message CloseStackPlan {
message Request {
int64 plan_handle = 1;
}
message Response {
}
}
message ApplyStackChanges {
message Request {
// This must refer to exactly the same configuration that was
// passed to PlanStackChanges when creating this plan, or the
// results will be unpredictable.
int64 stack_config_handle = 1;
// The caller should send all of the keys present in the previous
// apply's description map. Terraform Core will use this for
// situations such as updating existing descriptions to newer
// formats even if no change is being made to the corresponding
// real objects.
repeated string known_description_keys = 3;
// The handle for a saved plan previously loaded using the
// Stacks.OpenPlan function.
// Applying a plan immediately invalidates it, so the handle will
// be automatically closed.
int64 plan_handle = 8;
// This must include all of the "raw" values emitted through
// PlannedChange events during the PlanStackChanges operation
// that created this plan, concatenated together in the same
// order they were written to the PlanStackChanges event stream.
//
// Use plan_handle instead. This will be removed in future.
repeated google.protobuf.Any planned_changes = 4 [deprecated = true];
// This must be equivalent to the argument of the same name
// passed to PlanStackChanges when creating this plan.
int64 dependency_locks_handle = 5;
// This must be equivalent to the argument of the same name
// passed to PlanStackChanges when creating this plan.
int64 provider_cache_handle = 6;
// Any input variables identified as an "apply-time input variable"
// in the plan must have values provided here.
//
// Callers may also optionally include values for other declared input
// variables, but if so their values must exactly match those used when
// creating the plan.
map<string, DynamicValueWithSource> input_values = 7;
reserved 2; // (formerly the previous state, but we now propagate that as part of planned_changes as an implementation detail)
}
message Event {
oneof event {
AppliedChange applied_change = 1;
terraform1.Diagnostic diagnostic = 2;
StackChangeProgress progress = 3;
}
}
}
message OpenStackInspector {
message Request {
int64 stack_config_handle = 1;
map<string, google.protobuf.Any> state = 2;
int64 dependency_locks_handle = 3;
int64 provider_cache_handle = 4;
map<string, DynamicValueWithSource> input_values = 5;
}
message Response {
int64 stack_inspector_handle = 1;
repeated terraform1.Diagnostic diagnostics = 2;
}
}
message InspectExpressionResult {
message Request {
int64 stack_inspector_handle = 1;
bytes expression_src = 2;
string stack_addr = 3;
}
message Response {
// The result of evaluating the expression, if successful enough to
// produce a result. Unpopulated if the expression was too invalid
// to produce a result, with the problem then described in the
// associated diagnostics.
//
// Uses a MessagePack encoding with in-band type information.
DynamicValue result = 1;
repeated terraform1.Diagnostic diagnostics = 2;
}
}
// Represents dynamically-typed data from within the Terraform language.
// Typically only one of the available serialization formats will be populated,
// depending on what serializations are appropriate for a particular context
// and what capabilities the client and the server negotiated during Handshake.
message DynamicValue {
bytes msgpack = 1; // The default serialization format
repeated AttributePath sensitive = 2; // Paths to any sensitive-marked values.
}
// Represents a change of some object from one dynamic value to another.
message DynamicValueChange {
DynamicValue old = 1;
DynamicValue new = 2;
}
// Represents a DynamicValue accompanied by a source location where it was
// presumably defined, for values that originated in configuration files for
// situations such as returning error messages.
message DynamicValueWithSource {
DynamicValue value = 1;
terraform1.SourceRange source_range = 2;
}
message AttributePath {
message Step {
oneof selector {
// Set "attribute_name" to represent looking up an attribute
// in the current object value.
string attribute_name = 1;
// Set "element_key_*" to represent looking up an element in
// an indexable collection type.
string element_key_string = 2;
int64 element_key_int = 3;
}
}
repeated Step steps = 1;
}
// Represents the address of a specific component instance within a stack.
message ComponentInstanceInStackAddr {
// The address of the static component that this is an instance of.
string component_addr = 1;
// The address of the instance that's being announced. For
// multi-instance components this could have any combination of
// instance keys on the component itself or instance keys on any
// of the containing embedded stacks.
string component_instance_addr = 2;
}
// Represents the address of a specific resource instance inside a specific
// component instance within the containing stack.
message ResourceInstanceInStackAddr {
// Unique address of the component instance that this resource instance
// belongs to. This is comparable with
string component_instance_addr = 1;
// Unique address of the resource instance within the given component
// instance. Each component instance has a separate namespace of
// resource instance addresses, so callers must take both fields together
// to produce a key that's unique throughout the entire plan.
string resource_instance_addr = 2;
}
// Represents the address of a specific resource instance object inside a
// specific component instance within the containing stack.
message ResourceInstanceObjectInStackAddr {
// Unique address of the component instance that this resource instance
// belongs to. This is comparable with
string component_instance_addr = 1;
// Unique address of the resource instance within the given component
// instance. Each component instance has a separate namespace of
// resource instance addresses, so callers must take both fields together
// to produce a key that's unique throughout the entire plan.
string resource_instance_addr = 2;
// Optional "deposed key" populated only for non-current (deposed) objects,
// which can appear for "create before destroy" replacements where the
// create succeeds but then the destroy fails, leaving us with two different
// objects to track for the same resource instance.
string deposed_key = 3;
}
enum ResourceMode {
UNKNOWN = 0;
MANAGED = 1;
DATA = 2;
}
enum PlanMode {
NORMAL = 0;
REFRESH_ONLY = 1;
DESTROY = 2;
}
enum ChangeType {
NOOP = 0;
READ = 1;
CREATE = 2;
UPDATE = 3;
DELETE = 4;
FORGET = 5;
}
// Describes one item in a stack plan. The overall plan is the concatentation
// of all messages of this type emitted as events during the plan; splitting
// this information over multiple messages just allows the individual events
// to double as progress notifications for an interactive UI.
message PlannedChange {
// Terraform Core's internal representation(s) of this change. Callers
// must provide the messages in this field, if any, verbatim to the
// ApplyStackChanges RPC in order to apply this change, and must not
// attempt to decode or analyze the contents because they are subject
// to change in future versions of Terraform Core.
//
// This might be unpopulated if this message represents only information
// for the caller and Terraform Core doesn't actually need to recall this
// information during the apply step. Callers must append each raw item
// to the raw plan in the order specified, and provide them all together
// in the same order to ApplyStackChanges.
repeated google.protobuf.Any raw = 1;
// Caller-facing descriptions of this change, to use for presenting
// information to end-users in the UI and for other subsystems such as
// imposing policy rules on the resulting plan.
//
// There can be zero or more description objects associated with each
// change. More than one is not common, but should be supported by clients
// by treating them the same way as if each description had arrived in
// a separate PlannedChange message. Clients should not treat the grouping
// or not-grouping of change description objects as meaningful information,
// since it's subject to change in future Terraform Core versions.
//
// DO NOT attempt to use this to surgically filter particular changes
// from a larger plan. Although external descriptions often match with
// the raw representations in field "raw", that is not guaranteed and
// Terraform Core assumes that it will always be provided with the full
// set of raw messages -- in the same order they were emitted -- during
// the apply step. For example, some raw messages might omit information
// that is implied by earlier raw messages and would therefore be
// incomplete if isolated.
repeated ChangeDescription descriptions = 2;
reserved 3 to 6; // formerly used for an inline "oneof description", now factored out into a separate message type
// Represents a single caller-facing description of a change, to use for
// presenting information to end users in the UI and for other subsystems
// such as imposing policy rules on the resulting plan.
//
// New description types might be added in future versions of Terraform
// Core, and so clients should tolerate description messages that appear
// to have none of the oneof fields set, and should just ignore those
// messages entirely.
message ChangeDescription {
oneof description {
ComponentInstance component_instance_planned = 1;
ResourceInstance resource_instance_planned = 2;
OutputValue output_value_planned = 3;
bool plan_applyable = 4;
ResourceInstanceDeferred resource_instance_deferred = 5;
InputVariableDuringApply apply_time_input_variable = 6;
}
}
// Reports the existence of a particular instance of a component,
// once Terraform has resolved arguments such as "for_each" that
// might make the set of instances dynamic.
message ComponentInstance {
ComponentInstanceInStackAddr addr = 1;
// The changes to the existence of this instance relative to the
// prior state. This only considers the component instance directly,
// and doesn't take into account what actions are planned for any
// resource instances inside.
repeated ChangeType actions = 2;
// A flag for whether applying this plan is expected to cause the
// desired state and actual state to become converged.
//
// If this field is false, that means Terraform expects that at least
// one more plan/apply round will be needed to reach convergence.
//
// If this field is true then Terraform hopes to be able to converge
// after this plan is applied, but callers should ideally still check
// anyway by running one more plan to confirm that there aren't any
// unexpected differences caused by such situations as contradictory
// configuration or provider bugs.
bool plan_complete = 3;
}
message ResourceInstance {
ResourceInstanceObjectInStackAddr addr = 1;
repeated ChangeType actions = 2;
DynamicValueChange values = 3;
Moved moved = 4;
Imported imported = 5;
ResourceMode resource_mode = 6;
string resource_type = 7;
string provider_addr = 8;
// previous_run_value is included only if it would be
// different from values.old, which typically means that
// Terraform detected some changes made outside of Terraform
// since the previous run. In that case, this field is
// the un-refreshed (but still upgraded) value from
// the previous run and values.old is the refreshed version.
//
// If this isn't set then values.old should be used as the
// previous run value, if needed.
DynamicValue previous_run_value = 9;
// This flag is set if Terraform Core considers the difference
// between previous_run_value and values.old to be "notable",
// which is a heuristic subject to change over time but is
// broadly intended to mean that it would be worth mentioning
// the difference between the two in the UI as a
// "change outside of Terraform". If this isn't set then the
// difference is probably not worth mentioning to the user
// by default, although it could still be shown behind an
// optional disclosure in UI contexts where such things are possible.
bool notable_change_outside = 10;
repeated AttributePath replace_paths = 11;
string resource_name = 12;
Index index = 13;
string module_addr = 14;
string action_reason = 15;
message Index {
DynamicValue value = 1;
bool unknown = 2;
}
message Moved {
ResourceInstanceInStackAddr prev_addr = 1;
}
message Imported {
string import_id = 1;
bool unknown = 2;
string generated_config = 3;
}
}
// Note: this is only for output values from the topmost
// stack configuration, because all other output values are
// internal to the configuration and not part of its public API.
message OutputValue {
string name = 1;
repeated ChangeType actions = 2;
DynamicValueChange values = 3;
}
message ResourceInstanceDeferred {
ResourceInstance resource_instance = 1;
Deferred deferred = 2;
}
// Describes an input variable that must have a value provided
// during the apply phase.
//
// This currently arises only when the variable was declared
// as ephemeral and was set to a non-null value during the planning
// phase.
message InputVariableDuringApply {
string name = 1;
}
}
// Deferred contains all the metadata about a the deferral of a resource
// instance change.
message Deferred {
// Reason describes the reason why a resource instance change was
// deferred.
enum Reason {
INVALID = 0;
INSTANCE_COUNT_UNKNOWN = 1;
RESOURCE_CONFIG_UNKNOWN = 2;
PROVIDER_CONFIG_UNKNOWN = 3;
ABSENT_PREREQ = 4;
DEFERRED_PREREQ = 5;
}
Reason reason = 1;
}
// Describes a change made during a Stacks.ApplyStackChanges call.
//
// All of the events of this type taken together represent a sort of "patch"
// modifying the two data structures that the caller must maintain: the
// raw state map, and the description map. Callers must apply these changes
// in the order of the emission of the messages and then retain the entirety
// of both data structures to populate fields in the next PlanStackChanges call.
message AppliedChange {
// Terraform Core's internal representation of the change, presented as
// a sequence of modifications to the raw state data structure.
//
// For each element, in order:
// - If both key and value are set and the key matches an element
// already in the raw state map, the new value replaces the existing one.
// - If both key and value are set but the key does not match an
// element in the raw state map, this represents inserting a new element
// into the map.
// - If key is set and value is not, this represents removing any existing
// element from the raw state map which has the given key, or a no-op
// if no such element exists.
// - No other situation is legal.
//
// This sequence can potentially be zero-length if a particular event only
// has a external-facing "description" component and no raw equivalent. In
// that case the raw state map is unmodified.
repeated RawChange raw = 1;
// Caller-facing description of this change, to use for presenting
// information to end-users in the UI and for other subsystems such as
// billing.
//
// Callers are expected to maintain a map of description objects that
// gets updated piecemeal by messages in this field. Callers must treat
// the keys as entirely opaque and thus treat the resulting data structure
// as if it were an unsorted set of ChangeDescription objects; the keys
// exist only to allow patching the data structure over time.
//
// For each element, in order:
// - If both key and description are set and the key matches an element
// from the previous apply's description map, the new value replaces
// the existing one.
// - If both key and value are set but the key does not match an
// element in the previous apply's description map, this represents
// inserting a new element into the map.
// - If key is set and description is "deleted", this represents removing
// any existing element from the previous apply's description map which
// has the given key, or a no-op if no such element exists.
// - If a description field is set that the caller doesn't understand,
// the caller should still write it to the updated description map
// but ignore it in further processing.
// - No other situation is legal.
//
// Callers MUST preserve the verbatim description message in the
// description map, even if it contains fields that are not present in
// the caller's current protobuf stubs. In other words, callers must use
// a protocol buffers implementation that is able to preserve unknown
// fields and store them so that future versions of the caller might
// use an updated set of stubs to interact with the previously-stored
// description.
//
// DO NOT attempt to use this to surgically filter particular raw state
// updates from a larger plan. Although external descriptions often match
// with the raw representations in field "raw", that is not guaranteed and
// Terraform Core assumes that it will always be provided with the full
// raw state map during the next plan step.
repeated ChangeDescription descriptions = 2;
message RawChange {
string key = 1;
google.protobuf.Any value = 2;
}
message ChangeDescription {
string key = 1;
oneof description {
Nothing deleted = 4; // explicitly represents the absence of a description
Nothing moved = 6; // explicitly represents the absence of a description
ResourceInstance resource_instance = 2;
OutputValue output_value = 3;
ComponentInstance component_instance = 5;
}
// Field number 20000 is reserved as a field number that will
// always be unknown to any client, to allow clients to test
// whether they correctly preserve unexpected fields.
reserved 20000;
}
message ResourceInstance {
ResourceInstanceObjectInStackAddr addr = 1;
DynamicValue new_value = 2;
ResourceMode resource_mode = 4;
string resource_type = 5;
string provider_addr = 6;
// Sometimes Terraform needs to make changes to a resource in
// multiple steps during the apply phase, with each step
// changing something about the state. This flag will be set
// for such interim updates, and left unset for whatever
// description Terraform Core considers to be "final", at
// which point the new value should be converged with the
// desired state.
//
// The intended use for this is when presenting updated values
// to users in the UI, where it might be best to ignore or
// present differently interim updates to avoid creating
// confusion by showing the not-yet-converged intermediate
// states.
//
// If Terraform encounters a problem during the apply phase
// and needs to stop partway through then a "final" change
// description might never arrive. In that case, callers
// should save the most recent interim object as the final
// description, since it would represent the most accurate
// description of the state the remote system has been left
// in.
bool interim = 3;
}
message ComponentInstance {
string component_addr = 3;
string component_instance_addr = 1;
map<string,DynamicValue> output_values = 2;
}
message OutputValue {
string name = 1;
DynamicValue new_value = 2;
}
message Nothing {}
}
// A container for "progress report" events in both Stacks.PlanStackChanges
// and Stacks.ApplyStackChanges, which share this message type to allow
// clients to share event-handling code between the two phases.
message StackChangeProgress {
// Some event types are relevant only to one of the two operations, while
// others are common across both but will include different status codes,
// etc in different phases.
oneof event {
ComponentInstanceStatus component_instance_status = 1;
ResourceInstanceStatus resource_instance_status = 2;
ResourceInstancePlannedChange resource_instance_planned_change = 3;
ProvisionerStatus provisioner_status = 4;
ProvisionerOutput provisioner_output = 5;
ComponentInstanceChanges component_instance_changes = 6;
ComponentInstances component_instances = 7;
DeferredResourceInstancePlannedChange deferred_resource_instance_planned_change = 8;
}
// ComponentInstanceStatus describes the current status of a component instance
// undergoing a plan or apply operation.
message ComponentInstanceStatus {
ComponentInstanceInStackAddr addr = 1;
Status status = 2;
enum Status {
INVALID = 0;
PENDING = 1;
PLANNING = 2;
PLANNED = 3;
APPLYING = 4;
APPLIED = 5;
ERRORED = 6;
DEFERRED = 7;
}
}
// ComponentInstanceStatus describes the current status of a resource instance
// undergoing a plan or apply operation.
message ResourceInstanceStatus {
ResourceInstanceObjectInStackAddr addr = 1;
Status status = 2;
string provider_addr = 3;
enum Status {
INVALID = 0;
PENDING = 1;
REFRESHING = 2;
REFRESHED = 3;
PLANNING = 4;
PLANNED = 5;
APPLYING = 6;
APPLIED = 7;
ERRORED = 8;
}
}
// ResourceInstancePlannedChange describes summary information about a planned
// change for a resource instance. This does not include the full object change,
// which is described in PlannedChange.ResourceChange. The information in this
// message is intended for the event stream and need not include the instance's
// full object values.
message ResourceInstancePlannedChange {
ResourceInstanceObjectInStackAddr addr = 1;
repeated ChangeType actions = 2;
Moved moved = 3;
Imported imported = 4;
string provider_addr = 5;
message Moved {
ResourceInstanceInStackAddr prev_addr = 1;
}
message Imported {
string import_id = 1;
bool unknown = 2;
}
}
// DeferredResourceInstancePlannedChange represents a planned change for a
// resource instance that is deferred due to the reason provided.
message DeferredResourceInstancePlannedChange {
Deferred deferred = 1;
ResourceInstancePlannedChange change = 2;
}
// ProvisionerStatus represents the progress of a given provisioner during its
// resource instance's apply operation.
message ProvisionerStatus {
ResourceInstanceObjectInStackAddr addr = 1;
string name = 2;
ProvisionerStatus status = 3;
enum Status {
INVALID = 0;
PROVISIONING = 1;
PROVISIONED = 2;
ERRORED = 3;
}
}
// ProvisionerOutput represents recorded output data emitted by a provisioner
// during a resource instance's apply operation.
message ProvisionerOutput {
ResourceInstanceObjectInStackAddr addr = 1;
string name = 2;
string output = 3;
}
// ComponentInstanceChanges represents a roll-up of change counts for a
// component instance plan or apply operation.
message ComponentInstanceChanges {
ComponentInstanceInStackAddr addr = 1;
// total is the sum of all of the other count fields.
//
// Clients should sum all of the other count fields they know about
// and compare to total. If the sum is less than total then the
// difference should be treated as an "other change types" category,
// for forward-compatibility when the Terraform Core RPC server is
// using a newer version of this protocol than the client.
int32 total = 2;
int32 add = 3;
int32 change = 4;
int32 import = 5;
int32 remove = 6;
int32 defer = 7;
int32 move = 8;
int32 forget = 9;
}
// ComponentInstances represents the result of expanding a component into zero
// or more instances.
message ComponentInstances {
string component_addr = 1;
repeated string instance_addrs = 2;
}
}

15191
internal/rpcapi/terraform1/terraform1.pb.go
View file

File diff suppressed because it is too large Load diff

1302
internal/rpcapi/terraform1/terraform1.proto
View file

File diff suppressed because it is too large Load diff

152
internal/stacks/stackplan/planned_change.go
View file

@ -21,7 +21,7 @@ import (
"github.com/hashicorp/terraform/internal/plans/planfile"
"github.com/hashicorp/terraform/internal/plans/planproto"
"github.com/hashicorp/terraform/internal/providers"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
"github.com/hashicorp/terraform/internal/stacks/stackutils"
"github.com/hashicorp/terraform/internal/stacks/tfstackdata1"
@ -43,7 +43,7 @@ import (
type PlannedChange interface {
// PlannedChangeProto returns the protocol buffers representation of
// the change, ready to be sent verbatim to an RPC API client.
PlannedChangeProto() (*terraform1.PlannedChange, error)
PlannedChangeProto() (*stacks.PlannedChange, error)
}
// PlannedChangeRootInputValue announces the existence of a root stack input
@ -75,7 +75,7 @@ type PlannedChangeRootInputValue struct {
var _ PlannedChange = (*PlannedChangeRootInputValue)(nil)
// PlannedChangeProto implements PlannedChange.
func (pc *PlannedChangeRootInputValue) PlannedChangeProto() (*terraform1.PlannedChange, error) {
func (pc *PlannedChangeRootInputValue) PlannedChangeProto() (*stacks.PlannedChange, error) {
// We use cty.DynamicPseudoType here so that we'll save both the
// value _and_ its dynamic type in the plan, so we can recover
// exactly the same value later.
@ -100,15 +100,15 @@ func (pc *PlannedChangeRootInputValue) PlannedChangeProto() (*terraform1.Planned
return nil, err
}
var descs []*terraform1.PlannedChange_ChangeDescription
var descs []*stacks.PlannedChange_ChangeDescription
if pc.RequiredOnApply {
// We only include a change description for the subset of variables
// which must be re-supplied during apply. This allows an apply-time
// caller to know which subset of variables it needs to provide.
descs = []*terraform1.PlannedChange_ChangeDescription{
descs = []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ApplyTimeInputVariable{
ApplyTimeInputVariable: &terraform1.PlannedChange_InputVariableDuringApply{
Description: &stacks.PlannedChange_ChangeDescription_ApplyTimeInputVariable{
ApplyTimeInputVariable: &stacks.PlannedChange_InputVariableDuringApply{
Name: pc.Addr.Name,
},
},
@ -116,7 +116,7 @@ func (pc *PlannedChangeRootInputValue) PlannedChangeProto() (*terraform1.Planned
}
}
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
Raw: []*anypb.Any{&raw},
Descriptions: descs,
}, nil
@ -185,7 +185,7 @@ type PlannedChangeComponentInstance struct {
var _ PlannedChange = (*PlannedChangeComponentInstance)(nil)
// PlannedChangeProto implements PlannedChange.
func (pc *PlannedChangeComponentInstance) PlannedChangeProto() (*terraform1.PlannedChange, error) {
func (pc *PlannedChangeComponentInstance) PlannedChangeProto() (*stacks.PlannedChange, error) {
var plannedInputValues map[string]*tfstackdata1.DynamicValue
if n := len(pc.PlannedInputValues); n != 0 {
plannedInputValues = make(map[string]*tfstackdata1.DynamicValue, n)
@ -256,18 +256,18 @@ func (pc *PlannedChangeComponentInstance) PlannedChangeProto() (*terraform1.Plan
return nil, err
}
protoChangeTypes, err := terraform1.ChangeTypesForPlanAction(pc.Action)
protoChangeTypes, err := stacks.ChangeTypesForPlanAction(pc.Action)
if err != nil {
return nil, err
}
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
Raw: []*anypb.Any{&raw},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ComponentInstancePlanned{
ComponentInstancePlanned: &terraform1.PlannedChange_ComponentInstance{
Addr: &terraform1.ComponentInstanceInStackAddr{
Description: &stacks.PlannedChange_ChangeDescription_ComponentInstancePlanned{
ComponentInstancePlanned: &stacks.PlannedChange_ComponentInstance{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: stackaddrs.ConfigComponentForAbsInstance(pc.Addr).String(),
ComponentInstanceAddr: pc.Addr.String(),
},
@ -355,7 +355,7 @@ func (pc *PlannedChangeResourceInstancePlanned) PlanResourceInstanceChangePlanne
}, nil
}
func (pc *PlannedChangeResourceInstancePlanned) ChangeDescription() (*terraform1.PlannedChange_ChangeDescription, error) {
func (pc *PlannedChangeResourceInstancePlanned) ChangeDescription() (*stacks.PlannedChange_ChangeDescription, error) {
rioAddr := pc.ResourceInstanceObjectAddr
// We only emit an external description if there's a change to describe.
// Otherwise, we just emit a raw to remind us to update the state for
@ -364,7 +364,7 @@ func (pc *PlannedChangeResourceInstancePlanned) ChangeDescription() (*terraform1
return nil, nil
}
protoChangeTypes, err := terraform1.ChangeTypesForPlanAction(pc.ChangeSrc.Action)
protoChangeTypes, err := stacks.ChangeTypesForPlanAction(pc.ChangeSrc.Action)
if err != nil {
return nil, err
}
@ -373,12 +373,12 @@ func (pc *PlannedChangeResourceInstancePlanned) ChangeDescription() (*terraform1
return nil, err
}
var moved *terraform1.PlannedChange_ResourceInstance_Moved
var imported *terraform1.PlannedChange_ResourceInstance_Imported
var moved *stacks.PlannedChange_ResourceInstance_Moved
var imported *stacks.PlannedChange_ResourceInstance_Imported
if pc.ChangeSrc.Moved() {
moved = &terraform1.PlannedChange_ResourceInstance_Moved{
PrevAddr: terraform1.NewResourceInstanceInStackAddr(stackaddrs.AbsResourceInstance{
moved = &stacks.PlannedChange_ResourceInstance_Moved{
PrevAddr: stacks.NewResourceInstanceInStackAddr(stackaddrs.AbsResourceInstance{
Component: rioAddr.Component,
Item: pc.ChangeSrc.PrevRunAddr,
}),
@ -386,17 +386,17 @@ func (pc *PlannedChangeResourceInstancePlanned) ChangeDescription() (*terraform1
}
if pc.ChangeSrc.Importing != nil {
imported = &terraform1.PlannedChange_ResourceInstance_Imported{
imported = &stacks.PlannedChange_ResourceInstance_Imported{
ImportId: pc.ChangeSrc.Importing.ID,
Unknown: pc.ChangeSrc.Importing.Unknown,
}
}
var index *terraform1.PlannedChange_ResourceInstance_Index
var index *stacks.PlannedChange_ResourceInstance_Index
if pc.ChangeSrc.Addr.Resource.Key != nil {
key := pc.ChangeSrc.Addr.Resource.Key
if key == addrs.WildcardKey {
index = &terraform1.PlannedChange_ResourceInstance_Index{
index = &stacks.PlannedChange_ResourceInstance_Index{
Unknown: true,
}
} else {
@ -404,16 +404,16 @@ func (pc *PlannedChangeResourceInstancePlanned) ChangeDescription() (*terraform1
if err != nil {
return nil, err
}
index = &terraform1.PlannedChange_ResourceInstance_Index{
index = &stacks.PlannedChange_ResourceInstance_Index{
Value: value,
}
}
}
return &terraform1.PlannedChange_ChangeDescription{
Description: &terraform1.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &terraform1.PlannedChange_ResourceInstance{
Addr: terraform1.NewResourceInstanceObjectInStackAddr(rioAddr),
return &stacks.PlannedChange_ChangeDescription{
Description: &stacks.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &stacks.PlannedChange_ResourceInstance{
Addr: stacks.NewResourceInstanceObjectInStackAddr(rioAddr),
ResourceName: pc.ChangeSrc.Addr.Resource.Resource.Name,
Index: index,
ModuleAddr: pc.ChangeSrc.Addr.Module.String(),
@ -423,12 +423,12 @@ func (pc *PlannedChangeResourceInstancePlanned) ChangeDescription() (*terraform1
ActionReason: pc.ChangeSrc.ActionReason.String(),
Actions: protoChangeTypes,
Values: &terraform1.DynamicValueChange{
Old: terraform1.NewDynamicValue(
Values: &stacks.DynamicValueChange{
Old: stacks.NewDynamicValue(
pc.ChangeSrc.Before,
pc.ChangeSrc.BeforeSensitivePaths,
),
New: terraform1.NewDynamicValue(
New: stacks.NewDynamicValue(
pc.ChangeSrc.After,
pc.ChangeSrc.AfterSensitivePaths,
),
@ -442,7 +442,7 @@ func (pc *PlannedChangeResourceInstancePlanned) ChangeDescription() (*terraform1
}
func DynamicValueToTerraform1(val cty.Value, ty cty.Type) (*terraform1.DynamicValue, error) {
func DynamicValueToTerraform1(val cty.Value, ty cty.Type) (*stacks.DynamicValue, error) {
unmarkedVal, markPaths := val.UnmarkDeepWithPaths()
sensitivePaths, withOtherMarks := marks.PathsWithMark(markPaths, marks.Sensitive)
if len(withOtherMarks) != 0 {
@ -456,7 +456,7 @@ func DynamicValueToTerraform1(val cty.Value, ty cty.Type) (*terraform1.DynamicVa
if err != nil {
return nil, err
}
ret := &terraform1.DynamicValue{
ret := &stacks.DynamicValue{
Msgpack: rawVal,
}
@ -464,15 +464,15 @@ func DynamicValueToTerraform1(val cty.Value, ty cty.Type) (*terraform1.DynamicVa
return ret, nil
}
ret.Sensitive = make([]*terraform1.AttributePath, 0, len(markPaths))
ret.Sensitive = make([]*stacks.AttributePath, 0, len(markPaths))
for _, path := range sensitivePaths {
ret.Sensitive = append(ret.Sensitive, terraform1.NewAttributePath(path))
ret.Sensitive = append(ret.Sensitive, stacks.NewAttributePath(path))
}
return ret, nil
}
// PlannedChangeProto implements PlannedChange.
func (pc *PlannedChangeResourceInstancePlanned) PlannedChangeProto() (*terraform1.PlannedChange, error) {
func (pc *PlannedChangeResourceInstancePlanned) PlannedChangeProto() (*stacks.PlannedChange, error) {
pric, err := pc.PlanResourceInstanceChangePlannedProto()
if err != nil {
return nil, err
@ -488,12 +488,12 @@ func (pc *PlannedChangeResourceInstancePlanned) PlannedChangeProto() (*terraform
// uninteresting edge-case. The PlanResourceInstanceChangePlannedProto
// function should have returned a placeholder value for this use case.
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
Raw: []*anypb.Any{&raw},
}, nil
}
var descs []*terraform1.PlannedChange_ChangeDescription
var descs []*stacks.PlannedChange_ChangeDescription
desc, err := pc.ChangeDescription()
if err != nil {
return nil, err
@ -502,7 +502,7 @@ func (pc *PlannedChangeResourceInstancePlanned) PlannedChangeProto() (*terraform
descs = append(descs, desc)
}
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
Raw: []*anypb.Any{&raw},
Descriptions: descs,
}, nil
@ -521,7 +521,7 @@ type PlannedChangeDeferredResourceInstancePlanned struct {
var _ PlannedChange = (*PlannedChangeDeferredResourceInstancePlanned)(nil)
// PlannedChangeProto implements PlannedChange.
func (dpc *PlannedChangeDeferredResourceInstancePlanned) PlannedChangeProto() (*terraform1.PlannedChange, error) {
func (dpc *PlannedChangeDeferredResourceInstancePlanned) PlannedChangeProto() (*stacks.PlannedChange, error) {
change, err := dpc.ResourceInstancePlanned.PlanResourceInstanceChangePlannedProto()
if err != nil {
return nil, err
@ -550,51 +550,51 @@ func (dpc *PlannedChangeDeferredResourceInstancePlanned) PlannedChangeProto() (*
return nil, err
}
var descs []*terraform1.PlannedChange_ChangeDescription
descs = append(descs, &terraform1.PlannedChange_ChangeDescription{
Description: &terraform1.PlannedChange_ChangeDescription_ResourceInstanceDeferred{
ResourceInstanceDeferred: &terraform1.PlannedChange_ResourceInstanceDeferred{
var descs []*stacks.PlannedChange_ChangeDescription
descs = append(descs, &stacks.PlannedChange_ChangeDescription{
Description: &stacks.PlannedChange_ChangeDescription_ResourceInstanceDeferred{
ResourceInstanceDeferred: &stacks.PlannedChange_ResourceInstanceDeferred{
ResourceInstance: ricd.GetResourceInstancePlanned(),
Deferred: EncodeDeferred(dpc.DeferredReason),
},
},
})
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
Raw: []*anypb.Any{&raw},
Descriptions: descs,
}, nil
}
func EncodeDeferred(reason providers.DeferredReason) *terraform1.Deferred {
deferred := new(terraform1.Deferred)
func EncodeDeferred(reason providers.DeferredReason) *stacks.Deferred {
deferred := new(stacks.Deferred)
switch reason {
case providers.DeferredReasonInstanceCountUnknown:
deferred.Reason = terraform1.Deferred_INSTANCE_COUNT_UNKNOWN
deferred.Reason = stacks.Deferred_INSTANCE_COUNT_UNKNOWN
case providers.DeferredReasonResourceConfigUnknown:
deferred.Reason = terraform1.Deferred_RESOURCE_CONFIG_UNKNOWN
deferred.Reason = stacks.Deferred_RESOURCE_CONFIG_UNKNOWN
case providers.DeferredReasonProviderConfigUnknown:
deferred.Reason = terraform1.Deferred_PROVIDER_CONFIG_UNKNOWN
deferred.Reason = stacks.Deferred_PROVIDER_CONFIG_UNKNOWN
case providers.DeferredReasonAbsentPrereq:
deferred.Reason = terraform1.Deferred_ABSENT_PREREQ
deferred.Reason = stacks.Deferred_ABSENT_PREREQ
case providers.DeferredReasonDeferredPrereq:
deferred.Reason = terraform1.Deferred_DEFERRED_PREREQ
deferred.Reason = stacks.Deferred_DEFERRED_PREREQ
default:
deferred.Reason = terraform1.Deferred_INVALID
deferred.Reason = stacks.Deferred_INVALID
}
return deferred
}
func encodePathSet(pathSet cty.PathSet) ([]*terraform1.AttributePath, error) {
func encodePathSet(pathSet cty.PathSet) ([]*stacks.AttributePath, error) {
if pathSet.Empty() {
return nil, nil
}
pathList := pathSet.List()
paths := make([]*terraform1.AttributePath, 0, len(pathList))
paths := make([]*stacks.AttributePath, 0, len(pathList))
for _, path := range pathList {
paths = append(paths, terraform1.NewAttributePath(path))
paths = append(paths, stacks.NewAttributePath(path))
}
return paths, nil
}
@ -615,26 +615,26 @@ type PlannedChangeOutputValue struct {
var _ PlannedChange = (*PlannedChangeOutputValue)(nil)
// PlannedChangeProto implements PlannedChange.
func (pc *PlannedChangeOutputValue) PlannedChangeProto() (*terraform1.PlannedChange, error) {
protoChangeTypes, err := terraform1.ChangeTypesForPlanAction(pc.Action)
func (pc *PlannedChangeOutputValue) PlannedChangeProto() (*stacks.PlannedChange, error) {
protoChangeTypes, err := stacks.ChangeTypesForPlanAction(pc.Action)
if err != nil {
return nil, err
}
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
// No "raw" representation for output values; we emit them only for
// external consumption, since Terraform Core will just recalculate
// them during apply anyway.
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_OutputValuePlanned{
OutputValuePlanned: &terraform1.PlannedChange_OutputValue{
Description: &stacks.PlannedChange_ChangeDescription_OutputValuePlanned{
OutputValuePlanned: &stacks.PlannedChange_OutputValue{
Name: pc.Addr.Name,
Actions: protoChangeTypes,
Values: &terraform1.DynamicValueChange{
Old: terraform1.NewDynamicValue(pc.OldValue, pc.OldValueSensitivePaths),
New: terraform1.NewDynamicValue(pc.NewValue, pc.NewValueSensitivePaths),
Values: &stacks.DynamicValueChange{
Old: stacks.NewDynamicValue(pc.OldValue, pc.OldValueSensitivePaths),
New: stacks.NewDynamicValue(pc.NewValue, pc.NewValueSensitivePaths),
},
},
},
@ -657,7 +657,7 @@ type PlannedChangeHeader struct {
var _ PlannedChange = (*PlannedChangeHeader)(nil)
// PlannedChangeProto implements PlannedChange.
func (pc *PlannedChangeHeader) PlannedChangeProto() (*terraform1.PlannedChange, error) {
func (pc *PlannedChangeHeader) PlannedChangeProto() (*stacks.PlannedChange, error) {
var raw anypb.Any
err := anypb.MarshalFrom(&raw, &tfstackdata1.PlanHeader{
TerraformVersion: pc.TerraformVersion.String(),
@ -666,7 +666,7 @@ func (pc *PlannedChangeHeader) PlannedChangeProto() (*terraform1.PlannedChange,
return nil, err
}
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
Raw: []*anypb.Any{&raw},
}, nil
}
@ -687,7 +687,7 @@ type PlannedChangePriorStateElement struct {
var _ PlannedChange = (*PlannedChangePriorStateElement)(nil)
// PlannedChangeProto implements PlannedChange.
func (pc *PlannedChangePriorStateElement) PlannedChangeProto() (*terraform1.PlannedChange, error) {
func (pc *PlannedChangePriorStateElement) PlannedChangeProto() (*stacks.PlannedChange, error) {
var raw anypb.Any
err := anypb.MarshalFrom(&raw, &tfstackdata1.PlanPriorStateElem{
Key: pc.Key,
@ -697,7 +697,7 @@ func (pc *PlannedChangePriorStateElement) PlannedChangeProto() (*terraform1.Plan
return nil, err
}
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
Raw: []*anypb.Any{&raw},
}, nil
}
@ -711,7 +711,7 @@ type PlannedChangePlannedTimestamp struct {
var _ PlannedChange = (*PlannedChangePlannedTimestamp)(nil)
// PlannedChangeProto implements PlannedChange.
func (pc *PlannedChangePlannedTimestamp) PlannedChangeProto() (*terraform1.PlannedChange, error) {
func (pc *PlannedChangePlannedTimestamp) PlannedChangeProto() (*stacks.PlannedChange, error) {
var raw anypb.Any
err := anypb.MarshalFrom(&raw, &tfstackdata1.PlanTimestamp{
PlanTimestamp: pc.PlannedTimestamp.Format(time.RFC3339),
@ -720,7 +720,7 @@ func (pc *PlannedChangePlannedTimestamp) PlannedChangeProto() (*terraform1.Plann
return nil, err
}
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
Raw: []*anypb.Any{&raw},
}, nil
}
@ -736,7 +736,7 @@ type PlannedChangeApplyable struct {
var _ PlannedChange = (*PlannedChangeApplyable)(nil)
// PlannedChangeProto implements PlannedChange.
func (pc *PlannedChangeApplyable) PlannedChangeProto() (*terraform1.PlannedChange, error) {
func (pc *PlannedChangeApplyable) PlannedChangeProto() (*stacks.PlannedChange, error) {
var raw anypb.Any
err := anypb.MarshalFrom(&raw, &tfstackdata1.PlanApplyable{
Applyable: pc.Applyable,
@ -745,11 +745,11 @@ func (pc *PlannedChangeApplyable) PlannedChangeProto() (*terraform1.PlannedChang
return nil, err
}
return &terraform1.PlannedChange{
return &stacks.PlannedChange{
Raw: []*anypb.Any{&raw},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_PlanApplyable{
Description: &stacks.PlannedChange_ChangeDescription_PlanApplyable{
PlanApplyable: pc.Applyable,
},
},

220
internal/stacks/stackplan/planned_change_test.go
View file

@ -18,7 +18,7 @@ import (
"github.com/hashicorp/terraform/internal/plans"
"github.com/hashicorp/terraform/internal/plans/planproto"
"github.com/hashicorp/terraform/internal/providers"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
"github.com/hashicorp/terraform/internal/stacks/tfstackdata1"
)
@ -52,13 +52,13 @@ func TestPlannedChangeAsProto(t *testing.T) {
tests := map[string]struct {
Receiver PlannedChange
Want *terraform1.PlannedChange
Want *stacks.PlannedChange
}{
"header": {
Receiver: &PlannedChangeHeader{
TerraformVersion: version.Must(version.NewSemver("1.2.3-beta4")),
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanHeader{
TerraformVersion: "1.2.3-beta4",
@ -70,15 +70,15 @@ func TestPlannedChangeAsProto(t *testing.T) {
Receiver: &PlannedChangeApplyable{
Applyable: true,
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanApplyable{
Applyable: true,
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_PlanApplyable{
Description: &stacks.PlannedChange_ChangeDescription_PlanApplyable{
PlanApplyable: true,
},
},
@ -89,15 +89,15 @@ func TestPlannedChangeAsProto(t *testing.T) {
Receiver: &PlannedChangeApplyable{
Applyable: false,
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanApplyable{
// false is the default
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_PlanApplyable{
Description: &stacks.PlannedChange_ChangeDescription_PlanApplyable{
PlanApplyable: false,
},
},
@ -115,7 +115,7 @@ func TestPlannedChangeAsProto(t *testing.T) {
Action: plans.Create,
PlanTimestamp: fakePlanTimestamp,
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanComponentInstance{
ComponentInstanceAddr: "component.foo",
@ -123,15 +123,15 @@ func TestPlannedChangeAsProto(t *testing.T) {
PlannedAction: planproto.Action_CREATE,
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ComponentInstancePlanned{
ComponentInstancePlanned: &terraform1.PlannedChange_ComponentInstance{
Addr: &terraform1.ComponentInstanceInStackAddr{
Description: &stacks.PlannedChange_ChangeDescription_ComponentInstancePlanned{
ComponentInstancePlanned: &stacks.PlannedChange_ComponentInstance{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: "component.foo",
ComponentInstanceAddr: "component.foo",
},
Actions: []terraform1.ChangeType{terraform1.ChangeType_CREATE},
Actions: []stacks.ChangeType{stacks.ChangeType_CREATE},
},
},
},
@ -150,19 +150,19 @@ func TestPlannedChangeAsProto(t *testing.T) {
Action: plans.NoOp,
PlanTimestamp: fakePlanTimestamp,
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanComponentInstance{
ComponentInstanceAddr: `component.foo["bar"]`,
PlanTimestamp: "2017-03-27T10:00:00-08:00",
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ComponentInstancePlanned{
ComponentInstancePlanned: &terraform1.PlannedChange_ComponentInstance{
Actions: []terraform1.ChangeType{terraform1.ChangeType_NOOP},
Addr: &terraform1.ComponentInstanceInStackAddr{
Description: &stacks.PlannedChange_ChangeDescription_ComponentInstancePlanned{
ComponentInstancePlanned: &stacks.PlannedChange_ComponentInstance{
Actions: []stacks.ChangeType{stacks.ChangeType_NOOP},
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: "component.foo",
ComponentInstanceAddr: `component.foo["bar"]`,
},
@ -182,22 +182,22 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
Action: plans.Delete,
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanComponentInstance{
ComponentInstanceAddr: `stack.a["boop"].component.foo`,
PlannedAction: planproto.Action_DELETE,
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ComponentInstancePlanned{
ComponentInstancePlanned: &terraform1.PlannedChange_ComponentInstance{
Addr: &terraform1.ComponentInstanceInStackAddr{
Description: &stacks.PlannedChange_ChangeDescription_ComponentInstancePlanned{
ComponentInstancePlanned: &stacks.PlannedChange_ComponentInstance{
Addr: &stacks.ComponentInstanceInStackAddr{
ComponentAddr: "stack.a.component.foo",
ComponentInstanceAddr: `stack.a["boop"].component.foo`,
},
Actions: []terraform1.ChangeType{terraform1.ChangeType_DELETE},
Actions: []stacks.ChangeType{stacks.ChangeType_DELETE},
},
},
},
@ -252,7 +252,7 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
DeferredReason: providers.DeferredReasonResourceConfigUnknown,
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanDeferredResourceInstanceChange{
Change: &tfstackdata1.PlanResourceInstanceChangePlanned{
@ -277,39 +277,39 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ResourceInstanceDeferred{
ResourceInstanceDeferred: &terraform1.PlannedChange_ResourceInstanceDeferred{
ResourceInstance: &terraform1.PlannedChange_ResourceInstance{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Description: &stacks.PlannedChange_ChangeDescription_ResourceInstanceDeferred{
ResourceInstanceDeferred: &stacks.PlannedChange_ResourceInstanceDeferred{
ResourceInstance: &stacks.PlannedChange_ResourceInstance{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
ResourceInstanceAddr: `module.pizza["chicken"].thingy.wotsit[1]`,
DeposedKey: "aaaaaaaa",
},
ResourceMode: terraform1.ResourceMode_MANAGED,
ResourceMode: stacks.ResourceMode_MANAGED,
ResourceType: "thingy",
ProviderAddr: "example.com/thingers/thingy",
Actions: []terraform1.ChangeType{terraform1.ChangeType_CREATE},
Actions: []stacks.ChangeType{stacks.ChangeType_CREATE},
ActionReason: "ResourceInstanceChangeNoReason",
Index: &terraform1.PlannedChange_ResourceInstance_Index{
Value: &terraform1.DynamicValue{
Index: &stacks.PlannedChange_ResourceInstance_Index{
Value: &stacks.DynamicValue{
Msgpack: []byte{0x92, 0xc4, 0x08, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x01}, // 1
},
},
ModuleAddr: `module.pizza["chicken"]`,
ResourceName: "wotsit",
Values: &terraform1.DynamicValueChange{
Old: &terraform1.DynamicValue{
Values: &stacks.DynamicValueChange{
Old: &stacks.DynamicValue{
Msgpack: []byte{'\xc0'}, // null
},
New: &terraform1.DynamicValue{
New: &stacks.DynamicValue{
Msgpack: []byte{'\x80'}, // zero-length mapping
},
},
},
Deferred: &terraform1.Deferred{
Reason: terraform1.Deferred_RESOURCE_CONFIG_UNKNOWN,
Deferred: &stacks.Deferred{
Reason: stacks.Deferred_RESOURCE_CONFIG_UNKNOWN,
},
},
},
@ -362,7 +362,7 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
},
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanResourceInstanceChangePlanned{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
@ -382,32 +382,32 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &terraform1.PlannedChange_ResourceInstance{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Description: &stacks.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &stacks.PlannedChange_ResourceInstance{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
ResourceInstanceAddr: `module.pizza["chicken"].thingy.wotsit[1]`,
DeposedKey: "aaaaaaaa",
},
ResourceMode: terraform1.ResourceMode_MANAGED,
ResourceMode: stacks.ResourceMode_MANAGED,
ResourceType: "thingy",
ProviderAddr: "example.com/thingers/thingy",
Actions: []terraform1.ChangeType{terraform1.ChangeType_CREATE},
Actions: []stacks.ChangeType{stacks.ChangeType_CREATE},
ActionReason: "ResourceInstanceChangeNoReason",
Index: &terraform1.PlannedChange_ResourceInstance_Index{
Value: &terraform1.DynamicValue{
Index: &stacks.PlannedChange_ResourceInstance_Index{
Value: &stacks.DynamicValue{
Msgpack: []byte{0x92, 0xc4, 0x08, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x01}, // 1
},
},
ModuleAddr: `module.pizza["chicken"]`,
ResourceName: "wotsit",
Values: &terraform1.DynamicValueChange{
Old: &terraform1.DynamicValue{
Values: &stacks.DynamicValueChange{
Old: &stacks.DynamicValue{
Msgpack: []byte{'\xc0'}, // null
},
New: &terraform1.DynamicValue{
New: &stacks.DynamicValue{
Msgpack: []byte{'\x80'}, // zero-length mapping
},
},
@ -463,7 +463,7 @@ func TestPlannedChangeAsProto(t *testing.T) {
RequiredReplace: cty.NewPathSet(cty.GetAttrPath("foo")),
},
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanResourceInstanceChangePlanned{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
@ -493,40 +493,40 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &terraform1.PlannedChange_ResourceInstance{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Description: &stacks.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &stacks.PlannedChange_ResourceInstance{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
ResourceInstanceAddr: `module.pizza["chicken"].thingy.wotsit[1]`,
DeposedKey: "aaaaaaaa",
},
ResourceMode: terraform1.ResourceMode_MANAGED,
ResourceMode: stacks.ResourceMode_MANAGED,
ResourceType: "thingy",
ProviderAddr: "example.com/thingers/thingy",
Actions: []terraform1.ChangeType{terraform1.ChangeType_DELETE, terraform1.ChangeType_CREATE},
Actions: []stacks.ChangeType{stacks.ChangeType_DELETE, stacks.ChangeType_CREATE},
ActionReason: "ResourceInstanceChangeNoReason",
Index: &terraform1.PlannedChange_ResourceInstance_Index{
Value: &terraform1.DynamicValue{
Index: &stacks.PlannedChange_ResourceInstance_Index{
Value: &stacks.DynamicValue{
Msgpack: []byte{0x92, 0xc4, 0x08, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x01}, // 1
},
},
ModuleAddr: `module.pizza["chicken"]`,
ResourceName: "wotsit",
Values: &terraform1.DynamicValueChange{
Old: &terraform1.DynamicValue{
Values: &stacks.DynamicValueChange{
Old: &stacks.DynamicValue{
Msgpack: []byte("\x81\xa3foo\xa3bar"),
},
New: &terraform1.DynamicValue{
New: &stacks.DynamicValue{
Msgpack: []byte("\x81\xa3foo\xa3baz"),
},
},
ReplacePaths: []*terraform1.AttributePath{
ReplacePaths: []*stacks.AttributePath{
{
Steps: []*terraform1.AttributePath_Step{
Steps: []*stacks.AttributePath_Step{
{
Selector: &terraform1.AttributePath_Step_AttributeName{
Selector: &stacks.AttributePath_Step_AttributeName{
AttributeName: "foo",
},
},
@ -585,7 +585,7 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
},
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanResourceInstanceChangePlanned{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
@ -606,35 +606,35 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &terraform1.PlannedChange_ResourceInstance{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Description: &stacks.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &stacks.PlannedChange_ResourceInstance{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
ResourceInstanceAddr: `module.pizza["chicken"].thingy.wotsit[1]`,
},
ResourceMode: terraform1.ResourceMode_MANAGED,
ResourceMode: stacks.ResourceMode_MANAGED,
ResourceType: "thingy",
ProviderAddr: "example.com/thingers/thingy",
Actions: []terraform1.ChangeType{terraform1.ChangeType_NOOP},
Actions: []stacks.ChangeType{stacks.ChangeType_NOOP},
ActionReason: "ResourceInstanceChangeNoReason",
Index: &terraform1.PlannedChange_ResourceInstance_Index{
Value: &terraform1.DynamicValue{
Index: &stacks.PlannedChange_ResourceInstance_Index{
Value: &stacks.DynamicValue{
Msgpack: []byte{0x92, 0xc4, 0x08, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x01}, // 1
},
},
ModuleAddr: `module.pizza["chicken"]`,
ResourceName: "wotsit",
Values: &terraform1.DynamicValueChange{
Old: &terraform1.DynamicValue{
Values: &stacks.DynamicValueChange{
Old: &stacks.DynamicValue{
Msgpack: []byte{'\x80'}, // zero-length mapping
},
New: &terraform1.DynamicValue{
New: &stacks.DynamicValue{
Msgpack: []byte{'\x80'}, // zero-length mapping
},
},
Imported: &terraform1.PlannedChange_ResourceInstance_Imported{
Imported: &stacks.PlannedChange_ResourceInstance_Imported{
ImportId: "bbbbbbb",
},
},
@ -694,7 +694,7 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
},
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanResourceInstanceChangePlanned{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
@ -713,36 +713,36 @@ func TestPlannedChangeAsProto(t *testing.T) {
},
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &terraform1.PlannedChange_ResourceInstance{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Description: &stacks.PlannedChange_ChangeDescription_ResourceInstancePlanned{
ResourceInstancePlanned: &stacks.PlannedChange_ResourceInstance{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
ResourceInstanceAddr: `module.pizza["chicken"].thingy.wotsit[1]`,
},
ResourceMode: terraform1.ResourceMode_MANAGED,
ResourceMode: stacks.ResourceMode_MANAGED,
ResourceType: "thingy",
ProviderAddr: "example.com/thingers/thingy",
Actions: []terraform1.ChangeType{terraform1.ChangeType_NOOP},
Actions: []stacks.ChangeType{stacks.ChangeType_NOOP},
ActionReason: "ResourceInstanceChangeNoReason",
Index: &terraform1.PlannedChange_ResourceInstance_Index{
Value: &terraform1.DynamicValue{
Index: &stacks.PlannedChange_ResourceInstance_Index{
Value: &stacks.DynamicValue{
Msgpack: []byte{0x92, 0xc4, 0x08, 0x22, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x01}, // 1
},
},
ModuleAddr: `module.pizza["chicken"]`,
ResourceName: "wotsit",
Values: &terraform1.DynamicValueChange{
Old: &terraform1.DynamicValue{
Values: &stacks.DynamicValueChange{
Old: &stacks.DynamicValue{
Msgpack: []byte{'\x80'}, // zero-length mapping
},
New: &terraform1.DynamicValue{
New: &stacks.DynamicValue{
Msgpack: []byte{'\x80'}, // zero-length mapping
},
},
Moved: &terraform1.PlannedChange_ResourceInstance_Moved{
PrevAddr: &terraform1.ResourceInstanceInStackAddr{
Moved: &stacks.PlannedChange_ResourceInstance_Moved{
PrevAddr: &stacks.ResourceInstanceInStackAddr{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
ResourceInstanceAddr: `module.pizza["chicken"].thingy.wotsit`,
},
@ -764,21 +764,21 @@ func TestPlannedChangeAsProto(t *testing.T) {
OldValue: emptyObjectForPlan,
NewValue: emptyObjectForPlan,
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
// Output value changes don't generate any raw representation;
// the diff is only for the benefit of the operator and
// other subsystems operating on their behalf.
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
{
Description: &terraform1.PlannedChange_ChangeDescription_OutputValuePlanned{
OutputValuePlanned: &terraform1.PlannedChange_OutputValue{
Description: &stacks.PlannedChange_ChangeDescription_OutputValuePlanned{
OutputValuePlanned: &stacks.PlannedChange_OutputValue{
Name: "thingy_id",
Actions: []terraform1.ChangeType{terraform1.ChangeType_UPDATE},
Values: &terraform1.DynamicValueChange{
Old: &terraform1.DynamicValue{
Actions: []stacks.ChangeType{stacks.ChangeType_UPDATE},
Values: &stacks.DynamicValueChange{
Old: &stacks.DynamicValue{
Msgpack: []byte{'\x80'}, // zero-length mapping
},
New: &terraform1.DynamicValue{
New: &stacks.DynamicValue{
Msgpack: []byte{'\x80'}, // zero-length mapping
},
},
@ -793,7 +793,7 @@ func TestPlannedChangeAsProto(t *testing.T) {
Addr: stackaddrs.InputVariable{Name: "thingy_id"},
Value: cty.StringVal("boop"),
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanRootInputValue{
Name: "thingy_id",
@ -811,17 +811,17 @@ func TestPlannedChangeAsProto(t *testing.T) {
// No value in this case: the value must be re-supplied during
// apply specifically so that we can avoid the need to store it.
},
Want: &terraform1.PlannedChange{
Want: &stacks.PlannedChange{
Raw: []*anypb.Any{
mustMarshalAnyPb(&tfstackdata1.PlanRootInputValue{
Name: "thingy_id",
RequiredOnApply: true,
}),
},
Descriptions: []*terraform1.PlannedChange_ChangeDescription{
&terraform1.PlannedChange_ChangeDescription{
Description: &terraform1.PlannedChange_ChangeDescription_ApplyTimeInputVariable{
ApplyTimeInputVariable: &terraform1.PlannedChange_InputVariableDuringApply{
Descriptions: []*stacks.PlannedChange_ChangeDescription{
&stacks.PlannedChange_ChangeDescription{
Description: &stacks.PlannedChange_ChangeDescription_ApplyTimeInputVariable{
ApplyTimeInputVariable: &stacks.PlannedChange_InputVariableDuringApply{
Name: "thingy_id",
},
},

20
internal/stacks/stackruntime/hooks/component_instance.go
View file

@ -5,7 +5,7 @@ package hooks
import (
"github.com/hashicorp/terraform/internal/plans"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
)
@ -29,24 +29,24 @@ const (
)
// TODO: move this into the rpcapi package somewhere
func (s ComponentInstanceStatus) ForProtobuf() terraform1.StackChangeProgress_ComponentInstanceStatus_Status {
func (s ComponentInstanceStatus) ForProtobuf() stacks.StackChangeProgress_ComponentInstanceStatus_Status {
switch s {
case ComponentInstancePending:
return terraform1.StackChangeProgress_ComponentInstanceStatus_PENDING
return stacks.StackChangeProgress_ComponentInstanceStatus_PENDING
case ComponentInstancePlanning:
return terraform1.StackChangeProgress_ComponentInstanceStatus_PLANNING
return stacks.StackChangeProgress_ComponentInstanceStatus_PLANNING
case ComponentInstancePlanned:
return terraform1.StackChangeProgress_ComponentInstanceStatus_PLANNED
return stacks.StackChangeProgress_ComponentInstanceStatus_PLANNED
case ComponentInstanceApplying:
return terraform1.StackChangeProgress_ComponentInstanceStatus_APPLYING
return stacks.StackChangeProgress_ComponentInstanceStatus_APPLYING
case ComponentInstanceApplied:
return terraform1.StackChangeProgress_ComponentInstanceStatus_APPLIED
return stacks.StackChangeProgress_ComponentInstanceStatus_APPLIED
case ComponentInstanceErrored:
return terraform1.StackChangeProgress_ComponentInstanceStatus_ERRORED
return stacks.StackChangeProgress_ComponentInstanceStatus_ERRORED
case ComponentInstanceDeferred:
return terraform1.StackChangeProgress_ComponentInstanceStatus_DEFERRED
return stacks.StackChangeProgress_ComponentInstanceStatus_DEFERRED
default:
return terraform1.StackChangeProgress_ComponentInstanceStatus_INVALID
return stacks.StackChangeProgress_ComponentInstanceStatus_INVALID
}
}

32
internal/stacks/stackruntime/hooks/resource_instance.go
View file

@ -7,7 +7,7 @@ import (
"github.com/hashicorp/terraform/internal/addrs"
"github.com/hashicorp/terraform/internal/plans"
"github.com/hashicorp/terraform/internal/providers"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
)
@ -32,26 +32,26 @@ const (
)
// TODO: move this into the rpcapi package somewhere
func (s ResourceInstanceStatus) ForProtobuf() terraform1.StackChangeProgress_ResourceInstanceStatus_Status {
func (s ResourceInstanceStatus) ForProtobuf() stacks.StackChangeProgress_ResourceInstanceStatus_Status {
switch s {
case ResourceInstancePending:
return terraform1.StackChangeProgress_ResourceInstanceStatus_PENDING
return stacks.StackChangeProgress_ResourceInstanceStatus_PENDING
case ResourceInstanceRefreshing:
return terraform1.StackChangeProgress_ResourceInstanceStatus_REFRESHING
return stacks.StackChangeProgress_ResourceInstanceStatus_REFRESHING
case ResourceInstanceRefreshed:
return terraform1.StackChangeProgress_ResourceInstanceStatus_REFRESHED
return stacks.StackChangeProgress_ResourceInstanceStatus_REFRESHED
case ResourceInstancePlanning:
return terraform1.StackChangeProgress_ResourceInstanceStatus_PLANNING
return stacks.StackChangeProgress_ResourceInstanceStatus_PLANNING
case ResourceInstancePlanned:
return terraform1.StackChangeProgress_ResourceInstanceStatus_PLANNED
return stacks.StackChangeProgress_ResourceInstanceStatus_PLANNED
case ResourceInstanceApplying:
return terraform1.StackChangeProgress_ResourceInstanceStatus_APPLYING
return stacks.StackChangeProgress_ResourceInstanceStatus_APPLYING
case ResourceInstanceApplied:
return terraform1.StackChangeProgress_ResourceInstanceStatus_APPLIED
return stacks.StackChangeProgress_ResourceInstanceStatus_APPLIED
case ResourceInstanceErrored:
return terraform1.StackChangeProgress_ResourceInstanceStatus_ERRORED
return stacks.StackChangeProgress_ResourceInstanceStatus_ERRORED
default:
return terraform1.StackChangeProgress_ResourceInstanceStatus_INVALID
return stacks.StackChangeProgress_ResourceInstanceStatus_INVALID
}
}
@ -71,16 +71,16 @@ const (
)
// TODO: move this into the rpcapi package somewhere
func (s ProvisionerStatus) ForProtobuf() terraform1.StackChangeProgress_ProvisionerStatus_Status {
func (s ProvisionerStatus) ForProtobuf() stacks.StackChangeProgress_ProvisionerStatus_Status {
switch s {
case ProvisionerProvisioning:
return terraform1.StackChangeProgress_ProvisionerStatus_PROVISIONING
return stacks.StackChangeProgress_ProvisionerStatus_PROVISIONING
case ProvisionerProvisioned:
return terraform1.StackChangeProgress_ProvisionerStatus_PROVISIONING
return stacks.StackChangeProgress_ProvisionerStatus_PROVISIONING
case ProvisionerErrored:
return terraform1.StackChangeProgress_ProvisionerStatus_ERRORED
return stacks.StackChangeProgress_ProvisionerStatus_ERRORED
default:
return terraform1.StackChangeProgress_ProvisionerStatus_INVALID
return stacks.StackChangeProgress_ProvisionerStatus_INVALID
}
}

76
internal/stacks/stackstate/applied_change.go
View file

@ -15,7 +15,7 @@ import (
"github.com/hashicorp/terraform/internal/configs/configschema"
"github.com/hashicorp/terraform/internal/lang/marks"
"github.com/hashicorp/terraform/internal/plans"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
"github.com/hashicorp/terraform/internal/stacks/stackstate/statekeys"
"github.com/hashicorp/terraform/internal/stacks/stackutils"
@ -35,7 +35,7 @@ import (
type AppliedChange interface {
// AppliedChangeProto returns the protocol buffers representation of
// the change, ready to be sent verbatim to an RPC API client.
AppliedChangeProto() (*terraform1.AppliedChange, error)
AppliedChangeProto() (*stacks.AppliedChange, error)
}
// AppliedChangeResourceInstanceObject announces the result of applying changes to
@ -70,20 +70,20 @@ type AppliedChangeResourceInstanceObject struct {
var _ AppliedChange = (*AppliedChangeResourceInstanceObject)(nil)
// AppliedChangeProto implements AppliedChange.
func (ac *AppliedChangeResourceInstanceObject) AppliedChangeProto() (*terraform1.AppliedChange, error) {
func (ac *AppliedChangeResourceInstanceObject) AppliedChangeProto() (*stacks.AppliedChange, error) {
descs, raws, err := ac.protosForObject()
if err != nil {
return nil, fmt.Errorf("encoding %s: %w", ac.ResourceInstanceObjectAddr, err)
}
return &terraform1.AppliedChange{
return &stacks.AppliedChange{
Raw: raws,
Descriptions: descs,
}, nil
}
func (ac *AppliedChangeResourceInstanceObject) protosForObject() ([]*terraform1.AppliedChange_ChangeDescription, []*terraform1.AppliedChange_RawChange, error) {
var descs []*terraform1.AppliedChange_ChangeDescription
var raws []*terraform1.AppliedChange_RawChange
func (ac *AppliedChangeResourceInstanceObject) protosForObject() ([]*stacks.AppliedChange_ChangeDescription, []*stacks.AppliedChange_RawChange, error) {
var descs []*stacks.AppliedChange_ChangeDescription
var raws []*stacks.AppliedChange_RawChange
var addr = ac.ResourceInstanceObjectAddr
var provider = ac.ProviderConfigAddr
@ -103,13 +103,13 @@ func (ac *AppliedChangeResourceInstanceObject) protosForObject() ([]*terraform1.
if objSrc == nil {
// If the new object is nil then we'll emit a "deleted" description
// to ensure that any existing prior state value gets removed.
descs = append(descs, &terraform1.AppliedChange_ChangeDescription{
descs = append(descs, &stacks.AppliedChange_ChangeDescription{
Key: objKeyRaw,
Description: &terraform1.AppliedChange_ChangeDescription_Deleted{
Deleted: &terraform1.AppliedChange_Nothing{},
Description: &stacks.AppliedChange_ChangeDescription_Deleted{
Deleted: &stacks.AppliedChange_Nothing{},
},
})
raws = append(raws, &terraform1.AppliedChange_RawChange{
raws = append(raws, &stacks.AppliedChange_RawChange{
Key: objKeyRaw,
Value: nil, // unset Value field represents "delete" for raw changes
})
@ -129,13 +129,13 @@ func (ac *AppliedChangeResourceInstanceObject) protosForObject() ([]*terraform1.
}
prevKeyRaw := statekeys.String(prevKey)
descs = append(descs, &terraform1.AppliedChange_ChangeDescription{
descs = append(descs, &stacks.AppliedChange_ChangeDescription{
Key: prevKeyRaw,
Description: &terraform1.AppliedChange_ChangeDescription_Moved{
Moved: &terraform1.AppliedChange_Nothing{},
Description: &stacks.AppliedChange_ChangeDescription_Moved{
Moved: &stacks.AppliedChange_Nothing{},
},
})
raws = append(raws, &terraform1.AppliedChange_RawChange{
raws = append(raws, &stacks.AppliedChange_RawChange{
Key: prevKeyRaw,
Value: nil, // unset Value field represents "delete" for raw changes
})
@ -176,13 +176,13 @@ func (ac *AppliedChangeResourceInstanceObject) protosForObject() ([]*terraform1.
if err != nil {
return nil, nil, fmt.Errorf("cannot encode new state for %s in preparation for saving it: %w", addr, err)
}
protoValue := terraform1.NewDynamicValue(encValue, sensitivePaths)
protoValue := stacks.NewDynamicValue(encValue, sensitivePaths)
descs = append(descs, &terraform1.AppliedChange_ChangeDescription{
descs = append(descs, &stacks.AppliedChange_ChangeDescription{
Key: objKeyRaw,
Description: &terraform1.AppliedChange_ChangeDescription_ResourceInstance{
ResourceInstance: &terraform1.AppliedChange_ResourceInstance{
Addr: terraform1.NewResourceInstanceObjectInStackAddr(addr),
Description: &stacks.AppliedChange_ChangeDescription_ResourceInstance{
ResourceInstance: &stacks.AppliedChange_ResourceInstance{
Addr: stacks.NewResourceInstanceObjectInStackAddr(addr),
NewValue: protoValue,
ResourceMode: stackutils.ResourceModeForProto(addr.Item.ResourceInstance.Resource.Resource.Mode),
ResourceType: addr.Item.ResourceInstance.Resource.Resource.Type,
@ -197,7 +197,7 @@ func (ac *AppliedChangeResourceInstanceObject) protosForObject() ([]*terraform1.
if err != nil {
return nil, nil, fmt.Errorf("encoding raw state object: %w", err)
}
raws = append(raws, &terraform1.AppliedChange_RawChange{
raws = append(raws, &stacks.AppliedChange_RawChange{
Key: objKeyRaw,
Value: &raw,
})
@ -230,10 +230,10 @@ type AppliedChangeComponentInstance struct {
var _ AppliedChange = (*AppliedChangeComponentInstance)(nil)
// AppliedChangeProto implements AppliedChange.
func (ac *AppliedChangeComponentInstance) AppliedChangeProto() (*terraform1.AppliedChange, error) {
ret := &terraform1.AppliedChange{
Raw: make([]*terraform1.AppliedChange_RawChange, 0, 1),
Descriptions: make([]*terraform1.AppliedChange_ChangeDescription, 0, 1),
func (ac *AppliedChangeComponentInstance) AppliedChangeProto() (*stacks.AppliedChange, error) {
ret := &stacks.AppliedChange{
Raw: make([]*stacks.AppliedChange_RawChange, 0, 1),
Descriptions: make([]*stacks.AppliedChange_ChangeDescription, 0, 1),
}
stateKey := statekeys.ComponentInstance{
ComponentInstanceAddr: ac.ComponentInstanceAddr,
@ -249,7 +249,7 @@ func (ac *AppliedChangeComponentInstance) AppliedChangeProto() (*terraform1.Appl
return nil, fmt.Errorf("encoding raw state for %s: %w", ac.ComponentInstanceAddr, err)
}
outputDescs := make(map[string]*terraform1.DynamicValue, len(ac.OutputValues))
outputDescs := make(map[string]*stacks.DynamicValue, len(ac.OutputValues))
for addr, val := range ac.OutputValues {
unmarkedValue, markses := val.UnmarkDeepWithPaths()
sensitivePaths, otherMarkses := marks.PathsWithMark(markses, marks.Sensitive)
@ -266,18 +266,18 @@ func (ac *AppliedChangeComponentInstance) AppliedChangeProto() (*terraform1.Appl
if err != nil {
return nil, fmt.Errorf("encoding new state for %s in %s in preparation for saving it: %w", addr, ac.ComponentInstanceAddr, err)
}
protoValue := terraform1.NewDynamicValue(encValue, sensitivePaths)
protoValue := stacks.NewDynamicValue(encValue, sensitivePaths)
outputDescs[addr.Name] = protoValue
}
ret.Raw = append(ret.Raw, &terraform1.AppliedChange_RawChange{
ret.Raw = append(ret.Raw, &stacks.AppliedChange_RawChange{
Key: statekeys.String(stateKey),
Value: &raw,
})
ret.Descriptions = append(ret.Descriptions, &terraform1.AppliedChange_ChangeDescription{
ret.Descriptions = append(ret.Descriptions, &stacks.AppliedChange_ChangeDescription{
Key: statekeys.String(stateKey),
Description: &terraform1.AppliedChange_ChangeDescription_ComponentInstance{
ComponentInstance: &terraform1.AppliedChange_ComponentInstance{
Description: &stacks.AppliedChange_ChangeDescription_ComponentInstance{
ComponentInstance: &stacks.AppliedChange_ComponentInstance{
ComponentAddr: ac.ComponentAddr.String(),
ComponentInstanceAddr: ac.ComponentInstanceAddr.String(),
},
@ -294,21 +294,21 @@ type AppliedChangeDiscardKeys struct {
var _ AppliedChange = (*AppliedChangeDiscardKeys)(nil)
// AppliedChangeProto implements AppliedChange.
func (ac *AppliedChangeDiscardKeys) AppliedChangeProto() (*terraform1.AppliedChange, error) {
ret := &terraform1.AppliedChange{
Raw: make([]*terraform1.AppliedChange_RawChange, 0, ac.DiscardRawKeys.Len()),
Descriptions: make([]*terraform1.AppliedChange_ChangeDescription, 0, ac.DiscardDescKeys.Len()),
func (ac *AppliedChangeDiscardKeys) AppliedChangeProto() (*stacks.AppliedChange, error) {
ret := &stacks.AppliedChange{
Raw: make([]*stacks.AppliedChange_RawChange, 0, ac.DiscardRawKeys.Len()),
Descriptions: make([]*stacks.AppliedChange_ChangeDescription, 0, ac.DiscardDescKeys.Len()),
}
for _, key := range ac.DiscardRawKeys.Elems() {
ret.Raw = append(ret.Raw, &terraform1.AppliedChange_RawChange{
ret.Raw = append(ret.Raw, &stacks.AppliedChange_RawChange{
Key: statekeys.String(key),
Value: nil, // nil represents deletion
})
}
for _, key := range ac.DiscardDescKeys.Elems() {
ret.Descriptions = append(ret.Descriptions, &terraform1.AppliedChange_ChangeDescription{
ret.Descriptions = append(ret.Descriptions, &stacks.AppliedChange_ChangeDescription{
Key: statekeys.String(key),
Description: &terraform1.AppliedChange_ChangeDescription_Deleted{
Description: &stacks.AppliedChange_ChangeDescription_Deleted{
// Selection of this empty variant represents deletion
},
})

52
internal/stacks/stackstate/applied_change_test.go
View file

@ -18,7 +18,7 @@ import (
"github.com/hashicorp/terraform/internal/addrs"
"github.com/hashicorp/terraform/internal/configs/configschema"
"github.com/hashicorp/terraform/internal/plans/planproto"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/stacks/stackaddrs"
"github.com/hashicorp/terraform/internal/stacks/tfstackdata1"
"github.com/hashicorp/terraform/internal/states"
@ -27,7 +27,7 @@ import (
func TestAppliedChangeAsProto(t *testing.T) {
tests := map[string]struct {
Receiver AppliedChange
Want *terraform1.AppliedChange
Want *stacks.AppliedChange
}{
"resource instance": {
Receiver: &AppliedChangeResourceInstanceObject{
@ -73,8 +73,8 @@ func TestAppliedChangeAsProto(t *testing.T) {
},
},
},
Want: &terraform1.AppliedChange{
Raw: []*terraform1.AppliedChange_RawChange{
Want: &stacks.AppliedChange{
Raw: []*stacks.AppliedChange_RawChange{
{
Key: `RSRCstack.a["boop"].component.foo["beep"],module.pizza["chicken"].thingy.thingamajig[1],cur`,
Value: mustMarshalAnyPb(t, &tfstackdata1.StateResourceInstanceObjectV1{
@ -90,27 +90,27 @@ func TestAppliedChangeAsProto(t *testing.T) {
}),
},
},
Descriptions: []*terraform1.AppliedChange_ChangeDescription{
Descriptions: []*stacks.AppliedChange_ChangeDescription{
{
Key: `RSRCstack.a["boop"].component.foo["beep"],module.pizza["chicken"].thingy.thingamajig[1],cur`,
Description: &terraform1.AppliedChange_ChangeDescription_ResourceInstance{
ResourceInstance: &terraform1.AppliedChange_ResourceInstance{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Description: &stacks.AppliedChange_ChangeDescription_ResourceInstance{
ResourceInstance: &stacks.AppliedChange_ResourceInstance{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
ResourceInstanceAddr: `module.pizza["chicken"].thingy.thingamajig[1]`,
},
NewValue: &terraform1.DynamicValue{
NewValue: &stacks.DynamicValue{
Msgpack: mustMsgpack(t, cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("bar"),
"secret": cty.StringVal("top"),
}), cty.Object(map[string]cty.Type{"id": cty.String, "secret": cty.String})),
Sensitive: []*terraform1.AttributePath{{
Steps: []*terraform1.AttributePath_Step{{
Selector: &terraform1.AttributePath_Step_AttributeName{AttributeName: "secret"},
Sensitive: []*stacks.AttributePath{{
Steps: []*stacks.AttributePath_Step{{
Selector: &stacks.AttributePath_Step_AttributeName{AttributeName: "secret"},
}}},
},
},
ResourceMode: terraform1.ResourceMode_MANAGED,
ResourceMode: stacks.ResourceMode_MANAGED,
ResourceType: "thingy",
ProviderAddr: "example.com/thingers/thingy",
},
@ -181,8 +181,8 @@ func TestAppliedChangeAsProto(t *testing.T) {
},
},
},
Want: &terraform1.AppliedChange{
Raw: []*terraform1.AppliedChange_RawChange{
Want: &stacks.AppliedChange{
Raw: []*stacks.AppliedChange_RawChange{
{
Key: `RSRCstack.a["boop"].component.foo["beep"],module.pizza["chicken"].thingy.previous_thingamajig[1],cur`,
Value: nil,
@ -202,33 +202,33 @@ func TestAppliedChangeAsProto(t *testing.T) {
}),
},
},
Descriptions: []*terraform1.AppliedChange_ChangeDescription{
Descriptions: []*stacks.AppliedChange_ChangeDescription{
{
Key: `RSRCstack.a["boop"].component.foo["beep"],module.pizza["chicken"].thingy.previous_thingamajig[1],cur`,
Description: &terraform1.AppliedChange_ChangeDescription_Moved{
Moved: &terraform1.AppliedChange_Nothing{},
Description: &stacks.AppliedChange_ChangeDescription_Moved{
Moved: &stacks.AppliedChange_Nothing{},
},
},
{
Key: `RSRCstack.a["boop"].component.foo["beep"],module.pizza["chicken"].thingy.thingamajig[1],cur`,
Description: &terraform1.AppliedChange_ChangeDescription_ResourceInstance{
ResourceInstance: &terraform1.AppliedChange_ResourceInstance{
Addr: &terraform1.ResourceInstanceObjectInStackAddr{
Description: &stacks.AppliedChange_ChangeDescription_ResourceInstance{
ResourceInstance: &stacks.AppliedChange_ResourceInstance{
Addr: &stacks.ResourceInstanceObjectInStackAddr{
ComponentInstanceAddr: `stack.a["boop"].component.foo["beep"]`,
ResourceInstanceAddr: `module.pizza["chicken"].thingy.thingamajig[1]`,
},
NewValue: &terraform1.DynamicValue{
NewValue: &stacks.DynamicValue{
Msgpack: mustMsgpack(t, cty.ObjectVal(map[string]cty.Value{
"id": cty.StringVal("bar"),
"secret": cty.StringVal("top"),
}), cty.Object(map[string]cty.Type{"id": cty.String, "secret": cty.String})),
Sensitive: []*terraform1.AttributePath{{
Steps: []*terraform1.AttributePath_Step{{
Selector: &terraform1.AttributePath_Step_AttributeName{AttributeName: "secret"},
Sensitive: []*stacks.AttributePath{{
Steps: []*stacks.AttributePath_Step{{
Selector: &stacks.AttributePath_Step_AttributeName{AttributeName: "secret"},
}}},
},
},
ResourceMode: terraform1.ResourceMode_MANAGED,
ResourceMode: stacks.ResourceMode_MANAGED,
ResourceType: "thingy",
ProviderAddr: "example.com/thingers/thingy",
},

10
internal/stacks/stackutils/proto_util.go
View file

@ -5,18 +5,18 @@ package stackutils
import (
"github.com/hashicorp/terraform/internal/addrs"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
)
func ResourceModeForProto(mode addrs.ResourceMode) terraform1.ResourceMode {
func ResourceModeForProto(mode addrs.ResourceMode) stacks.ResourceMode {
switch mode {
case addrs.ManagedResourceMode:
return terraform1.ResourceMode_MANAGED
return stacks.ResourceMode_MANAGED
case addrs.DataResourceMode:
return terraform1.ResourceMode_DATA
return stacks.ResourceMode_DATA
default:
// Should not get here, because the above should be exhaustive for
// all addrs.ResourceMode variants.
return terraform1.ResourceMode_UNKNOWN
return stacks.ResourceMode_UNKNOWN
}
}

16
internal/stacks/tfstackdata1/convert.go
View file

@ -14,7 +14,7 @@ import (
"github.com/hashicorp/terraform/internal/plans"
"github.com/hashicorp/terraform/internal/plans/planfile"
"github.com/hashicorp/terraform/internal/plans/planproto"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1"
"github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks"
"github.com/hashicorp/terraform/internal/states"
)
@ -29,7 +29,7 @@ func ResourceInstanceObjectStateToTFStackData1(objSrc *states.ResourceInstanceOb
// attribute paths here just so we don't need to reimplement the
// slice-of-paths conversion in yet another place. We don't
// actually do anything with the value part of this.
protoValue := terraform1.NewDynamicValue(plans.DynamicValue(nil), objSrc.AttrSensitivePaths)
protoValue := stacks.NewDynamicValue(plans.DynamicValue(nil), objSrc.AttrSensitivePaths)
rawMsg := &StateResourceInstanceObjectV1{
SchemaVersion: objSrc.SchemaVersion,
ValueJson: objSrc.AttrsJSON,
@ -129,7 +129,7 @@ func DynamicValueFromTFStackData1(protoVal *DynamicValue, ty cty.Type) (cty.Valu
return unmarkedV.MarkWithPaths(markses), nil
}
func Terraform1ToPlanProtoAttributePaths(paths []*terraform1.AttributePath) []*planproto.Path {
func Terraform1ToPlanProtoAttributePaths(paths []*stacks.AttributePath) []*planproto.Path {
if len(paths) == 0 {
return nil
}
@ -140,7 +140,7 @@ func Terraform1ToPlanProtoAttributePaths(paths []*terraform1.AttributePath) []*p
return ret
}
func Terraform1ToPlanProtoAttributePath(path *terraform1.AttributePath) *planproto.Path {
func Terraform1ToPlanProtoAttributePath(path *stacks.AttributePath) *planproto.Path {
if path == nil {
return nil
}
@ -155,17 +155,17 @@ func Terraform1ToPlanProtoAttributePath(path *terraform1.AttributePath) *planpro
return ret
}
func Terraform1ToPlanProtoAttributePathStep(step *terraform1.AttributePath_Step) *planproto.Path_Step {
func Terraform1ToPlanProtoAttributePathStep(step *stacks.AttributePath_Step) *planproto.Path_Step {
if step == nil {
return nil
}
ret := &planproto.Path_Step{}
switch sel := step.Selector.(type) {
case *terraform1.AttributePath_Step_AttributeName:
case *stacks.AttributePath_Step_AttributeName:
ret.Selector = &planproto.Path_Step_AttributeName{
AttributeName: sel.AttributeName,
}
case *terraform1.AttributePath_Step_ElementKeyInt:
case *stacks.AttributePath_Step_ElementKeyInt:
encInt, err := msgpack.Marshal(cty.NumberIntVal(sel.ElementKeyInt), cty.Number)
if err != nil {
// This should not be possible because all integers have a cty msgpack encoding
@ -176,7 +176,7 @@ func Terraform1ToPlanProtoAttributePathStep(step *terraform1.AttributePath_Step)
Msgpack: encInt,
},
}
case *terraform1.AttributePath_Step_ElementKeyString:
case *stacks.AttributePath_Step_ElementKeyString:
encStr, err := msgpack.Marshal(cty.StringVal(sel.ElementKeyString), cty.String)
if err != nil {
// This should not be possible because all strings have a cty msgpack encoding

41
tools/protobuf-compile/protobuf-compile.go
View file

@ -58,6 +58,47 @@ var protocSteps = []protocStep{
"internal/rpcapi/terraform1",
[]string{"--go_out=paths=source_relative,plugins=grpc:.", "--go_opt=Mterraform1.proto=github.com/hashicorp/terraform/internal/rpcapi/terraform1", "./terraform1.proto"},
},
{
"terraform1 (Terraform Core RPC API) setup",
"internal/rpcapi/terraform1/setup",
[]string{"--go_out=paths=source_relative,plugins=grpc:.", "--go_opt=Msetup.proto=github.com/hashicorp/terraform/internal/rpcapi/terraform1/setup", "./setup.proto"},
},
{
"terraform1 (Terraform Core RPC API) dependencies",
"internal/rpcapi/terraform1/dependencies",
[]string{
"--go_out=paths=source_relative,plugins=grpc:.",
"--go_opt=Mterraform1.proto=github.com/hashicorp/terraform/internal/rpcapi/terraform1",
"--go_opt=Mdependencies.proto=github.com/hashicorp/terraform/internal/rpcapi/terraform1/dependencies",
"-I.",
"-I..",
"./dependencies.proto",
},
},
{
"terraform1 (Terraform Core RPC API) stacks",
"internal/rpcapi/terraform1/stacks",
[]string{
"--go_out=paths=source_relative,plugins=grpc:.",
"--go_opt=Mterraform1.proto=github.com/hashicorp/terraform/internal/rpcapi/terraform1",
"--go_opt=Mstacks.proto=github.com/hashicorp/terraform/internal/rpcapi/terraform1/stacks",
"-I.",
"-I..",
"./stacks.proto",
},
},
{
"terraform1 (Terraform Core RPC API) packages",
"internal/rpcapi/terraform1/packages",
[]string{
"--go_out=paths=source_relative,plugins=grpc:.",
"--go_opt=Mterraform1.proto=github.com/hashicorp/terraform/internal/rpcapi/terraform1",
"--go_opt=Mpackages.proto=github.com/hashicorp/terraform/internal/rpcapi/terraform1/packages",
"-I.",
"-I..",
"./packages.proto",
},
},
{
"tfplan (plan file serialization)",
"internal/plans/planproto",