feat: vpn

commands/cdn/distribution/get.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/ionos-cloud/ionosctl/v6/commands/cdn/completer"
+
 	"github.com/ionos-cloud/ionosctl/v6/internal/client"
 	"github.com/ionos-cloud/ionosctl/v6/internal/constants"
 	"github.com/ionos-cloud/ionosctl/v6/internal/core"

commands/cloudapi-v6/completer/ids.go

@@ -52,6 +52,37 @@ func AttachedCdromsIds(datacenterId, serverId string) []string {
 	return attachedCdromsIds
 }
 
+func DatacenterIdsFilterLocation(loc string) []string {
+	req := client.Must().CloudClient.DataCentersApi.DatacentersGet(context.Background())
+	if loc != "" {
+		req = req.Filter("location", loc)
+	}
+	dcs, _, err := req.Execute()
+	if err != nil {
+		return nil
+	}
+
+	var dcIds []string
+	for _, item := range *dcs.Items {
+		var completion string
+		if item.Id == nil {
+			continue
+		}
+		completion = *item.Id
+		if props, ok := item.GetPropertiesOk(); ok {
+			if name, ok := props.GetNameOk(); ok {
+				completion = fmt.Sprintf("%s\t%s", completion, *name)
+			}
+			if location, ok := props.GetLocationOk(); ok {
+				completion = fmt.Sprintf("%s - %s", completion, *location)
+			}
+		}
+
+		dcIds = append(dcIds, completion)
+	}
+	return dcIds
+}
+
 func DataCentersIds(filters ...func(datacenter ionoscloud.Datacenter) bool) []string {
 	datacenterSvc := resources.NewDataCenterService(client.Must(), context.Background())
 	datacenters, _, err := datacenterSvc.List(resources.ListQueryParams{})

commands/dbaas/completer/completer.go

@@ -14,49 +14,55 @@ import (
 )
 
 func GetCidrCompletionFunc(cmd *core.Command) func(c *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-	getNicIp := func() (string, error) {
-		ls, _, err := client.Must().CloudClient.ServersApi.DatacentersServersGet(context.Background(),
-			viper.GetString(core.GetFlagName(cmd.NS, constants.FlagDatacenterId))).Execute()
-		if err != nil || ls.Items == nil || len(*ls.Items) == 0 {
-			return "", fmt.Errorf("failed getting servers %w", err)
+	return func(c *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		databaseIp := "192.168.1.128" // fallback in case of no servers / errs
+		ip, err := getNicIp(cmd)
+		if err != nil || ip == "" {
+			ip = databaseIp
 		}
+		cidrs := generateCidrs(cmd, ip)
+		return []string{strings.Join(cidrs, ",")}, cobra.ShellCompDirectiveNoFileComp
+	}
+}
 
-		for _, server := range *ls.Items {
-			if server.Id == nil {
-				return "", fmt.Errorf("failed getting ID")
-			}
+func getNicIp(cmd *core.Command) (string, error) {
+	ls, _, err := client.Must().CloudClient.ServersApi.DatacentersServersGet(context.Background(),
+		viper.GetString(core.GetFlagName(cmd.NS, constants.FlagDatacenterId))).Execute()
+	if err != nil || ls.Items == nil || len(*ls.Items) == 0 {
+		return "", fmt.Errorf("failed getting servers %w", err)
+	}
 
-			nics, _, err := client.Must().CloudClient.NetworkInterfacesApi.DatacentersServersNicsGet(context.Background(),
-				viper.GetString(core.GetFlagName(cmd.NS, constants.FlagDatacenterId)), *server.Id).Execute()
-			if err != nil || nics.Items == nil || len(*nics.Items) == 0 {
-				return "", fmt.Errorf("failed getting nics %w", err)
-			}
-			// Find the first nic with IPs not empty and return it
-			for _, nic := range *nics.Items {
-				if nic.Properties != nil && nic.Properties.Ips != nil && len(*nic.Properties.Ips) > 0 {
-					return (*nic.Properties.Ips)[0], nil
-				}
+	for _, server := range *ls.Items {
+		if server.Id == nil {
+			return "", fmt.Errorf("failed getting ID")
+		}
+
+		nics, _, err := client.Must().CloudClient.NetworkInterfacesApi.DatacentersServersNicsGet(context.Background(),
+			viper.GetString(core.GetFlagName(cmd.NS, constants.FlagDatacenterId)), *server.Id).Execute()
+		if err != nil || nics.Items == nil || len(*nics.Items) == 0 {
+			return "", fmt.Errorf("failed getting nics %w", err)
+		}
+		// Find the first nic with IPs not empty and return it
+		for _, nic := range *nics.Items {
+			if nic.Properties != nil && nic.Properties.Ips != nil && len(*nic.Properties.Ips) > 0 {
+				return (*nic.Properties.Ips)[0], nil
 			}
 		}
-		return "", fmt.Errorf("no NIC with IP")
 	}
+	return "", fmt.Errorf("no NIC with IP")
+}
 
-	generateCidrs := func(ip string, instances int) []string {
-		var cidrs []string
-		for i := 0; i < instances; i++ {
-			cidrs = append(cidrs, fake.IP(fake.WithIPv4(), fake.WithIPCIDR(ip+"/24"))+"/24")
-		}
-		return cidrs
+func generateCidrs(cmd *core.Command, ip string) []string {
+	var cidrs []string
+
+	instances := viper.GetInt(core.GetFlagName(cmd.NS, constants.FlagInstances))
+	if instances == 0 {
+		instances = 1 // flag might not be set
 	}
 
-	return func(c *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		databaseIp := "192.168.1.128" // fallback in case of no servers / errs
-		ip, err := getNicIp()
-		if err != nil || ip == "" {
-			ip = databaseIp
-		}
-		instances := viper.GetInt(core.GetFlagName(cmd.NS, constants.FlagInstances))
-		cidrs := generateCidrs(ip, instances)
-		return []string{strings.Join(cidrs, ",")}, cobra.ShellCompDirectiveNoFileComp
+	for i := 0; i < instances; i++ {
+		cidrs = append(cidrs, fake.IP(fake.WithIPv4(), fake.WithIPCIDR(ip+"/24"))+"/24")
 	}
+
+	return cidrs
 }

commands/root.go

@@ -6,7 +6,6 @@ import (
 	"strings"
 
 	"github.com/ionos-cloud/ionosctl/v6/commands/cdn"
-	"github.com/ionos-cloud/ionosctl/v6/commands/kafka"
 
 	certificates "github.com/ionos-cloud/ionosctl/v6/commands/certmanager"
 	"github.com/ionos-cloud/ionosctl/v6/commands/cfg"
@@ -18,6 +17,7 @@ import (
 	logging_service "github.com/ionos-cloud/ionosctl/v6/commands/logging-service"
 	"github.com/ionos-cloud/ionosctl/v6/commands/token"
 	vm_autoscaling "github.com/ionos-cloud/ionosctl/v6/commands/vm-autoscaling"
+	"github.com/ionos-cloud/ionosctl/v6/commands/vpn"
 	"github.com/ionos-cloud/ionosctl/v6/internal/config"
 	"github.com/ionos-cloud/ionosctl/v6/internal/constants"
 	"github.com/ionos-cloud/ionosctl/v6/internal/core"
@@ -225,11 +225,9 @@ func addCommands() {
 	rootCmd.AddCommand(dns.Root())
 	rootCmd.AddCommand(logging_service.Root())
 
-	// CDN
 	rootCmd.AddCommand(cdn.Command())
 
-	// Kafka
-	rootCmd.AddCommand(kafka.Command())
+	rootCmd.AddCommand(vpn.Root())
 }
 
 const (

commands/vpn/ipsec/completer/completer.go

@@ -0,0 +1,81 @@
+package completer
+
+import (
+	"context"
+
+	"github.com/ionos-cloud/ionosctl/v6/internal/client"
+	"github.com/ionos-cloud/ionosctl/v6/pkg/functional"
+	vpn "github.com/ionos-cloud/sdk-go-vpn"
+)
+
+// -- GATEWAYS
+
+// GatewaysProperty returns a list of properties of all gateways matching the given filters
+func GatewaysProperty[V any](f func(gateway vpn.IPSecGatewayRead) V, fs ...GatewayFilter) []V {
+	recs, err := Gateways(fs...)
+	if err != nil {
+		return nil
+	}
+	return functional.Map(*recs.Items, f)
+}
+
+// Gateways returns all distributions matching the given filters
+func Gateways(fs ...GatewayFilter) (vpn.IPSecGatewayReadList, error) {
+	req := client.Must().VPNClient.IPSecGatewaysApi.IpsecgatewaysGet(context.Background())
+	for _, f := range fs {
+		var err error
+		req, err = f(req)
+		if err != nil {
+			return vpn.IPSecGatewayReadList{}, err
+		}
+	}
+
+	ls, _, err := req.Execute()
+	if err != nil {
+		return vpn.IPSecGatewayReadList{}, err
+	}
+	return ls, nil
+}
+
+type GatewayFilter func(request vpn.ApiIpsecgatewaysGetRequest) (vpn.ApiIpsecgatewaysGetRequest, error)
+
+// TunnelsProperty returns a list of properties of all tunnels matching the given filters
+func TunnelsProperty[V any](gatewayID string, f func(tunnel vpn.IPSecTunnelRead) V, fs ...TunnelFilter) []V {
+	recs, err := Tunnels(gatewayID, fs...)
+	if err != nil {
+		return nil
+	}
+	return functional.Map(*recs.Items, f)
+}
+
+// Tunnels returns all distributions matching the given filters
+func Tunnels(gatewayID string, fs ...TunnelFilter) (vpn.IPSecTunnelReadList, error) {
+	req := client.Must().VPNClient.IPSecTunnelsApi.IpsecgatewaysTunnelsGet(context.Background(), gatewayID)
+	for _, f := range fs {
+		var err error
+		req, err = f(req)
+		if err != nil {
+			return vpn.IPSecTunnelReadList{}, err
+		}
+	}
+
+	ls, _, err := req.Execute()
+	if err != nil {
+		return vpn.IPSecTunnelReadList{}, err
+	}
+	return ls, nil
+}
+
+type TunnelFilter func(request vpn.ApiIpsecgatewaysTunnelsGetRequest) (vpn.ApiIpsecgatewaysTunnelsGetRequest, error)
+
+func GatewayIDs() []string {
+	return GatewaysProperty(func(gateway vpn.IPSecGatewayRead) string {
+		return *gateway.Id + "\t" + *gateway.Properties.Name + "(" + *gateway.Properties.GatewayIP + ")"
+	})
+}
+
+func TunnelIDs(gatewayID string) []string {
+	return TunnelsProperty(gatewayID, func(p vpn.IPSecTunnelRead) string {
+		return *p.Id + "\t" + *p.Properties.Name + "(" + *p.Properties.RemoteHost + ")"
+	})
+}