You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
359 lines
6.9 KiB
Go
359 lines
6.9 KiB
Go
package storage
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"log"
|
|
"math/bits"
|
|
|
|
"git.sp4ke.com/sp4ke/bit4sat/db"
|
|
"git.sp4ke.com/sp4ke/bit4sat/ln"
|
|
"github.com/jmoiron/sqlx"
|
|
"github.com/lib/pq"
|
|
"github.com/mediocregopher/radix/v3"
|
|
)
|
|
|
|
var DB = db.DB
|
|
|
|
const (
|
|
//TODO: sync upload status from redis
|
|
// TODO: status is currently handled in cache not here
|
|
DBUploadSchema = `
|
|
CREATE TABLE IF NOT EXISTS upload (
|
|
id serial PRIMARY KEY,
|
|
upload_id varchar(9) NOT NULL,
|
|
sha256 varchar(64) NOT NULL,
|
|
file_name varchar(255) NOT NULL,
|
|
file_type varchar(255) DEFAULT '',
|
|
file_size integer NOT NULL,
|
|
file_ext varchar(255) DEFAULT '',
|
|
ask_fee integer NOT NULL DEFAULT 0,
|
|
stored boolean DEFAULT '0',
|
|
UNIQUE (upload_id, sha256)
|
|
);
|
|
`
|
|
|
|
QNewUpload = `INSERT INTO upload
|
|
(upload_id, sha256, file_name, file_type, file_size, file_ext, stored, ask_fee)
|
|
VALUES
|
|
(:upload_id, :sha256, :file_name, :file_type, :file_size, :file_ext, :stored, :ask_fee)`
|
|
|
|
QSetStored = `UPDATE upload SET stored = :stored WHERE upload_id = :upload_id `
|
|
|
|
QGetByHashID = `SELECT upload_id,
|
|
sha256,
|
|
file_name,
|
|
file_type,
|
|
file_size,
|
|
file_ext,
|
|
ask_fee,
|
|
stored
|
|
FROM upload WHERE sha256 = $1 AND upload_id = $2`
|
|
)
|
|
|
|
type UpStatus uint32
|
|
|
|
func (st UpStatus) MarshalJSON() ([]byte, error) {
|
|
res := map[string]string{}
|
|
res["pay_status"] = st.PrintPayStatus()
|
|
res["store_status"] = st.PrintStoreStatus()
|
|
|
|
return json.Marshal(res)
|
|
}
|
|
|
|
func (st *UpStatus) UnmarshalBinary(b []byte) error {
|
|
//fmt.Printf("%#v\n", b)
|
|
|
|
// first 4 bits are reseved
|
|
// Single byte will be for 0 value
|
|
if len(b) == 1 {
|
|
*st = 0
|
|
return nil
|
|
}
|
|
|
|
view := binary.BigEndian.Uint32(b)
|
|
view = bits.Reverse32(view)
|
|
//fmt.Printf("%32b\n", view)
|
|
//log.Printf("%d\n", view)
|
|
|
|
*st = UpStatus(view)
|
|
|
|
return nil
|
|
}
|
|
|
|
// Get list of positions set
|
|
func (st UpStatus) GetFlagPositions() []int {
|
|
var i uint32
|
|
|
|
var setBits []int
|
|
|
|
for i = 31; i > 0; i-- {
|
|
if st&(1<<i) != 0 {
|
|
setBits = append(setBits, int(i))
|
|
}
|
|
}
|
|
|
|
return setBits
|
|
}
|
|
|
|
func (st UpStatus) PrintStoreStatus() string {
|
|
if st.Stored() {
|
|
return UploadStatus[UpStored]
|
|
} else if st.StoreFail() {
|
|
return UploadStatus[WaitStore]
|
|
} else {
|
|
return UploadStatus[WaitStore]
|
|
}
|
|
}
|
|
|
|
func (st UpStatus) PrintPayStatus() string {
|
|
if st.Paid() {
|
|
return UploadStatus[UpPaid]
|
|
}
|
|
if st.Expired() {
|
|
return UploadStatus[UpPayExpired]
|
|
}
|
|
|
|
return UploadStatus[WaitPay]
|
|
}
|
|
|
|
func (st UpStatus) IsNew() bool {
|
|
return (st & UpNew) != 0
|
|
}
|
|
|
|
func (st UpStatus) WaitPay() bool {
|
|
return (!st.Paid()) && (!st.Expired())
|
|
}
|
|
|
|
func (st UpStatus) Stored() bool {
|
|
return (st & UpStored) != 0
|
|
}
|
|
|
|
func (st UpStatus) StoreFail() bool {
|
|
return (st & UpStoreFail) != 0
|
|
}
|
|
|
|
func (st UpStatus) Paid() bool {
|
|
return (st & UpPaid) != 0
|
|
}
|
|
|
|
func (st UpStatus) Expired() bool {
|
|
return (st & UpPayExpired) != 0
|
|
}
|
|
|
|
func (st UpStatus) GetStoreStatus() UpStatus {
|
|
return st & StoreMask
|
|
}
|
|
|
|
func (st UpStatus) GetPayStatus() UpStatus {
|
|
return st & PayMask
|
|
}
|
|
|
|
// First 4 bits are reserved for easier parsing from redis
|
|
const (
|
|
UpPayExpired UpStatus = 1 << (32 - 1 - iota)
|
|
UpPaid
|
|
|
|
UpStored // All files for this upload where stored
|
|
UpStoreFail
|
|
|
|
// Only used for printing
|
|
WaitStore
|
|
WaitPay
|
|
|
|
UpNew = UpStatus(0)
|
|
|
|
PayMask = UpPaid | UpPayExpired
|
|
|
|
StoreMask = UpStored
|
|
)
|
|
|
|
var UploadStatus = map[UpStatus]string{
|
|
UpNew: "new upload",
|
|
|
|
// Payment
|
|
UpPayExpired: "expired",
|
|
UpPaid: "paid",
|
|
WaitPay: "waiting",
|
|
|
|
// Storage
|
|
WaitStore: "waiting storage",
|
|
UpStored: "stored",
|
|
}
|
|
|
|
var (
|
|
ErrDoesNotExist = errors.New("does not exist")
|
|
ErrAlreadyExists = errors.New("already exists")
|
|
)
|
|
|
|
type Upload struct {
|
|
ID string `db:"upload_id"`
|
|
Free bool `db:"-"` // is this a free upload
|
|
SHA256 string `db:"sha256"`
|
|
FileName string `db:"file_name"`
|
|
FileType string `db:"file_type"`
|
|
FileSize int64 `db:"file_size"`
|
|
FileExt string `db:"file_ext"`
|
|
Stored bool `db:"stored"`
|
|
AskFee int `db:"ask_fee"` // fee asked for download
|
|
}
|
|
|
|
// TODO: sync from redis to db
|
|
//func SyncUploadStatusToDB(){
|
|
|
|
//}
|
|
|
|
func GetUploadInvoice(uploadId string) (*ln.Invoice, error) {
|
|
invoice := ln.Invoice{}
|
|
|
|
uploadInvoiceKey := fmt.Sprintf("upload_%s_invoice", uploadId)
|
|
|
|
err := DB.Redis.Do(radix.FlatCmd(&invoice, "GET", uploadInvoiceKey))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &invoice, nil
|
|
}
|
|
|
|
func GetUploadInvoiceId(uploadId string) (string, error) {
|
|
invoice, err := GetUploadInvoice(uploadId)
|
|
|
|
return invoice.RHash, err
|
|
}
|
|
|
|
func SetUploadStatus(id string, status UpStatus) error {
|
|
//log.Printf("setting upload status for %s", id)
|
|
|
|
key := fmt.Sprintf("upload_status_%s", id)
|
|
|
|
if status == UpNew {
|
|
return DB.Redis.Do(radix.FlatCmd(nil, "SETBIT", key, 31, 0))
|
|
}
|
|
|
|
//log.Println("setting upload status for bit positions ", status.GetFlagPositions())
|
|
// get bit positions
|
|
|
|
for _, offset := range status.GetFlagPositions() {
|
|
//log.Printf("setting bit at position %d", offset)
|
|
err := DB.Redis.Do(radix.FlatCmd(nil,
|
|
"SETBIT", key, offset, 1))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
log.Println("done set bit")
|
|
|
|
return nil
|
|
}
|
|
|
|
func GetUploadStatus(id string) (status UpStatus, err error) {
|
|
//log.Println("Getting upload status")
|
|
|
|
key := fmt.Sprintf("upload_status_%s", id)
|
|
|
|
err = DB.Redis.Do(radix.FlatCmd(&status, "GET", key))
|
|
|
|
return
|
|
}
|
|
|
|
func SetUploadInvoice(uploadId string, invoice *ln.Invoice) error {
|
|
uploadInvoiceKey := fmt.Sprintf("upload_%s_invoice", uploadId)
|
|
|
|
invoiceJson, err := json.Marshal(invoice)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = DB.Redis.Do(radix.FlatCmd(nil, "SET", uploadInvoiceKey, invoiceJson))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Set inverse relation
|
|
invoiceUploadKey := fmt.Sprintf("invoice_%s_upload", invoice.RHash)
|
|
return DB.Redis.Do(radix.FlatCmd(nil, "SET", invoiceUploadKey, uploadId))
|
|
}
|
|
|
|
// Returns true if id exists in DB
|
|
func IdExists(id string) (exists bool, err error) {
|
|
key := fmt.Sprintf("upload_status_%s", id)
|
|
|
|
err = DB.Redis.Do(radix.Cmd(&exists, "EXISTS", key))
|
|
return
|
|
}
|
|
|
|
// Get a file by upload id and hash
|
|
func GetByHashID(sha256 string, id string) (*Upload, error) {
|
|
var up Upload
|
|
|
|
err := DB.Sql.Get(&up, QGetByHashID, sha256, id)
|
|
|
|
if err == sql.ErrNoRows {
|
|
return nil, ErrDoesNotExist
|
|
}
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &up, nil
|
|
}
|
|
|
|
func (u *Upload) TxSetFileStored(tx *sqlx.Tx) error {
|
|
u.Stored = true
|
|
_, err := tx.NamedExec(QSetStored, u)
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (u *Upload) TxWrite(tx *sqlx.Tx) error {
|
|
|
|
_, err := tx.NamedExec(QNewUpload, u)
|
|
|
|
if pqError, ok := err.(*pq.Error); ok {
|
|
// unique constraint
|
|
if pqError.Code == "23505" {
|
|
return ErrAlreadyExists
|
|
}
|
|
}
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (u *Upload) Write() error {
|
|
_, err := DB.Sql.NamedExec(QNewUpload, u)
|
|
|
|
if pqError, ok := err.(*pq.Error); ok {
|
|
// unique constraint
|
|
if pqError.Code == "23505" {
|
|
return ErrAlreadyExists
|
|
}
|
|
}
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
_, err := DB.Sql.Exec(DBUploadSchema)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|