Important Notes:
Performance: Erasure coding is CPU and I/O intensive. Consider running during off-peak hours.
-
Durability: With ` + fmt.Sprintf("%d+%d", config.ShardCount, config.ParityCount) + ` configuration, can tolerate up to ` + fmt.Sprintf("%d", config.ParityCount) + ` shard failures.
+
Durability: With 10+4 configuration, can tolerate up to 4 shard failures.
+
Configuration: Use the dropdown to select time units (days, hours, minutes). Fullness ratio should be between 0.0 and 1.0 (e.g., 0.90 for 90%).
@@ -180,27 +179,41 @@ func (ui *UIProvider) RenderConfigForm(currentConfig interface{}) (template.HTML
// ParseConfigForm parses form data into configuration
func (ui *UIProvider) ParseConfigForm(formData map[string][]string) (interface{}, error) {
- config := &ErasureCodingConfig{}
+ config := ErasureCodingConfig{}
// Parse enabled
config.Enabled = len(formData["enabled"]) > 0
- // Parse volume age hours
- if values, ok := formData["volume_age_hours_seconds"]; ok && len(values) > 0 {
- hours, err := strconv.Atoi(values[0])
+ // Parse quiet for duration
+ if values, ok := formData["quiet_for_seconds_value"]; ok && len(values) > 0 {
+ value, err := strconv.Atoi(values[0])
if err != nil {
- return nil, fmt.Errorf("invalid volume age hours: %w", err)
+ return nil, fmt.Errorf("invalid quiet for duration value: %w", err)
}
- config.VolumeAgeHoursSeconds = hours
+
+ unit := "minute" // default
+ if units, ok := formData["quiet_for_seconds_unit"]; ok && len(units) > 0 {
+ unit = units[0]
+ }
+
+ // Convert to seconds using the helper function from types package
+ config.QuietForSeconds = types.IntervalValueUnitToSeconds(value, unit)
}
// Parse scan interval
- if values, ok := formData["scan_interval_seconds"]; ok && len(values) > 0 {
- interval, err := strconv.Atoi(values[0])
+ if values, ok := formData["scan_interval_seconds_value"]; ok && len(values) > 0 {
+ value, err := strconv.Atoi(values[0])
if err != nil {
- return nil, fmt.Errorf("invalid scan interval: %w", err)
+ return nil, fmt.Errorf("invalid scan interval value: %w", err)
}
- config.ScanIntervalSeconds = interval
+
+ unit := "minute" // default
+ if units, ok := formData["scan_interval_seconds_unit"]; ok && len(units) > 0 {
+ unit = units[0]
+ }
+
+ // Convert to seconds
+ config.ScanIntervalSeconds = types.IntervalValueUnitToSeconds(value, unit)
}
// Parse max concurrent
@@ -215,28 +228,21 @@ func (ui *UIProvider) ParseConfigForm(formData map[string][]string) (interface{}
config.MaxConcurrent = maxConcurrent
}
- // Parse shard count
- if values, ok := formData["shard_count"]; ok && len(values) > 0 {
- shardCount, err := strconv.Atoi(values[0])
+ // Parse fullness ratio
+ if values, ok := formData["fullness_ratio"]; ok && len(values) > 0 {
+ fullnessRatio, err := strconv.ParseFloat(values[0], 64)
if err != nil {
- return nil, fmt.Errorf("invalid shard count: %w", err)
+ return nil, fmt.Errorf("invalid fullness ratio: %w", err)
}
- if shardCount < 1 {
- return nil, fmt.Errorf("shard count must be at least 1")
+ if fullnessRatio < 0 || fullnessRatio > 1 {
+ return nil, fmt.Errorf("fullness ratio must be between 0.0 and 1.0")
}
- config.ShardCount = shardCount
+ config.FullnessRatio = fullnessRatio
}
- // Parse parity count
- if values, ok := formData["parity_count"]; ok && len(values) > 0 {
- parityCount, err := strconv.Atoi(values[0])
- if err != nil {
- return nil, fmt.Errorf("invalid parity count: %w", err)
- }
- if parityCount < 1 {
- return nil, fmt.Errorf("parity count must be at least 1")
- }
- config.ParityCount = parityCount
+ // Parse collection filter
+ if values, ok := formData["collection_filter"]; ok && len(values) > 0 {
+ config.CollectionFilter = values[0]
}
return config, nil
@@ -257,7 +263,9 @@ func (ui *UIProvider) ApplyConfig(config interface{}) error {
// Apply to detector
if ui.detector != nil {
ui.detector.SetEnabled(ecConfig.Enabled)
- ui.detector.SetVolumeAgeHours(ecConfig.VolumeAgeHoursSeconds)
+ ui.detector.SetQuietForSeconds(ecConfig.QuietForSeconds)
+ ui.detector.SetFullnessRatio(ecConfig.FullnessRatio)
+ ui.detector.SetCollectionFilter(ecConfig.CollectionFilter)
ui.detector.SetScanInterval(secondsToDuration(ecConfig.ScanIntervalSeconds))
}
@@ -267,8 +275,8 @@ func (ui *UIProvider) ApplyConfig(config interface{}) error {
ui.scheduler.SetMaxConcurrent(ecConfig.MaxConcurrent)
}
- glog.V(1).Infof("Applied erasure coding configuration: enabled=%v, age_threshold=%v, max_concurrent=%d, shards=%d+%d",
- ecConfig.Enabled, ecConfig.VolumeAgeHoursSeconds, ecConfig.MaxConcurrent, ecConfig.ShardCount, ecConfig.ParityCount)
+ glog.V(1).Infof("Applied erasure coding configuration: enabled=%v, quiet_for=%v seconds, max_concurrent=%d, fullness_ratio=%f, collection_filter=%s, shards=10+4",
+ ecConfig.Enabled, ecConfig.QuietForSeconds, ecConfig.MaxConcurrent, ecConfig.FullnessRatio, ecConfig.CollectionFilter)
return nil
}
@@ -277,18 +285,20 @@ func (ui *UIProvider) ApplyConfig(config interface{}) error {
func (ui *UIProvider) getCurrentECConfig() ErasureCodingConfig {
config := ErasureCodingConfig{
// Default values (fallback if detectors/schedulers are nil)
- Enabled: true,
- VolumeAgeHoursSeconds: 24 * 3600, // 24 hours in seconds
- ScanIntervalSeconds: 2 * 3600, // 2 hours in seconds
- MaxConcurrent: 1,
- ShardCount: 10,
- ParityCount: 4,
+ Enabled: true,
+ QuietForSeconds: 24 * 3600, // Default to 24 hours in seconds
+ ScanIntervalSeconds: 2 * 3600, // 2 hours in seconds
+ MaxConcurrent: 1,
+ FullnessRatio: 0.90, // Default fullness ratio
+ CollectionFilter: "",
}
// Get current values from detector
if ui.detector != nil {
config.Enabled = ui.detector.IsEnabled()
- config.VolumeAgeHoursSeconds = ui.detector.GetVolumeAgeHours()
+ config.QuietForSeconds = ui.detector.GetQuietForSeconds()
+ config.FullnessRatio = ui.detector.GetFullnessRatio()
+ config.CollectionFilter = ui.detector.GetCollectionFilter()
config.ScanIntervalSeconds = durationToSeconds(ui.detector.ScanInterval())
}
diff --git a/weed/worker/tasks/vacuum/ui.go b/weed/worker/tasks/vacuum/ui.go
index 6f67a801a..7d1eebb6d 100644
--- a/weed/worker/tasks/vacuum/ui.go
+++ b/weed/worker/tasks/vacuum/ui.go
@@ -101,19 +101,19 @@ func (ui *UIProvider) RenderConfigForm(currentConfig interface{}) (template.HTML
true,
)
- form.AddDurationField(
+ form.AddIntervalField(
"scan_interval",
"Scan Interval",
"How often to scan for volumes needing vacuum",
- secondsToDuration(config.ScanIntervalSeconds),
+ config.ScanIntervalSeconds,
true,
)
- form.AddDurationField(
+ form.AddIntervalField(
"min_volume_age",
"Minimum Volume Age",
"Only vacuum volumes older than this duration",
- secondsToDuration(config.MinVolumeAgeSeconds),
+ config.MinVolumeAgeSeconds,
true,
)
@@ -189,21 +189,35 @@ func (ui *UIProvider) ParseConfigForm(formData map[string][]string) (interface{}
}
// Parse scan interval
- if intervalStr := formData["scan_interval"]; len(intervalStr) > 0 {
- if interval, err := time.ParseDuration(intervalStr[0]); err != nil {
- return nil, fmt.Errorf("invalid scan interval: %w", err)
- } else {
- config.ScanIntervalSeconds = durationToSeconds(interval)
+ if values, ok := formData["scan_interval_value"]; ok && len(values) > 0 {
+ value, err := strconv.Atoi(values[0])
+ if err != nil {
+ return nil, fmt.Errorf("invalid scan interval value: %w", err)
+ }
+
+ unit := "minute" // default
+ if units, ok := formData["scan_interval_unit"]; ok && len(units) > 0 {
+ unit = units[0]
}
+
+ // Convert to seconds
+ config.ScanIntervalSeconds = types.IntervalValueUnitToSeconds(value, unit)
}
// Parse min volume age
- if ageStr := formData["min_volume_age"]; len(ageStr) > 0 {
- if age, err := time.ParseDuration(ageStr[0]); err != nil {
- return nil, fmt.Errorf("invalid min volume age: %w", err)
- } else {
- config.MinVolumeAgeSeconds = durationToSeconds(age)
+ if values, ok := formData["min_volume_age_value"]; ok && len(values) > 0 {
+ value, err := strconv.Atoi(values[0])
+ if err != nil {
+ return nil, fmt.Errorf("invalid min volume age value: %w", err)
}
+
+ unit := "minute" // default
+ if units, ok := formData["min_volume_age_unit"]; ok && len(units) > 0 {
+ unit = units[0]
+ }
+
+ // Convert to seconds
+ config.MinVolumeAgeSeconds = types.IntervalValueUnitToSeconds(value, unit)
}
// Parse max concurrent
diff --git a/weed/worker/types/task_ui.go b/weed/worker/types/task_ui.go
index e1e2752ba..7ad5437f6 100644
--- a/weed/worker/types/task_ui.go
+++ b/weed/worker/types/task_ui.go
@@ -6,6 +6,40 @@ import (
"time"
)
+// Helper function to convert seconds to the most appropriate interval unit
+func secondsToIntervalValueUnit(totalSeconds int) (int, string) {
+ if totalSeconds == 0 {
+ return 0, "minute"
+ }
+
+ // Check if it's evenly divisible by days
+ if totalSeconds%(24*3600) == 0 {
+ return totalSeconds / (24 * 3600), "day"
+ }
+
+ // Check if it's evenly divisible by hours
+ if totalSeconds%3600 == 0 {
+ return totalSeconds / 3600, "hour"
+ }
+
+ // Default to minutes
+ return totalSeconds / 60, "minute"
+}
+
+// Helper function to convert interval value and unit to seconds
+func IntervalValueUnitToSeconds(value int, unit string) int {
+ switch unit {
+ case "day":
+ return value * 24 * 3600
+ case "hour":
+ return value * 3600
+ case "minute":
+ return value * 60
+ default:
+ return value * 60 // Default to minutes
+ }
+}
+
// TaskUIProvider defines how tasks provide their configuration UI
type TaskUIProvider interface {
// GetTaskType returns the task type
@@ -100,11 +134,14 @@ type TaskDetailsData struct {
type FormField struct {
Name string `json:"name"`
Label string `json:"label"`
- Type string `json:"type"` // text, number, checkbox, select, duration
+ Type string `json:"type"` // text, number, checkbox, select, duration, interval
Value interface{} `json:"value"`
Description string `json:"description"`
Required bool `json:"required"`
Options []FormOption `json:"options,omitempty"` // For select fields
+ // Interval-specific fields
+ IntervalValue int `json:"interval_value,omitempty"` // Numeric value for interval
+ IntervalUnit string `json:"interval_unit,omitempty"` // Unit for interval (day, hour, minute)
}
type FormOption struct {
@@ -190,6 +227,23 @@ func (fb *FormBuilder) AddDurationField(name, label, description string, value t
return fb
}
+// AddIntervalField adds an interval field with value and unit dropdown
+func (fb *FormBuilder) AddIntervalField(name, label, description string, totalSeconds int, required bool) *FormBuilder {
+ // Convert seconds to the most appropriate unit
+ value, unit := secondsToIntervalValueUnit(totalSeconds)
+
+ fb.fields = append(fb.fields, FormField{
+ Name: name,
+ Label: label,
+ Type: "interval",
+ Description: description,
+ Required: required,
+ IntervalValue: value,
+ IntervalUnit: unit,
+ })
+ return fb
+}
+
// Build generates the HTML form fields with Bootstrap styling
func (fb *FormBuilder) Build() template.HTML {
html := ""
@@ -269,6 +323,37 @@ func (fb *FormBuilder) renderField(field FormField) string {
html += " required"
}
html += ">\n"
+
+ case "interval":
+ // Create input group with number input and unit select
+ html += "