Support ignorable platform properties

Author: palfrey

nativelink-config/examples/basic_cas.json5

@@ -60,6 +60,7 @@
           "container-image": "priority",
           "lre-rs": "priority",
           ISA: "exact",
+          InputRootAbsolutePath: "ignore", // used by chromium builds, but we can drop it
         },
       },
     },

nativelink-config/src/schedulers.rs

@@ -53,6 +53,10 @@ pub enum PropertyType {
     /// to cause the scheduler to prefer certain workers over others, but not
     /// restrict them based on these values.
     Priority,
+
+    //// Allows jobs to be requested with said key, but without requiring workers
+    //// to have that key
+    Ignore,
 }
 
 /// When a worker is being searched for to run a job, this will be used

nativelink-scheduler/src/platform_property_manager.rs

@@ -88,6 +88,7 @@ impl PlatformPropertyManager {
                 )),
                 PropertyType::Exact => Ok(PlatformPropertyValue::Exact(value.to_string())),
                 PropertyType::Priority => Ok(PlatformPropertyValue::Priority(value.to_string())),
+                PropertyType::Ignore => Ok(PlatformPropertyValue::Ignore(value.to_string())),
             };
         }
         Err(make_input_err!("Unknown platform property '{}'", key))

nativelink-scheduler/src/worker_capability_index.rs

@@ -90,9 +90,11 @@ impl WorkerCapabilityIndex {
                         .or_default()
                         .insert(worker_id.clone());
                 }
-                PlatformPropertyValue::Minimum(_) => {
+                PlatformPropertyValue::Minimum(_) | PlatformPropertyValue::Ignore(_) => {
                     // Minimum properties are tracked via property_presence only.
                     // Their actual values are checked at runtime since they're dynamic.
+
+                    // Ignore properties we just drop
                 }
             }
         }
@@ -200,6 +202,7 @@ impl WorkerCapabilityIndex {
                     }
                     candidates = Some(internal_candidates);
                 }
+                PlatformPropertyValue::Ignore(_) => {}
             }
         }
 

nativelink-scheduler/tests/worker_capability_index_test.rs

@@ -214,3 +214,25 @@ fn test_priority_property() {
     let result = index.find_matching_workers(&props, true);
     assert_eq!(result.len(), 2);
 }
+
+#[test]
+fn test_ignore_property() {
+    let mut index = WorkerCapabilityIndex::new();
+
+    let worker1 = make_worker_id("worker1");
+    let worker2 = make_worker_id("worker2");
+
+    index.add_worker(
+        &worker1,
+        &make_properties(&[("foo", PlatformPropertyValue::Priority("high".to_string()))]),
+    );
+    index.add_worker(
+        &worker2,
+        &make_properties(&[("bar", PlatformPropertyValue::Priority("low".to_string()))]),
+    );
+
+    // Ignore doesn't care if the worker has the property, so both workers with and without it should match
+    let props = make_properties(&[("foo", PlatformPropertyValue::Ignore("any".to_string()))]);
+    let result = index.find_matching_workers(&props, true);
+    assert_eq!(result.len(), 2);
+}

nativelink-util/BUILD.bazel

@@ -103,6 +103,7 @@ rust_test_suite(
         "tests/metrics_test.rs",
         "tests/operation_id_tests.rs",
         "tests/origin_event_test.rs",
+        "tests/platform_properties_tests.rs",
         "tests/proto_stream_utils_test.rs",
         "tests/resource_info_test.rs",
         "tests/retry_test.rs",

nativelink-util/src/platform_properties.rs

@@ -106,11 +106,15 @@ impl From<&PlatformProperties> for ProtoPlatform {
 ///            TODO(palfrey) In the future this will be used by the scheduler and
 ///            worker to cause the scheduler to prefer certain workers over others,
 ///            but not restrict them based on these values.
+/// Ignore   - Jobs can request this key, but workers do not have to have it. This allows
+///            for example the `InputRootAbsolutePath` case for chromium builds, where we can safely
+///            ignore it without having to change the worker configs.
 #[derive(Eq, PartialEq, Hash, Clone, Ord, PartialOrd, Debug, Serialize, Deserialize)]
 pub enum PlatformPropertyValue {
     Exact(String),
     Minimum(u64),
     Priority(String),
+    Ignore(String),
     Unknown(String),
 }
 
@@ -131,17 +135,18 @@ impl PlatformPropertyValue {
             // Priority is used to pass info to the worker and not restrict which
             // workers can be selected, but might be used to prefer certain workers
             // over others.
-            Self::Priority(_) => true,
+            Self::Priority(_) | Self::Ignore(_) => true,
             // Success exact case is handled above.
             Self::Exact(_) | Self::Unknown(_) => false,
         }
     }
 
     pub fn as_str(&self) -> Cow<'_, str> {
         match self {
-            Self::Exact(value) | Self::Priority(value) | Self::Unknown(value) => {
-                Cow::Borrowed(value)
-            }
+            Self::Exact(value)
+            | Self::Priority(value)
+            | Self::Unknown(value)
+            | Self::Ignore(value) => Cow::Borrowed(value),
             Self::Minimum(value) => Cow::Owned(value.to_string()),
         }
     }
@@ -159,6 +164,7 @@ impl MetricsComponent for PlatformPropertyValue {
             Self::Exact(v) => publish!(name, v, kind, help, "exact"),
             Self::Minimum(v) => publish!(name, v, kind, help, "minimum"),
             Self::Priority(v) => publish!(name, v, kind, help, "priority"),
+            Self::Ignore(v) => publish!(name, v, kind, help, "ignore"),
             Self::Unknown(v) => publish!(name, v, kind, help, "unknown"),
         }
 

nativelink-util/tests/platform_properties_tests.rs

@@ -0,0 +1,9 @@
+use nativelink_util::platform_properties::PlatformPropertyValue;
+
+#[test]
+fn ignore_properties_match_all() {
+    let ignore_property = PlatformPropertyValue::Ignore("foo".to_string());
+    let other_property = PlatformPropertyValue::Exact("bar".to_string());
+    assert!(ignore_property.is_satisfied_by(&ignore_property));
+    assert!(ignore_property.is_satisfied_by(&other_property));
+}