[hyperactor] mesh: define resource::Resource, and mesh::Mesh in terms of it

We formalize a resource controller behavior:

```

/// A trait that bundles a set of types that together define a resource.
pub trait Resource {
    /// The spec specification for this resource.
    type Spec: Named + Serialize + for<'de> Deserialize<'de> + Send + Sync + std::fmt::Debug;

    /// The state for this resource.
    type State: Named + Serialize + for<'de> Deserialize<'de> + Send + Sync + std::fmt::Debug;
}

// A behavior defining the interface for a mesh controller.
hyperactor::behavior!(
    Controller<R: Resource>,
    CreateOrUpdate<R::Spec>,
    GetState<R::State>,
    Stop,
);
```

Anything that is a controller should behave-as a `resource::Controller`.

We then formalize the mesh controller behavior as a specialization of a resource controller, by implementing `Resource` for any mesh:

```
impl<M: Mesh> Resource for M {
    type Spec = Spec<M::Spec>;
    type State = State<M::State>;
}
```

This resolves to the same set of bindings and aliases (except we use `resource::Controller<Mesh>` rather than `mesh::Controller<Mesh>`) -- the existing behaviors continue to assert.

Differential Revision: [D86905562](https://our.internmc.facebook.com/intern/diff/D86905562/)

**NOTE FOR REVIEWERS**: This PR has internal Meta-specific changes or comments, please review them on [Phabricator](https://our.internmc.facebook.com/intern/diff/D86905562/)!

ghstack-source-id: 322844163
Pull Request resolved: #1841

Author: mariusae

hyperactor_mesh/src/resource.rs

@@ -334,6 +334,23 @@ where
     }
 }
 
+/// A trait that bundles a set of types that together define a resource.
+pub trait Resource {
+    /// The spec specification for this resource.
+    type Spec: Named + Serialize + for<'de> Deserialize<'de> + Send + Sync + std::fmt::Debug;
+
+    /// The state for this resource.
+    type State: Named + Serialize + for<'de> Deserialize<'de> + Send + Sync + std::fmt::Debug;
+}
+
+// A behavior defining the interface for a mesh controller.
+hyperactor::behavior!(
+    Controller<R: Resource>,
+    CreateOrUpdate<R::Spec>,
+    GetState<R::State>,
+    Stop,
+);
+
 /// RankedValues compactly represents rank-indexed values of type T.
 /// It stores contiguous values in a set of intervals; thus it is
 /// efficient and compact when the cardinality of T-typed values is

hyperactor_mesh/src/resource/mesh.rs

@@ -21,6 +21,7 @@ use serde::Serialize;
 
 use crate::resource::CreateOrUpdate;
 use crate::resource::GetState;
+use crate::resource::Resource;
 use crate::resource::Status;
 use crate::resource::Stop;
 use crate::v1::ValueMesh;
@@ -49,17 +50,14 @@ pub trait Mesh {
     /// The mesh-specific specification for this resource.
     type Spec: Named + Serialize + for<'de> Deserialize<'de> + Send + Sync + std::fmt::Debug;
 
-    /// The mesh-specific state for thsi resource.
+    /// The mesh-specific state for this resource.
     type State: Named + Serialize + for<'de> Deserialize<'de> + Send + Sync + std::fmt::Debug;
 }
 
-// A behavior defining the interface for a mesh controller.
-hyperactor::behavior!(
-    Controller<M: Mesh>,
-    CreateOrUpdate<Spec<M::Spec>>,
-    GetState<State<M::State>>,
-    Stop,
-);
+impl<M: Mesh> Resource for M {
+    type Spec = Spec<M::Spec>;
+    type State = State<M::State>;
+}
 
 #[cfg(test)]
 mod test {
@@ -68,6 +66,7 @@ mod test {
     use hyperactor::Handler;
 
     use super::*;
+    use crate::resource::Controller;
 
     // Consider upstreaming this into `hyperactor` -- lightweight handler definitions
     // can be quite useful.