move volume vacuum to gRpc

weed/server/master_server.go

@@ -24,7 +24,7 @@ type MasterServer struct {
 	preallocate             int64
 	pulseSeconds            int
 	defaultReplicaPlacement string
-	garbageThreshold        string
+	garbageThreshold        float64
 	guard                   *security.Guard
 
 	Topo   *topology.Topology
@@ -43,7 +43,7 @@ func NewMasterServer(r *mux.Router, port int, metaFolder string,
 	preallocate bool,
 	pulseSeconds int,
 	defaultReplicaPlacement string,
-	garbageThreshold string,
+	garbageThreshold float64,
 	whiteList []string,
 	secureKey string,
 ) *MasterServer {

weed/server/master_server_handlers_admin.go

@@ -37,9 +37,15 @@ func (ms *MasterServer) dirStatusHandler(w http.ResponseWriter, r *http.Request)
 }
 
 func (ms *MasterServer) volumeVacuumHandler(w http.ResponseWriter, r *http.Request) {
-	gcThreshold := r.FormValue("garbageThreshold")
-	if gcThreshold == "" {
-		gcThreshold = ms.garbageThreshold
+	gcString := r.FormValue("garbageThreshold")
+	gcThreshold := ms.garbageThreshold
+	if gcString != "" {
+		var err error
+		gcThreshold, err = strconv.ParseFloat(gcString, 32)
+		if err != nil {
+			glog.V(0).Infof("garbageThreshold %s is not a valid float number: %v", gcString, err)
+			return
+		}
 	}
 	glog.Infoln("garbageThreshold =", gcThreshold)
 	ms.Topo.Vacuum(gcThreshold, ms.preallocate)

weed/server/volume_grpc_server_vacuum.go

@@ -0,0 +1,73 @@
+package weed_server
+
+import (
+	"context"
+
+	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/pb/volume_server_pb"
+	"github.com/chrislusf/seaweedfs/weed/storage"
+)
+
+func (vs *VolumeServer) VacuumVolumeCheck(ctx context.Context, req *volume_server_pb.VacuumVolumeCheckRequest) (*volume_server_pb.VacuumVolumeCheckResponse, error) {
+
+	resp := &volume_server_pb.VacuumVolumeCheckResponse{}
+
+	garbageRatio, err := vs.store.CheckCompactVolume(storage.VolumeId(req.VolumdId))
+
+	resp.GarbageRatio = garbageRatio
+
+	if err != nil {
+		glog.V(3).Infof("check volume %d: %f", req.VolumdId, err)
+	}
+
+	return resp, err
+
+}
+
+func (vs *VolumeServer) VacuumVolumeCompact(ctx context.Context, req *volume_server_pb.VacuumVolumeCompactRequest) (*volume_server_pb.VacuumVolumeCompactResponse, error) {
+
+	resp := &volume_server_pb.VacuumVolumeCompactResponse{}
+
+	err := vs.store.CompactVolume(storage.VolumeId(req.VolumdId), req.Preallocate)
+
+	if err != nil {
+		glog.Errorf("compact volume %d: %f", req.VolumdId, err)
+	} else {
+		glog.V(1).Infof("compact volume %d", req.VolumdId)
+	}
+
+	return resp, err
+
+}
+
+func (vs *VolumeServer) VacuumVolumeCommit(ctx context.Context, req *volume_server_pb.VacuumVolumeCommitRequest) (*volume_server_pb.VacuumVolumeCommitResponse, error) {
+
+	resp := &volume_server_pb.VacuumVolumeCommitResponse{}
+
+	err := vs.store.CommitCompactVolume(storage.VolumeId(req.VolumdId))
+
+	if err != nil {
+		glog.Errorf("commit volume %d: %f", req.VolumdId, err)
+	} else {
+		glog.V(1).Infof("commit volume %d", req.VolumdId)
+	}
+
+	return resp, err
+
+}
+
+func (vs *VolumeServer) VacuumVolumeCleanup(ctx context.Context, req *volume_server_pb.VacuumVolumeCleanupRequest) (*volume_server_pb.VacuumVolumeCleanupResponse, error) {
+
+	resp := &volume_server_pb.VacuumVolumeCleanupResponse{}
+
+	err := vs.store.CommitCleanupVolume(storage.VolumeId(req.VolumdId))
+
+	if err != nil {
+		glog.Errorf("cleanup volume %d: %f", req.VolumdId, err)
+	} else {
+		glog.V(1).Infof("cleanup volume %d", req.VolumdId)
+	}
+
+	return resp, err
+
+}

weed/server/volume_server.go

@@ -48,10 +48,6 @@ func NewVolumeServer(adminMux, publicMux *http.ServeMux, ip string,
 	adminMux.HandleFunc("/ui/index.html", vs.uiStatusHandler)
 	adminMux.HandleFunc("/status", vs.guard.WhiteList(vs.statusHandler))
 	adminMux.HandleFunc("/admin/assign_volume", vs.guard.WhiteList(vs.assignVolumeHandler))
-	adminMux.HandleFunc("/admin/vacuum/check", vs.guard.WhiteList(vs.vacuumVolumeCheckHandler))
-	adminMux.HandleFunc("/admin/vacuum/compact", vs.guard.WhiteList(vs.vacuumVolumeCompactHandler))
-	adminMux.HandleFunc("/admin/vacuum/commit", vs.guard.WhiteList(vs.vacuumVolumeCommitHandler))
-	adminMux.HandleFunc("/admin/vacuum/cleanup", vs.guard.WhiteList(vs.vacuumVolumeCleanupHandler))
 	adminMux.HandleFunc("/admin/delete_collection", vs.guard.WhiteList(vs.deleteCollectionHandler))
 	adminMux.HandleFunc("/admin/sync/status", vs.guard.WhiteList(vs.getVolumeSyncStatusHandler))
 	adminMux.HandleFunc("/admin/sync/index", vs.guard.WhiteList(vs.getVolumeIndexContentHandler))

weed/server/volume_server_handlers_vacuum.go

@@ -1,53 +0,0 @@
-package weed_server
-
-import (
-	"net/http"
-	"strconv"
-
-	"github.com/chrislusf/seaweedfs/weed/glog"
-)
-
-func (vs *VolumeServer) vacuumVolumeCheckHandler(w http.ResponseWriter, r *http.Request) {
-	err, ret := vs.store.CheckCompactVolume(r.FormValue("volume"), r.FormValue("garbageThreshold"))
-	if err == nil {
-		writeJsonQuiet(w, r, http.StatusOK, map[string]interface{}{"error": "", "result": ret})
-	} else {
-		writeJsonQuiet(w, r, http.StatusInternalServerError, map[string]interface{}{"error": err.Error(), "result": false})
-	}
-	glog.V(2).Infoln("checked compacting volume =", r.FormValue("volume"), "garbageThreshold =", r.FormValue("garbageThreshold"), "vacuum =", ret)
-}
-func (vs *VolumeServer) vacuumVolumeCompactHandler(w http.ResponseWriter, r *http.Request) {
-	var preallocate int64
-	var err error
-	if r.FormValue("preallocate") != "" {
-		preallocate, err = strconv.ParseInt(r.FormValue("preallocate"), 10, 64)
-		if err != nil {
-			glog.V(0).Infof("Failed to parse int64 preallocate = %s: %v", r.FormValue("preallocate"), err)
-		}
-	}
-	err = vs.store.CompactVolume(r.FormValue("volume"), preallocate)
-	if err == nil {
-		writeJsonQuiet(w, r, http.StatusOK, map[string]string{"error": ""})
-	} else {
-		writeJsonError(w, r, http.StatusInternalServerError, err)
-	}
-	glog.V(2).Infoln("compacted volume =", r.FormValue("volume"), ", error =", err)
-}
-func (vs *VolumeServer) vacuumVolumeCommitHandler(w http.ResponseWriter, r *http.Request) {
-	err := vs.store.CommitCompactVolume(r.FormValue("volume"))
-	if err == nil {
-		writeJsonQuiet(w, r, http.StatusOK, map[string]string{"error": ""})
-	} else {
-		writeJsonError(w, r, http.StatusInternalServerError, err)
-	}
-	glog.V(2).Infoln("commit compact volume =", r.FormValue("volume"), ", error =", err)
-}
-func (vs *VolumeServer) vacuumVolumeCleanupHandler(w http.ResponseWriter, r *http.Request) {
-	err := vs.store.CommitCleanupVolume(r.FormValue("volume"))
-	if err == nil {
-		writeJsonQuiet(w, r, http.StatusOK, map[string]string{"error": ""})
-	} else {
-		writeJsonError(w, r, http.StatusInternalServerError, err)
-	}
-	glog.V(2).Infoln("cleanup compact volume =", r.FormValue("volume"), ", error =", err)
-}