refactor(motion): convert singularity to option

blob/blob.go

@@ -25,6 +25,8 @@ type (
 		ModificationTime time.Time
 	}
 	Store interface {
+		Start(context.Context) error
+		Shutdown(context.Context) error
 		Put(context.Context, io.ReadCloser) (*Descriptor, error)
 		Get(context.Context, ID) (io.ReadSeekCloser, *Descriptor, error)
 	}

blob/local_store.go

@@ -54,6 +54,14 @@ func NewLocalStore(dir string) *LocalStore {
 	}
 }
 
+func (l *LocalStore) Start(_ context.Context) error {
+	return nil
+}
+
+func (l *LocalStore) Shutdown(_ context.Context) error {
+	return nil
+}
+
 // Put reads the given reader fully and stores its content in the store directory as flat files.
 // The reader content is first stored in a temporary directory and upon successful storage is moved to the store directory.
 // The Descriptor.ModificationTime is set to the modification date of the file that corresponds to the content.

blob/singularity_store.go

@@ -14,6 +14,7 @@ import (
 )
 
 type SingularityService interface {
+	Start(ctx context.Context, dir string) error
 	GetItem(ctx context.Context, id uint64) (*model.Item, error)
 	PushItem(ctx context.Context, path string) (*model.Item, error)
 }
@@ -23,13 +24,31 @@ type SingularityStore struct {
 	singularity SingularityService
 }
 
+func OpenSingularityStore(dir string) (*SingularityStore, error) {
+	dbFile := path.Join(path.Clean(dir), "singularity.db")
+	singularityService, err := singularity.OpenSQLiteSingularity(dbFile)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open singularity database: %w")
+	}
+	local := NewLocalStore(dir)
+	return NewSingularityStore(local, singularityService), nil
+}
+
 func NewSingularityStore(local *LocalStore, singularity SingularityService) *SingularityStore {
 	return &SingularityStore{
 		local:       local,
 		singularity: singularity,
 	}
 }
 
+func (l *SingularityStore) Start(ctx context.Context) error {
+	return l.singularity.Start(ctx, l.local.dir)
+}
+
+func (l *SingularityStore) Shutdown(_ context.Context) error {
+	return nil
+}
+
 func (s *SingularityStore) Put(ctx context.Context, reader io.ReadCloser) (*Descriptor, error) {
 	desc, err := s.local.Put(ctx, reader)
 	if err != nil {

cmd/motion/main.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/filecoin-project/motion"
 	"github.com/filecoin-project/motion/blob"
-	"github.com/filecoin-project/motion/singularity"
 	"github.com/ipfs/go-log/v2"
 	"github.com/urfave/cli/v2"
 )
@@ -28,35 +27,34 @@ func main() {
 				Value:       os.TempDir(),
 				EnvVars:     []string{"MOTION_STORE_DIR"},
 			},
-			&cli.StringFlag{
-				Name:        "dbFile",
-				Usage:       "file path for sqlite database",
-				DefaultText: "in memory db",
-				Value:       "",
-				EnvVars:     []string{"MOTION_STORE_DIR"},
+			&cli.BoolFlag{
+				Name:        "experimentalSingularityStore",
+				Usage:       "whether to use experimental Singularity store as the storage and deal making engine",
+				DefaultText: "Local storage is used",
 			},
 		},
 		Action: func(cctx *cli.Context) error {
 			storeDir := cctx.String("storeDir")
-			logger.Infow("Using local blob store", "storeDir", storeDir)
-			dbFile := cctx.String("dbFile")
-			ctx := cctx.Context
-
-			singularityService, err := initializeSingularity(dbFile)
-			if err != nil {
-				logger.Fatalw("Failed to open singularity database", "err", err)
-			}
-			err = singularityService.Start(ctx, storeDir)
-			if err != nil {
-				logger.Fatalw("Failed to setup singularity for motion", "err", err)
+			var store blob.Store
+			if cctx.Bool("experimentalSingularityStore") {
+				var err error
+				store, err = blob.OpenSingularityStore(storeDir)
+				if err != nil {
+					return err
+				}
+				logger.Infow("Using Singularity blob store", "storeDir", storeDir)
+			} else {
+				store = blob.NewLocalStore(storeDir)
+				logger.Infow("Using local blob store", "storeDir", storeDir)
 			}
-			local := blob.NewLocalStore(storeDir)
+
 			m, err := motion.New(
-				motion.WithBlobStore(blob.NewSingularityStore(local, singularityService)),
+				motion.WithBlobStore(store),
 			)
 			if err != nil {
 				logger.Fatalw("Failed to instantiate Motion", "err", err)
 			}
+			ctx := cctx.Context
 
 			if err := m.Start(ctx); err != nil {
 				logger.Fatalw("Failed to start Motion", "err", err)
@@ -77,14 +75,3 @@ func main() {
 		logger.Error(err)
 	}
 }
-
-func initializeSingularity(dbFile string) (*singularity.LocalSingularity, error) {
-
-	if dbFile != "" {
-		logger.Infow("Using SQLite database file", "dbFile", dbFile)
-		return singularity.OpenSQLiteSingularity(dbFile)
-	} else {
-		return singularity.OpenMemorySingularity()
-	}
-
-}

motion.go

@@ -36,10 +36,16 @@ func New(o ...Option) (*Motion, error) {
 // Start starts the motion services.
 func (m *Motion) Start(ctx context.Context) error {
 	// TODO start other components like deal engine, wallets etc.
+	if err := m.blobStore.Start(ctx); err != nil {
+		return err
+	}
 	return m.httpServer.Start(ctx)
 }
 
 // Shutdown Start shuts down the motion services.
 func (m *Motion) Shutdown(ctx context.Context) error {
+	if err := m.blobStore.Shutdown(ctx); err != nil {
+		return err
+	}
 	return m.httpServer.Shutdown(ctx)
 }

singularity/local.go

@@ -54,6 +54,11 @@ func NewLocalSingularity(db *gorm.DB) *LocalSingularity {
 }
 
 func (l *LocalSingularity) Start(ctx context.Context, dir string) error {
+	// migrate the db
+	if err := model.AutoMigrate(l.db); err != nil {
+		return err
+	}
+
 	// insure the creation of the default dataset, source, and root directory
 	return database.DoRetry(func() error {
 		return l.db.Transaction(func(db *gorm.DB) error {