Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

refactoring: cleaner usage of blob storage (#684)

Guilherme Oenninga6b0af153bfd
diff --git a/.test.env b/.test.env
index 5b8aa2733..5bad92c7a 100644
--- a/.test.env
+++ b/.test.env
@@ -5,11 +5,12 @@ DATABASE_URL=postgres://fider_test:fider_test_pw@localhost:5566/fider_test?sslmo
HOST_DOMAIN=test.fider.io
JWT_SECRET=SOME_RANDOM_TOKEN_JUST_FOR_TESTING
-S3_ENDPOINT_URL=http://localhost:9000
-S3_REGION=us-east-1
-S3_ACCESS_KEY_ID=s3user
-S3_SECRET_ACCESS_KEY=s3user-s3cr3t
-S3_BUCKET=test-bucket
+BLOB_STORAGE=s3
+BLOB_STORAGE_S3_ENDPOINT_URL=http://localhost:9000
+BLOB_STORAGE_S3_REGION=us-east-1
+BLOB_STORAGE_S3_ACCESS_KEY_ID=s3user
+BLOB_STORAGE_S3_SECRET_ACCESS_KEY=s3user-s3cr3t
+BLOB_STORAGE_S3_BUCKET=test-bucket
CDN_HOST=
diff --git a/app/actions/actions_test.go b/app/actions/actions_test.go
index adfa81cfd..ae4b82fe7 100644
--- a/app/actions/actions_test.go
+++ b/app/actions/actions_test.go
@@ -3,6 +3,8 @@ package actions_test
import (
"github.com/getfider/fider/app"
. "github.com/getfider/fider/app/pkg/assert"
+ "github.com/getfider/fider/app/pkg/blob/fs"
+ "github.com/getfider/fider/app/pkg/env"
"github.com/getfider/fider/app/pkg/jwt"
"github.com/getfider/fider/app/pkg/validate"
"github.com/getfider/fider/app/storage/inmemory"
@@ -21,6 +23,7 @@ var services = &app.Services{
Posts: inmemory.NewPostStorage(),
Tags: inmemory.NewTagStorage(),
Notifications: inmemory.NewNotificationStorage(),
+ Blobs: fs.NewStorage(env.Path("tmp")),
}
func ExpectFailed(result *validate.Result, expectedFields ...string) {
diff --git a/app/middlewares/setup.go b/app/middlewares/setup.go
index eac5812ba..2afc63af7 100644
--- a/app/middlewares/setup.go
+++ b/app/middlewares/setup.go
@@ -5,11 +5,7 @@ import (
"time"
"github.com/getfider/fider/app"
- "github.com/getfider/fider/app/pkg/email"
- "github.com/getfider/fider/app/pkg/email/mailgun"
- "github.com/getfider/fider/app/pkg/email/noop"
- "github.com/getfider/fider/app/pkg/email/smtp"
- "github.com/getfider/fider/app/pkg/env"
+ "github.com/getfider/fider/app/pkg/di"
"github.com/getfider/fider/app/pkg/log"
"github.com/getfider/fider/app/pkg/web"
"github.com/getfider/fider/app/pkg/web/util"
@@ -70,7 +66,8 @@ func WorkerSetup() worker.MiddlewareFunc {
Posts: postgres.NewPostStorage(trx),
Tags: postgres.NewTagStorage(trx),
Notifications: postgres.NewNotificationStorage(trx),
- Emailer: newEmailer(c.Logger()),
+ Emailer: di.NewEmailer(c.Logger()),
+ Blobs: di.NewBlobStorage(trx),
})
//Execute the chain
@@ -157,7 +154,8 @@ func WebSetup() web.MiddlewareFunc {
Posts: postgres.NewPostStorage(trx),
Tags: postgres.NewTagStorage(trx),
Notifications: postgres.NewNotificationStorage(trx),
- Emailer: newEmailer(c.Logger()),
+ Emailer: di.NewEmailer(c.Logger()),
+ Blobs: di.NewBlobStorage(trx),
})
//Execute the chain
@@ -194,19 +192,3 @@ func WebSetup() web.MiddlewareFunc {
}
}
}
-
-func newEmailer(logger log.Logger) email.Sender {
- if env.IsTest() {
- return noop.NewSender()
- }
- if env.IsDefined("EMAIL_MAILGUN_API") {
- return mailgun.NewSender(logger, web.NewHTTPClient(), env.MustGet("EMAIL_MAILGUN_DOMAIN"), env.MustGet("EMAIL_MAILGUN_API"))
- }
- return smtp.NewSender(
- logger,
- env.MustGet("EMAIL_SMTP_HOST"),
- env.MustGet("EMAIL_SMTP_PORT"),
- env.GetEnvOrDefault("EMAIL_SMTP_USERNAME", ""),
- env.GetEnvOrDefault("EMAIL_SMTP_PASSWORD", ""),
- )
-}
diff --git a/app/pkg/blob/blob.go b/app/pkg/blob/blob.go
index 07e248376..0cb177007 100644
--- a/app/pkg/blob/blob.go
+++ b/app/pkg/blob/blob.go
@@ -34,12 +34,8 @@ func ValidateKey(key string) error {
// Storage is how Fider persists blobs
type Storage interface {
- NewSession(tenant *models.Tenant) Session
-}
-
-// Session is a per-request object to interact with the storage
-type Session interface {
+ SetCurrentTenant(tenant *models.Tenant)
Get(key string) (*Blob, error)
Delete(key string) error
- Store(b *Blob) error
+ Put(key string, content []byte, contentType string) error
}
diff --git a/app/pkg/blob/blob_test.go b/app/pkg/blob/blob_test.go
index bbfa2d5c3..412aaab2f 100644
--- a/app/pkg/blob/blob_test.go
+++ b/app/pkg/blob/blob_test.go
@@ -3,12 +3,9 @@ package blob_test
import (
"io/ioutil"
"os"
- "strings"
"testing"
"github.com/aws/aws-sdk-go/aws"
- "github.com/aws/aws-sdk-go/aws/credentials"
- "github.com/aws/aws-sdk-go/aws/session"
awss3 "github.com/aws/aws-sdk-go/service/s3"
"github.com/getfider/fider/app/pkg/errors"
@@ -33,33 +30,15 @@ var tenant2 = &models.Tenant{ID: 2}
func setupS3(t *testing.T) *s3.Storage {
RegisterT(t)
- endpointURL := env.GetEnvOrDefault("S3_ENDPOINT_URL", "")
- region := env.GetEnvOrDefault("S3_REGION", "")
- accessKeyID := env.GetEnvOrDefault("S3_ACCESS_KEY_ID", "")
- secretAccessKey := env.GetEnvOrDefault("S3_SECRET_ACCESS_KEY", "")
- bucket := env.GetEnvOrDefault("S3_BUCKET", "")
-
- s3Config := &aws.Config{
- Credentials: credentials.NewStaticCredentials(accessKeyID, secretAccessKey, ""),
- Endpoint: aws.String(endpointURL),
- Region: aws.String(region),
- DisableSSL: aws.Bool(strings.HasSuffix(endpointURL, "http://")),
- S3ForcePathStyle: aws.Bool(true),
- }
-
- awsSession := session.New(s3Config)
- s3Client := awss3.New(awsSession)
- s3Client.DeleteBucket(&awss3.DeleteBucketInput{
+ bucket := "test-bucket"
+ s3.DefaultClient.DeleteBucket(&awss3.DeleteBucketInput{
Bucket: aws.String(bucket),
})
- s3Client.CreateBucket(&awss3.CreateBucketInput{
+ s3.DefaultClient.CreateBucket(&awss3.CreateBucketInput{
Bucket: aws.String(bucket),
})
- client, err := s3.NewStorage(endpointURL, region, accessKeyID, secretAccessKey, bucket)
- Expect(err).IsNil()
-
- return client
+ return s3.NewStorage(bucket)
}
func setupSQL(t *testing.T) *sql.Storage {
@@ -67,24 +46,18 @@ func setupSQL(t *testing.T) *sql.Storage {
db := dbx.New()
db.Seed()
- client, err := sql.NewStorage(db)
+ trx, err := db.Begin()
Expect(err).IsNil()
-
- return client
+ return sql.NewStorage(trx)
}
func setupFS(t *testing.T) *fs.Storage {
RegisterT(t)
- rootFolder := env.Path("tmp/fs_test")
-
- err := os.RemoveAll(rootFolder)
- Expect(err).IsNil()
-
- client, err := fs.NewStorage(rootFolder)
+ err := os.RemoveAll("./tmp/fs_test")
Expect(err).IsNil()
- return client
+ return fs.NewStorage("./tmp/fs_test")
}
type blobTestCase func(client blob.Storage, t *testing.T)
@@ -101,26 +74,26 @@ var tests = []struct {
}
func TestBlobStorage(t *testing.T) {
+ sqlClient := setupSQL(t)
+ s3Client := setupS3(t)
+ fsClient := setupFS(t)
+
for _, tt := range tests {
t.Run("Test_FS_"+tt.name, func(t *testing.T) {
- client := setupFS(t)
- tt.test(client, t)
+ tt.test(fsClient, t)
})
t.Run("Test_S3_"+tt.name, func(t *testing.T) {
- client := setupS3(t)
- tt.test(client, t)
+ tt.test(s3Client, t)
})
t.Run("Test_SQL_"+tt.name, func(t *testing.T) {
- client := setupSQL(t)
- tt.test(client, t)
+ tt.test(sqlClient, t)
})
}
}
func AllOperations(client blob.Storage, t *testing.T) {
- sess := client.NewSession(nil)
var testCases = []struct {
localPath string
key string
@@ -132,62 +105,51 @@ func AllOperations(client blob.Storage, t *testing.T) {
for _, testCase := range testCases {
bytes, _ := ioutil.ReadFile(env.Path(testCase.localPath))
- err := sess.Store(&blob.Blob{
- Key: testCase.key,
- Object: bytes,
- ContentType: testCase.contentType,
- Size: int64(len(bytes)),
- })
+ err := client.Put(testCase.key, bytes, testCase.contentType)
Expect(err).IsNil()
- b, err := sess.Get(testCase.key)
+ b, err := client.Get(testCase.key)
Expect(err).IsNil()
Expect(b.Key).Equals(testCase.key)
Expect(b.Object).Equals(bytes)
Expect(b.Size).Equals(int64(len(bytes)))
Expect(b.ContentType).Equals(testCase.contentType)
- err = sess.Delete(testCase.key)
+ err = client.Delete(testCase.key)
Expect(err).IsNil()
- b, err = sess.Get(testCase.key)
+ b, err = client.Get(testCase.key)
Expect(b).IsNil()
Expect(err).Equals(blob.ErrNotFound)
}
}
func DeleteUnkownFile(client blob.Storage, t *testing.T) {
- sess := client.NewSession(nil)
- err := sess.Delete("path/somefile.txt")
+ err := client.Delete("path/somefile.txt")
Expect(err).IsNil()
}
func SameKey_DifferentTenant(client blob.Storage, t *testing.T) {
- sess := client.NewSession(tenant1)
+ client.SetCurrentTenant(tenant1)
key := "path/to/file3.txt"
bytes, _ := ioutil.ReadFile(env.Path("/app/pkg/blob/testdata/file3.txt"))
- err := sess.Store(&blob.Blob{
- Key: key,
- Object: bytes,
- ContentType: "text/plain; charset=utf-8",
- Size: int64(len(bytes)),
- })
+ err := client.Put(key, bytes, "text/plain; charset=utf-8")
Expect(err).IsNil()
- b, err := sess.Get(key)
+ b, err := client.Get(key)
Expect(err).IsNil()
Expect(b.Object).Equals(bytes)
- sess2 := client.NewSession(tenant2)
+ client.SetCurrentTenant(tenant2)
- b, err = sess2.Get(key)
+ b, err = client.Get(key)
Expect(b).IsNil()
Expect(err).Equals(blob.ErrNotFound)
- sess3 := client.NewSession(nil)
+ client.SetCurrentTenant(nil)
- b, err = sess3.Get(key)
+ b, err = client.Get(key)
Expect(b).IsNil()
Expect(err).Equals(blob.ErrNotFound)
}
@@ -197,50 +159,42 @@ func SameKey_DifferentTenant_Delete(client blob.Storage, t *testing.T) {
bytes1, _ := ioutil.ReadFile(env.Path("/app/pkg/blob/testdata/file.txt"))
bytes2, _ := ioutil.ReadFile(env.Path("/app/pkg/blob/testdata/file3.txt"))
- sess1 := client.NewSession(tenant1)
- sess2 := client.NewSession(tenant2)
-
- err := sess1.Store(&blob.Blob{
- Key: key,
- Object: bytes1,
- ContentType: "text/plain; charset=utf-8",
- Size: int64(len(bytes1)),
- })
+ client.SetCurrentTenant(tenant1)
+ err := client.Put(key, bytes1, "text/plain; charset=utf-8")
Expect(err).IsNil()
- err = sess2.Store(&blob.Blob{
- Key: key,
- Object: bytes2,
- ContentType: "text/plain; charset=utf-8",
- Size: int64(len(bytes2)),
- })
+ client.SetCurrentTenant(tenant2)
+ err = client.Put(key, bytes2, "text/plain; charset=utf-8")
Expect(err).IsNil()
- b, err := sess1.Get(key)
+ client.SetCurrentTenant(tenant1)
+ b, err := client.Get(key)
Expect(err).IsNil()
Expect(b.Object).Equals(len(bytes1))
- b, err = sess2.Get(key)
+ client.SetCurrentTenant(tenant2)
+ b, err = client.Get(key)
Expect(err).IsNil()
Expect(b.Object).Equals(len(bytes2))
- err = sess1.Delete(key)
+ client.SetCurrentTenant(tenant1)
+ err = client.Delete(key)
Expect(err).IsNil()
- b, err = sess2.Get(key)
+ client.SetCurrentTenant(tenant2)
+ b, err = client.Get(key)
Expect(err).IsNil()
Expect(b.Object).Equals(len(bytes2))
Expect(err).IsNil()
- sess3 := client.NewSession(nil)
- b, err = sess3.Get(key)
+ client.SetCurrentTenant(nil)
+ b, err = client.Get(key)
Expect(b).IsNil()
Expect(err).Equals(blob.ErrNotFound)
}
func KeyFormats(client blob.Storage, t *testing.T) {
RegisterT(t)
- sess := client.NewSession(nil)
testCases := []struct {
key string
@@ -281,12 +235,7 @@ func KeyFormats(client blob.Storage, t *testing.T) {
}
for _, testCase := range testCases {
- err := sess.Store(&blob.Blob{
- Key: testCase.key,
- Object: make([]byte, 0),
- ContentType: "text/plain; charset=utf-8",
- Size: 0,
- })
+ err := client.Put(testCase.key, make([]byte, 0), "text/plain; charset=utf-8")
if testCase.valid {
Expect(err).IsNil()
} else {
diff --git a/app/pkg/blob/fs/fs.go b/app/pkg/blob/fs/fs.go
index 744e17392..25e6c7439 100644
--- a/app/pkg/blob/fs/fs.go
+++ b/app/pkg/blob/fs/fs.go
@@ -19,45 +19,36 @@ var _ blob.Storage = (*Storage)(nil)
// Storage stores blobs on FileSystem
type Storage struct {
- path string
-}
-
-// Session is a per-request object to interact with the storage
-type Session struct {
- storage *Storage
- tenant *models.Tenant
+ path string
+ tenant *models.Tenant
}
// NewStorage creates a new FileSystem Storage
-func NewStorage(path string) (*Storage, error) {
+func NewStorage(path string) *Storage {
err := os.MkdirAll(path, perm)
if err != nil {
- return nil, errors.Wrap(err, "failed to create path '%s'", path)
+ panic(errors.Wrap(err, "failed to create path '%s'", path))
}
return &Storage{
- path,
- }, nil
+ path: path,
+ }
}
-// NewSession creates a new session
-func (s *Storage) NewSession(tenant *models.Tenant) blob.Session {
- return &Session{
- storage: s,
- tenant: tenant,
- }
+// SetCurrentTenant to current context
+func (s *Storage) SetCurrentTenant(tenant *models.Tenant) {
+ s.tenant = tenant
}
-func (s *Session) keyFullPath(key string) string {
- fullPath := path.Join(s.storage.path, key)
+func (s *Storage) keyFullPath(key string) string {
if s.tenant != nil {
- fullPath = path.Join("tenants", strconv.Itoa(s.tenant.ID), fullPath)
+ return path.Join(s.path, "tenants", strconv.Itoa(s.tenant.ID), key)
}
- return fullPath
+ return path.Join(s.path, key)
}
// Get returns a blob with given key
-func (s *Session) Get(key string) (*blob.Blob, error) {
+func (s *Storage) Get(key string) (*blob.Blob, error) {
fullPath := s.keyFullPath(key)
stats, err := os.Stat(fullPath)
if err != nil {
@@ -81,7 +72,7 @@ func (s *Session) Get(key string) (*blob.Blob, error) {
}
// Delete a blob with given key
-func (s *Session) Delete(key string) error {
+func (s *Storage) Delete(key string) error {
fullPath := s.keyFullPath(key)
err := os.Remove(fullPath)
if err != nil && !os.IsNotExist(err) {
@@ -90,20 +81,20 @@ func (s *Session) Delete(key string) error {
return nil
}
-// Store a blob with given key and content. Blobs with same key are replaced.
-func (s *Session) Store(b *blob.Blob) error {
- if err := blob.ValidateKey(b.Key); err != nil {
- return errors.Wrap(err, "failed to validate blob key '%s'", b.Key)
+// Put a blob with given key and content. Blobs with same key are replaced.
+func (s *Storage) Put(key string, content []byte, contentType string) error {
+ if err := blob.ValidateKey(key); err != nil {
+ return errors.Wrap(err, "failed to validate blob key '%s'", key)
}
- fullPath := s.keyFullPath(b.Key)
+ fullPath := s.keyFullPath(key)
err := os.MkdirAll(filepath.Dir(fullPath), perm)
if err != nil {
return errors.Wrap(err, "failed to create folder '%s' on FileSystem", fullPath)
}
- err = ioutil.WriteFile(fullPath, b.Object, perm)
+ err = ioutil.WriteFile(fullPath, content, perm)
if err != nil {
return errors.Wrap(err, "failed to create file '%s' on FileSystem", fullPath)
}
diff --git a/app/pkg/blob/s3/s3.go b/app/pkg/blob/s3/s3.go
index 0d7bf9535..705cab513 100644
--- a/app/pkg/blob/s3/s3.go
+++ b/app/pkg/blob/s3/s3.go
@@ -14,6 +14,7 @@ import (
"github.com/aws/aws-sdk-go/service/s3"
"github.com/getfider/fider/app/models"
"github.com/getfider/fider/app/pkg/blob"
+ "github.com/getfider/fider/app/pkg/env"
"github.com/getfider/fider/app/pkg/errors"
)
@@ -21,14 +22,8 @@ var _ blob.Storage = (*Storage)(nil)
// Storage stores blobs on an S3 compatible service
type Storage struct {
- s3Client *s3.S3
- bucket *string
-}
-
-// Session is a per-request object to interact with the storage
-type Session struct {
- storage *Storage
- tenant *models.Tenant
+ bucket *string
+ tenant *models.Tenant
}
func isNotFound(err error) bool {
@@ -38,43 +33,51 @@ func isNotFound(err error) bool {
return false
}
-// NewStorage creates a S3 compatible service storage
-func NewStorage(endpointURL, region, accessKeyID, secretAccessKey, bucket string) (*Storage, error) {
-
- s3Config := &aws.Config{
- Credentials: credentials.NewStaticCredentials(accessKeyID, secretAccessKey, ""),
- Endpoint: aws.String(endpointURL),
- Region: aws.String(region),
- DisableSSL: aws.Bool(strings.HasSuffix(endpointURL, "http://")),
- S3ForcePathStyle: aws.Bool(true),
+//Client is an S3 Client
+var DefaultClient *s3.S3
+
+func init() {
+ endpointURL := env.GetEnvOrDefault("BLOB_STORAGE_S3_ENDPOINT_URL", "")
+ if endpointURL != "" {
+ region := env.GetEnvOrDefault("BLOB_STORAGE_S3_REGION", "")
+ accessKeyID := env.GetEnvOrDefault("BLOB_STORAGE_S3_ACCESS_KEY_ID", "")
+ secretAccessKey := env.GetEnvOrDefault("BLOB_STORAGE_S3_SECRET_ACCESS_KEY", "")
+
+ s3Config := &aws.Config{
+ Credentials: credentials.NewStaticCredentials(accessKeyID, secretAccessKey, ""),
+ Endpoint: aws.String(endpointURL),
+ Region: aws.String(region),
+ DisableSSL: aws.Bool(strings.HasSuffix(endpointURL, "http://")),
+ S3ForcePathStyle: aws.Bool(true),
+ }
+ awsSession := session.New(s3Config)
+ DefaultClient = s3.New(awsSession)
}
- awsSession := session.New(s3Config)
-
- return &Storage{
- s3Client: s3.New(awsSession),
- bucket: aws.String(bucket),
- }, nil
}
-// NewSession creates a new session
-func (s *Storage) NewSession(tenant *models.Tenant) blob.Session {
- return &Session{
- storage: s,
- tenant: tenant,
+// NewStorage creates a S3 compatible service storage
+func NewStorage(bucket string) *Storage {
+ return &Storage{
+ bucket: aws.String(bucket),
}
}
-func (s *Session) keyFullPathURL(key string) string {
+func (s *Storage) keyFullPathURL(key string) string {
if s.tenant != nil {
return path.Join("tenants", strconv.Itoa(s.tenant.ID), key)
}
return key
}
+// SetCurrentTenant to current context
+func (s *Storage) SetCurrentTenant(tenant *models.Tenant) {
+ s.tenant = tenant
+}
+
// Get returns a blob with given key
-func (s *Session) Get(key string) (*blob.Blob, error) {
- resp, err := s.storage.s3Client.GetObject(&s3.GetObjectInput{
- Bucket: s.storage.bucket,
+func (s *Storage) Get(key string) (*blob.Blob, error) {
+ resp, err := DefaultClient.GetObject(&s3.GetObjectInput{
+ Bucket: s.bucket,
Key: aws.String(s.keyFullPathURL(key)),
})
if err != nil {
@@ -99,9 +102,9 @@ func (s *Session) Get(key string) (*blob.Blob, error) {
}
// Delete a blob with given key
-func (s *Session) Delete(key string) error {
- _, err := s.storage.s3Client.DeleteObject(&s3.DeleteObjectInput{
- Bucket: s.storage.bucket,
+func (s *Storage) Delete(key string) error {
+ _, err := DefaultClient.DeleteObject(&s3.DeleteObjectInput{
+ Bucket: s.bucket,
Key: aws.String(s.keyFullPathURL(key)),
})
if err != nil {
@@ -113,22 +116,22 @@ func (s *Session) Delete(key string) error {
return nil
}
-// Store a blob with given key and content. Blobs with same key are replaced.
-func (s *Session) Store(b *blob.Blob) error {
- if err := blob.ValidateKey(b.Key); err != nil {
- return errors.Wrap(err, "failed to validate blob key '%s'", b.Key)
+// Put a blob with given key and content. Blobs with same key are replaced.
+func (s *Storage) Put(key string, content []byte, contentType string) error {
+ if err := blob.ValidateKey(key); err != nil {
+ return errors.Wrap(err, "failed to validate blob key '%s'", key)
}
- reader := bytes.NewReader(b.Object)
- _, err := s.storage.s3Client.PutObject(&s3.PutObjectInput{
- Bucket: s.storage.bucket,
- Key: aws.String(s.keyFullPathURL(b.Key)),
- ContentType: aws.String(b.ContentType),
+ reader := bytes.NewReader(content)
+ _, err := DefaultClient.PutObject(&s3.PutObjectInput{
+ Bucket: s.bucket,
+ Key: aws.String(s.keyFullPathURL(key)),
+ ContentType: aws.String(contentType),
ACL: aws.String(s3.ObjectCannedACLPrivate),
Body: reader,
})
if err != nil {
- return errors.Wrap(err, "failed to upload blob '%s' to S3", b.Key)
+ return errors.Wrap(err, "failed to upload blob '%s' to S3", key)
}
return nil
}
diff --git a/app/pkg/blob/sql/sql.go b/app/pkg/blob/sql/sql.go
index 3a83b8845..9842ce728 100644
--- a/app/pkg/blob/sql/sql.go
+++ b/app/pkg/blob/sql/sql.go
@@ -25,45 +25,31 @@ type dbBlob struct {
// Storage stores blobs on FileSystem
type Storage struct {
- db *dbx.Database
+ trx *dbx.Trx
+ tenant *models.Tenant
}
-// Session is a per-request object to interact with the storage
-type Session struct {
- storage *Storage
- tenant *models.Tenant
-}
-
-// NewStorage creates a new FileSystem Storage
-func NewStorage(db *dbx.Database) (*Storage, error) {
+// NewStorage creates a new SQL Storage
+func NewStorage(trx *dbx.Trx) *Storage {
return &Storage{
- db,
- }, nil
+ trx: trx,
+ }
}
-// NewSession creates a new session
-func (s *Storage) NewSession(tenant *models.Tenant) blob.Session {
- return &Session{
- storage: s,
- tenant: tenant,
- }
+// SetCurrentTenant to current context
+func (s *Storage) SetCurrentTenant(tenant *models.Tenant) {
+ s.tenant = tenant
}
// Get returns a blob with given key
-func (s *Session) Get(key string) (*blob.Blob, error) {
- trx, err := s.storage.db.Begin()
- if err != nil {
- return nil, errors.Wrap(err, "failed to open transaction")
- }
- defer trx.Commit()
-
+func (s *Storage) Get(key string) (*blob.Blob, error) {
var tenantID sql.NullInt64
if s.tenant != nil {
tenantID.Scan(s.tenant.ID)
}
b := dbBlob{}
- err = trx.Get(&b, "SELECT file, content_type, size FROM blobs WHERE key = $1 AND (tenant_id = $2 OR ($2 IS NULL AND tenant_id IS NULL))", key, tenantID)
+ err := s.trx.Get(&b, "SELECT file, content_type, size FROM blobs WHERE key = $1 AND (tenant_id = $2 OR ($2 IS NULL AND tenant_id IS NULL))", key, tenantID)
if err != nil {
if err == app.ErrNotFound {
return nil, blob.ErrNotFound
@@ -80,40 +66,28 @@ func (s *Session) Get(key string) (*blob.Blob, error) {
}
// Delete a blob with given key
-func (s *Session) Delete(key string) error {
- trx, err := s.storage.db.Begin()
- if err != nil {
- return errors.Wrap(err, "failed to open transaction")
- }
-
+func (s *Storage) Delete(key string) error {
var tenantID sql.NullInt64
if s.tenant != nil {
tenantID.Scan(s.tenant.ID)
}
- _, err = trx.Execute("DELETE FROM blobs WHERE key = $1 AND (tenant_id = $2 OR ($2 IS NULL AND tenant_id IS NULL))", key, tenantID)
+ _, err := s.trx.Execute("DELETE FROM blobs WHERE key = $1 AND (tenant_id = $2 OR ($2 IS NULL AND tenant_id IS NULL))", key, tenantID)
if err != nil {
return errors.Wrap(err, "failed to delete blob with key '%s'", key)
}
- err = trx.Commit()
if err != nil {
- defer trx.Rollback()
return errors.Wrap(err, "failed to commit deletion of blob with key '%s'", key)
}
return nil
}
-// Store a blob with given key and content. Blobs with same key are replaced.
-func (s *Session) Store(b *blob.Blob) error {
- if err := blob.ValidateKey(b.Key); err != nil {
- return errors.Wrap(err, "failed to validate blob key '%s'", b.Key)
- }
-
- trx, err := s.storage.db.Begin()
- if err != nil {
- return errors.Wrap(err, "failed to open transaction")
+// Put a blob with given key and content. Blobs with same key are replaced.
+func (s *Storage) Put(key string, content []byte, contentType string) error {
+ if err := blob.ValidateKey(key); err != nil {
+ return errors.Wrap(err, "failed to validate blob key '%s'", key)
}
var tenantID sql.NullInt64
@@ -122,19 +96,17 @@ func (s *Session) Store(b *blob.Blob) error {
}
now := time.Now()
- _, err = trx.Execute(`
+ _, err := s.trx.Execute(`
INSERT INTO blobs (tenant_id, key, size, content_type, file, created_at, modified_at)
VALUES ($1, $2, $3, $4, $5, $6, $7) ON CONFLICT (tenant_id, key)
DO UPDATE SET size = $3, content_type = $4, file = $5, modified_at = $7
- `, tenantID, b.Key, b.Size, b.ContentType, b.Object, now, now)
+ `, tenantID, key, int64(len(content)), contentType, content, now, now)
if err != nil {
- return errors.Wrap(err, "failed to store blob with key '%s'", b.Key)
+ return errors.Wrap(err, "failed to store blob with key '%s'", key)
}
- err = trx.Commit()
if err != nil {
- defer trx.Rollback()
- return errors.Wrap(err, "failed to commit store of blob with key '%s'", b.Key)
+ return errors.Wrap(err, "failed to commit store of blob with key '%s'", key)
}
return nil
diff --git a/app/pkg/di/blob.go b/app/pkg/di/blob.go
new file mode 100644
index 000000000..116b75cd2
--- /dev/null
+++ b/app/pkg/di/blob.go
@@ -0,0 +1,49 @@
+package di
+
+import (
+ "strings"
+
+ "github.com/getfider/fider/app/pkg/blob"
+ "github.com/getfider/fider/app/pkg/blob/fs"
+ "github.com/getfider/fider/app/pkg/blob/s3"
+ "github.com/getfider/fider/app/pkg/blob/sql"
+ "github.com/getfider/fider/app/pkg/dbx"
+ "github.com/getfider/fider/app/pkg/email"
+ "github.com/getfider/fider/app/pkg/email/mailgun"
+ "github.com/getfider/fider/app/pkg/email/noop"
+ "github.com/getfider/fider/app/pkg/email/smtp"
+ "github.com/getfider/fider/app/pkg/env"
+ "github.com/getfider/fider/app/pkg/log"
+ "github.com/getfider/fider/app/pkg/web"
+)
+
+// NewEmailer creates a new emailer instance based on current configuration
+func NewEmailer(logger log.Logger) email.Sender {
+ if env.IsTest() {
+ return noop.NewSender()
+ }
+ if env.IsDefined("EMAIL_MAILGUN_API") {
+ return mailgun.NewSender(logger, web.NewHTTPClient(), env.MustGet("EMAIL_MAILGUN_DOMAIN"), env.MustGet("EMAIL_MAILGUN_API"))
+ }
+ return smtp.NewSender(
+ logger,
+ env.MustGet("EMAIL_SMTP_HOST"),
+ env.MustGet("EMAIL_SMTP_PORT"),
+ env.GetEnvOrDefault("EMAIL_SMTP_USERNAME", ""),
+ env.GetEnvOrDefault("EMAIL_SMTP_PASSWORD", ""),
+ )
+}
+
+// NewBlobStorage creates a new blob storage instance based on current configuration
+func NewBlobStorage(trx *dbx.Trx) blob.Storage {
+ storageType := strings.ToLower(env.GetEnvOrDefault("BLOB_STORAGE", "sql"))
+ switch storageType {
+ case "sql":
+ return sql.NewStorage(trx)
+ case "s3":
+ return s3.NewStorage(env.MustGet("BLOB_STORAGE_S3_BUCKET"))
+ case "fs":
+ return fs.NewStorage(env.MustGet("BLOB_STORAGE_FS_PATH"))
+ }
+ panic("Invalid blob storage type: " + storageType)
+}
diff --git a/app/pkg/mock/setup.go b/app/pkg/mock/setup.go
index f8abdb0b1..01e1be055 100644
--- a/app/pkg/mock/setup.go
+++ b/app/pkg/mock/setup.go
@@ -5,7 +5,9 @@ import (
"github.com/getfider/fider/app"
"github.com/getfider/fider/app/models"
+ "github.com/getfider/fider/app/pkg/blob/fs"
"github.com/getfider/fider/app/pkg/email/noop"
+ "github.com/getfider/fider/app/pkg/env"
"github.com/getfider/fider/app/pkg/oauth"
"github.com/getfider/fider/app/storage/inmemory"
)
@@ -54,6 +56,7 @@ func createServices(seed bool) *app.Services {
Posts: inmemory.NewPostStorage(),
OAuth: &OAuthService{},
Emailer: noop.NewSender(),
+ Blobs: fs.NewStorage(env.Path("tmp")),
}
if seed {
diff --git a/app/services.go b/app/services.go
index aa478e2ac..16de55709 100644
--- a/app/services.go
+++ b/app/services.go
@@ -2,6 +2,7 @@ package app
import (
"github.com/getfider/fider/app/models"
+ "github.com/getfider/fider/app/pkg/blob"
"github.com/getfider/fider/app/pkg/email"
"github.com/getfider/fider/app/pkg/oauth"
"github.com/getfider/fider/app/storage"
@@ -16,6 +17,7 @@ type Services struct {
Notifications storage.Notification
Posts storage.Post
Emailer email.Sender
+ Blobs blob.Storage
}
// SetCurrentTenant to current context
@@ -25,6 +27,7 @@ func (s *Services) SetCurrentTenant(tenant *models.Tenant) {
s.Tenants.SetCurrentTenant(tenant)
s.Posts.SetCurrentTenant(tenant)
s.Notifications.SetCurrentTenant(tenant)
+ s.Blobs.SetCurrentTenant(tenant)
}
// SetCurrentUser to current context