Files
COSMOS/oortconsole.go
T

1730 lines
53 KiB
Go
Raw Normal View History

package main
import (
"bytes"
"context"
"encoding/json"
"encoding/base64"
"github.com/google/uuid"
"fmt"
"io"
"log"
"net/http"
"net/http/httputil"
"sync"
"net/url"
"os"
"os/exec"
"path"
"strconv"
"strings"
"time"
"golang.org/x/crypto/bcrypt"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
const minioEndpoint = "127.0.0.1:9000"
const publicMinioEndpoint = "cosmos.linuxguy.space"
// authS3Console validates the session and returns (accessKey, secretKey, bucket).
// It looks up the session from the cosmos.users table.
func authS3Console(r *http.Request) (ak, sk, bucket string, ok bool) {
sid := r.URL.Query().Get("sid")
if sid == "" {
sid = r.Header.Get("X-Session-Id")
}
if sid == "" {
cookie, err := r.Cookie("cosmos_sid")
if err == nil {
sid = cookie.Value
}
}
if sid == "" {
cookie, err := r.Cookie("oort_session")
if err == nil {
sid = cookie.Value
}
}
if sid == "" {
cookie, err := r.Cookie("orbit_session")
if err == nil {
sid = cookie.Value
}
}
if sid == "" {
return "", "", "", false
}
_, ak, sk, bucket, err := lookupBySession("", sid)
if err != nil || ak == "" {
return "", "", "", false
}
return ak, sk, bucket, true
}
func minioClient(ak, sk string) (*minio.Client, error) {
return minio.New(minioEndpoint, &minio.Options{
Creds: credentials.NewStaticV4(ak, sk, ""),
Secure: false,
})
}
// ─── API Response helpers ─────────────────────────────────────────────────────
func jsonOK(w http.ResponseWriter, v any) {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(v)
}
func jsonErr(w http.ResponseWriter, msg string, code int) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(code)
json.NewEncoder(w).Encode(map[string]string{"error": msg})
}
// ─── Route dispatcher ─────────────────────────────────────────────────────────
func RegisterS3ConsoleRoutes(mux *http.ServeMux) {
// Ensure required tables exist
scyllaSession.Query(`CREATE TABLE IF NOT EXISTS cosmos.quota_requests (
req_token text PRIMARY KEY,
email text,
amount int
)`).Exec()
scyllaSession.Query(`CREATE TABLE IF NOT EXISTS cosmos.bucket_domains (
domain text PRIMARY KEY,
bucket_name text,
owner_email text
)`).Exec()
RegisterExpansionRoutes(mux)
mux.HandleFunc("/oort/api/objects/versions", handleS3ObjectVersions)
mux.HandleFunc("/oort/api/objects/restore", handleS3ObjectRestore)
mux.HandleFunc("/oort/api/objects/share", handleS3ShareObject)
mux.HandleFunc("/oort/console", handleS3ConsolePage)
mux.HandleFunc("/oort/api/buckets", func(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" { handleS3CreateBucket(w, r); return }
if r.Method == "DELETE" { handleS3DeleteBucket(w, r); return }
handleS3Buckets(w, r)
})
mux.HandleFunc("/oort/api/bucket/settings", handleS3BucketSettings)
mux.HandleFunc("/oort/api/analytics", handleS3Analytics)
mux.HandleFunc("/oort/api/stats", handleS3Stats)
mux.HandleFunc("/oort/api/objects", handleS3Objects)
mux.HandleFunc("/oort/api/upload/init", handleS3UploadInit)
mux.HandleFunc("/oort/api/upload/part", handleS3UploadPart)
mux.HandleFunc("/oort/api/upload/complete", handleS3UploadComplete)
mux.HandleFunc("/oort/api/upload/abort", handleS3UploadAbort)
mux.HandleFunc("/oort/api/delete", handleS3Delete)
mux.HandleFunc("/oort/api/bucket/empty", handleS3EmptyBucket)
mux.HandleFunc("/oort/api/cdn_proxy/", handleS3CDNProxy)
mux.HandleFunc("/oort/api/bucket/domains", handleS3BucketDomains)
mux.HandleFunc("/oort/api/bucket/domain/add", handleS3BucketDomainAdd)
mux.HandleFunc("/oort/api/bucket/domain/remove", handleS3BucketDomainRemove)
mux.HandleFunc("/oort/api/presign", handleS3Presign)
mux.HandleFunc("/oort/api/mkdir", handleS3Mkdir)
mux.HandleFunc("/oort/api/profile", handleS3Profile)
mux.HandleFunc("/oort/api/profile/image", handleS3ProfileImage)
mux.HandleFunc("/oort/api/profile/update", handleS3ProfileUpdate)
mux.HandleFunc("/oort/api/quota", handleS3Quota)
mux.HandleFunc("/oort/api/quota/approve", handleS3ApproveQuota)
mux.HandleFunc("/oort/api/password", handleS3Password)
mux.HandleFunc("/oort/api/objects/move", handleS3Move)
mux.HandleFunc("/oort/api/buckets/rename", handleS3RenameBucket)
}
// ─── Console HTML page ────────────────────────────────────────────────────────
func handleS3ConsolePage(w http.ResponseWriter, r *http.Request) {
_, _, _, ok := authS3Console(r)
if !ok {
http.Redirect(w, r, "/oort/login", http.StatusFound)
return
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("X-Frame-Options", "DENY")
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("Content-Security-Policy", "default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://static.cloudflareinsights.com; img-src 'self' data: blob:;")
sid := r.URL.Query().Get("sid")
if sid == "" {
if c, err := r.Cookie("cosmos_sid"); err == nil {
sid = c.Value
}
}
http.SetCookie(w, &http.Cookie{
Name: "cosmos_sid",
Value: sid,
Path: "/oort",
HttpOnly: true,
Secure: true,
SameSite: http.SameSiteStrictMode,
MaxAge: 86400 * 7,
})
var username string
scyllaSession.Query(`SELECT username FROM cosmos.users WHERE session_id=? ALLOW FILTERING`, sid).Scan(&username)
tmpl.ExecuteTemplate(w, "oortconsole.html", map[string]string{"SID": sid, "Username": username})
}
// ─── GET /oort/api/stats ────────────────────────────────────────────────────────
func handleS3Stats(w http.ResponseWriter, r *http.Request) {
ak, sk, defBucket, ok := authS3Console(r)
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
ctx := context.Background()
var totalSize int64
var objectCount int64
for obj := range mc.ListObjects(ctx, bucket, minio.ListObjectsOptions{Recursive: true}) {
if obj.Err != nil {
continue
}
totalSize += obj.Size
objectCount++
}
exists, _ := mc.BucketExists(ctx, bucket)
// Fetch real quota from MinIO via mc CLI
var quotaBytes int64 = 10 * 1024 * 1024 * 1024 // default 10GB
mcOut, mcErr := exec.Command("mc", "quota", "info", "cosmos/"+bucket, "--json").Output()
if mcErr == nil {
var qr struct {
Quota int64 `json:"quota"`
Type string `json:"type"`
}
if json.Unmarshal(mcOut, &qr) == nil && qr.Quota > 0 {
quotaBytes = qr.Quota
}
}
jsonOK(w, map[string]any{
"bucket": bucket,
"object_count": objectCount,
"total_size": totalSize,
"exists": exists,
"quota": quotaBytes,
})
}
// ─── GET /oort/api/objects?prefix=xxx ──────────────────────────────────────────
type S3Object struct {
Key string `json:"key"`
Name string `json:"name"`
Size int64 `json:"size"`
LastModified time.Time `json:"last_modified"`
IsDir bool `json:"is_dir"`
ContentType string `json:"content_type"`
ETag string `json:"etag"`
}
func handleS3Objects(w http.ResponseWriter, r *http.Request) {
ak, sk, defBucket, ok := authS3Console(r)
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
prefix := r.URL.Query().Get("prefix")
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
recursive := r.URL.Query().Get("recursive") == "true"
ctx := context.Background()
var objects []S3Object
for obj := range mc.ListObjects(ctx, bucket, minio.ListObjectsOptions{
Prefix: prefix,
Recursive: recursive,
}) {
if obj.Err != nil {
log.Printf("[S3] list error: %v", obj.Err)
continue
}
// Skip the exact directory object of the current prefix
if prefix != "" && obj.Key == prefix {
continue
}
isDir := strings.HasSuffix(obj.Key, "/")
name := obj.Key
if prefix != "" {
name = strings.TrimPrefix(name, prefix)
}
name = strings.TrimSuffix(name, "/")
objects = append(objects, S3Object{
Key: obj.Key,
Name: name,
Size: obj.Size,
LastModified: obj.LastModified,
IsDir: isDir,
ETag: strings.Trim(obj.ETag, "\""),
})
}
if objects == nil {
objects = []S3Object{}
}
jsonOK(w, map[string]any{
"prefix": prefix,
"bucket": bucket,
"objects": objects,
})
}
// ─── POST /oort/api/upload/init — initiate multipart ───────────────────────────
func handleS3UploadInit(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, sk, defBucket, ok := authS3Console(r)
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Key string `json:"key"`
ContentType string `json:"content_type"`
Bucket string `json:"bucket"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Key == "" {
jsonErr(w, "bad request", 400)
return
}
if req.Bucket != "" { bucket = req.Bucket }
// Sanitise key
req.Key = path.Clean(req.Key)
req.Key = strings.TrimPrefix(req.Key, "/")
if req.ContentType == "" {
req.ContentType = "application/octet-stream"
}
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
core := minio.Core{Client: mc}
uploadID, err := core.NewMultipartUpload(context.Background(), bucket, req.Key, minio.PutObjectOptions{
ContentType: req.ContentType,
})
if err != nil {
log.Printf("[S3] init multipart: %v", err)
jsonErr(w, "failed to init upload", 500)
return
}
jsonOK(w, map[string]string{
"upload_id": uploadID,
"key": req.Key,
"bucket": bucket,
})
}
// ─── POST /oort/api/upload/part — upload one chunk ─────────────────────────────
func handleS3UploadPart(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, sk, defBucket, ok := authS3Console(r)
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
key := r.URL.Query().Get("key")
uploadID := r.URL.Query().Get("upload_id")
partNumStr := r.URL.Query().Get("part")
sizeStr := r.URL.Query().Get("size")
if key == "" || uploadID == "" || partNumStr == "" {
jsonErr(w, "missing params", 400)
return
}
partNum, _ := strconv.Atoi(partNumStr)
size, _ := strconv.ParseInt(sizeStr, 10, 64)
if partNum < 1 || partNum > 10000 {
jsonErr(w, "invalid part number", 400)
return
}
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
core := minio.Core{Client: mc}
var reader io.Reader = r.Body
part, err := core.PutObjectPart(context.Background(), bucket, key, uploadID, partNum, reader, size, minio.PutObjectPartOptions{})
if err != nil {
log.Printf("[S3] put part %d: %v", partNum, err)
jsonErr(w, "failed to upload part", 500)
return
}
jsonOK(w, map[string]any{
"part": partNum,
"etag": strings.Trim(part.ETag, "\""),
"size": part.Size,
})
}
// ─── POST /oort/api/upload/complete ────────────────────────────────────────────
func handleS3UploadComplete(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, sk, defBucket, ok := authS3Console(r)
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Key string `json:"key"`
UploadID string `json:"upload_id"`
Bucket string `json:"bucket"`
Parts []struct {
Part int `json:"part"`
ETag string `json:"etag"`
} `json:"parts"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "bad request", 400)
return
}
if req.Bucket != "" { bucket = req.Bucket }
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
core := minio.Core{Client: mc}
var completeParts []minio.CompletePart
for _, p := range req.Parts {
completeParts = append(completeParts, minio.CompletePart{
PartNumber: p.Part,
ETag: p.ETag,
})
}
upload, err := core.CompleteMultipartUpload(context.Background(), bucket, req.Key, req.UploadID, completeParts, minio.PutObjectOptions{})
if err != nil {
log.Printf("[S3] complete multipart: %v", err)
jsonErr(w, "failed to complete upload", 500)
return
}
// Record a write hit for analytics
go recordHit(bucket, 200, 0, false, r.Header.Get("CF-IPCountry"), "write")
go dispatchWebhooks(bucket, "object:created", upload.Key, 0, "")
jsonOK(w, map[string]any{
"key": upload.Key,
"etag": strings.Trim(upload.ETag, "\""),
"bucket": upload.Bucket,
})
}
// ─── POST /oort/api/upload/abort ────────────────────────────────────────────────
func handleS3UploadAbort(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, sk, defBucket, ok := authS3Console(r)
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Key string `json:"key"`
UploadID string `json:"upload_id"`
Bucket string `json:"bucket"`
}
json.NewDecoder(r.Body).Decode(&req)
if req.Bucket != "" { bucket = req.Bucket }
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
core := minio.Core{Client: mc}
core.AbortMultipartUpload(context.Background(), bucket, req.Key, req.UploadID)
jsonOK(w, map[string]bool{"aborted": true})
}
// ─── DELETE /oort/api/delete?key=xxx ───────────────────────────────────────────
func handleS3Delete(w http.ResponseWriter, r *http.Request) {
if r.Method != "DELETE" && r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, sk, defBucket, ok := authS3Console(r)
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
key := r.URL.Query().Get("key")
if key == "" {
jsonErr(w, "missing key", 400)
return
}
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
ctx := context.Background()
// If it's a "folder", delete all objects and their versions with that prefix
if strings.HasSuffix(key, "/") {
for obj := range mc.ListObjects(ctx, bucket, minio.ListObjectsOptions{Prefix: key, Recursive: true, WithVersions: true}) {
if obj.Err == nil {
mc.RemoveObject(ctx, bucket, obj.Key, minio.RemoveObjectOptions{VersionID: obj.VersionID})
}
}
} else {
if err := mc.RemoveObject(ctx, bucket, key, minio.RemoveObjectOptions{}); err != nil {
jsonErr(w, "delete failed", 500)
return
}
}
go dispatchWebhooks(bucket, "object:deleted", key, 0, "")
jsonOK(w, map[string]bool{"deleted": true})
}
// ─── GET /oort/api/presign?key=xxx ─────────────────────────────────────────────
func handleS3Presign(w http.ResponseWriter, r *http.Request) {
ak, sk, defBucket, ok := authS3Console(r)
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
key := r.URL.Query().Get("key")
if key == "" {
jsonErr(w, "missing key", 400)
return
}
mc, err := minio.New(publicMinioEndpoint, &minio.Options{
Creds: credentials.NewStaticV4(ak, sk, ""),
Secure: true,
})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
u, err := mc.PresignedGetObject(context.Background(), bucket, key, 15*time.Minute, nil)
if err != nil {
jsonErr(w, "presign failed", 500)
return
}
jsonOK(w, map[string]string{"url": u.String()})
}
// ─── POST /oort/api/mkdir — create a "folder" placeholder ──────────────────────
func handleS3Mkdir(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, sk, defBucket, ok := authS3Console(r)
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Prefix string `json:"prefix"`
Key string `json:"key"`
Bucket string `json:"bucket"`
}
json.NewDecoder(r.Body).Decode(&req)
if req.Bucket != "" { bucket = req.Bucket }
// Accept either "key" or "prefix" field
if req.Prefix == "" && req.Key != "" {
req.Prefix = req.Key
}
// Auto-append trailing slash if missing
if req.Prefix != "" && !strings.HasSuffix(req.Prefix, "/") {
req.Prefix = req.Prefix + "/"
}
if req.Prefix == "" {
jsonErr(w, "folder name is required", 400)
return
}
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
// Put a zero-byte directory object (ends with /)
key := req.Prefix
_, err = mc.PutObject(context.Background(), bucket, key, strings.NewReader(""), 0,
minio.PutObjectOptions{ContentType: "application/x-directory"})
if err != nil {
log.Printf("[S3] mkdir: %v", err)
jsonErr(w, "mkdir failed", 500)
return
}
jsonOK(w, map[string]string{"prefix": req.Prefix})
}
// ─── POST /oort/api/objects/move ────────────────────────────────────────────────
func handleS3Move(w http.ResponseWriter, r *http.Request) {
ak, sk, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Bucket string `json:"bucket"`
SourceKey string `json:"source_key"`
DestKey string `json:"dest_key"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "invalid request", 400)
return
}
if req.Bucket == "" { req.Bucket = defBucket }
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
ctx := context.Background()
// If it's a folder, do a recursive move
if strings.HasSuffix(req.SourceKey, "/") {
if !strings.HasSuffix(req.DestKey, "/") {
req.DestKey += "/"
}
for obj := range mc.ListObjects(ctx, req.Bucket, minio.ListObjectsOptions{Prefix: req.SourceKey, Recursive: true}) {
if obj.Err != nil { continue }
newKey := req.DestKey + strings.TrimPrefix(obj.Key, req.SourceKey)
// Copy each object
srcOpts := minio.CopySrcOptions{Bucket: req.Bucket, Object: obj.Key}
dstOpts := minio.CopyDestOptions{Bucket: req.Bucket, Object: newKey}
_, copyErr := mc.CopyObject(ctx, dstOpts, srcOpts)
// Remove old object if copy succeeds
if copyErr == nil {
mc.RemoveObject(ctx, req.Bucket, obj.Key, minio.RemoveObjectOptions{})
}
}
} else {
// Copy single object
srcOpts := minio.CopySrcOptions{Bucket: req.Bucket, Object: req.SourceKey}
dstOpts := minio.CopyDestOptions{Bucket: req.Bucket, Object: req.DestKey}
_, err = mc.CopyObject(ctx, dstOpts, srcOpts)
if err != nil {
log.Printf("[S3] copy error: %v", err)
jsonErr(w, "failed to copy object", 500)
return
}
// Remove original object
err = mc.RemoveObject(ctx, req.Bucket, req.SourceKey, minio.RemoveObjectOptions{})
if err != nil {
log.Printf("[S3] remove error after copy: %v", err)
jsonErr(w, "failed to remove original object", 500)
return
}
}
jsonOK(w, map[string]string{"status": "moved"})
}
// ─── POST /oort/api/buckets/rename ─────────────────────────────────────────────
func handleS3RenameBucket(w http.ResponseWriter, r *http.Request) {
ak, _, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
OldName string `json:"old_name"`
NewName string `json:"new_name"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "invalid request", 400)
return
}
displayName := strings.TrimSpace(req.NewName)
if displayName == "" {
jsonErr(w, "Name cannot be empty", 400)
return
}
if req.OldName == defBucket {
// Rename default bucket
scyllaSession.Query(`UPDATE cosmos.users SET bucket_display_name = ? WHERE service = 'git' AND email = ?`, displayName, ak).Exec()
} else {
// Verify ownership in DB
var owner string
scyllaSession.Query(`SELECT owner_email FROM cosmos.buckets WHERE bucket_name = ?`, req.OldName).Scan(&owner)
if owner != ak {
jsonErr(w, "unauthorized or not found", 403)
return
}
// Rename custom bucket
scyllaSession.Query(`UPDATE cosmos.buckets SET display_name = ? WHERE bucket_name = ?`, displayName, req.OldName).Exec()
}
jsonOK(w, map[string]string{"status": "renamed"})
}
// ─── Format helpers (used in template) ───────────────────────────────────────
func formatBytes(b int64) string {
const unit = 1024
if b < unit {
return fmt.Sprintf("%d B", b)
}
div, exp := int64(unit), 0
for n := b / unit; n >= unit; n /= unit {
div *= unit
exp++
}
return fmt.Sprintf("%.1f %cB", float64(b)/float64(div), "KMGTPE"[exp])
}
// ─── GET /oort/api/buckets ──────────────────────────────────────────────────────
// ─── GET /oort/api/profile ──────────────────────────────────────────────────────
func handleS3Profile(w http.ResponseWriter, r *http.Request) {
ak, sk, defaultBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var name, username, profileImage string
scyllaSession.Query(`SELECT name, username, profile_image FROM cosmos.users WHERE service = 'git' AND email = ?`, ak).Scan(&name, &username, &profileImage)
jsonOK(w, map[string]any{
"access_key": ak,
"secret_key": sk,
"default_bucket": defaultBucket,
"endpoint": "https://cosmos.linuxguy.space",
"name": name,
"username": username,
"profile_image": profileImage,
})
}
// ─── POST /oort/api/quota ───────────────────────────────────────────────────────
// ─── POST /oort/api/password ────────────────────────────────────────────────────
// ─── POST /oort/api/quota ───────────────────────────────────────────────────────
func handleS3Quota(w http.ResponseWriter, r *http.Request) {
ak, _, _, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var body struct{ Amount int `json:"amount"` }
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
jsonErr(w, "invalid request", 400)
return
}
if body.Amount > 100 {
jsonErr(w, "maximum requested amount is 100GB", 400)
return
}
reqToken := uuid.New().String()
if err := scyllaSession.Query(`INSERT INTO cosmos.quota_requests (req_token, email, amount) VALUES (?, ?, ?)`, reqToken, ak, body.Amount).Exec(); err != nil {
jsonErr(w, "db error", 500)
return
}
go sendQuotaEmail(ak, reqToken, body.Amount)
jsonOK(w, map[string]bool{"success": true})
}
func sendQuotaEmail(userEmail, token string, amount int) {
link := fmt.Sprintf("https://cosmos.linuxguy.space/oort/api/quota/approve?token=%s", token)
msg := fmt.Sprintf("From: [email protected]\r\nTo: [email protected]\r\nSubject: Quota Request from %s\r\n\r\nUser %s has requested a quota increase to %d GB.\r\n\r\nClick here to approve: %s\r\n", userEmail, userEmail, amount, link)
cmd := exec.Command("msmtp", "-t")
cmd.Stdin = bytes.NewBufferString(msg)
if err := cmd.Run(); err != nil {
log.Printf("[MAIL] Failed to send quota email: %v", err)
}
}
func handleS3ApproveQuota(w http.ResponseWriter, r *http.Request) {
token := r.URL.Query().Get("token")
if token == "" {
http.Error(w, "missing token", 400)
return
}
var email string
var amount int
if err := scyllaSession.Query(`SELECT email, amount FROM cosmos.quota_requests WHERE req_token = ?`, token).Scan(&email, &amount); err != nil {
http.Error(w, "invalid token", 400)
return
}
// Apply quota to all user's buckets
iter := scyllaSession.Query(`SELECT bucket_name FROM cosmos.buckets WHERE owner_email = ? ALLOW FILTERING`, email).Iter()
var bName string
for iter.Scan(&bName) {
exec.Command("mc", "quota", "set", "cosmos/"+bName, "--size", fmt.Sprintf("%dG", amount)).Run()
}
iter.Close()
scyllaSession.Query(`DELETE FROM cosmos.quota_requests WHERE req_token = ?`, token).Exec()
w.Write([]byte("Quota approved and applied successfully!"))
}
func handleS3Password(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
jsonErr(w, "method not allowed", 405)
return
}
ak, _, _, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
NewPassword string `json:"new_password"`
}
json.NewDecoder(r.Body).Decode(&req)
if len(req.NewPassword) < 8 {
jsonErr(w, "password must be at least 8 characters", 400)
return
}
// Change in ScyllaDB ONLY. MinIO API token (secret_key) remains unchanged.
hash, _ := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
err := scyllaSession.Query(`UPDATE cosmos.users SET password_hash = ? WHERE service = 'git' AND email = ?`,
string(hash), ak).Exec()
if err != nil {
log.Printf("[S3] password update scylla: %v", err)
}
var gUser string
scyllaSession.Query(`SELECT username FROM cosmos.users WHERE service = 'git' AND email = ?`, ak).Scan(&gUser)
if gUser != "" {
syncGiteaPassword(gUser, req.NewPassword)
}
jsonOK(w, map[string]bool{"success": true})
}
func syncUserPolicy(email string) error {
var buckets []string
iter := scyllaSession.Query(`SELECT bucket_name FROM cosmos.buckets WHERE owner_email = ?`, email).Iter()
var b string
for iter.Scan(&b) {
buckets = append(buckets, b)
}
if err := iter.Close(); err != nil {
return err
}
var resources []string
for _, b := range buckets {
resources = append(resources, fmt.Sprintf(`"arn:aws:s3:::%s"`, b), fmt.Sprintf(`"arn:aws:s3:::%s/*"`, b))
}
resStr := strings.Join(resources, ",")
if resStr == "" {
resStr = `""`
}
policyStr := fmt.Sprintf(`{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["s3:*"],"Resource":[%s]}]}`, resStr)
safeEmail := strings.ReplaceAll(email, "@", "_")
safeEmail = strings.ReplaceAll(safeEmail, ".", "_")
policyName := "policy_" + safeEmail
policyFile := "/tmp/" + policyName + ".json"
os.WriteFile(policyFile, []byte(policyStr), 0644)
exec.Command("mc", "admin", "policy", "create", "cosmos", policyName, policyFile).Run()
exec.Command("mc", "admin", "policy", "attach", "cosmos", policyName, "--user", email).Run()
log.Printf("[S3] synced policy for %s with %d buckets", email, len(buckets))
return nil
}
// ─── GET /oort/api/buckets ──────────────────────────────────────────────────────
func handleS3Buckets(w http.ResponseWriter, r *http.Request) {
ak, _, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var buckets []map[string]any
// Always include the default private bucket
if defBucket != "" {
var defDisp string
scyllaSession.Query(`SELECT bucket_display_name FROM cosmos.users WHERE service='git' AND email=?`, ak).Scan(&defDisp)
if defDisp == "" {
defDisp = "mybucket"
}
buckets = append(buckets, map[string]any{"Name": defBucket, "DisplayName": defDisp})
}
// Fetch additional custom buckets
iter := scyllaSession.Query(`SELECT bucket_name, display_name FROM cosmos.buckets WHERE owner_email = ?`, ak).Iter()
var b, disp string
for iter.Scan(&b, &disp) {
if disp == "" {
disp = b
}
buckets = append(buckets, map[string]any{"Name": b, "DisplayName": disp})
}
iter.Close()
jsonOK(w, map[string]any{"buckets": buckets})
}
// ─── POST /oort/api/buckets (CREATE) ──────────────────────────────────────────
func handleS3CreateBucket(w http.ResponseWriter, r *http.Request) {
ak, _, _, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Name string `json:"name"` // Used as display name
}
json.NewDecoder(r.Body).Decode(&req)
displayName := strings.TrimSpace(req.Name)
if displayName == "" {
jsonErr(w, "Bucket name required", 400)
return
}
internalName := "cosmos-" + strings.ReplaceAll(uuid.New().String(), "-", "")[:16]
// Try creating it in MinIO.
if err := exec.Command("mc", "mb", "cosmos/"+internalName).Run(); err != nil {
jsonErr(w, "Failed to provision backend bucket", 500)
return
}
// Apply 10GB quota
exec.Command("mc", "quota", "set", "cosmos/"+internalName, "--size", "10G").Run()
// Enable versioning
exec.Command("mc", "version", "enable", "cosmos/"+internalName).Run()
// Save to DB
scyllaSession.Query(`INSERT INTO cosmos.buckets (bucket_name, owner_email, display_name) VALUES (?, ?, ?)`, internalName, ak, displayName).Exec()
// Sync policy
syncUserPolicy(ak)
jsonOK(w, map[string]string{"name": internalName})
}
// ─── DELETE /oort/api/buckets (DELETE) ────────────────────────────────────────
func handleS3DeleteBucket(w http.ResponseWriter, r *http.Request) {
ak, _, _, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
bucket := r.URL.Query().Get("bucket")
if bucket == "" {
jsonErr(w, "missing bucket name", 400)
return
}
// Verify ownership
var owner string
scyllaSession.Query(`SELECT owner_email FROM cosmos.buckets WHERE bucket_name = ?`, bucket).Scan(&owner)
if owner != ak {
jsonErr(w, "unauthorized or not found", 403)
return
}
// Delete from MinIO
exec.Command("mc", "rb", "--force", "cosmos/"+bucket).Run()
// Delete from DB
scyllaSession.Query(`DELETE FROM cosmos.buckets WHERE bucket_name = ?`, bucket).Exec()
// Sync policy
syncUserPolicy(ak)
jsonOK(w, map[string]bool{"deleted": true})
}
// ─── POST /oort/api/profile/image ───────────────────────────────────────────────
func handleS3ProfileImage(w http.ResponseWriter, r *http.Request) {
ak, _, _, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
r.ParseMultipartForm(10 << 20)
file, _, err := r.FormFile("profile_image")
if err != nil {
jsonErr(w, "missing image", 400)
return
}
defer file.Close()
bytes, err := io.ReadAll(file)
if err != nil || len(bytes) == 0 {
jsonErr(w, "invalid image", 400)
return
}
encoded := "data:image/jpeg;base64," + base64.StdEncoding.EncodeToString(bytes)
if err := scyllaSession.Query(`UPDATE cosmos.users SET profile_image = ? WHERE service = 'git' AND email = ?`, encoded, ak).Exec(); err != nil {
jsonErr(w, "db error", 500)
return
}
jsonOK(w, map[string]bool{"success": true})
}
// ─── POST /oort/api/profile/update ──────────────────────────────────────────────
func handleS3ProfileUpdate(w http.ResponseWriter, r *http.Request) {
ak, _, _, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
var req struct {
Name string `json:"name"`
Username string `json:"username"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "invalid request", 400)
return
}
req.Name = strings.TrimSpace(req.Name)
req.Username = strings.ToLower(strings.TrimSpace(req.Username))
if req.Name == "" || req.Username == "" {
jsonErr(w, "name and username are required", 400)
return
}
var ex string
if scyllaSession.Query(`SELECT email FROM cosmos.users WHERE username = ? ALLOW FILTERING`, req.Username).Scan(&ex) == nil && ex != ak {
jsonErr(w, "username already taken", 409)
return
}
if err := scyllaSession.Query(`UPDATE cosmos.users SET name = ?, username = ? WHERE service = 'git' AND email = ?`, req.Name, req.Username, ak).Exec(); err != nil {
jsonErr(w, "db error", 500)
return
}
jsonOK(w, map[string]bool{"success": true})
}
// ─── GET /oort/api/objects/share ───────────────────────────────────────────────
func handleS3ShareObject(w http.ResponseWriter, r *http.Request) {
ak, sk, _, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
bucket := r.URL.Query().Get("bucket")
key := r.URL.Query().Get("key")
if bucket == "" || key == "" {
jsonErr(w, "missing bucket or key", 400)
return
}
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
// 7 days max expiry
reqParams := make(url.Values)
presignedURL, err := mc.PresignedGetObject(context.Background(), bucket, key, time.Hour * 24 * 7, reqParams)
if err != nil {
jsonErr(w, err.Error(), 500)
return
}
jsonOK(w, map[string]string{"url": strings.Replace(presignedURL.String(), "http://"+minioEndpoint, "https://"+publicMinioEndpoint, 1)})
}
// ─── GET /oort/api/objects/versions ──────────────────────────────────────────────
func handleS3ObjectVersions(w http.ResponseWriter, r *http.Request) {
ak, sk, _, ok := authS3Console(r)
if !ok { jsonErr(w, "unauthorized", 401); return }
bucket := r.URL.Query().Get("bucket")
key := r.URL.Query().Get("prefix") // we use prefix for key
mc, err := minioClient(ak, sk)
if err != nil { jsonErr(w, "minio error", 500); return }
var versions []map[string]any
for objInfo := range mc.ListObjects(context.Background(), bucket, minio.ListObjectsOptions{Prefix: key, WithVersions: true}) {
if objInfo.Err != nil { continue }
if objInfo.Key != key { continue } // only exact matches
versions = append(versions, map[string]any{
"VersionID": objInfo.VersionID,
"IsLatest": objInfo.IsLatest,
"IsDeleteMarker": objInfo.IsDeleteMarker,
"LastModified": objInfo.LastModified,
"Size": objInfo.Size,
})
}
jsonOK(w, map[string]any{"versions": versions})
}
// ─── POST /oort/api/objects/restore ──────────────────────────────────────────────
func handleS3ObjectRestore(w http.ResponseWriter, r *http.Request) {
ak, sk, _, ok := authS3Console(r)
if !ok { jsonErr(w, "unauthorized", 401); return }
var req struct {
Bucket string `json:"bucket"`
Key string `json:"key"`
VersionID string `json:"version_id"`
}
json.NewDecoder(r.Body).Decode(&req)
mc, err := minioClient(ak, sk)
if err != nil { jsonErr(w, "minio error", 500); return }
src := minio.CopySrcOptions{
Bucket: req.Bucket,
Object: req.Key,
VersionID: req.VersionID,
}
dst := minio.CopyDestOptions{
Bucket: req.Bucket,
Object: req.Key,
}
_, err = mc.CopyObject(context.Background(), dst, src)
if err != nil {
jsonErr(w, err.Error(), 500)
return
}
jsonOK(w, map[string]bool{"success": true})
}
var publicBucketCache sync.Map
var proxyTransport = &http.Transport{
MaxIdleConns: 10000,
MaxIdleConnsPerHost: 10000,
IdleConnTimeout: 90 * time.Second,
}
func handleS3PublicProxy(w http.ResponseWriter, r *http.Request, username, path string) {
idx := strings.Index(path, "/")
if idx == -1 {
w.Header().Set("Content-Type", "text/html")
w.WriteHeader(404)
w.Write([]byte("<html><body><h1>404 - Not Found</h1></body></html>"))
return
}
displayBucket := path[:idx]
objectKey := path[idx+1:]
cacheKey := username + ":" + displayBucket
var actualBucket string
if cached, ok := publicBucketCache.Load(cacheKey); ok {
actualBucket = cached.(string)
} else {
var email, defBucket string
err := scyllaSession.Query(`SELECT email, bucket FROM cosmos.users WHERE username=? ALLOW FILTERING`, username).Scan(&email, &defBucket)
if err != nil {
w.Header().Set("Content-Type", "text/html")
w.WriteHeader(404)
w.Write([]byte("<html><body><h1>404 - User Not Found</h1></body></html>"))
return
}
var defDisp string
scyllaSession.Query(`SELECT bucket_display_name FROM cosmos.users WHERE service='git' AND email=?`, email).Scan(&defDisp)
if defDisp == "" {
defDisp = "mybucket"
}
if displayBucket == defDisp {
actualBucket = defBucket
} else {
iter := scyllaSession.Query(`SELECT bucket_name, display_name FROM cosmos.buckets WHERE owner_email = ?`, email).Iter()
var b, disp string
for iter.Scan(&b, &disp) {
if disp == "" {
disp = b
}
if disp == displayBucket {
actualBucket = b
break
}
}
iter.Close()
}
if actualBucket == "" {
w.Header().Set("Content-Type", "text/html")
w.WriteHeader(404)
w.Write([]byte("<html><body><h1>404 - Bucket Not Found</h1></body></html>"))
return
}
publicBucketCache.Store(cacheKey, actualBucket)
}
targetPath := fmt.Sprintf("/%s/%s", actualBucket, objectKey)
targetUrl, _ := url.Parse("http://127.0.0.1:9000")
proxy := httputil.NewSingleHostReverseProxy(targetUrl)
proxy.Transport = proxyTransport
r.URL.Path = targetPath
r.URL.RawPath = targetPath
proxy.ModifyResponse = func(resp *http.Response) error {
if resp.StatusCode == 403 {
resp.StatusCode = 403
resp.Body = io.NopCloser(strings.NewReader("<html><body><h1>403 - Access Denied</h1><p>Public access is not enabled for this bucket.</p></body></html>"))
resp.Header.Set("Content-Length", fmt.Sprintf("%d", len("<html><body><h1>403 - Access Denied</h1><p>Public access is not enabled for this bucket.</p></body></html>")))
resp.Header.Set("Content-Type", "text/html")
}
return nil
}
tw := &trackingResponseWriter{ResponseWriter: w, statusCode: 200}
proxy.ServeHTTP(tw, r)
recordHit(actualBucket, tw.statusCode, tw.bytes, false, r.Header.Get("CF-IPCountry"), "read")
}
func handleS3BucketSettings(w http.ResponseWriter, r *http.Request) {
ak, _, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
if r.Method == "GET" {
bucket := r.URL.Query().Get("bucket")
if bucket == "" {
jsonErr(w, "missing bucket", 400)
return
}
isOwner := false
if bucket == defBucket {
isOwner = true
} else {
var owner string
if err := scyllaSession.Query(`SELECT owner_email FROM cosmos.buckets WHERE bucket_name=?`, bucket).Scan(&owner); err == nil && owner == ak {
isOwner = true
}
}
if !isOwner {
jsonErr(w, "forbidden", 403)
return
}
cmd := exec.Command("mc", "anonymous", "get", "cosmos/"+bucket)
out, _ := cmd.CombinedOutput()
isPublic := strings.Contains(string(out), "download") || strings.Contains(string(out), "public")
metrics := getMetrics(bucket)
jsonOK(w, map[string]any{
"is_public": isPublic,
"metrics": map[string]any{
"total": metrics.TotalRequests,
"success": metrics.TotalSuccess,
"errors": metrics.Total4xx + metrics.Total5xx,
"bytes_served": metrics.TotalBytes,
"last_hit": metrics.LastHit,
},
})
return
} else if r.Method == "POST" {
var req struct {
Bucket string `json:"bucket"`
IsPublic bool `json:"is_public"`
}
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
jsonErr(w, "invalid request", 400)
return
}
isOwner := false
if req.Bucket == defBucket {
isOwner = true
} else {
var owner string
if err := scyllaSession.Query(`SELECT owner_email FROM cosmos.buckets WHERE bucket_name=?`, req.Bucket).Scan(&owner); err == nil && owner == ak {
isOwner = true
}
}
if !isOwner {
jsonErr(w, "forbidden", 403)
return
}
policyCmd := "private"
if req.IsPublic {
policyCmd = "download"
}
cmd := exec.Command("mc", "anonymous", "set", policyCmd, "cosmos/"+req.Bucket)
if out, err := cmd.CombinedOutput(); err != nil {
log.Printf("[S3] Failed to set bucket %s to %s: %v | %s", req.Bucket, policyCmd, err, string(out))
jsonErr(w, "Failed to update bucket privacy", 500)
return
}
// Invalidate cache
publicBucketCache.Range(func(key, value any) bool {
if value.(string) == req.Bucket {
publicBucketCache.Delete(key)
}
return true
})
jsonOK(w, map[string]any{"success": true})
return
}
http.Error(w, "Method not allowed", 405)
}
func handleS3Analytics(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
http.Error(w, "Method not allowed", 405)
return
}
ak, _, defBucket, ok := authS3Console(r)
if !ok {
jsonErr(w, "unauthorized", 401)
return
}
filterBucket := r.URL.Query().Get("bucket")
filterStart := r.URL.Query().Get("start")
filterEnd := r.URL.Query().Get("end")
filterRegion := r.URL.Query().Get("region")
filterOp := r.URL.Query().Get("op") // "read" or "write" or "all"
var userBuckets []string
userBuckets = append(userBuckets, defBucket)
iter := scyllaSession.Query(`SELECT bucket_name FROM cosmos.buckets WHERE owner_email = ?`, ak).Iter()
var b string
for iter.Scan(&b) {
userBuckets = append(userBuckets, b)
}
iter.Close()
validBuckets := make(map[string]bool)
for _, b := range userBuckets {
validBuckets[b] = true
}
if filterBucket != "" && !validBuckets[filterBucket] && filterBucket != "all" {
jsonErr(w, "forbidden bucket", 403)
return
}
bucketsToQuery := userBuckets
if filterBucket != "" && filterBucket != "all" {
bucketsToQuery = []string{filterBucket}
}
type point struct {
Reqs int64
Cache int64
Origin int64
}
timeseriesMap := make(map[int64]*point)
var globeData []map[string]any
var tReq, tCache, tOrigin, tSucc, t4, t5, tBytes int64
now := time.Now().Truncate(time.Hour)
startTime := now.Add(-23 * time.Hour)
if filterEnd != "" {
if t, err := time.Parse("2006-01-02T15:04", filterEnd); err == nil {
now = t.Truncate(time.Hour)
}
}
if filterStart != "" {
if t, err := time.Parse("2006-01-02T15:04", filterStart); err == nil {
startTime = t.Truncate(time.Hour)
}
} else if filterEnd != "" {
startTime = now.Add(-23 * time.Hour)
}
if startTime.After(now) {
startTime = now.Add(-23 * time.Hour) // fallback if user sets invalid range
}
hoursDiff := int(now.Sub(startTime).Hours())
if hoursDiff < 1 { hoursDiff = 1 }
if hoursDiff > 720 { hoursDiff = 720 } // limit points
type countryData struct {
Reads int64
Writes int64
Total int64
}
countryMap := make(map[string]*countryData)
for _, b := range bucketsToQuery {
q := `SELECT hour, country, total_requests, cache_hits, origin_hits, total_success, total_errors, total_bytes, total_reads, total_writes FROM cosmos.s3_analytics_hourly WHERE bucket_name = ? AND hour >= ? AND hour <= ? ALLOW FILTERING`
iter := scyllaSession.Query(q, b, startTime, now).Iter()
var hour time.Time
var country string
var req, cache, origin, succ, errs, bytes, reads, writes int64
for iter.Scan(&hour, &country, &req, &cache, &origin, &succ, &errs, &bytes, &reads, &writes) {
actualReq := req
if filterOp == "read" {
if reads == 0 { continue }
actualReq = reads
} else if filterOp == "write" {
if writes == 0 { continue }
actualReq = writes
}
// Always populate globe data for all countries
if _, ok := countryMap[country]; !ok {
countryMap[country] = &countryData{}
}
countryMap[country].Reads += reads
countryMap[country].Writes += writes
countryMap[country].Total += req
if filterRegion != "" && filterRegion != "all" && country != filterRegion {
continue
}
// Apply read/write filter to the totals being accumulated if possible
// But for time series we will just use the totals.
tReq += actualReq
tCache += cache
tOrigin += origin
tSucc += succ
t4 += errs
tBytes += bytes
unixH := hour.Unix()
if _, ok := timeseriesMap[unixH]; !ok {
timeseriesMap[unixH] = &point{}
}
timeseriesMap[unixH].Reqs += actualReq
timeseriesMap[unixH].Cache += cache
timeseriesMap[unixH].Origin += origin
// Country map populated above
}
iter.Close()
}
var labels []string
var reqData, cacheData, originData []int64
for i := 0; i <= hoursDiff; i++ {
h := startTime.Add(time.Duration(i) * time.Hour)
if hoursDiff > 48 {
labels = append(labels, h.Format("01/02 15h"))
} else {
labels = append(labels, h.Format("15:00"))
}
unixH := h.Unix()
if val, ok := timeseriesMap[unixH]; ok {
reqData = append(reqData, val.Reqs)
cacheData = append(cacheData, val.Cache)
originData = append(originData, val.Origin)
} else {
reqData = append(reqData, 0)
cacheData = append(cacheData, 0)
originData = append(originData, 0)
}
}
var bucketsInfo []map[string]any
for _, b := range userBuckets {
if filterBucket != "" && filterBucket != "all" && b != filterBucket {
continue
}
var disp string
if b == defBucket {
scyllaSession.Query(`SELECT bucket_display_name FROM cosmos.users WHERE service='git' AND email=?`, ak).Scan(&disp)
if disp == "" { disp = "mybucket" }
} else {
scyllaSession.Query(`SELECT display_name FROM cosmos.buckets WHERE bucket_name = ?`, b).Scan(&disp)
if disp == "" { disp = b }
}
m := getMetrics(b)
bucketsInfo = append(bucketsInfo, map[string]any{
"name": b,
"display": disp,
"requests": m.TotalRequests,
"cache_hits": m.CacheHits,
"origin_hits": m.OriginHits,
"errors": m.Total4xx + m.Total5xx,
"bytes": m.TotalBytes,
"last_hit": m.LastHit,
})
}
for code, data := range countryMap {
hits := data.Total
if filterOp == "read" { hits = data.Reads }
if filterOp == "write" { hits = data.Writes }
if hits > 0 {
globeData = append(globeData, map[string]any{
"country": code,
"hits": hits,
"reads": data.Reads,
"writes": data.Writes,
})
}
}
jsonOK(w, map[string]any{
"total_requests": tReq,
"total_cache_hits": tCache,
"total_origin_hits": tOrigin,
"total_success": tSucc,
"total_4xx": t4,
"total_5xx": t5,
"total_bytes": tBytes,
"buckets": bucketsInfo,
"timeseries": map[string]any{
"labels": labels,
"reqs": reqData,
"cache": cacheData,
"origin": originData,
},
"globe": globeData,
})
}
// ─── POST /oort/api/bucket/empty ───────────────────────────────────────────────
func handleS3EmptyBucket(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
}
// Verify ownership
if bucket != defBucket {
var owner string
scyllaSession.Query(`SELECT owner_email FROM cosmos.buckets WHERE bucket_name = ?`, bucket).Scan(&owner)
if owner != ak {
jsonErr(w, "unauthorized or not found", 403)
return
}
}
mc, err := minio.New(minioEndpoint, &minio.Options{Creds: credentials.NewStaticV4(ak, sk, ""), Secure: false})
if err != nil {
jsonErr(w, "minio error", 500)
return
}
ctx := context.Background()
// Loop through all objects AND versions and permanently delete them
objectsCh := mc.ListObjects(ctx, bucket, minio.ListObjectsOptions{Recursive: true, WithVersions: true})
for obj := range objectsCh {
if obj.Err == nil {
mc.RemoveObject(ctx, bucket, obj.Key, minio.RemoveObjectOptions{VersionID: obj.VersionID})
}
}
jsonOK(w, map[string]bool{"emptied": true})
}
// ─── CUSTOM DOMAINS ─────────────────────────────────────────────────────────
var domainCache sync.Map // map[string]string (domain -> bucketName)
func handleS3BucketDomains(w http.ResponseWriter, r *http.Request) {
ak, _, defBucket, ok := authS3Console(r)
if !ok { jsonErr(w, "unauthorized", 401); return }
bucket := r.URL.Query().Get("bucket")
if bucket == "" { bucket = defBucket }
// Verify ownership
if bucket != defBucket {
var owner string
scyllaSession.Query(`SELECT owner_email FROM cosmos.buckets WHERE bucket_name = ?`, bucket).Scan(&owner)
if owner != ak { jsonErr(w, "unauthorized", 403); return }
}
var domains []string
iter := scyllaSession.Query(`SELECT domain FROM cosmos.bucket_domains WHERE bucket_name = ? ALLOW FILTERING`, bucket).Iter()
var d string
for iter.Scan(&d) { domains = append(domains, d) }
if err := iter.Close(); err != nil {}
if domains == nil { domains = []string{} }
jsonOK(w, map[string]interface{}{"domains": domains})
}
func handleS3BucketDomainAdd(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"`
Domain string `json:"domain"`
}
json.NewDecoder(r.Body).Decode(&req)
if req.Bucket == "" { req.Bucket = defBucket }
if req.Domain == "" { jsonErr(w, "missing domain", 400); return }
if req.Bucket != defBucket {
var owner string
scyllaSession.Query(`SELECT owner_email FROM cosmos.buckets WHERE bucket_name = ?`, req.Bucket).Scan(&owner)
if owner != ak { jsonErr(w, "unauthorized", 403); return }
}
// Check if domain is already in use
var existingBucket string
scyllaSession.Query(`SELECT bucket_name FROM cosmos.bucket_domains WHERE domain = ?`, req.Domain).Scan(&existingBucket)
if existingBucket != "" {
jsonErr(w, "domain already in use", 400)
return
}
scyllaSession.Query(`INSERT INTO cosmos.bucket_domains (domain, bucket_name, owner_email) VALUES (?, ?, ?)`, req.Domain, req.Bucket, ak).Exec()
domainCache.Store(req.Domain, req.Bucket)
jsonOK(w, map[string]bool{"success": true})
}
func handleS3BucketDomainRemove(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" && r.Method != "DELETE" { jsonErr(w, "method not allowed", 405); return }
ak, _, _, ok := authS3Console(r)
if !ok { jsonErr(w, "unauthorized", 401); return }
var req struct {
Domain string `json:"domain"`
}
json.NewDecoder(r.Body).Decode(&req)
domain := req.Domain
if domain == "" { domain = r.URL.Query().Get("domain") }
if domain == "" { jsonErr(w, "missing domain", 400); return }
var owner string
scyllaSession.Query(`SELECT owner_email FROM cosmos.bucket_domains WHERE domain = ?`, domain).Scan(&owner)
if owner != ak { jsonErr(w, "unauthorized", 403); return }
scyllaSession.Query(`DELETE FROM cosmos.bucket_domains WHERE domain = ?`, domain).Exec()
domainCache.Delete(domain)
jsonOK(w, map[string]bool{"success": true})
}
// ─── CDN PROXY ─────────────────────────────────────────────────────────────
func handleS3CDNProxy(w http.ResponseWriter, r *http.Request) {
host := r.Host
if strings.Contains(host, ":") {
host = strings.Split(host, ":")[0]
}
// Fast cache lookup
bucketIntf, ok := domainCache.Load(host)
var bucket string
if ok {
bucket = bucketIntf.(string)
} else {
scyllaSession.Query(`SELECT bucket_name FROM cosmos.bucket_domains WHERE domain = ?`, host).Scan(&bucket)
if bucket == "" {
http.Error(w, "Domain not mapped to any bucket", 404)
return
}
domainCache.Store(host, bucket)
}
// Extract key
key := strings.TrimPrefix(r.URL.Path, "/oort/api/cdn_proxy/")
if key == "" { key = "index.html" }
targetPath := "/" + bucket + "/" + key
targetUrl, _ := url.Parse("http://127.0.0.1:9000")
proxy := httputil.NewSingleHostReverseProxy(targetUrl)
proxy.Director = func(req *http.Request) {
req.URL.Scheme = targetUrl.Scheme
req.URL.Host = targetUrl.Host
req.URL.Path = targetPath
req.Host = targetUrl.Host
}
proxy.ModifyResponse = func(resp *http.Response) error {
recordHit(bucket, resp.StatusCode, resp.ContentLength, false, r.Header.Get("CF-IPCountry"), "read")
return nil
}
proxy.ServeHTTP(w, r)
}