resource_pools.gen.go

// Code generated by chronogen; DO NOT EDIT
package configv1

import (
	"context"
	"fmt"

	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/client"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/clienterror"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/dry"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/file"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/groups"
	"github.com/chronosphereio/chronoctl-core/src/cmd/pkg/output"
	config_v1 "github.com/chronosphereio/chronoctl-core/src/generated/swagger/configv1/client/operations"
	"github.com/chronosphereio/chronoctl-core/src/generated/swagger/configv1/models"
	"github.com/chronosphereio/chronoctl-core/src/types"
	"github.com/spf13/cobra"
)

func init() { types.MustRegisterObject(ResourcePoolsTypeMeta, &ResourcePools{}) }

var _ types.Object = &ResourcePools{}

var ResourcePoolsTypeMeta = types.TypeMeta{
	APIVersion: "v1/config",
	Kind:       "ResourcePools",
}

type ResourcePools struct {
	types.TypeMeta `json:",inline"`
	Spec           *models.Configv1ResourcePools `json:"spec"`
}

func NewResourcePools(spec *models.Configv1ResourcePools) *ResourcePools {
	return &ResourcePools{
		TypeMeta: ResourcePoolsTypeMeta,
		Spec:     spec,
	}
}

func (e *ResourcePools) Description() string {
	return types.TypeDescription(e)
}

func (e *ResourcePools) Identifier() string {
	return "ResourcePools"
}

func CreateResourcePools(
	ctx context.Context,
	client config_v1.ClientService,
	entity *ResourcePools,
	dryRun bool,
) (*ResourcePools, error) {
	res, err := client.CreateResourcePools(&config_v1.CreateResourcePoolsParams{
		Context: ctx,
		Body: &models.Configv1CreateResourcePoolsRequest{
			DryRun:        dryRun,
			ResourcePools: entity.Spec,
		},
	})
	if err != nil {
		return nil, clienterror.Wrap(err)
	}
	return NewResourcePools(res.Payload.ResourcePools), nil
}

func newResourcePoolsCreateCmd() *cobra.Command {
	var (
		permissiveParsing bool
		dryRunFlags       = dry.NewFlags()
		clientFlags       = client.NewClientFlags()
		outputFlags       = output.NewFlags(output.WithoutOutputDirectory(), output.WithoutCreateFilePerObject())
		fileFlags         = file.NewFlags(true /* required */)
	)

	var (
		use   string
		short string
	)
	use = "create -f <file>"
	short = "Creates a single ResourcePools."

	cmd := &cobra.Command{
		Use:     use,
		GroupID: groups.Commands.ID,
		Short:   short,
		RunE: func(cmd *cobra.Command, args []string) error {
			ctx, cancel := context.WithTimeout(cmd.Context(), clientFlags.Timeout())
			defer cancel()
			if err := outputFlags.Validate(); err != nil {
				return err
			}
			defer outputFlags.Close(cmd.OutOrStdout())
			stderr := output.NewStderrPrinter(cmd)

			client, err := clientFlags.ConfigV1Client()
			if err != nil {
				return err
			}

			var resourcePools *ResourcePools
			file, err := fileFlags.File()
			if err != nil {
				return err
			}
			defer file.Close() //nolint:errcheck
			resourcePools, err = types.MustDecodeSingleObject[*ResourcePools](file, permissiveParsing)
			if err != nil {
				return err
			}

			if dryRunFlags.DryRun {
				stderr.Println("--dry-run is set")
			}
			fullResourcePools, err := CreateResourcePools(ctx, client, resourcePools, dryRunFlags.DryRun)
			if err != nil {
				return err
			}

			if dryRunFlags.DryRun {
				stderr.Println("ResourcePools is valid and can be created")
				return nil
			}
			stderr.Printf("ResourcePools created successfully\n")

			if err := outputFlags.WriteObject(fullResourcePools, cmd.OutOrStdout()); err != nil {
				return err
			}
			return nil
		},
	}
	dryRunFlags.AddFlags(cmd)
	clientFlags.AddFlags(cmd)
	outputFlags.AddFlags(cmd)
	fileFlags.AddFlags(cmd)
	cmd.Flags().BoolVar(&permissiveParsing, "no-strict", false, "If set, manifests with unknown fields are not rejected. Defaults to false.")

	return cmd
}

func GetResourcePools(
	ctx context.Context,
	client config_v1.ClientService,
) (*ResourcePools, error) {
	res, err := client.ReadResourcePools(&config_v1.ReadResourcePoolsParams{
		Context: ctx,
	})
	if err != nil {
		return nil, clienterror.Wrap(err)
	}
	return NewResourcePools(res.GetPayload().ResourcePools), nil
}

func newResourcePoolsReadCmd() *cobra.Command {
	clientFlags := client.NewClientFlags()
	outputFlags := output.NewFlags(output.WithoutOutputDirectory(), output.WithoutCreateFilePerObject())
	var (
		short string
		use   string
		args  cobra.PositionalArgs
	)
	short = "Reads a ResourcePools singleton"
	use = "read"

	cmd := &cobra.Command{
		Use:     use,
		GroupID: groups.Commands.ID,
		Short:   short,
		Args:    args,
		RunE: func(cmd *cobra.Command, args []string) error {
			ctx, cancel := context.WithTimeout(cmd.Context(), clientFlags.Timeout())
			defer cancel()
			if err := outputFlags.Validate(); err != nil {
				return err
			}
			defer outputFlags.Close(cmd.OutOrStdout())

			client, err := clientFlags.ConfigV1Client()
			if err != nil {
				return err
			}
			entity, err := GetResourcePools(ctx, client)
			if err != nil {
				return err
			}
			if err := outputFlags.WriteObject(entity, cmd.OutOrStdout()); err != nil {
				return err
			}
			return nil
		},
	}

	clientFlags.AddFlags(cmd)
	outputFlags.AddFlags(cmd)

	return cmd
}

func UpdateResourcePools(
	ctx context.Context,
	client config_v1.ClientService,
	entity *ResourcePools,
	opts UpdateOptions,
) (*ResourcePools, error) {
	res, err := client.UpdateResourcePools(&config_v1.UpdateResourcePoolsParams{
		Context: ctx,
		Body: &models.Configv1UpdateResourcePoolsRequest{
			CreateIfMissing: opts.CreateIfMissing,
			DryRun:          opts.DryRun,
			ResourcePools:   entity.Spec,
		},
	})
	if err != nil {
		return nil, clienterror.Wrap(err)
	}

	return NewResourcePools(res.Payload.ResourcePools), nil
}

func newResourcePoolsUpdateCmd() *cobra.Command {
	var (
		permissiveParsing bool
		createIfMissing   bool
		dryRunFlags       = dry.NewFlags()
		clientFlags       = client.NewClientFlags()
		outputFlags       = output.NewFlags(output.WithoutOutputDirectory(), output.WithoutCreateFilePerObject())
		fileFlags         = file.NewFlags(true /* required */)
	)

	cmd := &cobra.Command{
		Use:     "update -f <filename>",
		GroupID: groups.Commands.ID,
		Short:   "Updates an existing ResourcePools.",
		RunE: func(cmd *cobra.Command, args []string) error {
			ctx, cancel := context.WithTimeout(cmd.Context(), clientFlags.Timeout())
			defer cancel()
			if err := outputFlags.Validate(); err != nil {
				return err
			}
			defer outputFlags.Close(cmd.OutOrStdout())
			stderr := output.NewStderrPrinter(cmd)

			client, err := clientFlags.ConfigV1Client()
			if err != nil {
				return err
			}

			file, err := fileFlags.File()
			if err != nil {
				return err
			}
			defer file.Close() //nolint:errcheck

			resourcePools, err := types.MustDecodeSingleObject[*ResourcePools](file, permissiveParsing)
			if err != nil {
				return err
			}

			updateOpts := UpdateOptions{
				DryRun:          dryRunFlags.DryRun,
				CreateIfMissing: createIfMissing,
			}

			if dryRunFlags.DryRun {
				stderr.Println("--dry-run is set, update not persisted")
			}

			fullResourcePools, err := UpdateResourcePools(ctx, client, resourcePools, updateOpts)
			if err != nil {
				return err
			}

			if dryRunFlags.DryRun {
				stderr.Println("ResourcePools is valid and can be updated")
				return nil
			}
			stderr.Printf("ResourcePools applied successfully\n")

			if err := outputFlags.WriteObject(fullResourcePools, cmd.OutOrStdout()); err != nil {
				return err
			}
			return nil
		},
	}
	dryRunFlags.AddFlags(cmd)
	clientFlags.AddFlags(cmd)
	outputFlags.AddFlags(cmd)
	fileFlags.AddFlags(cmd)
	cmd.Flags().BoolVar(&permissiveParsing, "no-strict", false, "If set, manifests with unknown fields are allowed. Defaults to false.")
	cmd.Flags().BoolVar(&createIfMissing, "create-if-missing", false, "If set, creates the ResourcePools if it does not already exist. Defaults to false.")

	return cmd
}

func DeleteResourcePools(
	ctx context.Context,
	client config_v1.ClientService,
) error {
	_, err := client.DeleteResourcePools(&config_v1.DeleteResourcePoolsParams{
		Context: ctx,
	})
	if err != nil {
		return clienterror.Wrap(err)
	}
	return nil
}

func newResourcePoolsDeleteCmd() *cobra.Command {
	clientFlags := client.NewClientFlags()
	outputFlags := output.NewFlags(output.WithoutOutputDirectory(), output.WithoutCreateFilePerObject())

	cmd := &cobra.Command{
		Use:     "delete <slug>",
		GroupID: groups.Commands.ID,
		Short:   "Deletes a single ResourcePools by slug",
		RunE: func(cmd *cobra.Command, args []string) error {
			ctx, cancel := context.WithTimeout(cmd.Context(), clientFlags.Timeout())
			defer cancel()
			if err := outputFlags.Validate(); err != nil {
				return err
			}
			defer outputFlags.Close(cmd.OutOrStdout())

			client, err := clientFlags.ConfigV1Client()
			if err != nil {
				return err
			}

			res, err := client.DeleteResourcePools(&config_v1.DeleteResourcePoolsParams{
				Context: ctx,
			})
			if err != nil {
				return clienterror.Wrap(err)
			}
			_ = res
			fmt.Fprintf(cmd.OutOrStdout(), "deleted ResourcePools")
			return nil
		},
	}
	clientFlags.AddFlags(cmd)
	outputFlags.AddFlags(cmd)
	return cmd
}

const ResourcePoolsScaffoldYAML = `api_version: v1/config
kind: ResourcePools
spec:
    # Optional pools.
    pools:
        - # Required name of the pool. Must be unique.
          name: <string>
          # Required filters which define which metrics map to this pool, where any
          # metric which matches at least one filter will map to the pool.
          filters:
            - # Name of the label to match.
              name: <string>
              # Glob value of the label to match.
              value_glob: <string>
          allocation:
            # Percentage of the license to allocate to this pool. Must be between 0
            # and 100 inclusive. The percent_of_license values across all pools
            # (including the default pool) must add up to exactly 100.
            percent_of_license: <number>
          priorities:
            # Required filters which define which metrics are high priority, where any
            # metric which matches at least one filter is considered high priority.
            # High priority metrics are dropped last when the license limit is exceeded.
            high_priority_filters:
                - # Name of the label to match.
                  name: <string>
                  # Glob value of the label to match.
                  value_glob: <string>
            # Required filters which define which metrics are low priority, where any
            # metric which matches at least one filter is considered low priority. Low
            # priority metrics are dropped first when the license limit is exceeded.
            low_priority_filters:
                - # Name of the label to match.
                  name: <string>
                  # Glob value of the label to match.
                  value_glob: <string>
    default_pool:
        allocation:
            # Percentage of the license to allocate to this pool. Must be between 0
            # and 100 inclusive. The percent_of_license values across all pools
            # (including the default pool) must add up to exactly 100.
            percent_of_license: <number>
        priorities:
            # Required filters which define which metrics are high priority, where any
            # metric which matches at least one filter is considered high priority.
            # High priority metrics are dropped last when the license limit is exceeded.
            high_priority_filters:
                - # Name of the label to match.
                  name: <string>
                  # Glob value of the label to match.
                  value_glob: <string>
            # Required filters which define which metrics are low priority, where any
            # metric which matches at least one filter is considered low priority. Low
            # priority metrics are dropped first when the license limit is exceeded.
            low_priority_filters:
                - # Name of the label to match.
                  name: <string>
                  # Glob value of the label to match.
                  value_glob: <string>
`

func newResourcePoolsScaffoldCmd() *cobra.Command {
	cmd := &cobra.Command{
		Use:     "scaffold",
		GroupID: groups.Commands.ID,
		Short:   "Scaffolds a complete object with placeholder values",
		Run: func(cmd *cobra.Command, args []string) {
			fmt.Fprint(cmd.OutOrStdout(), ResourcePoolsScaffoldYAML)
		},
	}
	return cmd
}

func NewResourcePoolsCmd() *cobra.Command {
	root := &cobra.Command{
		Use:     "resource-pools",
		GroupID: groups.Config.ID,
		Short:   "All commands for ResourcePools",
	}

	root.AddGroup(groups.Commands)
	root.AddCommand(
		newResourcePoolsCreateCmd(),
		newResourcePoolsReadCmd(),
		newResourcePoolsUpdateCmd(),
		newResourcePoolsDeleteCmd(),
		newResourcePoolsScaffoldCmd(),
	)
	return root
}