github.com/hashicorp/packer@v1.14.3/internal/hcp/registry/ds_config.go (about)

     1  package registry
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/hashicorp/hcl/v2"
     7  	"github.com/zclconf/go-cty/cty"
     8  	"github.com/zclconf/go-cty/cty/gocty"
     9  )
    10  
    11  type hcpVersion struct {
    12  	VersionID string
    13  	ChannelID string
    14  }
    15  
    16  func versionValueToDSOutput(iterVal map[string]cty.Value) hcpVersion {
    17  	version := hcpVersion{}
    18  	for k, v := range iterVal {
    19  		switch k {
    20  		case "id":
    21  			version.VersionID = v.AsString()
    22  		case "channel_id":
    23  			version.ChannelID = v.AsString()
    24  		}
    25  	}
    26  	return version
    27  }
    28  
    29  type hcpArtifact struct {
    30  	ExternalIdentifier string
    31  	ChannelID          string
    32  	VersionID          string
    33  }
    34  
    35  func artifactValueToDSOutput(imageVal map[string]cty.Value) hcpArtifact {
    36  	artifact := hcpArtifact{}
    37  	for k, v := range imageVal {
    38  		switch k {
    39  		case "external_identifier":
    40  			artifact.ExternalIdentifier = v.AsString()
    41  		case "channel_id":
    42  			artifact.ChannelID = v.AsString()
    43  		case "version_id":
    44  			artifact.VersionID = v.AsString()
    45  		}
    46  	}
    47  
    48  	return artifact
    49  }
    50  
    51  func withDatasourceConfiguration(vals map[string]cty.Value) bucketConfigurationOpts {
    52  	return func(bucket *Bucket) hcl.Diagnostics {
    53  		var diags hcl.Diagnostics
    54  
    55  		versionDS, versionOK := vals[hcpVersionDatasourceType]
    56  		artifactDS, artifactOK := vals[hcpArtifactDatasourceType]
    57  
    58  		if !artifactOK && !versionOK {
    59  			return nil
    60  		}
    61  
    62  		versions := map[string]hcpVersion{}
    63  
    64  		var err error
    65  		if versionOK {
    66  			hcpData := map[string]cty.Value{}
    67  			err = gocty.FromCtyValue(versionDS, &hcpData)
    68  			if err != nil {
    69  				diags = append(diags, &hcl.Diagnostic{
    70  					Severity: hcl.DiagError,
    71  					Summary:  "Invalid HCP datasources",
    72  					Detail: fmt.Sprintf(
    73  						"Failed to decode hcp-packer-version datasources: %s", err,
    74  					),
    75  				})
    76  				return diags
    77  			}
    78  
    79  			for k, v := range hcpData {
    80  				versionVals := v.AsValueMap()
    81  				version := versionValueToDSOutput(versionVals)
    82  				versions[k] = version
    83  			}
    84  		}
    85  
    86  		artifacts := map[string]hcpArtifact{}
    87  
    88  		if artifactOK {
    89  			hcpData := map[string]cty.Value{}
    90  			err = gocty.FromCtyValue(artifactDS, &hcpData)
    91  			if err != nil {
    92  				diags = append(diags, &hcl.Diagnostic{
    93  					Severity: hcl.DiagError,
    94  					Summary:  "Invalid HCP datasources",
    95  					Detail: fmt.Sprintf(
    96  						"Failed to decode hcp-packer-artifact datasources: %s", err,
    97  					),
    98  				})
    99  				return diags
   100  			}
   101  
   102  			for k, v := range hcpData {
   103  				artifactVals := v.AsValueMap()
   104  				artifact := artifactValueToDSOutput(artifactVals)
   105  				artifacts[k] = artifact
   106  			}
   107  		}
   108  
   109  		for _, a := range artifacts {
   110  			parentVersion := ParentVersion{}
   111  			parentVersion.VersionID = a.VersionID
   112  
   113  			if a.ChannelID != "" {
   114  				parentVersion.ChannelID = a.ChannelID
   115  			} else {
   116  				for _, v := range versions {
   117  					if v.VersionID == a.VersionID {
   118  						parentVersion.ChannelID = v.ChannelID
   119  						break
   120  					}
   121  				}
   122  			}
   123  
   124  			bucket.SourceExternalIdentifierToParentVersions[a.ExternalIdentifier] = parentVersion
   125  		}
   126  
   127  		return diags
   128  	}
   129  }