added debug logs, fixed default schedule not respected

Author: WhySoBad

config.yml

@@ -4,7 +4,7 @@ registries:
       age.min:
       age.max:
       revisions: 10
-      schedule: 1/5 * * * * *
+      schedule: 1/45 * * * * *
     rule:
       test:
         age.min: 30s

src/instance.rs

@@ -28,11 +28,11 @@ pub struct Instance {
     client: Arc<Docker>
 }
 
-const RULE_REGEX: &str = "rule.(?<name>[a-z]+)";
+const RULE_REGEX: &str = "rule\\.(?<name>[a-z]+)";
 const DEFAULT_RULE_REGEX: &str = "default";
 const POLICY_NAME_REGEX: &str = "(?<policy>[a-z\\.]+)";
 /// Per default the schedule is set to daily at midnight
-const DEFAULT_SCHEDULE: &str = "0 0 * * * * *";
+const DEFAULT_SCHEDULE: &str = "0 0 0 * * * *";
 
 impl Instance {
     pub fn new(id: String, mut name: String, labels: HashMap<String, String>, networks: HashMap<String, EndpointSettings>, client: Arc<Docker>) -> Result<Self, Error> {
@@ -129,11 +129,11 @@ impl Instance {
     }
 
     fn get_default_rule_pattern() -> Regex {
-        Regex::new(format!("{NAME}.{DEFAULT_RULE_REGEX}.{POLICY_NAME_REGEX}").as_str()).expect("Default rule pattern should be valid")
+        Regex::new(format!("{NAME}\\.{DEFAULT_RULE_REGEX}\\.{POLICY_NAME_REGEX}").as_str()).expect("Default rule pattern should be valid")
     }
 
     fn get_rule_pattern() -> Regex {
-        Regex::new(format!("{NAME}.{RULE_REGEX}.{POLICY_NAME_REGEX}").as_str()).expect("Rule pattern should be valid")
+        Regex::new(format!("{NAME}\\.{RULE_REGEX}\\.{POLICY_NAME_REGEX}").as_str()).expect("Rule pattern should be valid")
     }
 
     /// Parse all rules including the default rule from the instance configuration
@@ -167,23 +167,29 @@ impl Instance {
                 entry.push((key, value.as_str()))
             });
 
+        debug!("Rule labels {rule_labels:?}");
 
         for (name, labels) in rule_labels {
             let is_default = default_rule_name.eq(&name);
             let rule = parse_rule(name.clone(), labels);
+            debug!("Parsed rule {rule:?} default? {is_default}");
             if let Some(rule) = rule {
                 if is_default {
                     default_rule.tag_policies.extend(rule.tag_policies);
                     default_rule.repository_policies.extend(rule.repository_policies);
-                    if default_rule.schedule.is_empty() {
+                    if rule.schedule.is_empty() {
                         default_rule.schedule = default_schedule.clone();
+                    } else {
+                        default_rule.schedule = rule.schedule;
                     }
                 } else {
                     rules.insert(name, rule);
                 }
             }
         }
 
+        debug!("Default rule {default_rule:?}");
+
         (default_rule, rules)
     }
 
@@ -207,6 +213,7 @@ impl Instance {
     /// All tags (on repositories) which match at least one of the rules will be deleted and
     /// additionally the garbage collector inside the registry will be run automatically
     pub async fn apply_rules(&self, rules: Vec<String>) -> Result<(), Error> {
+        debug!("Applying rules to registry '{}'", self.name);
         let distribution = Distribution::new(Arc::new(self.distribution.clone()));
         let repositories = distribution.get_repositories().await?;
 

src/task.rs

@@ -26,13 +26,17 @@ impl Task {
         let mut sched = JobScheduler::new().await.map_err(|err| Error::TaskCreationFailed(name.clone(), err.to_string()))?;
 
         for (cron, rules) in bundles {
+            debug!("Cron '{cron}' with rules '{}'", rules.join(", "));
             let instance = instance.clone();
             let copy_name = copy_name.clone();
-            let job = Job::new_async(cron.as_str(), move |_uuid, _l| {
+            let job = Job::new_async(cron.as_str(), move |_uuid, mut _l| {
                 let instance = instance.clone();
                 let rules = rules.clone();
                 let name = copy_name.clone();
+
                 Box::pin(async move {
+                    let next_tick = _l.next_tick_for_job(_uuid).await;
+                    debug!("Next tick for registry '{name}' is {:?}", next_tick.unwrap_or_default().unwrap_or_default());
                     info!("Applying rules '{}' to registry '{name}'", rules.join(", "));
                     match instance.apply_rules(rules.clone()).await {
                         Ok(_) => info!("Successfully applied rules '{}' to registry '{name}'", rules.join(", ")),

test-docker-compose.yml

@@ -9,15 +9,17 @@ services:
       - '5000:5000'
     labels:
       abwart.enable: true
-      abwart.rule.test.revisions: 2
-      abwart.rule.test.schedule: 1/30 * * * * *
+      # abwart.rule.test.revisions: 2
+      # abwart.rule.test.schedule: 1/30 * * * * *
       abwart.default.revisions: 10
-      abwart.default.schedule: 0 2 * * * *
+      abwart.default.schedule: 1/30 * * * * *
       abwart.network: test
     networks:
       - test
 
   abwart:
+    environment:
+      RUST_LOG: debug
     build:
       dockerfile: Dockerfile
     volumes: