fix merge conflicts with latest master

cmd/migrate/keyrotate/rotate.go

@@ -127,7 +127,7 @@ func rotateClusterModel(db *_gorm.DB, oldKey, newKey *[32]byte) error {
 	for i := 0; i < (int(count)/stepSize)+1; i++ {
 		clusters := []*models.Cluster{}
 
-		if err := db.Order("id asc").Offset(i * stepSize).Limit(stepSize).Preload("TokenCache").Find(&clusters).Error; err != nil {
+		if err := db.Order("id asc").Offset(i * stepSize).Limit(stepSize).Find(&clusters).Error; err != nil {
 			return err
 		}
 
@@ -143,8 +143,10 @@ func rotateClusterModel(db *_gorm.DB, oldKey, newKey *[32]byte) error {
 
 				// in these cases we'll wipe the data -- if it can't be decrypted, we can't
 				// recover it
-				cluster.CertificateAuthorityData = []byte{}
-				cluster.TokenCache.Token = []byte{}
+				if err := db.Unscoped().Where("id = ?", cluster.TokenCacheID).Delete(&ints.ClusterTokenCache{}).Error; err != nil {
+					return err
+				}
+				cluster.TokenCacheID = 0
 			}
 		}
 

cmd/migrate/main.go

@@ -39,6 +39,15 @@ func main() {
 		return
 	}
 
+	if err := db.Raw("ALTER TABLE clusters DROP CONSTRAINT IF EXISTS fk_cluster_token_caches").Error; err != nil {
+		logger.Fatal().Err(err).Msg("")
+		return
+	}
+	if err := db.Raw("ALTER TABLE cluster_token_caches DROP CONSTRAINT IF EXISTS fk_clusters_token_cache").Error; err != nil {
+		logger.Fatal().Err(err).Msg("")
+		return
+	}
+
 	if shouldRotate, oldKeyStr, newKeyStr := shouldKeyRotate(); shouldRotate {
 		oldKey := [32]byte{}
 		newKey := [32]byte{}

internal/adapter/gorm.go

@@ -2,8 +2,12 @@ package adapter
 
 import (
 	"fmt"
+	"log"
+	"os"
 	"time"
 
+	"gorm.io/gorm/logger"
+
 	"github.com/porter-dev/porter/api/server/shared/config/env"
 	"gorm.io/driver/postgres"
 	"gorm.io/driver/sqlite"
@@ -12,12 +16,22 @@ import (
 
 // New returns a new gorm database instance
 func New(conf *env.DBConf) (*gorm.DB, error) {
+	logger := logger.New(
+		log.New(os.Stdout, "\r\n", log.LstdFlags),
+		logger.Config{
+			SlowThreshold: time.Second,
+			LogLevel:      logger.Silent,
+			Colorful:      false,
+		},
+	)
+
 	if conf.SQLLite {
 		// we add DisableForeignKeyConstraintWhenMigrating since our sqlite does
 		// not support foreign key constraints
 		return gorm.Open(sqlite.Open(conf.SQLLitePath), &gorm.Config{
 			DisableForeignKeyConstraintWhenMigrating: true,
 			FullSaveAssociations:                     true,
+			Logger:                                   logger,
 		})
 	}
 
@@ -41,6 +55,7 @@ func New(conf *env.DBConf) (*gorm.DB, error) {
 
 	defaultDB, err := gorm.Open(postgres.Open(postgresDSN), &gorm.Config{
 		FullSaveAssociations: true,
+		Logger:               logger,
 	})
 
 	// attempt to create the database
@@ -51,6 +66,7 @@ func New(conf *env.DBConf) (*gorm.DB, error) {
 	// open the database connection
 	res, err := gorm.Open(postgres.Open(targetDSN), &gorm.Config{
 		FullSaveAssociations: true,
+		Logger:               logger,
 	})
 
 	// retry the connection 3 times
@@ -62,6 +78,7 @@ func New(conf *env.DBConf) (*gorm.DB, error) {
 			time.Sleep(timeout)
 			res, err = gorm.Open(postgres.Open(targetDSN), &gorm.Config{
 				FullSaveAssociations: true,
+				Logger:               logger,
 			})
 
 			if retryCount > 3 {

internal/models/cluster.go

@@ -63,7 +63,8 @@ type Cluster struct {
 	DOIntegrationID   uint
 
 	// A token cache that can be used by an auth mechanism, if desired
-	TokenCache integrations.ClusterTokenCache `json:"token_cache"`
+	TokenCache   integrations.ClusterTokenCache `json:"token_cache" gorm:"-" sql:"-"`
+	TokenCacheID uint                           `gorm:"token_cache_id"`
 
 	// CertificateAuthorityData for the cluster, encrypted at rest
 	CertificateAuthorityData []byte `json:"certificate-authority-data,omitempty"`

internal/repository/gorm/cluster.go

@@ -144,13 +144,15 @@ func (repo *ClusterRepository) CreateCluster(
 	}
 
 	// create a token cache by default
-	assoc = ctxDB.Model(cluster).Association("TokenCache")
+	cluster.TokenCache.ClusterID = cluster.ID
 
-	if assoc.Error != nil {
-		return nil, assoc.Error
+	if err := ctxDB.Create(&cluster.TokenCache).Error; err != nil {
+		return nil, err
 	}
 
-	if err := assoc.Append(&cluster.TokenCache); err != nil {
+	cluster.TokenCacheID = cluster.TokenCache.ID
+
+	if err := ctxDB.Save(cluster).Error; err != nil {
 		return nil, err
 	}
 
@@ -172,10 +174,20 @@ func (repo *ClusterRepository) ReadCluster(
 	cluster := &models.Cluster{}
 
 	// preload Clusters association
-	if err := ctxDB.Preload("TokenCache").Where("project_id = ? AND id = ?", projectID, clusterID).First(&cluster).Error; err != nil {
+	if err := ctxDB.Debug().Where("project_id = ? AND id = ?", projectID, clusterID).First(&cluster).Error; err != nil {
 		return nil, err
 	}
 
+	cache := ints.ClusterTokenCache{}
+
+	if cluster.TokenCacheID != 0 {
+		if err := ctxDB.Where("id = ?", cluster.TokenCacheID).First(&cache).Error; err != nil {
+			return nil, err
+		}
+	}
+
+	cluster.TokenCache = cache
+
 	err := repo.DecryptClusterData(cluster, repo.key)
 
 	if err != nil {
@@ -252,17 +264,29 @@ func (repo *ClusterRepository) UpdateClusterTokenCache(
 		return nil, err
 	}
 
-	// delete the existing token cache first
-	if err := ctxDB.Where("id = ?", tokenCache.ID).Unscoped().Delete(&cluster.TokenCache).Error; err != nil {
-		return nil, err
-	}
+	if cluster.TokenCacheID == 0 {
+		tokenCache.ClusterID = cluster.ID
+		if err := ctxDB.Create(tokenCache).Error; err != nil {
+			return nil, err
+		}
+		cluster.TokenCacheID = tokenCache.ID
+		if err := ctxDB.Save(cluster).Error; err != nil {
+			return nil, err
+		}
+	} else {
+		prev := &ints.ClusterTokenCache{}
 
-	// set the new token cache
-	cluster.TokenCache.Token = tokenCache.Token
-	cluster.TokenCache.Expiry = tokenCache.Expiry
+		if err := ctxDB.Where("id = ?", cluster.TokenCacheID).First(prev).Error; err != nil {
+			return nil, err
+		}
 
-	if err := ctxDB.Save(cluster).Error; err != nil {
-		return nil, err
+		prev.Token = tokenCache.Token
+		prev.Expiry = tokenCache.Expiry
+		prev.ClusterID = cluster.ID
+
+		if err := ctxDB.Save(prev).Error; err != nil {
+			return nil, err
+		}
 	}
 
 	return cluster, nil
@@ -273,16 +297,9 @@ func (repo *ClusterRepository) DeleteCluster(
 	cluster *models.Cluster,
 ) error {
 	// clear TokenCache association
-	assoc := repo.db.Model(cluster).Association("TokenCache")
-
-	if assoc.Error != nil {
-		return assoc.Error
-	}
-
-	if err := assoc.Clear(); err != nil {
+	if err := repo.db.Where("id = ?", cluster.TokenCacheID).Delete(&ints.TokenCache{}).Error; err != nil {
 		return err
 	}
-
 	if err := repo.db.Where("id = ?", cluster.ID).Delete(&models.Cluster{}).Error; err != nil {
 		return err
 	}