resource_socket.go

package border0

import (
	"context"
	"log"

	border0client "github.com/borderzero/border0-go/client"
	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)

func resourceSocket() *schema.Resource {
	return &schema.Resource{
		Description:   "The socket resource allows you to create and manage a Border socket.",
		ReadContext:   resourceSocketRead,
		CreateContext: resourceSocketCreate,
		UpdateContext: resourceSocketUpdate,
		DeleteContext: resourceSocketDelete,
		Importer: &schema.ResourceImporter{
			StateContext: schema.ImportStatePassthroughContext,
		},
		Schema: map[string]*schema.Schema{
			"name": {
				Type:        schema.TypeString,
				Required:    true,
				Description: "The name of the socket.",
			},
			"socket_type": {
				Type:        schema.TypeString,
				Required:    true,
				ForceNew:    true,
				Description: "The type of the socket.",
			},
			"description": {
				Type:        schema.TypeString,
				Optional:    true,
				Description: "The description of the socket.",
			},
			"upstream_type": {
				Type:        schema.TypeString,
				Optional:    true,
				Description: "The upstream type of the socket.",
			},
			"upstream_http_hostname": {
				Type:        schema.TypeString,
				Optional:    true,
				Description: "The upstream http hostname of the socket.",
			},
			"tags": {
				Type: schema.TypeMap,
				Elem: &schema.Schema{
					Type: schema.TypeString,
				},
				Optional:    true,
				Description: "The tags of the socket.",
			},
			"recording_enabled": {
				Type:        schema.TypeBool,
				Optional:    true,
				Default:     false,
				Description: "Indicates if recording is enabled for the socket.",
			},
			"connector_authentication_enabled": {
				Type:        schema.TypeBool,
				Optional:    true,
				Default:     false,
				Description: "Indicates if connector authentication is enabled for the socket.",
			},
		},
	}
}

func resourceSocketRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
	client := m.(*border0client.APIClient)
	socket, err := client.Socket(ctx, d.Id())
	if !d.IsNewResource() && border0client.NotFound(err) {
		log.Printf("[WARN] Socket (%s) not found, removing from state", d.Id())
		d.SetId("")
		return diag.Diagnostics{}
	}
	if err != nil {
		return diagnosticsError(err, "Failed to fetch socket")
	}

	var upstreamType string
	if socket.UpstreamType != socket.SocketType {
		upstreamType = socket.UpstreamType
	}

	return setValues(d, map[string]any{
		"name":                             socket.Name,
		"socket_type":                      socket.SocketType,
		"description":                      socket.Description,
		"upstream_type":                    upstreamType,
		"upstream_http_hostname":           socket.UpstreamHTTPHostname,
		"tags":                             socket.Tags,
		"recording_enabled":                socket.RecordingEnabled,
		"connector_authentication_enabled": socket.ConnectorAuthenticationEnabled,
	})
}

func resourceSocketCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
	client := m.(*border0client.APIClient)
	socket := &border0client.Socket{
		Name:       d.Get("name").(string),
		SocketType: d.Get("socket_type").(string),
	}

	if v, ok := d.GetOk("description"); ok {
		socket.Description = v.(string)
	}
	if v, ok := d.GetOk("recording_enabled"); ok {
		socket.RecordingEnabled = v.(bool)
	}
	if v, ok := d.GetOk("upstream_type"); ok {
		socket.UpstreamType = v.(string)
	}
	if v, ok := d.GetOk("upstream_http_hostname"); ok {
		socket.UpstreamHTTPHostname = v.(string)
	}
	if v, ok := d.GetOk("connector_authentication_enabled"); ok {
		socket.ConnectorAuthenticationEnabled = v.(bool)
	}
	if v, ok := d.GetOk("tags"); ok {
		tags := v.(map[string]any)
		socket.Tags = make(map[string]string)
		for key, value := range tags {
			socket.Tags[key] = value.(string)
		}
	}

	created, err := client.CreateSocket(ctx, socket)
	if err != nil {
		return diagnosticsError(err, "Failed to create key")
	}

	d.SetId(created.SocketID)

	return resourceSocketRead(ctx, d, m)
}

func resourceSocketUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
	client := m.(*border0client.APIClient)

	if d.HasChangesExcept("socket_type") {
		socketBeforeUpdate, err := client.Socket(ctx, d.Id())
		if err != nil {
			return diagnosticsError(err, "Failed to fetch socket")
		}
		socketUpdate := &border0client.Socket{
			Name:       d.Get("name").(string),
			SocketType: d.Get("socket_type").(string),
		}

		if v, ok := d.GetOk("description"); ok {
			socketUpdate.Description = v.(string)
		}
		if v, ok := d.GetOk("recording_enabled"); ok {
			socketUpdate.RecordingEnabled = v.(bool)
		}
		if v, ok := d.GetOk("upstream_type"); ok {
			socketUpdate.UpstreamType = v.(string)
		}
		if v, ok := d.GetOk("upstream_http_hostname"); ok {
			socketUpdate.UpstreamHTTPHostname = v.(string)
		}
		if v, ok := d.GetOk("connector_authentication_enabled"); ok {
			socketUpdate.ConnectorAuthenticationEnabled = v.(bool)
		}
		if v, ok := d.GetOk("tags"); ok {
			tagsUpdate := v.(map[string]any)
			socketUpdate.Tags = make(map[string]string)
			copiedTags := []string{"managed_by"}
			for _, key := range copiedTags {
				if value, ok := socketBeforeUpdate.Tags[key]; ok {
					socketUpdate.Tags[key] = value
				}
			}
			for key, value := range tagsUpdate {
				socketUpdate.Tags[key] = value.(string)
			}
		}

		_, err = client.UpdateSocket(ctx, d.Id(), socketUpdate)
		if err != nil {
			return diagnosticsError(err, "Failed to update socket")
		}
	}

	return resourceSocketRead(ctx, d, m)
}

func resourceSocketDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
	client := m.(*border0client.APIClient)
	if err := client.DeleteSocket(ctx, d.Id()); err != nil {
		return diagnosticsError(err, "Failed to delete socket")
	}
	d.SetId("")
	return nil
}