Documenten\Algora\Coder Registry\registry\melmathari\templates\hetzner-cloud> terraform plan
data.coder_workspace.me: Reading...
data.coder_parameter.volume_size: Reading...
data.coder_workspace_owner.me: Reading...
data.coder_parameter.custom_image_override: Reading...
data.coder_parameter.location: Reading...
data.coder_workspace.me: Read complete after 0s [id=30ceaa30-d232-4658-9ecd-1a606fab593e]
data.coder_workspace_owner.me: Read complete after 0s [id=0a750a1e-cf9a-4d2f-a542-c138720bb947]
data.coder_parameter.server_image: Reading...
data.coder_parameter.server_type: Reading...
data.coder_parameter.volume_size: Read complete after 0s [id=8d398208-1d8b-4538-afb6-86b4f9cbe18f]
data.coder_parameter.custom_image_override: Read complete after 0s [id=04312247-0d15-4115-941b-1ac2d1c53044]
data.coder_parameter.location: Read complete after 0s [id=14f7de84-5e6b-4252-8af8-d5c3bd35e1eb]
module.jetbrains[0].data.coder_workspace_owner.me: Reading...
module.jetbrains[0].data.coder_workspace.me: Reading...
module.jetbrains[0].data.coder_workspace.me: Read complete after 0s [id=99a1004c-4cef-45da-915e-c9c7ed1a306a]
module.jetbrains[0].data.coder_workspace_owner.me: Read complete after 0s [id=764a845f-7a73-4dfd-806c-bc49de99abf5]
data.coder_parameter.server_image: Read complete after 0s [id=d099152a-07e6-4cf7-b179-89569cb60c54]
data.coder_parameter.server_type: Read complete after 0s [id=87dd4cb5-7ab1-434e-b919-dd70b55cbe02]
module.jetbrains[0].data.http.jetbrains_ide_versions["RR"]: Reading...
module.jetbrains[0].data.http.jetbrains_ide_versions["GO"]: Reading...
module.jetbrains[0].data.http.jetbrains_ide_versions["RD"]: Reading...
module.jetbrains[0].data.http.jetbrains_ide_versions["PY"]: Reading...
module.jetbrains[0].data.http.jetbrains_ide_versions["IU"]: Reading...
module.jetbrains[0].data.http.jetbrains_ide_versions["WS"]: Reading...
module.jetbrains[0].data.coder_parameter.jetbrains_ides[0]: Reading...
module.jetbrains[0].data.http.jetbrains_ide_versions["PS"]: Reading...
module.jetbrains[0].data.http.jetbrains_ide_versions["CL"]: Reading...
module.jetbrains[0].data.http.jetbrains_ide_versions["RM"]: Reading...
module.jetbrains[0].data.coder_parameter.jetbrains_ides[0]: Read complete after 0s [id=bfef924d-2e6d-4c4b-910c-be7c32f5f128]
module.jetbrains[0].data.http.jetbrains_ide_versions["RM"]: Read complete after 0s [id=https://data.services.jetbrains.com/products/releases?code=RM&type=release&latest=true]
module.jetbrains[0].data.http.jetbrains_ide_versions["WS"]: Read complete after 0s [id=https://data.services.jetbrains.com/products/releases?code=WS&type=release&latest=true]
module.jetbrains[0].data.http.jetbrains_ide_versions["GO"]: Read complete after 0s [id=https://data.services.jetbrains.com/products/releases?code=GO&type=release&latest=true]
module.jetbrains[0].data.http.jetbrains_ide_versions["IU"]: Read complete after 0s [id=https://data.services.jetbrains.com/products/releases?code=IU&type=release&latest=true]
module.jetbrains[0].data.http.jetbrains_ide_versions["PS"]: Read complete after 0s [id=https://data.services.jetbrains.com/products/releases?code=PS&type=release&latest=true]
module.jetbrains[0].data.http.jetbrains_ide_versions["RR"]: Read complete after 0s [id=https://data.services.jetbrains.com/products/releases?code=RR&type=release&latest=true]
module.jetbrains[0].data.http.jetbrains_ide_versions["CL"]: Read complete after 0s [id=https://data.services.jetbrains.com/products/releases?code=CL&type=release&latest=true]
module.jetbrains[0].data.http.jetbrains_ide_versions["PY"]: Read complete after 0s [id=https://data.services.jetbrains.com/products/releases?code=PY&type=release&latest=true]
module.jetbrains[0].data.http.jetbrains_ide_versions["RD"]: Read complete after 0s [id=https://data.services.jetbrains.com/products/releases?code=RD&type=release&latest=true]

Terraform used the selected providers to generate the following execution plan. Resource actions    
are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # coder_agent.main will be created
  + resource "coder_agent" "main" {
      + api_key_scope           = "all"
      + arch                    = "amd64"
      + auth                    = "token"
      + connection_timeout      = 120
      + id                      = (known after apply)
      + init_script             = (known after apply)
      + os                      = "linux"
      + startup_script_behavior = "non-blocking"
      + token                   = (sensitive value)

      + display_apps (known after apply)

      + metadata {
          + display_name = "CPU Usage"
          + interval     = 5
          + key          = "cpu"
          + script       = "coder stat cpu"
          + timeout      = 5
        }
      + metadata {
          + display_name = "Memory Usage"
          + interval     = 5
          + key          = "memory"
          + script       = "coder stat mem"
          + timeout      = 5
        }
      + metadata {
          + display_name = "Home Usage"
          + interval     = 600
          + key          = "home"
          + script       = "coder stat disk --path /home/default"
          + timeout      = 30
        }
    }

  # coder_metadata.volume_info will be created
  + resource "coder_metadata" "volume_info" {
      + id          = (known after apply)
      + resource_id = (known after apply)

      + item {
          + is_null   = (known after apply)
          + key       = "size"
          + sensitive = false
          + value     = "20 GB"
        }
      + item {
          + is_null   = (known after apply)
          + key       = "location"
          + sensitive = false
          + value     = "fsn1"
        }
    }

  # coder_metadata.workspace_info[0] will be created
  + resource "coder_metadata" "workspace_info" {
      + id          = (known after apply)
      + resource_id = (known after apply)

      + item {
          + is_null   = (known after apply)
          + key       = "location"
          + sensitive = false
          + value     = "Falkenstein, Germany (fsn1)"
        }
      + item {
          + is_null   = (known after apply)
          + key       = "server_type"
          + sensitive = false
          + value     = "CX22 (2 vCPU, 8 GB RAM, AMD) (cx22)"
        }
      + item {
          + is_null   = (known after apply)
          + key       = "vcpus"
          + sensitive = false
          + value     = "2"
        }
      + item {
          + is_null   = (known after apply)
          + key       = "memory"
          + sensitive = false
          + value     = "8 GB"
        }
      + item {
          + is_null   = (known after apply)
          + key       = "image"
          + sensitive = false
          + value     = "Ubuntu 22.04 LTS"
        }
      + item {
          + is_null   = (known after apply)
          + key       = "public_ipv4"
          + sensitive = false
          + value     = (known after apply)
        }
    }

  # hcloud_firewall.workspace will be created
  + resource "hcloud_firewall" "workspace" {
      + id     = (known after apply)
      + labels = {
          + "coder.owner"     = "default"
          + "coder.resource"  = "firewall"
          + "coder.workspace" = "default"
        }
      + name   = "coder-default-default-30ceaa30-fw"

      + rule {
          + destination_ips = []
          + direction       = "in"
          + port            = "22"
          + protocol        = "tcp"
          + source_ips      = [
              + "0.0.0.0/0",
              + "::/0",
            ]
            # (1 unchanged attribute hidden)
        }
      + rule {
          + destination_ips = []
          + direction       = "in"
          + port            = "443"
          + protocol        = "tcp"
          + source_ips      = [
              + "0.0.0.0/0",
              + "::/0",
            ]
            # (1 unchanged attribute hidden)
        }
      + rule {
          + destination_ips = []
          + direction       = "in"
          + port            = "80"
          + protocol        = "tcp"
          + source_ips      = [
              + "0.0.0.0/0",
              + "::/0",
            ]
            # (1 unchanged attribute hidden)
        }
      + rule {
          + destination_ips = []
          + direction       = "in"
          + port            = "8080"
          + protocol        = "tcp"
          + source_ips      = [
              + "0.0.0.0/0",
              + "::/0",
            ]
            # (1 unchanged attribute hidden)
        }
    }

  # hcloud_network.workspace will be created
  + resource "hcloud_network" "workspace" {
      + delete_protection        = false
      + expose_routes_to_vswitch = false
      + id                       = (known after apply)
      + ip_range                 = "10.0.0.0/16"
      + labels                   = {
          + "coder.owner"     = "default"
          + "coder.resource"  = "network"
          + "coder.workspace" = "default"
        }
      + name                     = "coder-default-default-30ceaa30-net"
    }

  # hcloud_network_subnet.workspace will be created
  + resource "hcloud_network_subnet" "workspace" {
      + gateway      = (known after apply)
      + id           = (known after apply)
      + ip_range     = "10.0.1.0/24"
      + network_id   = (known after apply)
      + network_zone = "eu-central"
      + type         = "cloud"
    }

  # hcloud_server.workspace[0] will be created
  + resource "hcloud_server" "workspace" {
      + allow_deprecated_images    = false
      + backup_window              = (known after apply)
      + backups                    = false
      + datacenter                 = (known after apply)
      + delete_protection          = false
      + firewall_ids               = (known after apply)
      + id                         = (known after apply)
      + ignore_remote_firewall_ids = false
      + image                      = "ubuntu-22.04"
      + ipv4_address               = (known after apply)
      + ipv6_address               = (known after apply)
      + ipv6_network               = (known after apply)
      + keep_disk                  = false
      + labels                     = {
          + "coder.owner"     = "default"
          + "coder.resource"  = "workspace-server"
          + "coder.workspace" = "default"
        }
      + location                   = "fsn1"
      + name                       = "coder-default-default-30ceaa30"
      + primary_disk_size          = (known after apply)
      + rebuild_protection         = false
      + server_type                = "cx22"
      + shutdown_before_deletion   = false
      + ssh_keys                   = (sensitive value)
      + status                     = (known after apply)
      + user_data                  = (sensitive value)

      + network {
          + alias_ips   = (known after apply)
          + ip          = "10.0.1.5"
          + mac_address = (known after apply)
          + network_id  = (known after apply)
        }

      + public_net {
          + ipv4         = (known after apply)
          + ipv4_enabled = true
          + ipv6         = (known after apply)
          + ipv6_enabled = true
        }
    }

  # hcloud_volume.home_volume will be created
  + resource "hcloud_volume" "home_volume" {
      + delete_protection = false
      + format            = "ext4"
      + id                = (known after apply)
      + labels            = {
          + "coder.owner"     = "default"
          + "coder.resource"  = "home-volume"
          + "coder.workspace" = "default"
        }
      + linux_device      = (known after apply)
      + location          = "fsn1"
      + name              = "coder-default-default-30ceaa30-home"
      + server_id         = (known after apply)
      + size              = 20
    }

  # hcloud_volume_attachment.home_volume[0] will be created
  + resource "hcloud_volume_attachment" "home_volume" {
      + automount = true
      + id        = (known after apply)
      + server_id = (known after apply)
      + volume_id = (known after apply)
    }

  # module.code-server[0].coder_app.code-server will be created
  + resource "coder_app" "code-server" {
      + agent_id     = (known after apply)
      + display_name = "code-server"
      + external     = false
      + hidden       = false
      + icon         = "/icon/code.svg"
      + id           = (known after apply)
      + open_in      = "slim-window"
      + order        = 1
      + share        = "owner"
      + slug         = "code-server"
      + subdomain    = false
      + url          = "http://localhost:13337/"

      + healthcheck {
          + interval  = 5
          + threshold = 6
          + url       = "http://localhost:13337/healthz"
        }
    }

  # module.code-server[0].coder_script.code-server will be created
  + resource "coder_script" "code-server" {
      + agent_id           = (known after apply)
      + display_name       = "code-server"
      + icon               = "/icon/code.svg"
      + id                 = (known after apply)
      + run_on_start       = true
      + run_on_stop        = false
      + script             = <<-EOT
            #!/usr/bin/env bash

            EXTENSIONS=("")
            BOLD='\033[0;1m'
            CODE='\033[36;40;1m'
            RESET='\033[0m'
            CODE_SERVER="/tmp/code-server/bin/code-server"

            # Set extension directory
            EXTENSION_ARG=""
            if [ -n "" ]; then
              EXTENSION_ARG="--extensions-dir="
              mkdir -p ""
            fi

            function run_code_server() {
              echo "👷 Running code-server in the background..."
              echo "Check logs at /tmp/code-server.log!"
              $CODE_SERVER "$EXTENSION_ARG" --auth none --port "13337" --app-name "code-server" > "/tmp/code-server.log" 2>&1 &
            }

            # Check if the settings file exists...
            if [ ! -f ~/.local/share/code-server/User/settings.json ]; then
              echo "⚙️ Creating settings file..."
              mkdir -p ~/.local/share/code-server/User
              if command -v jq &> /dev/null; then
                echo "{}" | jq '.' > ~/.local/share/code-server/User/settings.json
              else
                echo "{}" > ~/.local/share/code-server/User/settings.json
              fi
            fi

            # Apply/overwrite template based settings
            echo "⚙️ Creating machine settings file..."
            mkdir -p ~/.local/share/code-server/Machine
            if command -v jq &> /dev/null; then
              echo "{}" | jq '.' > ~/.local/share/code-server/Machine/settings.json
            else
              echo "{}" > ~/.local/share/code-server/Machine/settings.json
            fi

            # Check if code-server is already installed for offline
            if [ "false" = true ]; then
              if [ -f "$CODE_SERVER" ]; then
                echo "🥳 Found a copy of code-server"
                run_code_server
                exit 0
              fi
              # Offline mode always expects a copy of code-server to be present
              echo "Failed to find a copy of code-server"
              exit 1
            fi

            # If there is no cached install OR we don't want to use a cached install
            if [ ! -f "$CODE_SERVER" ] || [ "false" != true ]; then
              printf "${BOLD}Installing code-server!\n"

              # Clean up from other install (in case install prefix changed).
              if [ -n "$CODER_SCRIPT_BIN_DIR" ] && [ -e "$CODER_SCRIPT_BIN_DIR/code-server" ]; then 
                rm "$CODER_SCRIPT_BIN_DIR/code-server"
              fi

              ARGS=(
                "--method=standalone"
                "--prefix=/tmp/code-server"
              )
              if [ -n "" ]; then
                ARGS+=("--version=")
              fi

              output=$(curl -fsSL https://code-server.dev/install.sh | sh -s -- "${ARGS[@]}")       
              if [ $? -ne 0 ]; then
                echo "Failed to install code-server: $output"
                exit 1
              fi
              printf "🥳 code-server has been installed in /tmp/code-server\n\n"
            fi

            # Make the code-server available in PATH.
            if [ -n "$CODER_SCRIPT_BIN_DIR" ] && [ ! -e "$CODER_SCRIPT_BIN_DIR/code-server" ]; then 
              ln -s "$CODE_SERVER" "$CODER_SCRIPT_BIN_DIR/code-server"
            fi

            # Get the list of installed extensions...
            LIST_EXTENSIONS=$($CODE_SERVER --list-extensions $EXTENSION_ARG)
            readarray -t EXTENSIONS_ARRAY <<< "$LIST_EXTENSIONS"
            function extension_installed() {
              if [ "false" != true ]; then
                return 1
              fi
              for _extension in "${EXTENSIONS_ARRAY[@]}"; do
                if [ "$_extension" == "$1" ]; then
                  echo "Extension $1 was already installed."
                  return 0
                fi
              done
              return 1
            }

            # Install each extension...
            IFS=',' read -r -a EXTENSIONLIST <<< "${EXTENSIONS}"
            for extension in "${EXTENSIONLIST[@]}"; do
              if [ -z "$extension" ]; then
                continue
              fi
              if extension_installed "$extension"; then
                continue
              fi
              printf "🧩 Installing extension ${CODE}$extension${RESET}...\n"
              output=$($CODE_SERVER "$EXTENSION_ARG" --force --install-extension "$extension")      
              if [ $? -ne 0 ]; then
                echo "Failed to install extension: $extension: $output"
                exit 1
              fi
            done

            if [ "false" = true ]; then
              if ! command -v jq > /dev/null; then
                echo "jq is required to install extensions from a workspace file."
                exit 0
              fi

              WORKSPACE_DIR="$HOME"
              if [ -n "" ]; then
                WORKSPACE_DIR=""
              fi

              if [ -f "$WORKSPACE_DIR/.vscode/extensions.json" ]; then
                printf "🧩 Installing extensions from %s/.vscode/extensions.json...\n" "$WORKSPACE_DIR"
                # Use sed to remove single-line comments before parsing with jq
                extensions=$(sed 's|//.*||g' "$WORKSPACE_DIR"/.vscode/extensions.json | jq -r '.recommendations[]')
                for extension in $extensions; do
                  if extension_installed "$extension"; then
                    continue
                  fi
                  $CODE_SERVER "$EXTENSION_ARG" --force --install-extension "$extension"
                done
              fi
            fi

            run_code_server
        EOT
      + start_blocks_login = false
      + timeout            = 0
    }

Plan: 11 to add, 0 to change, 0 to destroy.

─────────────────────────────────────────────────────────────────────────────────────────────────── 

Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take        
exactly these actions if you run "terraform apply" now.
PS C:\Users\Software Buddy\OneDrive\Documenten\Algora\Coder Registry\registry\melmathari\templates\hetzner-cloud>