Add dns cmd

Makefile

@@ -26,6 +26,7 @@ generate: deps
 	mockgen --destination ./internal/mocks/cloud_computing_regions_service.go --package=mocks --source ./vendor/github.com/serverscom/serverscom-go-client/pkg/cloud_computing_regions.go
 	mockgen --destination ./internal/mocks/cloud_block_storage_volumes_service.go --package=mocks --source ./vendor/github.com/serverscom/serverscom-go-client/pkg/cloud_block_storage_volumes.go
 	mockgen --destination ./internal/mocks/cloud_block_storage_backups_service.go --package=mocks --source ./vendor/github.com/serverscom/serverscom-go-client/pkg/cloud_block_storage_backups.go
+	mockgen --destination ./internal/mocks/dns_service.go --package=mocks --source ./vendor/github.com/serverscom/serverscom-go-client/pkg/dns.go
 	sed -i '' 's|github.com/serverscom/srvctl/vendor/github.com/serverscom/serverscom-go-client/pkg|github.com/serverscom/serverscom-go-client/pkg|g' \
 	./internal/mocks/ssh_service.go \
 	./internal/mocks/hosts_service.go \
@@ -43,7 +44,8 @@ generate: deps
 	./internal/mocks/cloud_instances_service.go \
 	./internal/mocks/cloud_computing_regions_service.go \
 	./internal/mocks/cloud_block_storage_volumes_service.go \
-	./internal/mocks/cloud_block_storage_backups_service.go
+	./internal/mocks/cloud_block_storage_backups_service.go \
+	./internal/mocks/dns_service.go
 
 docs:
 	go run cmd/gendoc/main.go

cmd/base/hooks.go

@@ -81,9 +81,6 @@ func CheckFormatterFlags(cmdContext *CmdContext, entities map[string]entities.En
 		if entity == nil {
 			return fmt.Errorf("can't find entity")
 		}
-		if err := entity.SetCmdDefaultFields(cmd.Name()); err != nil {
-			return err
-		}
 		if fieldList {
 			formatter.ListEntityFields(entity.GetFields())
 			os.Exit(0)

cmd/base/list_options.go

@@ -530,3 +530,33 @@ func (o *IsBackupOption[T]) ApplyToCollection(collection serverscom.Collection[T
 		collection.SetParam("is_backup", "true")
 	}
 }
+
+// dns domain delegation status option
+type DelegationStatusOption[T any] struct {
+	delegationStatus string
+}
+
+func (o *DelegationStatusOption[T]) AddFlags(cmd *cobra.Command) {
+	cmd.Flags().StringVar(&o.delegationStatus, "delegation-status", "", "Filter results by delegation status (delegated, verified, undelegated)")
+}
+
+func (o *DelegationStatusOption[T]) ApplyToCollection(collection serverscom.Collection[T]) {
+	if o.delegationStatus != "" {
+		collection.SetParam("delegation_status", o.delegationStatus)
+	}
+}
+
+// dns record type option
+type DNSRecordTypeOption[T any] struct {
+	recordType string
+}
+
+func (o *DNSRecordTypeOption[T]) AddFlags(cmd *cobra.Command) {
+	cmd.Flags().StringVar(&o.recordType, "type", "", "Filter results by record type (A, AAAA, CNAME, MX, TXT, NS, SRV, CAA, ALIAS, PTR, SOA)")
+}
+
+func (o *DNSRecordTypeOption[T]) ApplyToCollection(collection serverscom.Collection[T]) {
+	if o.recordType != "" {
+		collection.SetParam("type", strings.ToUpper(o.recordType))
+	}
+}

cmd/entities/cloud-instances/ptr.go

@@ -25,9 +25,9 @@ func newAddPTRCmd(cmdContext *base.CmdContext) *cobra.Command {
 
 			base.SetupProxy(cmd, manager)
 
-			input := serverscom.PTRRecordCreateInput{
-				Domain: data,
-				IP:     ip,
+			input := serverscom.CloudComputingInstancePTRRecordCreateInput{
+				Data: data,
+				IP:   ip,
 			}
 			if cmd.Flags().Changed("ttl") {
 				input.TTL = &ttl

cmd/entities/cloud-instances/ptr_test.go

@@ -161,8 +161,8 @@ func TestAddPTRCmd(t *testing.T) {
 			output:         "json",
 			expectedOutput: testutils.ReadFixture(filepath.Join(ptrFixtureBasePath, "get.json")),
 			configureMock: func(mock *mocks.MockCloudComputingInstancesService) {
-				in := serverscom.PTRRecordCreateInput{
-					Domain:   testPTR.Domain,
+				in := serverscom.CloudComputingInstancePTRRecordCreateInput{
+					Data:     testPTR.Domain,
 					IP:       testPTR.IP,
 					TTL:      &testPTR.TTL,
 					Priority: &testPTR.Priority,
@@ -177,9 +177,9 @@ func TestAddPTRCmd(t *testing.T) {
 			args:        []string{testInstanceID, "--data", testPTR.Domain, "--ip", testPTR.IP},
 			expectError: true,
 			configureMock: func(mock *mocks.MockCloudComputingInstancesService) {
-				in := serverscom.PTRRecordCreateInput{
-					Domain: testPTR.Domain,
-					IP:     testPTR.IP,
+				in := serverscom.CloudComputingInstancePTRRecordCreateInput{
+					Data: testPTR.Domain,
+					IP:   testPTR.IP,
 				}
 				mock.EXPECT().
 					CreatePTRRecord(gomock.Any(), testInstanceID, in).

cmd/entities/cloud-volumes/update.go

@@ -11,8 +11,6 @@ import (
 func newUpdateCmd(cmdContext *base.CmdContext) *cobra.Command {
 	var name string
 	var description string
-	var imageID string
-	var snapshotID string
 	var labels []string
 
 	cmd := &cobra.Command{
@@ -35,8 +33,6 @@ func newUpdateCmd(cmdContext *base.CmdContext) *cobra.Command {
 			input := serverscom.CloudBlockStorageVolumeUpdateInput{
 				Name:        name,
 				Description: description,
-				ImageID:     imageID,
-				SnapshotID:  snapshotID,
 				Labels:      labelsMap,
 			}
 
@@ -58,8 +54,6 @@ func newUpdateCmd(cmdContext *base.CmdContext) *cobra.Command {
 
 	cmd.Flags().StringVarP(&name, "name", "n", "", "A name of the cloud volume")
 	cmd.Flags().StringVar(&description, "description", "", "Description of the volume")
-	cmd.Flags().StringVar(&imageID, "image-id", "", "ID of the image")
-	cmd.Flags().StringVar(&snapshotID, "snapshot-id", "", "ID of the snapshot")
 	cmd.Flags().StringArrayVarP(&labels, "label", "l", []string{}, "string in key=value format")
 
 	return cmd

cmd/entities/dns/add.go

@@ -0,0 +1,100 @@
+package dns
+
+import (
+	serverscom "github.com/serverscom/serverscom-go-client/pkg"
+	"github.com/serverscom/srvctl/cmd/base"
+	"github.com/spf13/cobra"
+)
+
+type AddedFlags struct {
+	Skeleton  bool
+	InputPath string
+	Name      string
+	Email     string
+	TTL       int
+	Labels    []string
+}
+
+func newAddCmd(cmdContext *base.CmdContext) *cobra.Command {
+	flags := &AddedFlags{}
+
+	cmd := &cobra.Command{
+		Use:   "add",
+		Short: "Add a DNS domain",
+		Long:  "Create/Register a new DNS domain/zone",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			formatter := cmdContext.GetOrCreateFormatter(cmd)
+
+			if flags.Skeleton {
+				return formatter.FormatSkeleton("dns/add.json")
+			}
+
+			manager := cmdContext.GetManager()
+			ctx, cancel := base.SetupContext(cmd, manager)
+			defer cancel()
+
+			base.SetupProxy(cmd, manager)
+
+			input := &serverscom.DNSDomainCreateInput{}
+
+			if flags.InputPath != "" {
+				if err := base.ReadInputJSON(flags.InputPath, cmd.InOrStdin(), input); err != nil {
+					return err
+				}
+			} else {
+				required := []string{"name", "email"}
+				if err := base.ValidateFlags(cmd, required); err != nil {
+					return err
+				}
+			}
+
+			if err := flags.FillInput(cmd, input); err != nil {
+				return err
+			}
+
+			scClient := cmdContext.GetClient().SetVerbose(manager.GetVerbose(cmd)).GetScClient()
+			domain, err := scClient.DNS.CreateDomain(ctx, *input)
+			if err != nil {
+				return err
+			}
+
+			if domain != nil {
+				return formatter.Format(domain)
+			}
+			return nil
+		},
+	}
+
+	cmd.Flags().StringVarP(&flags.InputPath, "input", "i", "", "path to input file or '-' to read from stdin")
+	cmd.Flags().BoolVarP(&flags.Skeleton, "skeleton", "s", false, "JSON object with structure that is required to be passed")
+
+	cmd.Flags().StringVarP(&flags.Name, "name", "n", "", "A name of a DNS domain")
+	cmd.Flags().StringVarP(&flags.Email, "email", "", "", "An email used for the zone's SOA record")
+	cmd.Flags().IntVarP(&flags.TTL, "ttl", "", 0, "A default TTL in seconds (0-604800)")
+	cmd.Flags().StringArrayVarP(&flags.Labels, "label", "l", []string{}, "string in key=value format")
+
+	return cmd
+}
+
+func (f *AddedFlags) FillInput(cmd *cobra.Command, input *serverscom.DNSDomainCreateInput) error {
+	if cmd.Flags().Changed("name") {
+		input.Name = f.Name
+	}
+	if cmd.Flags().Changed("email") {
+		input.Email = f.Email
+	}
+	if cmd.Flags().Changed("ttl") {
+		input.TTL = f.TTL
+	}
+	if cmd.Flags().Changed("label") {
+		labelsMap, err := base.ParseLabels(f.Labels)
+		if err != nil {
+			return err
+		}
+
+		input.Labels = labelsMap
+	}
+
+	return nil
+}

cmd/entities/dns/add_record.go

@@ -0,0 +1,98 @@
+package dns
+
+import (
+	serverscom "github.com/serverscom/serverscom-go-client/pkg"
+	"github.com/serverscom/srvctl/cmd/base"
+	"github.com/spf13/cobra"
+)
+
+type AddRecordFlags struct {
+	Skeleton  bool
+	InputPath string
+	Type      string
+	Name      string
+	Data      string
+	TTL       int
+	Priority  int
+}
+
+func newAddRecordCmd(cmdContext *base.CmdContext) *cobra.Command {
+	flags := &AddRecordFlags{}
+
+	cmd := &cobra.Command{
+		Use:   "add-record <domain-id>",
+		Short: "Add a DNS record",
+		Long:  "Add a new DNS record to a domain",
+		Args:  base.SkeletonOrExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			formatter := cmdContext.GetOrCreateFormatter(cmd)
+
+			if flags.Skeleton {
+				return formatter.FormatSkeleton("dns/add-record.json")
+			}
+
+			manager := cmdContext.GetManager()
+			ctx, cancel := base.SetupContext(cmd, manager)
+			defer cancel()
+
+			base.SetupProxy(cmd, manager)
+
+			input := &serverscom.DNSRecordCreateInput{}
+
+			if flags.InputPath != "" {
+				if err := base.ReadInputJSON(flags.InputPath, cmd.InOrStdin(), input); err != nil {
+					return err
+				}
+			} else {
+				required := []string{"type", "name", "data"}
+				if err := base.ValidateFlags(cmd, required); err != nil {
+					return err
+				}
+			}
+
+			flags.FillInput(cmd, input)
+
+			scClient := cmdContext.GetClient().SetVerbose(manager.GetVerbose(cmd)).GetScClient()
+
+			domainID := args[0]
+			record, err := scClient.DNS.CreateRecord(ctx, domainID, *input)
+			if err != nil {
+				return err
+			}
+
+			if record != nil {
+				return formatter.Format(record)
+			}
+			return nil
+		},
+	}
+
+	cmd.Flags().StringVarP(&flags.InputPath, "input", "i", "", "path to input file or '-' to read from stdin")
+	cmd.Flags().BoolVarP(&flags.Skeleton, "skeleton", "s", false, "JSON object with structure that is required to be passed")
+
+	cmd.Flags().StringVarP(&flags.Type, "type", "", "", "A type of a DNS record (A, AAAA, CNAME, MX, TXT, NS, SRV, CAA, ALIAS)")
+	cmd.Flags().StringVarP(&flags.Name, "name", "n", "", "A name of a DNS record")
+	cmd.Flags().StringVarP(&flags.Data, "data", "", "", "A data of a DNS record")
+	cmd.Flags().IntVarP(&flags.TTL, "ttl", "", 0, "A TTL of a DNS record in seconds")
+	cmd.Flags().IntVarP(&flags.Priority, "priority", "", 0, "A priority of a DNS record (required by convention for MX/SRV, ignored for other types)")
+
+	return cmd
+}
+
+func (f *AddRecordFlags) FillInput(cmd *cobra.Command, input *serverscom.DNSRecordCreateInput) {
+	if cmd.Flags().Changed("type") {
+		input.Type = serverscom.DNSRecordType(f.Type)
+	}
+	if cmd.Flags().Changed("name") {
+		input.Name = f.Name
+	}
+	if cmd.Flags().Changed("data") {
+		input.Data = f.Data
+	}
+	if cmd.Flags().Changed("ttl") {
+		input.TTL = &f.TTL
+	}
+	if cmd.Flags().Changed("priority") {
+		input.Priority = &f.Priority
+	}
+}

cmd/entities/dns/delegation_data.go

@@ -0,0 +1,38 @@
+package dns
+
+import (
+	"github.com/serverscom/srvctl/cmd/base"
+	"github.com/spf13/cobra"
+)
+
+func newDelegationDataCmd(cmdContext *base.CmdContext) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "delegation-data",
+		Short: "Get DNS delegation data",
+		Long:  "Get the nameservers and required TXT record to configure at the domain registrar to delegate/verify a DNS zone",
+		Args:  cobra.ExactArgs(0),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			manager := cmdContext.GetManager()
+
+			ctx, cancel := base.SetupContext(cmd, manager)
+			defer cancel()
+
+			base.SetupProxy(cmd, manager)
+
+			scClient := cmdContext.GetClient().SetVerbose(manager.GetVerbose(cmd)).GetScClient()
+
+			data, err := scClient.DNS.GetDelegationData(ctx)
+			if err != nil {
+				return err
+			}
+
+			if data != nil {
+				formatter := cmdContext.GetOrCreateFormatter(cmd)
+				return formatter.Format(data)
+			}
+			return nil
+		},
+	}
+
+	return cmd
+}

cmd/entities/dns/delete.go

@@ -0,0 +1,30 @@
+package dns
+
+import (
+	"github.com/serverscom/srvctl/cmd/base"
+	"github.com/spf13/cobra"
+)
+
+func newDeleteCmd(cmdContext *base.CmdContext) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "delete <domain-id>",
+		Short: "Delete a DNS domain",
+		Long:  "Delete a DNS domain by id",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			manager := cmdContext.GetManager()
+
+			ctx, cancel := base.SetupContext(cmd, manager)
+			defer cancel()
+
+			base.SetupProxy(cmd, manager)
+
+			scClient := cmdContext.GetClient().SetVerbose(manager.GetVerbose(cmd)).GetScClient()
+
+			domainID := args[0]
+			return scClient.DNS.DeleteDomain(ctx, domainID)
+		},
+	}
+
+	return cmd
+}