save device type instead of caching it

pkg/cache/cache.go

@@ -13,7 +13,7 @@ const (
 
 // VolatileDir creates a new cache directory that is stored on a tmpfs.
 // This means data stored in this directory will NOT survive a reboot.
-// Use this when you need to store data that needs to survice deamon reboot but not between reboots
+// Use this when you need to store data that needs to survive deamon reboot but not between reboots
 // It is the caller's responsibility to remove the directory when no longer needed.
 // If the directory already exist error of type os.IsExist will be returned
 func VolatileDir(name string, size uint64) (string, error) {

pkg/storage/filesystem/device.go

@@ -4,12 +4,14 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
 
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog/log"
+	"github.com/threefoldtech/zos/pkg"
 	"github.com/threefoldtech/zos/pkg/gridtypes/zos"
 )
 
@@ -68,10 +70,38 @@ func (i *DeviceInfo) Used() bool {
 	return len(i.Label) != 0 || len(i.Filesystem) != 0
 }
 
-func (d *DeviceInfo) Type() (zos.DeviceType, error) {
+// DetectType returns the device type according to seektime
+func (d *DeviceInfo) DetectType() (zos.DeviceType, error) {
 	return d.mgr.Seektime(context.Background(), d.Path)
 }
 
+// SetType sets the device type to the disk
+func (d *DeviceInfo) SetType(typ pkg.DeviceType) error {
+	if err := os.WriteFile(filepath.Join("/mnt", d.Name(), ".seektime"), []byte(typ), 0644); err != nil {
+		return errors.Wrapf(err, "failed to store device type for '%s'", d.Name())
+	}
+
+	return nil
+}
+
+// Type gets the device type from the disk
+func (d *DeviceInfo) Type() (zos.DeviceType, bool, error) {
+	data, err := os.ReadFile(filepath.Join("/mnt", d.Name(), ".seektime"))
+	if os.IsNotExist(err) {
+		return "", false, nil
+	}
+
+	if err != nil {
+		return "", false, err
+	}
+
+	if len(data) == 0 {
+		return "", false, nil
+	}
+
+	return pkg.DeviceType(data), true, nil
+}
+
 func (d *DeviceInfo) Mountpoint(ctx context.Context) (string, error) {
 	return d.mgr.Mountpoint(ctx, d.Path)
 }

pkg/storage/filesystem/device_test.go

@@ -76,7 +76,7 @@ func TestDeviceManagerScan(t *testing.T) {
 	// make sure all types are set.
 	expected := []zos.DeviceType{zos.SSDDevice, zos.HDDDevice}
 	for i, dev := range cached {
-		typ, err := dev.Type()
+		typ, err := dev.DetectType()
 		require.NoError(err)
 		require.Equal(expected[i], typ)
 	}

pkg/storage/storage.go

@@ -65,14 +65,6 @@ type TypeCache struct {
 	base string
 }
 
-func (t *TypeCache) Set(name string, typ pkg.DeviceType) error {
-	if err := os.WriteFile(filepath.Join(t.base, name), []byte(typ), 0644); err != nil {
-		return errors.Wrapf(err, "failed to store device type for '%s'", name)
-	}
-
-	return nil
-}
-
 func (t *TypeCache) Get(name string) (pkg.DeviceType, bool) {
 	data, err := os.ReadFile(filepath.Join(t.base, name))
 	if err != nil {
@@ -157,6 +149,50 @@ func (s *Module) dump() {
 
 }
 
+// deviceType gets the device type of a disk
+func (s *Module) deviceType(device filesystem.DeviceInfo, vm bool) (zos.DeviceType, error) {
+	var typ zos.DeviceType
+
+	// for development purposes only
+	if vm {
+		// force ssd device for vms
+		typ = zos.SSDDevice
+
+		if device.Path == "/dev/vdd" || device.Path == "/dev/vde" {
+			typ = zos.HDDDevice
+		}
+		return typ, nil
+	}
+
+	log.Debug().Str("device", device.Path).Msg("checking device type in disk")
+	typ, ok, err := device.Type()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to get device type")
+	}
+
+	if ok {
+		log.Debug().Str("device", device.Path).Str("type", typ.String()).Msg("device type loaded from disk")
+		return typ, nil
+	}
+
+	log.Debug().Str("device", device.Path).Msg("checking device type in cache")
+	typ, ok = s.cache.Get(device.Name())
+	if !ok {
+		log.Debug().Str("device", device.Path).Msg("detecting device type")
+		typ, err = device.DetectType()
+		if err != nil {
+			return "", errors.Wrap(err, "failed to detect device type")
+		}
+	}
+
+	log.Debug().Str("device", device.Path).Str("type", typ.String()).Msg("setting device type")
+	if err := device.SetType(typ); err != nil {
+		return "", errors.Wrap(err, "failed to set device type")
+	}
+
+	return typ, nil
+}
+
 /*
 *
 initialize, must be called at least onetime each boot.
@@ -206,31 +242,11 @@ func (s *Module) initialize(ctx context.Context) error {
 			log.Error().Err(err).Str("pool", pool.Name()).Str("device", device.Path).Msg("failed to get usage of pool")
 		}
 
-		typ, ok := s.cache.Get(device.Name())
-		if !ok {
-			log.Debug().Str("device", device.Path).Msg("detecting device type")
-			typ, err = device.Type()
-			if err != nil {
-				log.Error().Str("device", device.Path).Err(err).Msg("failed to check device type")
-				continue
-			}
-
-			// for development purposes only
-			if vm {
-				// force ssd device for vms
-				typ = zos.SSDDevice
-
-				if device.Path == "/dev/vdd" || device.Path == "/dev/vde" {
-					typ = zos.HDDDevice
-				}
-			}
-
-			log.Debug().Str("device", device.Path).Str("type", typ.String()).Msg("caching device type")
-			if err := s.cache.Set(device.Name(), typ); err != nil {
-				log.Error().Str("device", device.Path).Err(err).Msg("failed to cache device type")
-			}
-		} else {
-			log.Debug().Str("device", device.Path).Str("type", typ.String()).Msg("device type loaded from cache")
+		typ, err := s.deviceType(device, vm)
+		if err != nil {
+			log.Error().Str("device", device.Path).Err(err).Msg("failed to get device type")
+			s.brokenDevices = append(s.brokenDevices, pkg.BrokenDevice{Path: device.Path, Err: err})
+			continue
 		}
 
 		switch typ {