Bugfixes for remote_state blocks

Author: Jessie Moss

bin/tflocal

@@ -55,8 +55,7 @@ LOCALSTACK_HOSTNAME = (
     or os.environ.get("LOCALSTACK_HOSTNAME")
     or "localhost"
 )
-EDGE_PORT = int(
-    urlparse(AWS_ENDPOINT_URL).port or os.environ.get("EDGE_PORT") or 4566)
+EDGE_PORT = int(urlparse(AWS_ENDPOINT_URL).port or os.environ.get("EDGE_PORT") or 4566)
 TF_VERSION: Optional[version.Version] = None
 TF_PROVIDER_CONFIG = """
 provider "aws" {
@@ -194,8 +193,7 @@ def create_provider_config_file(provider_file_path: str, provider_aliases=None)
     for provider in provider_aliases:
         provider_config = TF_PROVIDER_CONFIG.replace(
             "<access_key>",
-            get_access_key(
-                provider) if CUSTOMIZE_ACCESS_KEY else DEFAULT_ACCESS_KEY,
+            get_access_key(provider) if CUSTOMIZE_ACCESS_KEY else DEFAULT_ACCESS_KEY,
         )
         endpoints = "\n".join(
             [f'    {s} = "{get_service_endpoint(s)}"' for s in services]
@@ -343,8 +341,7 @@ def generate_s3_backend_config() -> str:
             for k, v in configs["endpoints"].items()
         }
     backend_config["access_key"] = (
-        get_access_key(
-            backend_config) if CUSTOMIZE_ACCESS_KEY else DEFAULT_ACCESS_KEY
+        get_access_key(backend_config) if CUSTOMIZE_ACCESS_KEY else DEFAULT_ACCESS_KEY
     )
     configs.update(backend_config)
     if not DRY_RUN:
@@ -383,62 +380,138 @@ def generate_s3_backend_config() -> str:
     result = result.replace("<configs>", config_options)
     return result
 
+
 def generate_remote_state_config() -> str:
     """
     Generate configuration for terraform_remote_state data sources to use LocalStack endpoints.
     Similar to generate_s3_backend_config but for terraform_remote_state blocks.
     """
+
+    is_tf_legacy = TF_VERSION < version.Version("1.6")
     tf_files = parse_tf_files()
-    if not tf_files:
-        return ""
+
+    legacy_endpoint_mappings = {
+        "endpoint": "s3",
+        "iam_endpoint": "iam",
+        "sts_endpoint": "sts",
+        "dynamodb_endpoint": "dynamodb",
+    }
 
     result = ""
     for filename, obj in tf_files.items():
         if LS_PROVIDERS_FILE == filename:
             continue
-            
         data_blocks = ensure_list(obj.get("data", []))
         for data_block in data_blocks:
             terraform_remote_state = data_block.get("terraform_remote_state")
             if not terraform_remote_state:
                 continue
-                
             for data_name, data_config in terraform_remote_state.items():
                 if data_config.get("backend") != "s3":
                     continue
-                    
                 # Create override for S3 remote state
                 config_attrs = data_config.get("config", {})
                 if not config_attrs:
                     continue
-                
+                # Merge in legacy endpoint configs if not existing already
+                if is_tf_legacy and config_attrs.get("endpoints"):
+                    print(
+                        "Warning: Unsupported backend option(s) detected (`endpoints`). Please make sure you always use the corresponding options to your Terraform version."
+                    )
+                    exit(1)
+                for legacy_endpoint, endpoint in legacy_endpoint_mappings.items():
+                    if (
+                        legacy_endpoint in config_attrs
+                        and config_attrs.get("endpoints")
+                        and endpoint in config_attrs["endpoints"]
+                    ):
+                        del config_attrs[legacy_endpoint]
+                        continue
+                    if legacy_endpoint in config_attrs and (
+                        not config_attrs.get("endpoints")
+                        or endpoint not in config_attrs["endpoints"]
+                    ):
+                        if not config_attrs.get("endpoints"):
+                            config_attrs["endpoints"] = {}
+                        config_attrs["endpoints"].update(
+                            {endpoint: config_attrs[legacy_endpoint]}
+                        )
+                        del config_attrs[legacy_endpoint]
+
                 # Set up default configs
                 configs = {
                     "bucket": config_attrs.get("bucket", "tf-test-state"),
                     "key": config_attrs.get("key", "terraform.tfstate"),
                     "region": config_attrs.get("region", get_region()),
-                    "endpoint": get_service_endpoint("s3"),
+                    "endpoints": {
+                        "s3": get_service_endpoint("s3"),
+                        "iam": get_service_endpoint("iam"),
+                        "sso": get_service_endpoint("sso"),
+                        "sts": get_service_endpoint("sts"),
+                    },
                 }
-                
+
+                # Add any missing default endpoints
+                if config_attrs.get("endpoints"):
+                    config_attrs["endpoints"] = {
+                        k: config_attrs["endpoints"].get(k) or v
+                        for k, v in configs["endpoints"].items()
+                    }
+
                 # Update with user-provided configs
                 configs.update(config_attrs)
-                
+
                 # Generate config string
                 config_options = ""
+                # for key, value in sorted(configs.items()):
+                #    if isinstance(value, bool):
+                #        value = str(value).lower()
+                #    elif isinstance(value, (str, int, float)):
+                #        value = f'"{value}"'
+                #    config_options += f"\n    {key} = {value}"
                 for key, value in sorted(configs.items()):
                     if isinstance(value, bool):
                         value = str(value).lower()
-                    elif isinstance(value, (str, int, float)):
-                        value = f'"{value}"'
-                    config_options += f'\n    {key} = {value}'
-                
+                    elif isinstance(value, dict):
+                        if key == "endpoints" and is_tf_legacy:
+                            for (
+                                legacy_endpoint,
+                                endpoint,
+                            ) in legacy_endpoint_mappings.items():
+                                config_options += f'\n    {legacy_endpoint} = "{configs[key][endpoint]}"'
+                            continue
+                        else:
+                            value = textwrap.indent(
+                                text=f"{key} = {{\n"
+                                + "\n".join(
+                                    [f'  {k} = "{v}"' for k, v in value.items()]
+                                )
+                                + "\n}",
+                                prefix=" " * 4,
+                            )
+                            config_options += f"\n{value}"
+                            continue
+                    elif isinstance(value, list):
+                        # TODO this will break if it's a list of dicts or other complex object
+                        # this serialization logic should probably be moved to a separate recursive function
+                        as_string = [f'"{item}"' for item in value]
+                        value = f"[{', '.join(as_string)}]"
+                    else:
+                        value = f'"{str(value)}"'
+                    config_options += f"\n    {key} = {value}"
+
                 # Create the final config
-                remote_state_config = TF_REMOTE_STATE_CONFIG.replace("<name>", data_name)
-                remote_state_config = remote_state_config.replace("<configs>", config_options)
+                remote_state_config = TF_REMOTE_STATE_CONFIG.replace(
+                    "<name>", data_name
+                )
+                remote_state_config = remote_state_config.replace(
+                    "<configs>", config_options
+                )
                 result += remote_state_config
-    
+
     return result
 
+
 def check_override_file(providers_file: str) -> None:
     """Checks override file existance"""
     if os.path.exists(providers_file):
@@ -559,8 +632,7 @@ def get_or_create_bucket(bucket_name: str):
         region = s3_client.meta.region_name
         kwargs = {}
         if region != "us-east-1":
-            kwargs = {"CreateBucketConfiguration": {
-                "LocationConstraint": region}}
+            kwargs = {"CreateBucketConfiguration": {"LocationConstraint": region}}
         return s3_client.create_bucket(Bucket=bucket_name, **kwargs)
 
 
@@ -574,8 +646,7 @@ def get_or_create_ddb_table(table_name: str, region: str = None):
             TableName=table_name,
             BillingMode="PAY_PER_REQUEST",
             KeySchema=[{"AttributeName": "LockID", "KeyType": "HASH"}],
-            AttributeDefinitions=[
-                {"AttributeName": "LockID", "AttributeType": "S"}],
+            AttributeDefinitions=[{"AttributeName": "LockID", "AttributeType": "S"}],
         )
 
 
@@ -685,8 +756,7 @@ def main():
         if not TF_VERSION:
             raise ValueError
     except (FileNotFoundError, ValueError) as e:
-        print(
-            f"Unable to determine version. See error message for details: {e}")
+        print(f"Unable to determine version. See error message for details: {e}")
         exit(1)
 
     config_override_files = []