placementgroup

Documentation

Index

• Variables
• func NewCommand(cli *state.State, client hcapi2.Client) *cobra.Command

Variables

var CreateCmd = base.Cmd{
	BaseCobraCommand: func(client hcapi2.Client) *cobra.Command {
		cmd := &cobra.Command{
			Use:   "create FLAGS",
			Short: "Create a placement group",
		}
		cmd.Flags().String("name", "", "Name")
		cmd.MarkFlagRequired("name")

		cmd.Flags().StringToString("label", nil, "User-defined labels ('key=value') (can be specified multiple times)")

		cmd.Flags().String("type", "", "Type of the placement group")
		cmd.MarkFlagRequired("type")
		return cmd
	},
	Run: func(ctx context.Context, client hcapi2.Client, actionWaiter state.ActionWaiter, cmd *cobra.Command, args []string) error {
		name, _ := cmd.Flags().GetString("name")
		labels, _ := cmd.Flags().GetStringToString("label")
		placementGroupType, _ := cmd.Flags().GetString("type")

		opts := hcloud.PlacementGroupCreateOpts{
			Name:   name,
			Labels: labels,
			Type:   hcloud.PlacementGroupType(placementGroupType),
		}

		result, _, err := client.PlacementGroup().Create(ctx, opts)
		if err != nil {
			return err
		}

		fmt.Printf("Placement group %d created\n", result.PlacementGroup.ID)

		return nil
	},
}

var DeleteCmd = base.DeleteCmd{
	ResourceNameSingular: "placement group",
	ShortDescription:     "Delete a placement group",
	NameSuggestions:      func(c hcapi2.Client) func() []string { return c.PlacementGroup().Names },
	Fetch: func(ctx context.Context, client hcapi2.Client, cmd *cobra.Command, idOrName string) (interface{}, *hcloud.Response, error) {
		return client.PlacementGroup().Get(ctx, idOrName)
	},
	Delete: func(ctx context.Context, client hcapi2.Client, cmd *cobra.Command, resource interface{}) error {
		placementGroup := resource.(*hcloud.PlacementGroup)
		if _, err := client.PlacementGroup().Delete(ctx, placementGroup); err != nil {
			return err
		}
		return nil
	},
}

var DescribeCmd = base.DescribeCmd{
	ResourceNameSingular: "placement group",
	ShortDescription:     "Describe a placement group",
	JSONKeyGetByID:       "placement_group",
	JSONKeyGetByName:     "placement_groups",
	NameSuggestions:      func(c hcapi2.Client) func() []string { return c.PlacementGroup().Names },
	Fetch: func(ctx context.Context, client hcapi2.Client, cmd *cobra.Command, idOrName string) (interface{}, *hcloud.Response, error) {
		return client.PlacementGroup().Get(ctx, idOrName)
	},
	PrintText: func(_ context.Context, client hcapi2.Client, cmd *cobra.Command, resource interface{}) error {
		placementGroup := resource.(*hcloud.PlacementGroup)

		fmt.Printf("ID:\t\t%d\n", placementGroup.ID)
		fmt.Printf("Name:\t\t%s\n", placementGroup.Name)
		fmt.Printf("Created:\t%s (%s)\n", util.Datetime(placementGroup.Created), humanize.Time(placementGroup.Created))

		fmt.Print("Labels:\n")
		if len(placementGroup.Labels) == 0 {
			fmt.Print("  No labels\n")
		} else {
			for key, value := range placementGroup.Labels {
				fmt.Printf("  %s: %s\n", key, value)
			}
		}

		fmt.Print("Servers:\n")
		for _, serverID := range placementGroup.Servers {
			fmt.Printf("  - Server ID:\t\t%d\n", serverID)
			fmt.Printf("    Server Name:\t%s\n", client.Server().ServerName(serverID))
		}

		fmt.Printf("Type:\t\t%s\n", placementGroup.Type)
		return nil
	},
}

var LabelCmds = base.LabelCmds{
	ResourceNameSingular:   "placement group",
	ShortDescriptionAdd:    "Add a label to a placement group",
	ShortDescriptionRemove: "Remove a label from a placement group",
	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.PlacementGroup().Names },
	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.PlacementGroup().LabelKeys },
	FetchLabels: func(ctx context.Context, client hcapi2.Client, idOrName string) (map[string]string, int, error) {
		placementGroup, _, err := client.PlacementGroup().Get(ctx, idOrName)
		if err != nil {
			return nil, 0, err
		}
		if placementGroup == nil {
			return nil, 0, fmt.Errorf("placement group not found: %s", idOrName)
		}
		return placementGroup.Labels, placementGroup.ID, nil
	},
	SetLabels: func(ctx context.Context, client hcapi2.Client, id int, labels map[string]string) error {
		opts := hcloud.PlacementGroupUpdateOpts{
			Labels: labels,
		}
		_, _, err := client.PlacementGroup().Update(ctx, &hcloud.PlacementGroup{ID: id}, opts)
		return err
	},
}

var ListCmd = base.ListCmd{
	ResourceNamePlural: "placement groups",
	DefaultColumns:     []string{"id", "name", "servers", "type", "age"},

	Fetch: func(ctx context.Context, client hcapi2.Client, cmd *cobra.Command, listOpts hcloud.ListOpts, sorts []string) ([]interface{}, error) {
		opts := hcloud.PlacementGroupListOpts{ListOpts: listOpts}
		if len(sorts) > 0 {
			opts.Sort = sorts
		}
		placementGroups, err := client.PlacementGroup().AllWithOpts(ctx, opts)

		var resources []interface{}
		for _, n := range placementGroups {
			resources = append(resources, n)
		}
		return resources, err
	},

	OutputTable: func(client hcapi2.Client) *output.Table {
		return output.NewTable().
			AddAllowedFields(hcloud.PlacementGroup{}).
			AddFieldFn("servers", output.FieldFn(func(obj interface{}) string {
				placementGroup := obj.(*hcloud.PlacementGroup)
				count := len(placementGroup.Servers)
				if count == 1 {
					return fmt.Sprintf("%d server", count)
				}
				return fmt.Sprintf("%d servers", count)
			})).
			AddFieldFn("created", output.FieldFn(func(obj interface{}) string {
				placementGroup := obj.(*hcloud.PlacementGroup)
				return util.Datetime(placementGroup.Created)
			})).
			AddFieldFn("age", output.FieldFn(func(obj interface{}) string {
				placementGroup := obj.(*hcloud.PlacementGroup)
				return util.Age(placementGroup.Created, time.Now())
			}))
	},

	JSONSchema: func(resources []interface{}) interface{} {
		var placementGroupSchemas []schema.PlacementGroup
		for _, resource := range resources {
			placementGroup := resource.(*hcloud.PlacementGroup)
			placementGroupSchema := schema.PlacementGroup{
				ID:      placementGroup.ID,
				Name:    placementGroup.Name,
				Labels:  placementGroup.Labels,
				Created: placementGroup.Created,
				Servers: placementGroup.Servers,
				Type:    string(placementGroup.Type),
			}

			placementGroupSchemas = append(placementGroupSchemas, placementGroupSchema)
		}
		return placementGroupSchemas
	},
}

var UpdateCmd = base.UpdateCmd{
	ResourceNameSingular: "placement group",
	ShortDescription:     "Update a placement group",
	NameSuggestions:      func(c hcapi2.Client) func() []string { return c.PlacementGroup().Names },
	Fetch: func(ctx context.Context, client hcapi2.Client, cmd *cobra.Command, idOrName string) (interface{}, *hcloud.Response, error) {
		return client.PlacementGroup().Get(ctx, idOrName)
	},
	DefineFlags: func(cmd *cobra.Command) {
		cmd.Flags().String("name", "", "Placement group name")
	},
	Update: func(ctx context.Context, client hcapi2.Client, cmd *cobra.Command, resource interface{}, flags map[string]pflag.Value) error {
		placementGroup := resource.(*hcloud.PlacementGroup)
		updOpts := hcloud.PlacementGroupUpdateOpts{
			Name: flags["name"].String(),
		}
		_, _, err := client.PlacementGroup().Update(ctx, placementGroup, updOpts)
		if err != nil {
			return err
		}
		return nil
	},
}

Functions

func NewCommand

func NewCommand(cli *state.State, client hcapi2.Client) *cobra.Command