Include more clean up to the storage type conversion

pkg/flist/flist.go

@@ -183,6 +183,11 @@ func (f *flistModule) mount(name, url, storage string, opts pkg.MountOptions) (s
 		if err != nil {
 			sublog.Info().Msgf("create new subvolume %s", name)
 			// and only create a new one if it doesn't exist
+			if opts.Limit == 0 || len(opts.Type) == 0 {
+				// sanity check in case type is not set always use hdd
+				return "", fmt.Errorf("invalid mount option, missing disk type and/or size")
+			}
+
 			path, err = f.storage.CreateFilesystem(name, opts.Limit*mib, opts.Type)
 			if err != nil {
 				return "", errors.Wrap(err, "failed to create read-write subvolume for 0-fs")

pkg/provision/primitives/volume.go

@@ -46,7 +46,7 @@ func (p *Provisioner) volumeProvisionImpl(ctx context.Context, reservation *prov
 		}, nil
 	}
 
-	_, err = storageClient.CreateFilesystem(reservation.ID, config.Size*gigabyte, pkg.DeviceType(config.Type))
+	_, err = storageClient.CreateFilesystem(reservation.ID, config.Size*gigabyte, config.Type)
 
 	return VolumeResult{
 		ID: reservation.ID,

pkg/provision/primitives/zdb.go

@@ -138,12 +138,26 @@ func (p *Provisioner) createZdbContainer(ctx context.Context, allocation pkg.All
 	hw := ifaceutil.HardwareAddrFromInputBytes([]byte(allocation.VolumeID))
 
 	slog.Debug().Str("flist", zdbFlistURL).Msg("mounting flist")
-	rootFS, err := flist.Mount(zdbFlistURL, "", pkg.MountOptions{
-		Limit:    10,
-		ReadOnly: false,
-	})
+	var err error
+	var rootFS string
+	for _, typ := range []pkg.DeviceType{pkg.HDDDevice, pkg.SSDDevice} {
+		rootFS, err = flist.Mount(zdbFlistURL, "", pkg.MountOptions{
+			Limit:    10,
+			ReadOnly: false,
+			Type:     typ,
+		})
+
+		if err != nil {
+			log.Error().Err(err).Msgf("failed to allocate rootfs for zdb container (type: '%s'): %s", typ, err)
+		}
+
+		if err == nil {
+			break
+		}
+	}
+
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to allocate rootfs for zdb container: %s", err)
 	}
 
 	cleanup := func() {

pkg/storage.go

@@ -33,6 +33,15 @@ func (e ErrNotEnoughSpace) Error() string {
 	return fmt.Sprintf("Not enough space left in pools of this type %s", e.DeviceType)
 }
 
+// ErrInvalidDeviceType raised when trying to allocate space on unsupported device type
+type ErrInvalidDeviceType struct {
+	DeviceType DeviceType
+}
+
+func (e ErrInvalidDeviceType) Error() string {
+	return fmt.Sprintf("invalid device type '%s'. type unknown", e.DeviceType)
+}
+
 // DeviceType is the actual type of hardware that the storage device runs on,
 // i.e. SSD or HDD
 type DeviceType string

pkg/storage/storage.go

@@ -442,6 +442,10 @@ func (s *storageModule) ensureCache() error {
 func (s *storageModule) createSubvol(size uint64, name string, poolType pkg.DeviceType) (filesystem.Volume, error) {
 	var err error
 
+	if poolType != pkg.HDDDevice && poolType != pkg.SSDDevice {
+		return nil, pkg.ErrInvalidDeviceType{DeviceType: poolType}
+	}
+
 	type Candidate struct {
 		Pool      filesystem.Pool
 		Available uint64

pkg/storage/zdb.go

@@ -57,6 +57,10 @@ func (s *storageModule) Allocate(nsID string, diskType pkg.DeviceType, size uint
 		Str("mode", string(mode)).
 		Logger()
 
+	if diskType != pkg.HDDDevice && diskType != pkg.SSDDevice {
+		return allocation, pkg.ErrInvalidDeviceType{DeviceType: diskType}
+	}
+
 	log.Info().Msg("try to allocation space for 0-DB")
 
 	for _, pool := range s.volumes {