done with API

api.go

@@ -1,48 +1,29 @@
 package main
 
 import (
-	//"context"
 	"errors"
 	"encoding/json"
-	garage "git.deuxfleurs.fr/garage-sdk/garage-admin-sdk-golang"
+	"fmt"
 	"github.com/gorilla/mux"
-	"log"
 	"net/http"
 )
 
-type ApiQuotaView struct {
+func handleAPIWebsiteList(w http.ResponseWriter, r *http.Request) {
-	files *uint64
+	user := RequireUserApi(w, r)
-	size  *uint64
-}
 
-type ApiBucketView struct {
+	if user == nil {
-	global *bool
-	max    *ApiQuotaView
-	used   *ApiQuotaView
-}
-
-type BucketRequest struct {
-	s3key      *garage.KeyInfo
-	bucketName string
-	bucketId   string
-	global     bool
-	http       *http.Request
-}
-
-func handleAPIWebsite(w http.ResponseWriter, r *http.Request) {
-	
-	br, err := buildBucketRequest(w, r)
-	if err != nil {
 		return 
 	}
 
-	if r.Method == http.MethodPatch {
+	ctrl, err := NewWebsiteController(user)
-		patchGarageBucket(w, br)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
 
 	if r.Method == http.MethodGet {
-		getGarageBucket(w, br)
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(ctrl.Describe())
 		return
 	}
 
@@ -50,131 +31,92 @@ func handleAPIWebsite(w http.ResponseWriter, r *http.Request) {
 	return
 }
 
-func buildBucketRequest(w http.ResponseWriter, r *http.Request) (*BucketRequest, error) {
+func handleAPIWebsiteInspect(w http.ResponseWriter, r *http.Request) {
 	user := RequireUserApi(w, r)
+
 	if user == nil {
-		return nil, errors.New("Unable to fetch user")
+		return 
 	}
 
-	// FETCH BUCKET ID by iterating over buckets owned by this key
 	bucketName := mux.Vars(r)["bucket"]
-	var bucketId *string
+	ctrl, err := NewWebsiteController(user)
-	var global *bool
-
-	s3key, err := user.S3KeyInfo()
 	if err != nil {
-		return nil, err
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
 	}
 
-findBucketIdLoop:
+	if r.Method == http.MethodGet {
-	for _, bucket := range s3key.Buckets {
+		view, err := ctrl.Inspect(bucketName)
-		for _, localAlias := range bucket.LocalAliases {
+		if errors.Is(err, ErrWebsiteNotFound) {
-			if localAlias == bucketName {
+			http.Error(w, err.Error(), http.StatusNotFound)
-				bucketId = bucket.Id
+			return
-				*global = false
+		} else if err != nil {
-				break findBucketIdLoop
+			http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
+			return
-		}
-		for _, globalAlias := range bucket.GlobalAliases {
-			if globalAlias == bucketName {
-				bucketId = bucket.Id
-				*global = true
-				break findBucketIdLoop
-			}
 		}
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(view)
+		return
 	}
 
-	if bucketId == nil || global == nil {
+	if r.Method == http.MethodPost {
-		http.Error(w, "Bucket not found in this account", http.StatusNotFound)
+		view, err := ctrl.Create(bucketName)
-		return nil, errors.New("Unable to fetch bucket ID")
+		if errors.Is(err, ErrEmptyBucketName) {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		} else if errors.Is(err, ErrWebsiteQuotaReached) {
+			http.Error(w, err.Error(), http.StatusForbidden)
+			return
+		} else if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
 		}
 
-	return &BucketRequest{
+		w.WriteHeader(http.StatusCreated)
-		s3key:      s3key,
+		w.Header().Set("Content-Type", "application/json")
-		bucketName: bucketName,
+		json.NewEncoder(w).Encode(view)
-		bucketId:   *bucketId,
+		return
-		global:     *global,
+	}
-		http:       r,
-	}, nil
 
-}
+	if r.Method == http.MethodPatch {
-
+		var patch WebsitePatch
-func patchGarageBucket(w http.ResponseWriter, br *BucketRequest) {
+		err := json.NewDecoder(r.Body).Decode(&patch)
-	var err error
+    		if err != nil {
-
+			http.Error(w, errors.Join(fmt.Errorf("Can't parse the request body as a website patch JSON"), err).Error(), http.StatusBadRequest)
-	// DECODE BODY
+			return
-	var queuedChange ApiBucketView
+		}
-	decoder := json.NewDecoder(br.http.Body)
+
-	err = decoder.Decode(&queuedChange)
+		view, err := ctrl.Patch(bucketName, &patch)
-	if err != nil {
+		if errors.Is(err, ErrWebsiteNotFound) {
-		log.Println(err)
+			http.Error(w, err.Error(), http.StatusNotFound)
-		http.Error(w, "Unable to decode the body", http.StatusBadRequest)
+			return
-		return
+		} else if err != nil {
-	}
+			http.Error(w, err.Error(), http.StatusInternalServerError)
-
+			return
-	// SET THE GLOBAL FLAG
+		} 
-	if queuedChange.global != nil {
+
-		if *queuedChange.global && !br.global {
+		w.Header().Set("Content-Type", "application/json")
-			_, err = grgAddGlobalAlias(br.bucketId, br.bucketName)
+		json.NewEncoder(w).Encode(view)
-			if err != nil {
+		return
-				http.Error(w, "Unable to add the requested name as global alias for this bucket", http.StatusInternalServerError)
+	}
-				return
+
-			}
+	if r.Method == http.MethodDelete {
-			_, err = grgDelLocalAlias(br.bucketId, *br.s3key.AccessKeyId, br.bucketName)
+		err := ctrl.Delete(bucketName)
-			if err != nil {
+		if errors.Is(err, ErrEmptyBucketName) || errors.Is(err, ErrBucketDeleteNotEmpty) || errors.Is(err, ErrBucketDeleteUnfinishedUpload) {
-				http.Error(w, "Unable to remove the local alias for this bucket", http.StatusInternalServerError)
+			http.Error(w, err.Error(), http.StatusBadRequest)
-				return
+			return
-			}
+		} else if errors.Is(err, ErrWebsiteNotFound) {
-		} else if !*queuedChange.global && br.global {
+			http.Error(w, err.Error(), http.StatusNotFound)
-			grgAddLocalAlias(br.bucketId, *br.s3key.AccessKeyId, br.bucketName)
+			return
-			if err != nil {
+		} else if err != nil {
-				http.Error(w, "Unable to add the requested name as local alias for this bucket", http.StatusInternalServerError)
+			http.Error(w, err.Error(), http.StatusInternalServerError)
-				return
+			return
-			}
+		}
-			grgDelGlobalAlias(br.bucketId, br.bucketName)
+		w.WriteHeader(http.StatusNoContent)
-			if err != nil {
+		return
-				http.Error(w, "Unable to remove the global alias for this bucket", http.StatusInternalServerError)
+		
-				return
+	}
-			}
+
-		}
+	http.Error(w, "This method is not implemented for this endpoint", http.StatusNotImplemented)
-	}
+	return
-
-	// CHECK IF QUOTA MUST BE ADDED TO THIS BUCKET
-
-	// VALIDATE IT
-	// --- global ---
-	// 1. can be true, false, or nil (use pointers)
-	// 2. if nil do nothing
-	// 3. if false, throw "not yet implemented" (501)
-	// 4. if true, check that the bucket name does not exist yet in the global namespace, throw "forbidden" (403)
-	// --- quota.size ---
-	// 1. if no quota on the bucket + this field is none, set to 50MB
-	// 2. if lower than 50MB, set to 50MB. If higher than 200MB, set to 200MB
-	// --- quota.files ---
-	// 1. if no quota on the bucket + this field is none, set to 10k
-	// 2. if lower than 10k, set to 10k. If higher than 40k, set to 40k
-	// READ BODY JSON
-
-	// IF BODY.GLOBAL is not NONE
-	// DO: Add an alias
-
-	// IF BODY.QUOTA.SIZE is not NONE
-	// DO: Change quota
-
-	// IF BODY.QUOTA.FILE is not NONE
-	// DO: Change quota
-
-	getGarageBucket(w, br)
-}
-
-func getGarageBucket(w http.ResponseWriter, br *BucketRequest) {
-	// FETCH AN UPDATED BUCKET VIEW
-	bucket, err := grgGetBucket(br.bucketId)
-	if err != nil {
-		http.Error(w, "Unable to fetch bucket details", http.StatusInternalServerError)
-		return
-	}
-
-	// BUILD A VIEW
-	log.Println(bucket)
 }

garage.go

@@ -194,9 +194,9 @@ func handleWebsiteList(w http.ResponseWriter, r *http.Request) {
 		return 
 	}
 
-	list := ctrl.List()
+	desc := ctrl.Describe()
-	if len(list) > 0 {
+	if len(desc.Websites) > 0 {
-		http.Redirect(w, r, "/website/inspect/"+list[0].Pretty, http.StatusFound)
+		http.Redirect(w, r, "/website/inspect/"+desc.Websites[0].Pretty, http.StatusFound)
 	} else {
 		http.Redirect(w, r, "/website/new", http.StatusFound)
 	}
@@ -271,7 +271,7 @@ func handleWebsiteInspect(w http.ResponseWriter, r *http.Request) {
 		action := strings.Join(r.Form["action"],"")
 		switch action {
 			case "increase_quota":
-				_, processErr = ctrl.Patch(bucketName, &WebsitePatch { size: &user.Quota.WebsiteSizeBursted })
+				_, processErr = ctrl.Patch(bucketName, &WebsitePatch { Size: &user.Quota.WebsiteSizeBursted })
 			case "delete_bucket":
 				processErr = ctrl.Delete(bucketName)
 				http.Redirect(w, r, "/website", http.StatusFound)

main.go

@@ -147,7 +147,8 @@ func server(args []string) {
 	r.HandleFunc("/login", handleLogin)
 	r.HandleFunc("/logout", handleLogout)
 
-	r.HandleFunc("/api/unstable/website/{bucket}", handleAPIWebsite)
+	r.HandleFunc("/api/unstable/website", handleAPIWebsiteList)
+	r.HandleFunc("/api/unstable/website/{bucket}", handleAPIWebsiteInspect)
 
 	r.HandleFunc("/profile", handleProfile)
 	r.HandleFunc("/passwd", handlePasswd)

quotas.go

@@ -102,10 +102,10 @@ func (q *UserQuota) WebsiteSizeBurstedPretty() string {
 
 // --- A quota stat we can use
 type QuotaStat struct {
-	Current   int64
+	Current   int64 `json:"current"`
-	Max	  int64
+	Max	  int64 `json:"max"`
-	Ratio	  float64
+	Ratio	  float64 `json:"ratio"`
-	Burstable bool
+	Burstable bool `json:"burstable"`
 }
 func NewQuotaStat(current, max int64, burstable bool) QuotaStat {
 	return QuotaStat {

templates/home.html

@@ -24,11 +24,11 @@
 <div class="mt-3">
     <div class="card">
         <div class="card-header">
-            Garage
+            Mon espace sur la toile
         </div>
         <div class="list-group list-group-flush">
             <a class="list-group-item list-group-item-action" href="/website/configure">Mes identifiants</a>
-            <a class="list-group-item list-group-item-action" href="/website">Mes sites webs</a>
+            <a class="list-group-item list-group-item-action" href="/website">Mes sites Web</a>
         </div>
     </div>
 </div>

website.go

@@ -22,11 +22,11 @@ var (
 
 
 type WebsiteId struct {
-	Pretty string
+	Pretty string `json:"name"`
-	Internal string
+	Internal string `json:"-"`
-	Alt []string
+	Alt []string `json:"alt_name"`
-	Expanded bool
+	Expanded bool `json:"expanded"`
-	Url string
+	Url string `json:"domain"`
 
 }
 func NewWebsiteId(id string, aliases []string) *WebsiteId {
@@ -80,12 +80,17 @@ func NewWebsiteController(user *LoggedUser) (*WebsiteController, error) {
 	return &WebsiteController { user, idx, wlist, quota }, nil
 }
 
-func (w *WebsiteController) List() []*WebsiteId {
+type WebsiteDescribe struct {
+	AllowedWebsites *QuotaStat `json:"quota"`
+	Websites []*WebsiteId `json:"vhosts"`
+}
+
+func (w *WebsiteController) Describe() *WebsiteDescribe {
 	r := make([]*WebsiteId, 0, len(w.PrettyList))
 	for _, k := range w.PrettyList {
 		r = append(r, w.WebsiteIdx[k]) 
 	}
-	return r
+	return &WebsiteDescribe { &w.WebsiteCount, r }
 }
 
 func (w *WebsiteController) Inspect(pretty string) (*WebsiteView, error) {
@@ -117,8 +122,8 @@ func (w *WebsiteController) Patch(pretty string, patch *WebsitePatch) (*WebsiteV
 	urQuota := garage.NewUpdateBucketRequestQuotas()
 	urQuota.SetMaxSize(w.User.Quota.WebsiteSizeAdjust(binfo.Quotas.GetMaxSize()))
 	urQuota.SetMaxObjects(w.User.Quota.WebsiteObjectAdjust(binfo.Quotas.GetMaxObjects()))
-	if patch.size != nil {
+	if patch.Size != nil {
-		urQuota.SetMaxSize(w.User.Quota.WebsiteSizeAdjust(*patch.size))
+		urQuota.SetMaxSize(w.User.Quota.WebsiteSizeAdjust(*patch.Size))
 	}
 
 	// Build the update
@@ -205,9 +210,9 @@ func (w *WebsiteController) Delete(pretty string) error {
 
 
 type WebsiteView struct {
-	Name *WebsiteId
+	Name *WebsiteId `json:"identified_as"`
-	Size QuotaStat
+	Size QuotaStat `json:"quota_size"`
-	Files QuotaStat
+	Files QuotaStat `json:"quota_files"`
 }
 
 func NewWebsiteView(binfo *garage.BucketInfo) *WebsiteView {
@@ -220,5 +225,5 @@ func NewWebsiteView(binfo *garage.BucketInfo) *WebsiteView {
 }
 
 type WebsitePatch struct {
-	size *int64
+	Size *int64 `json:"quota_size"`
 }