Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

5.0 KB
Raw Blame
package repo

import (
	"context"
	"database/sql"
	"errors"
	"fmt"

	"github.com/ente/stacktrace"

	"github.com/ente/museum/ente"
	"github.com/ente/museum/pkg/utils/time"
)

// ObjectCleanupRepository maintains state related to objects that might need to
// be cleaned up.
//
// In particular, all presigned urls start their life as a "temp object" that is
// liable to be cleaned up if not marked as a successful upload by the client.
type ObjectCleanupRepository struct {
	DB *sql.DB
}

func (repo *ObjectCleanupRepository) AddTempObject(tempObject ente.TempObject, expirationTime int64) error {
	_, err := repo.DB.Exec(`
		INSERT INTO temp_objects (
		    object_key, expiration_time, upload_id, is_multipart, bucket_id,
		    user_id, app, purpose, content_length, content_md5, client
		) VALUES ($1, $2, NULLIF($3, ''), $4, $5, NULLIF($6::BIGINT, 0), NULLIF($7, ''), NULLIF($8, ''), $9, $10, NULLIF($11, ''))`,
		tempObject.ObjectKey, expirationTime, tempObject.UploadID, tempObject.IsMultipart, tempObject.BucketId,
		tempObject.UserID, tempObject.App, tempObject.Purpose, tempObject.ContentLength, tempObject.ContentMD5, tempObject.Client)
	return stacktrace.Propagate(err, "")
}

func (repo *ObjectCleanupRepository) ConsumeFileUpload(ctx context.Context, tx *sql.Tx, objectKey string, userID int64, app ente.App) error {
	res, err := tx.ExecContext(ctx, `DELETE FROM temp_objects WHERE object_key = $1
		AND (user_id IS NULL OR user_id = $2)
		AND (app IS NULL OR app = $3)
		AND (purpose IS NULL OR purpose = 'file_upload')`, objectKey, userID, app)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	rowsAffected, err := res.RowsAffected()
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	if rowsAffected != 1 {
		return stacktrace.Propagate(ente.NewBadRequestWithMessage("staged upload not found"), "")
	}
	return nil
}

func (repo *ObjectCleanupRepository) RemoveTempObjectFromDC(ctx context.Context, tx *sql.Tx, objectKey string, dc string) error {
	res, err := tx.ExecContext(ctx, `DELETE FROM temp_objects WHERE object_key = $1 and bucket_id = $2`, objectKey, dc)
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	rowsAffected, err := res.RowsAffected()
	if err != nil {
		return stacktrace.Propagate(err, "")
	}
	if rowsAffected != 1 {
		return stacktrace.Propagate(fmt.Errorf("only one row should be affected not %d", rowsAffected), "")
	}
	return nil
}

func (repo *ObjectCleanupRepository) DoesTempObjectExist(ctx context.Context, objectKey string, uploadID string) (bool, error) {
	var exists bool
	query := `SELECT EXISTS(SELECT 1 FROM temp_objects WHERE object_key = $1 AND upload_id = $2)`
	err := repo.DB.QueryRowContext(ctx, query, objectKey, uploadID).Scan(&exists)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return false, nil
		}
		return false, stacktrace.Propagate(err, "failed to check if temp object exists")
	}
	return exists, nil
}

func (repo *ObjectCleanupRepository) GetAndLockExpiredObjects() (*sql.Tx, []ente.TempObject, error) {
	tx, err := repo.DB.Begin()
	if err != nil {
		return nil, nil, stacktrace.Propagate(err, "")
	}

	transferred := false
	defer func() {
		if !transferred {
			_ = tx.Rollback()
		}
	}()

	rows, err := tx.Query(`
	SELECT object_key, is_multipart, upload_id, bucket_id FROM temp_objects
	WHERE expiration_time <= $1
	LIMIT 1000
	FOR UPDATE SKIP LOCKED
	`, time.Microseconds())

	if err != nil {
		return nil, nil, stacktrace.Propagate(err, "")
	}

	defer rows.Close()
	tempObjects := make([]ente.TempObject, 0)
	for rows.Next() {
		var tempObject ente.TempObject
		var uploadID sql.NullString
		var bucketID sql.NullString
		err := rows.Scan(&tempObject.ObjectKey, &tempObject.IsMultipart, &uploadID, &bucketID)
		if err != nil {
			return nil, nil, stacktrace.Propagate(err, "")
		}
		if tempObject.IsMultipart {
			tempObject.UploadID = uploadID.String
		}
		if bucketID.Valid {
			tempObject.BucketId = bucketID.String
		}
		tempObjects = append(tempObjects, tempObject)
	}
	if err := rows.Err(); err != nil {
		return nil, nil, stacktrace.Propagate(err, "")
	}
	transferred = true
	return tx, tempObjects, nil
}

func (repo *ObjectCleanupRepository) SetExpiryForTempObject(tx *sql.Tx, tempObject ente.TempObject, expirationTime int64) error {
	if tempObject.IsMultipart {
		_, err := tx.Exec(`
			UPDATE temp_objects SET expiration_time = $1 WHERE object_key = $2 AND upload_id = $3
			`, expirationTime, tempObject.ObjectKey, tempObject.UploadID)
		return stacktrace.Propagate(err, "")
	} else {
		_, err := tx.Exec(`
			UPDATE temp_objects SET expiration_time = $1 WHERE object_key = $2
			`, expirationTime, tempObject.ObjectKey)
		return stacktrace.Propagate(err, "")
	}
}

func (repo *ObjectCleanupRepository) RemoveTempObject(tx *sql.Tx, tempObject ente.TempObject) error {
	if tempObject.IsMultipart {
		_, err := tx.Exec(`
			DELETE FROM temp_objects WHERE object_key = $1 AND upload_id = $2
			`, tempObject.ObjectKey, tempObject.UploadID)
		return stacktrace.Propagate(err, "")
	} else {
		_, err := tx.Exec(`
			DELETE FROM temp_objects WHERE object_key = $1
			`, tempObject.ObjectKey)
		return stacktrace.Propagate(err, "")
	}
}