432 lines
14 KiB
Go
432 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
library "git.ailur.dev/ailur/fg-library/v2"
|
|
"path/filepath"
|
|
|
|
"io"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/go-playground/validator/v10"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type InsertFile struct {
|
|
File File `validate:"required"`
|
|
Stream io.Reader `validate:"required"`
|
|
}
|
|
|
|
type ReadFile struct {
|
|
File File `validate:"required"`
|
|
Stream io.Writer `validate:"required"`
|
|
}
|
|
|
|
type File struct {
|
|
Name string `validate:"required"`
|
|
Size int64 `validate:"required"`
|
|
User uuid.UUID `validate:"required"`
|
|
}
|
|
|
|
var ServiceInformation = library.Service{
|
|
Name: "Storage",
|
|
Permissions: library.Permissions{
|
|
Authenticate: false, // This service does not require authentication
|
|
Database: true, // This service requires database access to store quotas
|
|
BlobStorage: false, // This service *is* the blob storage
|
|
InterServiceCommunication: true, // This service does require inter-service communication
|
|
},
|
|
ServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000003"),
|
|
}
|
|
|
|
var conn library.Database
|
|
|
|
func getQuota(user uuid.UUID, information library.ServiceInitializationInformation) (int64, error) {
|
|
// Get the user's quota from the database
|
|
var quota int64
|
|
userBytes, err := user.MarshalBinary()
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
err = conn.DB.QueryRow("SELECT quota FROM quotas WHERE id = $1", userBytes).Scan("a)
|
|
if err != nil {
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
// The user has no quota set, so we'll set it to the default quota
|
|
_, err = conn.DB.Exec("INSERT INTO quotas (id, quota) VALUES ($1, $2)", userBytes, int64(information.Configuration["defaultQuota"].(float64)))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return int64(information.Configuration["defaultQuota"].(float64)), nil
|
|
}
|
|
return 0, err
|
|
}
|
|
|
|
return quota, nil
|
|
}
|
|
|
|
func getUsed(user uuid.UUID, information library.ServiceInitializationInformation) (int64, error) {
|
|
// Check the user's used space via the filesystem
|
|
var used int64
|
|
_, err := os.Stat(filepath.Join(information.Configuration["path"].(string), user.String()))
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
// The user has no files stored, so we'll set it to 0
|
|
return 0, nil
|
|
}
|
|
return 0, err
|
|
} else {
|
|
err := filepath.Walk(filepath.Join(information.Configuration["path"].(string), user.String()), func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
used += info.Size()
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return used, nil
|
|
}
|
|
}
|
|
|
|
func logFunc(message string, messageType uint64, information library.ServiceInitializationInformation) {
|
|
// Log the error message to the logger service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000002"), // Logger service
|
|
MessageType: messageType,
|
|
SentAt: time.Now(),
|
|
Message: message,
|
|
}
|
|
}
|
|
|
|
func storeFile(file InsertFile, serviceID uuid.UUID, information library.ServiceInitializationInformation) {
|
|
// Create a folder for the user if it doesn't exist
|
|
err := os.MkdirAll(filepath.Join(information.Configuration["path"].(string), file.File.User.String()), 0755)
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Check if the user has enough space to store the file
|
|
quota, err := getQuota(file.File.User, information)
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
used, err := getUsed(file.File.User, information)
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Check if the user has enough space to store the file
|
|
if used+file.File.Size > quota {
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 3, // It's the user's fault (never say that to the customer ;P)
|
|
SentAt: time.Now(),
|
|
Message: "User has exceeded their quota",
|
|
}
|
|
}
|
|
|
|
// Create a folder within that for the service if it doesn't exist
|
|
err = os.MkdirAll(filepath.Join(information.Configuration["path"].(string), file.File.User.String(), serviceID.String()), 0755)
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Store the file
|
|
fileStream, err := os.OpenFile(filepath.Join(information.Configuration["path"].(string), file.File.User.String(), serviceID.String(), file.File.Name), os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Write the file
|
|
_, err = io.Copy(fileStream, file.Stream)
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Close the file
|
|
err = fileStream.Close()
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Report success
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 0, // Success
|
|
SentAt: time.Now(),
|
|
Message: nil,
|
|
}
|
|
}
|
|
|
|
func readFile(file ReadFile, serviceID uuid.UUID, information library.ServiceInitializationInformation) {
|
|
// Open the file
|
|
fileStream, err := os.Open(filepath.Join(information.Configuration["path"].(string), file.File.User.String(), serviceID.String(), file.File.Name))
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Read the file
|
|
_, err = io.Copy(file.Stream, fileStream)
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Close the file
|
|
err = fileStream.Close()
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Report success
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 0, // Success
|
|
SentAt: time.Now(),
|
|
Message: nil,
|
|
}
|
|
}
|
|
|
|
func removeFile(file File, serviceID uuid.UUID, information library.ServiceInitializationInformation) {
|
|
// Remove the file
|
|
err := os.Remove(filepath.Join(information.Configuration["path"].(string), file.User.String(), serviceID.String(), file.Name))
|
|
if err != nil {
|
|
// First contact the logger service
|
|
logFunc(err.Error(), 2, information)
|
|
|
|
// Then send the error message to the requesting service
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 1, // An error that's not your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
|
|
// Report success
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: serviceID,
|
|
MessageType: 0, // Success
|
|
SentAt: time.Now(),
|
|
Message: nil,
|
|
}
|
|
}
|
|
|
|
func Main(information library.ServiceInitializationInformation) {
|
|
go func() {
|
|
for {
|
|
message := <-information.Inbox
|
|
if message.ServiceID == uuid.MustParse("00000000-0000-0000-0000-000000000001") {
|
|
if message.MessageType == 1 {
|
|
// We've received an error message. This should never happen.
|
|
logFunc("Bit flip error: Error given to non-errored service. Move away from radiation or use ECC memory.", 3, information)
|
|
}
|
|
} else {
|
|
switch message.MessageType {
|
|
case 0:
|
|
// Insert file
|
|
validate := validator.New()
|
|
err := validate.Struct(message.Message.(InsertFile))
|
|
if err != nil {
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 2, // An error that's your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
} else {
|
|
// Store file
|
|
storeFile(message.Message.(InsertFile), message.ServiceID, information)
|
|
}
|
|
case 1:
|
|
// Read file
|
|
validate := validator.New()
|
|
err := validate.Struct(message.Message.(ReadFile))
|
|
if err != nil {
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 2, // An error that's your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
} else {
|
|
// Read file
|
|
readFile(message.Message.(ReadFile), message.ServiceID, information)
|
|
}
|
|
case 2:
|
|
// Remove file
|
|
validate := validator.New()
|
|
err := validate.Struct(message.Message.(File))
|
|
if err != nil {
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: message.ServiceID,
|
|
MessageType: 2, // An error that's your fault
|
|
SentAt: time.Now(),
|
|
Message: err.Error(),
|
|
}
|
|
} else {
|
|
// Remove file
|
|
removeFile(message.Message.(File), message.ServiceID, information)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
|
|
// Initiate a connection to the database
|
|
// Call service ID 1 to get the database connection information
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"), // Service initialization service
|
|
MessageType: 1, // Request connection information
|
|
SentAt: time.Now(),
|
|
Message: nil,
|
|
}
|
|
|
|
// Wait for the response
|
|
response := <-information.Inbox
|
|
if response.MessageType == 2 {
|
|
// This is the connection information
|
|
// Set up the database connection
|
|
conn = response.Message.(library.Database)
|
|
// Create the quotas table if it doesn't exist
|
|
if conn.DBType == library.Sqlite {
|
|
_, err := conn.DB.Exec("CREATE TABLE IF NOT EXISTS quotas (id BLOB PRIMARY KEY, quota BIGINT)")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
}
|
|
} else {
|
|
_, err := conn.DB.Exec("CREATE TABLE IF NOT EXISTS quotas (id BYTEA PRIMARY KEY, quota BIGINT)")
|
|
if err != nil {
|
|
logFunc(err.Error(), 3, information)
|
|
}
|
|
}
|
|
} else {
|
|
// This is an error message
|
|
// Log the error message to the logger service
|
|
logFunc(response.Message.(error).Error(), 3, information)
|
|
}
|
|
|
|
// Report a successful activation
|
|
information.Outbox <- library.InterServiceMessage{
|
|
ServiceID: ServiceInformation.ServiceID,
|
|
ForServiceID: uuid.MustParse("00000000-0000-0000-0000-000000000001"), // Activation service
|
|
MessageType: 0,
|
|
SentAt: time.Now(),
|
|
Message: nil,
|
|
}
|
|
}
|