feat: add placement groups

- add placement groups using --hetzner-placement-group
- auto-created pgs will be deleted with the last server within them
- added --hetzner-auto-spread for a driver-managed placement group

Closes: #72

Author: JonasProgrammer

driver.go

@@ -36,7 +36,7 @@ type Driver struct {
 	cachedKey         *hcloud.SSHKey
 	IsExistingKey     bool
 	originalKey       string
-	danglingKeys      []*hcloud.SSHKey
+	dangling          []func()
 	ServerID          int
 	userData          string
 	volumes           []string
@@ -46,6 +46,8 @@ type Driver struct {
 	cachedServer      *hcloud.Server
 	serverLabels      map[string]string
 	keyLabels         map[string]string
+	placementGroup    string
+	cachedPGrp        *hcloud.PlacementGroup
 
 	additionalKeys       []string
 	AdditionalKeyIDs     []int
@@ -71,6 +73,14 @@ const (
 	flagAdditionalKeys    = "hetzner-additional-key"
 	flagServerLabel       = "hetzner-server-label"
 	flagKeyLabel          = "hetzner-key-label"
+	flagPlacementGroup    = "hetzner-placement-group"
+	flagAutoSpread        = "hetzner-auto-spread"
+
+	labelNamespace    = "docker-machine"
+	labelAutoSpreadPg = "auto-spread"
+	labelAutoCreated  = "auto-created"
+
+	autoSpreadPgName = "__auto_spread"
 )
 
 // NewDriver initializes a new driver instance; see [drivers.Driver.NewDriver]
@@ -79,7 +89,6 @@ func NewDriver() *Driver {
 		Image:         defaultImage,
 		Type:          defaultType,
 		IsExistingKey: false,
-		danglingKeys:  []*hcloud.SSHKey{},
 		BaseDriver: &drivers.BaseDriver{
 			SSHUser: drivers.DefaultSSHUser,
 			SSHPort: drivers.DefaultSSHPort,
@@ -183,6 +192,17 @@ func (d *Driver) GetCreateFlags() []mcnflag.Flag {
 			Usage:  "Key value pairs of additional labels to assign to the SSH key",
 			Value:  []string{},
 		},
+		mcnflag.StringFlag{
+			EnvVar: "HETZNER_PLACEMENT_GROUP",
+			Name:   flagPlacementGroup,
+			Usage:  "Placement group ID or name to add the server to; will be created if it does not exist",
+			Value:  "",
+		},
+		mcnflag.BoolFlag{
+			EnvVar: "HETZNER_AUTO_SPREAD",
+			Name:   flagAutoSpread,
+			Usage:  "Auto-spread on a docker-machine-specific default placement group",
+		},
 	}
 }
 
@@ -204,6 +224,14 @@ func (d *Driver) SetConfigFromFlags(opts drivers.DriverOptions) error {
 	d.firewalls = opts.StringSlice(flagFirewalls)
 	d.additionalKeys = opts.StringSlice(flagAdditionalKeys)
 
+	d.placementGroup = opts.String(flagPlacementGroup)
+	if opts.Bool(flagAutoSpread) {
+		if d.placementGroup != "" {
+			return errors.Errorf(flagAutoSpread + " and " + flagPlacementGroup + " are mutually exclusive")
+		}
+		d.placementGroup = autoSpreadPgName
+	}
+
 	err := d.setLabelsFromFlags(opts)
 	if err != nil {
 		return err
@@ -283,6 +311,10 @@ func (d *Driver) PreCreateCheck() error {
 		return errors.Wrap(err, "could not get location")
 	}
 
+	if _, err := d.getPlacementGroup(); err != nil {
+		return fmt.Errorf("could not create placement group: %w", err)
+	}
+
 	if d.UsePrivateNetwork && len(d.networks) == 0 {
 		return errors.Errorf("No private network attached.")
 	}
@@ -297,7 +329,7 @@ func (d *Driver) Create() error {
 		return err
 	}
 
-	defer d.destroyDanglingKeys()
+	defer d.destroyDangling()
 	err = d.createRemoteKeys()
 	if err != nil {
 		return err
@@ -335,7 +367,7 @@ func (d *Driver) Create() error {
 
 	log.Infof(" -> Server %s[%d] ready. Ip %s", srv.Server.Name, srv.Server.ID, d.IPAddress)
 	// Successful creation, so no keys dangle anymore
-	d.danglingKeys = nil
+	d.dangling = nil
 
 	return nil
 }
@@ -379,10 +411,16 @@ func (d *Driver) waitForRunningServer() error {
 }
 
 func (d *Driver) makeCreateServerOptions() (*hcloud.ServerCreateOpts, error) {
+	pgrp, err := d.getPlacementGroup()
+	if err != nil {
+		return nil, err
+	}
+
 	srvopts := hcloud.ServerCreateOpts{
-		Name:     d.GetMachineName(),
-		UserData: d.userData,
-		Labels:   d.serverLabels,
+		Name:           d.GetMachineName(),
+		UserData:       d.userData,
+		Labels:         d.serverLabels,
+		PlacementGroup: pgrp,
 	}
 
 	networks, err := d.createNetworks()
@@ -546,16 +584,19 @@ func (d *Driver) makeKey(name string, pubkey string, labels map[string]string) (
 		return nil, errors.Errorf("key upload did not return an error, but key was nil")
 	}
 
-	d.danglingKeys = append(d.danglingKeys, key)
+	d.dangling = append(d.dangling, func() {
+		_, err := d.getClient().SSHKey.Delete(context.Background(), key)
+		if err != nil {
+			log.Error(fmt.Errorf("could not delete ssh key: %w", err))
+		}
+	})
+
 	return key, nil
 }
 
-func (d *Driver) destroyDanglingKeys() {
-	for _, key := range d.danglingKeys {
-		if _, err := d.getClient().SSHKey.Delete(context.Background(), key); err != nil {
-			log.Errorf("could not delete ssh key: %v", err)
-			return
-		}
+func (d *Driver) destroyDangling() {
+	for _, destructor := range d.dangling {
+		destructor()
 	}
 }
 
@@ -615,6 +656,11 @@ func (d *Driver) Remove() error {
 			if _, err := d.getClient().Server.Delete(context.Background(), srv); err != nil {
 				return errors.Wrap(err, "could not delete server")
 			}
+
+			err = d.removeEmptyServerPlacementGroup(srv)
+			if err != nil {
+				log.Error(err) // not a hard failure
+			}
 		}
 	}
 
@@ -870,3 +916,101 @@ func (d *Driver) waitForAction(a *hcloud.Action) error {
 	}
 	return nil
 }
+
+func (d *Driver) labelName(name string) string {
+	return labelNamespace + "/" + name
+}
+
+func (d *Driver) getAutoPlacementGroup() (*hcloud.PlacementGroup, error) {
+	res, err := d.getClient().PlacementGroup.AllWithOpts(context.Background(), hcloud.PlacementGroupListOpts{
+		ListOpts: hcloud.ListOpts{LabelSelector: d.labelName(labelAutoSpreadPg)},
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	if len(res) != 0 {
+		return res[0], nil
+	}
+
+	grp, err := d.makePlacementGroup("Docker-Machine auto spread", map[string]string{
+		d.labelName(labelAutoSpreadPg): "true",
+		d.labelName(labelAutoCreated):  "true",
+	})
+
+	return grp, err
+}
+
+func (d *Driver) makePlacementGroup(name string, labels map[string]string) (*hcloud.PlacementGroup, error) {
+	grp, _, err := d.getClient().PlacementGroup.Create(context.Background(), hcloud.PlacementGroupCreateOpts{
+		Name:   name,
+		Labels: labels,
+		Type:   "spread",
+	})
+
+	if grp.PlacementGroup != nil {
+		d.dangling = append(d.dangling, func() {
+			_, err := d.getClient().PlacementGroup.Delete(context.Background(), grp.PlacementGroup)
+			if err != nil {
+				log.Error(fmt.Errorf("could not delete placement group: %w", err))
+			}
+		})
+	}
+
+	if err != nil {
+		err = fmt.Errorf("could not create placement group: %w", err)
+	}
+
+	return grp.PlacementGroup, err
+}
+
+func (d *Driver) getPlacementGroup() (*hcloud.PlacementGroup, error) {
+	if d.placementGroup == "" {
+		return nil, nil
+	} else if d.cachedPGrp != nil {
+		return d.cachedPGrp, nil
+	}
+
+	name := d.placementGroup
+	if name == autoSpreadPgName {
+		grp, err := d.getAutoPlacementGroup()
+		d.cachedPGrp = grp
+		return grp, err
+	} else {
+		client := d.getClient().PlacementGroup
+		grp, _, err := client.Get(context.Background(), name)
+		if err != nil {
+			return nil, fmt.Errorf("could not get placement group: %w", err)
+		}
+
+		if grp != nil {
+			return grp, nil
+		}
+
+		return d.makePlacementGroup(name, map[string]string{d.labelName(labelAutoCreated): "true"})
+	}
+}
+
+func (d *Driver) removeEmptyServerPlacementGroup(srv *hcloud.Server) error {
+	pg := srv.PlacementGroup
+	if pg == nil {
+		return nil
+	}
+
+	if len(pg.Servers) > 1 {
+		log.Debugf("more than 1 servers in group, ignoring %v", pg)
+		return nil
+	}
+
+	if auto, exists := pg.Labels[d.labelName(labelAutoCreated)]; exists && auto == "true" {
+		_, err := d.getClient().PlacementGroup.Delete(context.Background(), pg)
+		if err != nil {
+			err = fmt.Errorf("could not remove placement group: %w", err)
+		}
+		return err
+	} else {
+		log.Debugf("group not auto-created, ignoring: %v", pg)
+		return nil
+	}
+}

go.mod

@@ -6,12 +6,8 @@ require (
 	github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78 // indirect
 	github.com/docker/docker v0.0.0-20181018193557-f7e5154f37a4 // indirect
 	github.com/docker/machine v0.16.2
-	github.com/hetznercloud/hcloud-go v1.24.0
-	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
-	github.com/pkg/errors v0.8.1
-	github.com/sirupsen/logrus v1.4.2 // indirect
-	github.com/stretchr/testify v1.3.0 // indirect
-	golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4
-	golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb // indirect
+	github.com/hetznercloud/hcloud-go v1.32.0
+	github.com/pkg/errors v0.9.1
+	golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9
 	gotest.tools v2.2.0+incompatible // indirect
 )