Add wireguard interface resource

routeros/provider.go

@@ -50,6 +50,7 @@ func Provider() *schema.Provider {
 			"routeros_interface_bridge_vlan": resourceInterfaceBridgeVlan(),
 			"routeros_interface_bridge_port": resourceInterfaceBridgePort(),
 			"routeros_interface_bridge":      resourceInterfaceBridge(),
+			"routeros_interface_wireguard":   resourceInterfaceWireguard(),
 		},
 		DataSourcesMap: map[string]*schema.Resource{
 			"routeros_ip_addresses": datasourceIPAddresses(),

routeros/resource_interface_wireguard.go

@@ -39,8 +39,9 @@ func resourceInterfaceWireguard() *schema.Resource {
 				Required: true,
 			},
 			"private_key": {
-				Type:     schema.TypeString,
-				Computed: true,
+				Type:      schema.TypeString,
+				Computed:  true,
+				Sensitive: true,
 			},
 			"public_key": {
 				Type:     schema.TypeString,
@@ -60,27 +61,52 @@ func resourceInterfaceWireguardCreate(d *schema.ResourceData, m interface{}) err
 	interface_wireguard := new(roscl.InterfaceWireguard)
 	interface_wireguard.Name = d.Get("name").(string)
 	interface_wireguard.Disabled = strconv.FormatBool(d.Get("disabled").(bool))
+	interface_wireguard.ListenPort = strconv.Itoa(d.Get("listen_port").(int))
+	interface_wireguard.Mtu = strconv.Itoa(d.Get("mtu").(int))
 
 	res, err := c.CreateInterfaceWireguard(interface_wireguard)
 	if err != nil {
 		return fmt.Errorf("error creating ip pool: %s", err.Error())
 	}
 
+	disabled, _ := strconv.ParseBool(res.Disabled)
+	listen_port, _ := strconv.Atoi(res.ListenPort)
+	mtu, _ := strconv.Atoi(res.Mtu)
+	running, _ := strconv.ParseBool(res.Running)
+
 	d.SetId(res.ID)
+	d.Set("disabled", disabled)
+	d.Set("listen_port", listen_port)
+	d.Set("mtu", mtu)
+	d.Set("running", running)
+	d.Set("name", res.Name)
+	d.Set("private_key", res.PrivateKey)
+	d.Set("public_key", res.PublicKey)
+
 	return nil
 }
 
 func resourceInterfaceWireguardRead(d *schema.ResourceData, m interface{}) error {
 	c := m.(*roscl.Client)
-	interface_wireguard, err := c.ReadInterfaceWireguard(d.Id())
+	res, err := c.ReadInterfaceWireguard(d.Id())
 
 	if err != nil {
 		return fmt.Errorf("error fetching ip pool: %s", err.Error())
 	}
 
-	d.SetId(interface_wireguard.ID)
-	d.Set("name", interface_wireguard.Name)
-	d.Set("ranges", interface_wireguard.Ranges)
+	disabled, _ := strconv.ParseBool(res.Disabled)
+	listen_port, _ := strconv.Atoi(res.ListenPort)
+	mtu, _ := strconv.Atoi(res.Mtu)
+	running, _ := strconv.ParseBool(res.Running)
+
+	d.SetId(res.ID)
+	d.Set("disabled", disabled)
+	d.Set("listen_port", listen_port)
+	d.Set("mtu", mtu)
+	d.Set("running", running)
+	d.Set("name", res.Name)
+	d.Set("private_key", res.PrivateKey)
+	d.Set("public_key", res.PublicKey)
 
 	return nil
 
@@ -90,15 +116,29 @@ func resourceInterfaceWireguardUpdate(d *schema.ResourceData, m interface{}) err
 	c := m.(*roscl.Client)
 	interface_wireguard := new(roscl.InterfaceWireguard)
 	interface_wireguard.Name = d.Get("name").(string)
-	interface_wireguard.Ranges = d.Get("ranges").(string)
+	interface_wireguard.Disabled = strconv.FormatBool(d.Get("disabled").(bool))
+	interface_wireguard.ListenPort = strconv.Itoa(d.Get("listen_port").(int))
+	interface_wireguard.Mtu = strconv.Itoa(d.Get("mtu").(int))
 
 	res, err := c.UpdateInterfaceWireguard(d.Id(), interface_wireguard)
 
 	if err != nil {
 		return fmt.Errorf("error updating ip address: %s", err.Error())
 	}
 
+	disabled, _ := strconv.ParseBool(res.Disabled)
+	listen_port, _ := strconv.Atoi(res.ListenPort)
+	mtu, _ := strconv.Atoi(res.Mtu)
+	running, _ := strconv.ParseBool(res.Running)
+
 	d.SetId(res.ID)
+	d.Set("disabled", disabled)
+	d.Set("listen_port", listen_port)
+	d.Set("mtu", mtu)
+	d.Set("running", running)
+	d.Set("name", res.Name)
+	d.Set("private_key", res.PrivateKey)
+	d.Set("public_key", res.PublicKey)
 
 	return nil
 }

routeros/resource_interface_wireguard_test.go

@@ -0,0 +1,87 @@
+package routeros
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+
+	"github.com/gnewbury1/terraform-provider-routeros/client"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
+)
+
+const testInterfaceWireguardAddress = "routeros_interface_wireguard.test_wg_interface"
+
+func TestAccInterfaceWireguardTest_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckInterfaceWireguardDestroy,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccInterfaceWireguardConfig(),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckInterfaceWireguardExists(testInterfaceWireguardAddress),
+					resource.TestCheckResourceAttr(testInterfaceWireguardAddress, "listen_port", "13231"),
+				),
+			},
+		},
+	})
+}
+
+func testAccCheckInterfaceWireguardExists(name string) resource.TestCheckFunc {
+	return func(s *terraform.State) error {
+		rs, ok := s.RootModule().Resources[name]
+		if !ok {
+			return fmt.Errorf("not found: %s", name)
+		}
+
+		if rs.Primary.ID == "" {
+			return fmt.Errorf("no id is set")
+		}
+
+		return nil
+	}
+}
+
+func testAccInterfaceWireguardConfig() string {
+	return `
+
+provider "routeros" {
+	insecure = true
+}
+
+resource "routeros_interface_wireguard" "test_wg_interface" {
+	name   		= "test_wg_interface"
+	listen_port = "13231"
+  }
+
+`
+}
+
+func testAccCheckInterfaceWireguardDestroy(s *terraform.State) error {
+	c := testAccProvider.Meta().(*client.Client)
+	for _, rs := range s.RootModule().Resources {
+		if rs.Type != "routeros_interface_wireguard" {
+			continue
+		}
+		id := rs.Primary.ID
+		req, err := http.NewRequest("GET", fmt.Sprintf("%s/interface/wireguard/%s", c.HostURL, id), nil)
+		if err != nil {
+			return err
+		}
+		req.Header.Set("Content-Type", "application/json")
+		req.SetBasicAuth(c.Username, c.Password)
+
+		res, err := c.HTTPClient.Do(req)
+		if err != nil {
+			return nil
+		}
+		if res.StatusCode != 404 {
+			return fmt.Errorf("wireguard interface %s has been found", id)
+		}
+		return nil
+	}
+
+	return nil
+}