Files
COSMOS/oortexpansion.go
T

1067 lines
28 KiB
Go
Raw Normal View History

package main
import (
"archive/zip"
"bytes"
"crypto/hmac"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"fmt"
"io"
"log"
"mime"
"net/http"
"path"
"strconv"
"strings"
"time"
"github.com/google/uuid"
"github.com/minio/minio-go/v7"
"golang.org/x/crypto/bcrypt"
)
// ─── INITIALIZE EXPANSION SCHEMA ──────────────────────────────────────────────
func InitExpansionSchema() {
if scyllaSession == nil {
return
}
// Share links
scyllaSession.Query(`CREATE TABLE IF NOT EXISTS cosmos.share_links (
share_token text PRIMARY KEY,
bucket text,
object_key text,
owner_email text,
created_at timestamp,
expires_at timestamp,
password_hash text,
max_downloads int,
download_count int,
is_active boolean
)`).Exec()
// Bucket website config
scyllaSession.Query(`CREATE TABLE IF NOT EXISTS cosmos.bucket_website_config (
bucket text PRIMARY KEY,
enabled boolean,
index_doc text,
error_doc text,
spa_mode boolean
)`).Exec()
// Bucket webhooks
scyllaSession.Query(`CREATE TABLE IF NOT EXISTS cosmos.bucket_webhooks (
bucket text,
webhook_id text,
target_url text,
secret text,
events set<text>,
created_at timestamp,
PRIMARY KEY (bucket, webhook_id)
)`).Exec()
}
// ─── EXPANSION ROUTE REGISTRATION ─────────────────────────────────────────────
func RegisterExpansionRoutes(mux *http.ServeMux) {
InitExpansionSchema()
// Public share links
mux.HandleFunc("/s/", handlePublicShare)
// Share management API
mux.HandleFunc("/oort/api/shares/create", handleShareCreate)
mux.HandleFunc("/oort/api/shares/list", handleShareList)
mux.HandleFunc("/oort/api/shares/revoke", handleShareRevoke)
// File preview & live text editor
mux.HandleFunc("/oort/api/preview", handlePreview)
mux.HandleFunc("/oort/api/preview/save", handlePreviewSave)
// Batch operations (Multi-select Zip & Delete)
mux.HandleFunc("/oort/api/batch/zip", handleBatchZip)
mux.HandleFunc("/oort/api/batch/delete", handleBatchDelete)
// Static website hosting
mux.HandleFunc("/oort/api/bucket/website", handleBucketWebsiteConfig)
mux.HandleFunc("/oort/site/", handleStaticSite)
// Webhooks
mux.HandleFunc("/oort/api/bucket/webhooks", handleBucketWebhooks)
mux.HandleFunc("/oort/api/bucket/webhooks/test", handleBucketWebhookTest)
// Storage breakdown analytics
mux.HandleFunc("/oort/api/storage/breakdown", handleStorageBreakdown)
}
// ─── HELPERS ──────────────────────────────────────────────────────────────────
func generateSecureToken(byteLen int) string {
b := make([]byte, byteLen)
if _, err := rand.Read(b); err != nil {
return uuid.New().String()
}
return base64.RawURLEncoding.EncodeToString(b)
}
func getOwnerCredentials(bucketOrEmail string) (ak, sk, email string, err error) {
if strings.Contains(bucketOrEmail, "@") {
email = bucketOrEmail
} else {
err = scyllaSession.Query(`SELECT owner_email FROM cosmos.buckets WHERE bucket_name = ?`, bucketOrEmail).Scan(&email)
if err != nil || email == "" {
scyllaSession.Query(`SELECT email FROM cosmos.users WHERE bucket = ? ALLOW FILTERING`, bucketOrEmail).Scan(&email)
}
}
if email == "" {
return "", "", "", fmt.Errorf("owner not found")
}
err = scyllaSession.Query(`SELECT access_key, secret_key FROM cosmos.users WHERE email = ? ALLOW FILTERING`, email).Scan(&ak, &sk)
return ak, sk, email, err
}
func renderSharePage(w http.ResponseWriter, data map[string]any) {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if tmpl != nil {
err := tmpl.ExecuteTemplate(w, "share.html", data)
if err == nil {
return
}
log.Printf("[SHARE] template render error: %v", err)
}
w.Write([]byte(fmt.Sprintf("<html><body><h1>Cosmos Oort Share</h1><p>%v</p></body></html>", data)))
}
// ─── SHARE LINKS HANDLERS ─────────────────────────────────────────────────────
func handleShareCreate(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, _, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Bucket string `json:"bucket"`
Key string `json:"key"`
ExpiresInSec int64 `json:"expires_in_sec"`
Password string `json:"password"`
MaxDownloads int `json:"max_downloads"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "invalid request", 400)
return
}
if req.Bucket == "" {
req.Bucket = defBucket
}
if req.Key == "" {
jsonErr(w, "missing key", 400)
return
}
if req.ExpiresInSec <= 0 {
req.ExpiresInSec = 86400 // default 24h
}
// Max expiry 30 days
if req.ExpiresInSec > 86400*30 {
req.ExpiresInSec = 86400 * 30
}
var pwdHash string
if req.Password != "" {
hashBytes, err := bcrypt.GenerateFromPassword([]byte(req.Password), 10)
if err == nil {
pwdHash = string(hashBytes)
}
}
token := generateSecureToken(18)
now := time.Now()
expiresAt := now.Add(time.Duration(req.ExpiresInSec) * time.Second)
err := scyllaSession.Query(`INSERT INTO cosmos.share_links (share_token, bucket, object_key, owner_email, created_at, expires_at, password_hash, max_downloads, download_count, is_active) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
token, req.Bucket, req.Key, ak, now, expiresAt, pwdHash, req.MaxDownloads, 0, true).Exec()
if err != nil {
jsonErr(w, "database insert failed", 500)
return
}
jsonOK(w, map[string]any{
"ok": true,
"share_token": token,
"share_url": "/s/" + token,
"expires_at": expiresAt.Unix(),
})
}
func handleShareList(w http.ResponseWriter, r *http.Request) {
_, _, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
bucket := r.URL.Query().Get("bucket")
if bucket == "" {
bucket = defBucket
}
iter := scyllaSession.Query(`SELECT share_token, object_key, created_at, expires_at, password_hash, max_downloads, download_count, is_active FROM cosmos.share_links ALLOW FILTERING`).Iter()
var links []map[string]any
var token, objKey, pwdHash string
var createdAt, expiresAt time.Time
var maxDl, dlCount int
var isActive bool
now := time.Now()
for iter.Scan(&token, &objKey, &createdAt, &expiresAt, &pwdHash, &maxDl, &dlCount, &isActive) {
// Filter by bucket owner
if now.After(expiresAt) {
isActive = false
}
if maxDl > 0 && dlCount >= maxDl {
isActive = false
}
links = append(links, map[string]any{
"token": token,
"key": objKey,
"created_at": createdAt.Unix(),
"expires_at": expiresAt.Unix(),
"has_password": pwdHash != "",
"max_downloads": maxDl,
"download_count": dlCount,
"is_active": isActive,
"url": "/s/" + token,
})
}
iter.Close()
if links == nil {
links = []map[string]any{}
}
jsonOK(w, links)
}
func handleShareRevoke(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" && r.Method != "DELETE" {
jsonErr(w, "method not allowed", 405)
return
}
_, _, _, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
token := r.URL.Query().Get("token")
if token == "" {
var req struct {
Token string `json:"token"`
}
json.NewDecoder(r.Body).Decode(&req)
token = req.Token
}
if token == "" {
jsonErr(w, "missing token", 400)
return
}
scyllaSession.Query(`UPDATE cosmos.share_links SET is_active = false WHERE share_token = ?`, token).Exec()
jsonOK(w, map[string]any{"ok": true})
}
func handlePublicShare(w http.ResponseWriter, r *http.Request) {
token := strings.TrimPrefix(r.URL.Path, "/s/")
isDownload := false
if strings.HasSuffix(token, "/download") {
isDownload = true
token = strings.TrimSuffix(token, "/download")
}
token = strings.Trim(token, "/")
if token == "" {
http.NotFound(w, r)
return
}
var bucket, objectKey, ownerEmail, passwordHash string
var createdAt, expiresAt time.Time
var maxDownloads, downloadCount int
var isActive bool
err := scyllaSession.Query(`SELECT bucket, object_key, owner_email, created_at, expires_at, password_hash, max_downloads, download_count, is_active FROM cosmos.share_links WHERE share_token = ?`, token).
Scan(&bucket, &objectKey, &ownerEmail, &createdAt, &expiresAt, &passwordHash, &maxDownloads, &downloadCount, &isActive)
if err != nil || !isActive {
renderSharePage(w, map[string]any{"Expired": true})
return
}
// Check expiry
if time.Now().After(expiresAt) {
scyllaSession.Query(`UPDATE cosmos.share_links SET is_active = false WHERE share_token = ?`, token).Exec()
renderSharePage(w, map[string]any{"Expired": true})
return
}
// Check max downloads
if maxDownloads > 0 && downloadCount >= maxDownloads {
scyllaSession.Query(`UPDATE cosmos.share_links SET is_active = false WHERE share_token = ?`, token).Exec()
renderSharePage(w, map[string]any{"Expired": true})
return
}
requiresPassword := passwordHash != ""
authenticated := false
if requiresPassword {
cookie, err := r.Cookie("share_auth_" + token)
if err == nil && cookie.Value == "valid" {
authenticated = true
}
if r.Method == "POST" {
r.ParseForm()
pwd := r.FormValue("password")
if bcrypt.CompareHashAndPassword([]byte(passwordHash), []byte(pwd)) == nil {
authenticated = true
http.SetCookie(w, &http.Cookie{
Name: "share_auth_" + token,
Value: "valid",
Path: "/s/" + token,
HttpOnly: true,
MaxAge: 3600 * 24,
})
http.Redirect(w, r, "/s/"+token, http.StatusSeeOther)
return
} else {
renderSharePage(w, map[string]any{
"Token": token,
"FileName": path.Base(objectKey),
"RequiresPassword": true,
"Error": "Incorrect password. Please try again.",
})
return
}
}
} else {
authenticated = true
}
ak, sk, _, err := getOwnerCredentials(bucket)
if err != nil {
ak, sk, _, err = getOwnerCredentials(ownerEmail)
}
if err != nil {
renderSharePage(w, map[string]any{"Expired": true, "Error": "Storage credentials error"})
return
}
mc, err := minioClient(ak, sk)
if err != nil {
renderSharePage(w, map[string]any{"Expired": true, "Error": "MinIO client error"})
return
}
stat, err := mc.StatObject(r.Context(), bucket, objectKey, minio.StatObjectOptions{})
if err != nil {
renderSharePage(w, map[string]any{"Expired": true, "Error": "Object not found in storage"})
return
}
if isDownload {
if !authenticated {
http.Redirect(w, r, "/s/"+token, http.StatusSeeOther)
return
}
newCount := downloadCount + 1
newActive := true
if maxDownloads > 0 && newCount >= maxDownloads {
newActive = false
}
scyllaSession.Query(`UPDATE cosmos.share_links SET download_count = ?, is_active = ? WHERE share_token = ?`, newCount, newActive, token).Exec()
obj, err := mc.GetObject(r.Context(), bucket, objectKey, minio.GetObjectOptions{})
if err != nil {
http.Error(w, "Failed to retrieve object", 500)
return
}
defer obj.Close()
w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="%s"`, path.Base(objectKey)))
w.Header().Set("Content-Type", stat.ContentType)
w.Header().Set("Content-Length", strconv.FormatInt(stat.Size, 10))
io.Copy(w, obj)
return
}
expiresIn := time.Until(expiresAt).Round(time.Minute).String()
downloadsRemaining := "Unlimited"
if maxDownloads > 0 {
downloadsRemaining = fmt.Sprintf("%d left (of %d)", maxDownloads-downloadCount, maxDownloads)
}
renderSharePage(w, map[string]any{
"Token": token,
"FileName": path.Base(objectKey),
"FileSize": formatBytes(stat.Size),
"ContentType": stat.ContentType,
"ExpiresIn": expiresIn,
"DownloadsRemaining": downloadsRemaining,
"RequiresPassword": requiresPassword && !authenticated,
"DownloadURL": "/s/" + token + "/download",
})
}
// ─── FILE PREVIEWS & CODE EDITOR ──────────────────────────────────────────────
func handlePreview(w http.ResponseWriter, r *http.Request) {
ak, sk, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
bucket := r.URL.Query().Get("bucket")
if bucket == "" {
bucket = defBucket
}
key := r.URL.Query().Get("key")
if key == "" {
jsonErr(w, "missing key", 400)
return
}
mc, err := minioClient(ak, sk)
if err != nil {
jsonErr(w, "storage client error", 500)
return
}
obj, err := mc.GetObject(r.Context(), bucket, key, minio.GetObjectOptions{})
if err != nil {
jsonErr(w, "not found", 404)
return
}
defer obj.Close()
stat, err := obj.Stat()
if err != nil {
jsonErr(w, "object stat error", 404)
return
}
contentType := stat.ContentType
if contentType == "" || contentType == "application/octet-stream" {
contentType = mime.TypeByExtension(path.Ext(key))
if contentType == "" {
contentType = "text/plain; charset=utf-8"
}
}
w.Header().Set("Content-Type", contentType)
w.Header().Set("Accept-Ranges", "bytes")
w.Header().Set("Content-Length", strconv.FormatInt(stat.Size, 10))
io.Copy(w, obj)
}
func handlePreviewSave(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, sk, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Bucket string `json:"bucket"`
Key string `json:"key"`
Content string `json:"content"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "invalid request", 400)
return
}
if req.Bucket == "" {
req.Bucket = defBucket
}
if req.Key == "" {
jsonErr(w, "missing key", 400)
return
}
mc, err := minioClient(ak, sk)
if err != nil {
jsonErr(w, "storage client error", 500)
return
}
contentBytes := []byte(req.Content)
contentType := mime.TypeByExtension(path.Ext(req.Key))
if contentType == "" {
contentType = "text/plain; charset=utf-8"
}
_, err = mc.PutObject(r.Context(), req.Bucket, req.Key, bytes.NewReader(contentBytes), int64(len(contentBytes)), minio.PutObjectOptions{
ContentType: contentType,
})
if err != nil {
jsonErr(w, err.Error(), 500)
return
}
go dispatchWebhooks(req.Bucket, "object:created", req.Key, int64(len(contentBytes)), contentType)
jsonOK(w, map[string]any{"ok": true, "size": len(contentBytes)})
}
// ─── BATCH OPERATIONS (ZIP & DELETE) ──────────────────────────────────────────
func handleBatchZip(w http.ResponseWriter, r *http.Request) {
ak, sk, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
bucket := r.URL.Query().Get("bucket")
if bucket == "" {
bucket = defBucket
}
keysParam := r.URL.Query().Get("keys")
if keysParam == "" {
jsonErr(w, "missing keys", 400)
return
}
keys := strings.Split(keysParam, ",")
if len(keys) == 0 {
jsonErr(w, "no keys provided", 400)
return
}
mc, err := minioClient(ak, sk)
if err != nil {
jsonErr(w, "storage client error", 500)
return
}
w.Header().Set("Content-Type", "application/zip")
w.Header().Set("Content-Disposition", fmt.Sprintf(`attachment; filename="cosmos-export-%d.zip"`, time.Now().Unix()))
zw := zip.NewWriter(w)
defer zw.Close()
ctx := r.Context()
for _, key := range keys {
key = strings.TrimSpace(key)
if key == "" {
continue
}
obj, err := mc.GetObject(ctx, bucket, key, minio.GetObjectOptions{})
if err != nil {
continue
}
stat, err := obj.Stat()
if err != nil {
obj.Close()
continue
}
header := &zip.FileHeader{
Name: key,
Method: zip.Deflate,
Modified: stat.LastModified,
}
ew, err := zw.CreateHeader(header)
if err == nil {
io.Copy(ew, obj)
}
obj.Close()
}
}
func handleBatchDelete(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, sk, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Bucket string `json:"bucket"`
Keys []string `json:"keys"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "invalid request body", 400)
return
}
if req.Bucket == "" {
req.Bucket = defBucket
}
if len(req.Keys) == 0 {
jsonErr(w, "no keys provided", 400)
return
}
mc, err := minioClient(ak, sk)
if err != nil {
jsonErr(w, "storage client error", 500)
return
}
ctx := r.Context()
deleted := 0
for _, key := range req.Keys {
if key == "" {
continue
}
err := mc.RemoveObject(ctx, req.Bucket, key, minio.RemoveObjectOptions{})
if err == nil {
deleted++
go dispatchWebhooks(req.Bucket, "object:deleted", key, 0, "")
}
}
jsonOK(w, map[string]any{"ok": true, "deleted_count": deleted})
}
// ─── STATIC WEBSITE HOSTING ───────────────────────────────────────────────────
func handleBucketWebsiteConfig(w http.ResponseWriter, r *http.Request) {
_, _, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
bucket := r.URL.Query().Get("bucket")
if bucket == "" {
bucket = defBucket
}
if r.Method == "GET" {
var enabled, spaMode bool
var indexDoc, errorDoc string
err := scyllaSession.Query(`SELECT enabled, index_doc, error_doc, spa_mode FROM cosmos.bucket_website_config WHERE bucket = ?`, bucket).
Scan(&enabled, &indexDoc, &errorDoc, &spaMode)
if err != nil {
indexDoc = "index.html"
errorDoc = "404.html"
}
jsonOK(w, map[string]any{
"bucket": bucket,
"enabled": enabled,
"index_doc": indexDoc,
"error_doc": errorDoc,
"spa_mode": spaMode,
})
return
}
if r.Method == "POST" {
var req struct {
Bucket string `json:"bucket"`
Enabled bool `json:"enabled"`
IndexDoc string `json:"index_doc"`
ErrorDoc string `json:"error_doc"`
SpaMode bool `json:"spa_mode"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "invalid request", 400)
return
}
if req.Bucket == "" {
req.Bucket = bucket
}
if req.IndexDoc == "" {
req.IndexDoc = "index.html"
}
if req.ErrorDoc == "" {
req.ErrorDoc = "404.html"
}
scyllaSession.Query(`INSERT INTO cosmos.bucket_website_config (bucket, enabled, index_doc, error_doc, spa_mode) VALUES (?, ?, ?, ?, ?)`,
req.Bucket, req.Enabled, req.IndexDoc, req.ErrorDoc, req.SpaMode).Exec()
jsonOK(w, map[string]any{"ok": true})
return
}
jsonErr(w, "method not allowed", 405)
}
func handleStaticSite(w http.ResponseWriter, r *http.Request) {
pathParts := strings.TrimPrefix(r.URL.Path, "/oort/site/")
slashIdx := strings.Index(pathParts, "/")
var bucket, reqPath string
if slashIdx == -1 {
bucket = pathParts
reqPath = ""
} else {
bucket = pathParts[:slashIdx]
reqPath = pathParts[slashIdx+1:]
}
if bucket == "" {
http.Error(w, "Bucket not specified", 400)
return
}
var enabled, spaMode bool
var indexDoc, errorDoc string
err := scyllaSession.Query(`SELECT enabled, index_doc, error_doc, spa_mode FROM cosmos.bucket_website_config WHERE bucket = ?`, bucket).
Scan(&enabled, &indexDoc, &errorDoc, &spaMode)
if err != nil || !enabled {
http.Error(w, "Static website hosting is not enabled for this bucket", 404)
return
}
if indexDoc == "" {
indexDoc = "index.html"
}
ak, sk, _, err := getOwnerCredentials(bucket)
if err != nil {
http.Error(w, "Bucket owner credentials error", 500)
return
}
mc, err := minioClient(ak, sk)
if err != nil {
http.Error(w, "Storage client error", 500)
return
}
targetKey := reqPath
if targetKey == "" || strings.HasSuffix(targetKey, "/") {
targetKey = path.Join(targetKey, indexDoc)
}
ctx := r.Context()
obj, err := mc.GetObject(ctx, bucket, targetKey, minio.GetObjectOptions{})
var stat minio.ObjectInfo
if err == nil {
stat, err = obj.Stat()
}
if err != nil {
if !strings.HasSuffix(targetKey, ".html") {
htmlKey := targetKey + ".html"
hObj, hErr := mc.GetObject(ctx, bucket, htmlKey, minio.GetObjectOptions{})
if hErr == nil {
hStat, hStatErr := hObj.Stat()
if hStatErr == nil {
obj = hObj
stat = hStat
err = nil
} else {
hObj.Close()
}
}
}
}
if err != nil && spaMode {
sObj, sErr := mc.GetObject(ctx, bucket, indexDoc, minio.GetObjectOptions{})
if sErr == nil {
sStat, sStatErr := sObj.Stat()
if sStatErr == nil {
obj = sObj
stat = sStat
err = nil
} else {
sObj.Close()
}
}
}
if err != nil {
if errorDoc != "" {
eObj, eErr := mc.GetObject(ctx, bucket, errorDoc, minio.GetObjectOptions{})
if eErr == nil {
_, eStatErr := eObj.Stat()
if eStatErr == nil {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.WriteHeader(404)
io.Copy(w, eObj)
eObj.Close()
return
}
eObj.Close()
}
}
http.NotFound(w, r)
return
}
defer obj.Close()
ct := stat.ContentType
if ct == "" || ct == "application/octet-stream" {
ct = mime.TypeByExtension(path.Ext(stat.Key))
if ct == "" {
ct = "text/html; charset=utf-8"
}
}
w.Header().Set("Content-Type", ct)
w.Header().Set("Content-Length", strconv.FormatInt(stat.Size, 10))
io.Copy(w, obj)
}
// ─── WEBHOOK DISPATCHER ───────────────────────────────────────────────────────
func handleBucketWebhooks(w http.ResponseWriter, r *http.Request) {
_, _, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
bucket := r.URL.Query().Get("bucket")
if bucket == "" {
bucket = defBucket
}
if r.Method == "GET" {
iter := scyllaSession.Query(`SELECT webhook_id, target_url, secret, events, created_at FROM cosmos.bucket_webhooks WHERE bucket = ?`, bucket).Iter()
var webhooks []map[string]any
var id, targetUrl, secret string
var events []string
var createdAt time.Time
for iter.Scan(&id, &targetUrl, &secret, &events, &createdAt) {
hasSecret := secret != ""
webhooks = append(webhooks, map[string]any{
"id": id,
"target_url": targetUrl,
"has_secret": hasSecret,
"events": events,
"created_at": createdAt,
})
}
iter.Close()
if webhooks == nil {
webhooks = []map[string]any{}
}
jsonOK(w, webhooks)
return
}
if r.Method == "POST" {
var req struct {
Bucket string `json:"bucket"`
TargetURL string `json:"target_url"`
Secret string `json:"secret"`
Events []string `json:"events"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "invalid request", 400)
return
}
if req.Bucket == "" {
req.Bucket = bucket
}
if req.TargetURL == "" {
jsonErr(w, "missing target_url", 400)
return
}
if len(req.Events) == 0 {
req.Events = []string{"object:created", "object:deleted"}
}
id := uuid.New().String()
scyllaSession.Query(`INSERT INTO cosmos.bucket_webhooks (bucket, webhook_id, target_url, secret, events, created_at) VALUES (?, ?, ?, ?, ?, ?)`,
req.Bucket, id, req.TargetURL, req.Secret, req.Events, time.Now()).Exec()
jsonOK(w, map[string]any{"ok": true, "id": id})
return
}
if r.Method == "DELETE" {
id := r.URL.Query().Get("id")
if id == "" {
jsonErr(w, "missing webhook id", 400)
return
}
scyllaSession.Query(`DELETE FROM cosmos.bucket_webhooks WHERE bucket = ? AND webhook_id = ?`, bucket, id).Exec()
jsonOK(w, map[string]any{"ok": true})
return
}
jsonErr(w, "method not allowed", 405)
}
func handleBucketWebhookTest(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
_, _, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
bucket := r.URL.Query().Get("bucket")
if bucket == "" {
bucket = defBucket
}
id := r.URL.Query().Get("id")
if id == "" {
jsonErr(w, "missing id", 400)
return
}
var targetUrl, secret string
err := scyllaSession.Query(`SELECT target_url, secret FROM cosmos.bucket_webhooks WHERE bucket = ? AND webhook_id = ?`, bucket, id).Scan(&targetUrl, &secret)
if err != nil {
jsonErr(w, "webhook not found", 404)
return
}
payload, _ := json.Marshal(map[string]any{
"event": "ping",
"bucket": bucket,
"message": "Cosmos Oort Webhook Test",
"timestamp": time.Now().UTC().Format(time.RFC3339),
})
req, _ := http.NewRequest("POST", targetUrl, bytes.NewReader(payload))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("User-Agent", "Cosmos-Oort-Webhook/1.0")
if secret != "" {
mac := hmac.New(sha256.New, []byte(secret))
mac.Write(payload)
req.Header.Set("X-Cosmos-Signature", "sha256="+hex.EncodeToString(mac.Sum(nil)))
}
client := &http.Client{Timeout: 5 * time.Second}
start := time.Now()
resp, err := client.Do(req)
duration := time.Since(start).Milliseconds()
if err != nil {
jsonOK(w, map[string]any{"ok": false, "error": err.Error(), "duration_ms": duration})
return
}
defer resp.Body.Close()
jsonOK(w, map[string]any{"ok": true, "status_code": resp.StatusCode, "duration_ms": duration})
}
func dispatchWebhooks(bucket, event, key string, size int64, contentType string) {
if scyllaSession == nil {
return
}
iter := scyllaSession.Query(`SELECT target_url, secret, events FROM cosmos.bucket_webhooks WHERE bucket = ?`, bucket).Iter()
var targetUrl, secret string
var events []string
for iter.Scan(&targetUrl, &secret, &events) {
matched := false
for _, ev := range events {
if ev == event || ev == "*" {
matched = true
break
}
}
if !matched {
continue
}
go func(u, s string) {
payload, err := json.Marshal(map[string]any{
"event": event,
"bucket": bucket,
"key": key,
"size": size,
"content_type": contentType,
"timestamp": time.Now().UTC().Format(time.RFC3339),
})
if err != nil {
return
}
req, err := http.NewRequest("POST", u, bytes.NewReader(payload))
if err != nil {
return
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("User-Agent", "Cosmos-Oort-Webhook/1.0")
if s != "" {
mac := hmac.New(sha256.New, []byte(s))
mac.Write(payload)
req.Header.Set("X-Cosmos-Signature", "sha256="+hex.EncodeToString(mac.Sum(nil)))
}
client := &http.Client{Timeout: 5 * time.Second}
resp, err := client.Do(req)
if err == nil && resp != nil {
resp.Body.Close()
}
}(targetUrl, secret)
}
iter.Close()
}
// ─── STORAGE BREAKDOWN ────────────────────────────────────────────────────────
func handleStorageBreakdown(w http.ResponseWriter, r *http.Request) {
ak, sk, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
bucket := r.URL.Query().Get("bucket")
if bucket == "" {
bucket = defBucket
}
mc, err := minioClient(ak, sk)
if err != nil {
jsonErr(w, "storage client error", 500)
return
}
type CatStat struct {
Count int64 `json:"count"`
Bytes int64 `json:"bytes"`
}
stats := map[string]*CatStat{
"images": {0, 0},
"videos": {0, 0},
"audio": {0, 0},
"documents": {0, 0},
"code": {0, 0},
"archives": {0, 0},
"others": {0, 0},
}
var totalBytes, totalCount int64
ctx := r.Context()
for obj := range mc.ListObjects(ctx, bucket, minio.ListObjectsOptions{Recursive: true}) {
if obj.Err != nil || strings.HasSuffix(obj.Key, "/") {
continue
}
ext := strings.ToLower(path.Ext(obj.Key))
cat := "others"
switch ext {
case ".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp", ".ico", ".tiff":
cat = "images"
case ".mp4", ".webm", ".mkv", ".mov", ".avi", ".flv":
cat = "videos"
case ".mp3", ".wav", ".ogg", ".flac", ".aac", ".m4a":
cat = "audio"
case ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".txt", ".csv":
cat = "documents"
case ".js", ".ts", ".html", ".css", ".go", ".py", ".json", ".yml", ".yaml", ".sql", ".sh", ".c", ".cpp", ".rs", ".md":
cat = "code"
case ".zip", ".tar", ".gz", ".rar", ".7z", ".iso", ".bz2":
cat = "archives"
}
stats[cat].Count++
stats[cat].Bytes += obj.Size
totalBytes += obj.Size
totalCount++
}
jsonOK(w, map[string]any{
"bucket": bucket,
"total_bytes": totalBytes,
"total_count": totalCount,
"categories": stats,
})
}