Api framework impl

bffhd/capnp/machine.rs

@@ -1,15 +1,25 @@
-use api::machine_capnp::machine::{
-    admin, admin::Server as AdminServer,
-    check, check::Server as CheckServer,
-    info, info::Server as InfoServer,
-    in_use as inuse, in_use::Server as InUseServer,
-    manage, manage::Server as ManageServer,
-    use_, use_::Server as UseServer,
-};
+use crate::resources::modules::fabaccess::MachineState;
+use crate::resources::Resource;
 use crate::session::SessionHandle;
+use api::machine_capnp::machine::{
+    admin, admin::Server as AdminServer, check, check::Server as CheckServer, in_use as inuse,
+    in_use::Server as InUseServer, info, info::Server as InfoServer, manage,
+    manage::Server as ManageServer, use_, use_::Server as UseServer, Builder,
+};
+use capnp::capability::Promise;
+use capnp_rpc::pry;
 
+#[derive(Clone)]
 pub struct Machine {
     session: SessionHandle,
+    resource: Resource,
+}
+
+impl Machine {
+    /// Builds a machine into the given builder. Re
+    pub fn build(session: SessionHandle, resource: Resource, builder: Builder) {
+        if resource.visible(&session) {}
+    }
 }
 
 impl InfoServer for Machine {
@@ -17,8 +27,8 @@ impl InfoServer for Machine {
         &mut self,
         _: info::GetPropertyListParams,
         _: info::GetPropertyListResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
@@ -26,38 +36,46 @@ impl InfoServer for Machine {
         &mut self,
         _: info::GetReservationListParams,
         _: info::GetReservationListResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
 }
 
 impl UseServer for Machine {
-    fn use_(
-        &mut self,
-        _: use_::UseParams,
-        _: use_::UseResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+    fn use_(&mut self, _: use_::UseParams, _: use_::UseResults) -> Promise<(), ::capnp::Error> {
+        let resource = self.resource.clone();
+        let session = self.session.clone();
+        Promise::from_future(async move {
+            let user = session.get_user();
+            resource.try_update(session, MachineState::used(user)).await;
+            Ok(())
+        })
     }
+
     fn reserve(
         &mut self,
         _: use_::ReserveParams,
         _: use_::ReserveResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+    ) -> Promise<(), ::capnp::Error> {
+        let resource = self.resource.clone();
+        let session = self.session.clone();
+        Promise::from_future(async move {
+            let user = session.get_user();
+            resource
+                .try_update(session, MachineState::reserved(user))
+                .await;
+            Ok(())
+        })
     }
+
     fn reserveto(
         &mut self,
         _: use_::ReservetoParams,
         _: use_::ReservetoResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
@@ -68,17 +86,21 @@ impl InUseServer for Machine {
         &mut self,
         _: inuse::GiveBackParams,
         _: inuse::GiveBackResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+    ) -> Promise<(), ::capnp::Error> {
+        let resource = self.resource.clone();
+        let session = self.session.clone();
+        Promise::from_future(async move {
+            resource.give_back(session.clone()).await;
+            Ok(())
+        })
     }
+
     fn send_raw_data(
         &mut self,
         _: inuse::SendRawDataParams,
         _: inuse::SendRawDataResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
@@ -89,17 +111,18 @@ impl CheckServer for Machine {
         &mut self,
         _: check::CheckParams,
         _: check::CheckResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
+
     fn reject(
         &mut self,
         _: check::RejectParams,
         _: check::RejectResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
@@ -110,8 +133,8 @@ impl ManageServer for Machine {
         &mut self,
         _: manage::GetMachineInfoExtendedParams,
         _: manage::GetMachineInfoExtendedResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
@@ -119,8 +142,8 @@ impl ManageServer for Machine {
         &mut self,
         _: manage::SetPropertyParams,
         _: manage::SetPropertyResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
@@ -128,74 +151,104 @@ impl ManageServer for Machine {
         &mut self,
         _: manage::RemovePropertyParams,
         _: manage::RemovePropertyResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
+
     fn force_use(
         &mut self,
         _: manage::ForceUseParams,
         _: manage::ForceUseResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+    ) -> Promise<(), ::capnp::Error> {
+        let resource = self.resource.clone();
+        let session = self.session.clone();
+        Promise::from_future(async move {
+            resource
+                .force_set(MachineState::used(session.get_user()))
+                .await;
+            Ok(())
+        })
     }
+
     fn force_free(
         &mut self,
         _: manage::ForceFreeParams,
         _: manage::ForceFreeResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+    ) -> Promise<(), ::capnp::Error> {
+        let resource = self.resource.clone();
+        let session = self.session.clone();
+        Promise::from_future(async move {
+            resource.force_set(MachineState::free()).await;
+            Ok(())
+        })
     }
     fn force_transfer(
         &mut self,
         _: manage::ForceTransferParams,
         _: manage::ForceTransferResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
+
     fn block(
         &mut self,
         _: manage::BlockParams,
         _: manage::BlockResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+    ) -> Promise<(), ::capnp::Error> {
+        let resource = self.resource.clone();
+        let session = self.session.clone();
+        Promise::from_future(async move {
+            resource
+                .force_set(MachineState::blocked(session.get_user()))
+                .await;
+            Ok(())
+        })
     }
     fn disabled(
         &mut self,
         _: manage::DisabledParams,
         _: manage::DisabledResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+    ) -> Promise<(), ::capnp::Error> {
+        let mut resource = self.resource.clone();
+        Promise::from_future(async move {
+            resource.force_set(MachineState::disabled()).await;
+            Ok(())
+        })
     }
 }
 
 impl AdminServer for Machine {
     fn force_set_state(
         &mut self,
-        _: admin::ForceSetStateParams,
+        params: admin::ForceSetStateParams,
         _: admin::ForceSetStateResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+    ) -> Promise<(), ::capnp::Error> {
+        use api::schema::machine_capnp::machine::MachineState as APIMState;
+        let user = self.session.get_user();
+        let state = match pry!(pry!(params.get()).get_state()) {
+            APIMState::Free => MachineState::free(),
+            APIMState::Blocked => MachineState::blocked(user),
+            APIMState::Disabled => MachineState::disabled(),
+            APIMState::InUse => MachineState::used(user),
+            APIMState::Reserved => MachineState::reserved(user),
+            APIMState::ToCheck => MachineState::check(user),
+            APIMState::Totakeover => return Promise::err(::capnp::Error::unimplemented(
+                    "totakeover not implemented".to_string(),
+                )),
+        };
+        self.resource.force_set(state);
+        Promise::ok(())
     }
     fn force_set_user(
         &mut self,
         _: admin::ForceSetUserParams,
         _: admin::ForceSetUserResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
@@ -203,8 +256,8 @@ impl AdminServer for Machine {
         &mut self,
         _: admin::GetAdminPropertyListParams,
         _: admin::GetAdminPropertyListResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
@@ -212,8 +265,8 @@ impl AdminServer for Machine {
         &mut self,
         _: admin::SetAdminPropertyParams,
         _: admin::SetAdminPropertyResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }
@@ -221,8 +274,8 @@ impl AdminServer for Machine {
         &mut self,
         _: admin::RemoveAdminPropertyParams,
         _: admin::RemoveAdminPropertyResults,
-    ) -> ::capnp::capability::Promise<(), ::capnp::Error> {
-        ::capnp::capability::Promise::err(::capnp::Error::unimplemented(
+    ) -> Promise<(), ::capnp::Error> {
+        Promise::err(::capnp::Error::unimplemented(
             "method not implemented".to_string(),
         ))
     }

bffhd/capnp/machinesystem.rs

@@ -4,23 +4,29 @@ use api::machinesystem_capnp::machine_system::{
     info, InfoParams, InfoResults, Server as MachineSystem,
 };
 use capnp::capability::Promise;
+use capnp_rpc::pry;
+use crate::capnp::machine::Machine;
+use crate::resources::Resource;
+use crate::resources::search::ResourcesHandle;
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct Machines {
     session: SessionHandle,
+    resources: ResourcesHandle,
 }
 
 impl Machines {
     pub fn new(session: SessionHandle) -> Self {
-        Self { session }
+        let resources = ResourcesHandle::new();
+        Self { session, resources }
     }
 }
 
 impl MachineSystem for Machines {
-    fn info(&mut self, _: InfoParams, _: InfoResults) -> Promise<(), ::capnp::Error> {
-        Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+    fn info(&mut self, _: InfoParams, mut result: InfoResults) -> Promise<(), ::capnp::Error> {
+        // TODO permission checking
+        result.get().set_info(capnp_rpc::new_client(self.clone()));
+        Promise::ok(())
     }
 }
 
@@ -28,28 +34,52 @@ impl info::Server for Machines {
     fn get_machine_list(
         &mut self,
         _: info::GetMachineListParams,
-        _: info::GetMachineListResults,
+        mut result: info::GetMachineListResults,
     ) -> Promise<(), ::capnp::Error> {
-        Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+        let machine_list: Vec<(usize, &Resource)> = self.resources.list_all()
+            .into_iter()
+            .filter(|resource| resource.visible(&self.session))
+            .enumerate()
+            .collect();
+        let mut builder = result.get().init_machine_list(machine_list.len() as u32);
+        for (i, m) in machine_list {
+            let resource = m.clone();
+            let mut mbuilder = builder.reborrow().get(i as u32);
+            Machine::build(self.session.clone(), resource, mbuilder);
+        }
+
+        Promise::ok(())
     }
+
     fn get_machine(
         &mut self,
-        _: info::GetMachineParams,
-        _: info::GetMachineResults,
+        params: info::GetMachineParams,
+        mut result: info::GetMachineResults,
     ) -> Promise<(), ::capnp::Error> {
-        Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+        let params = pry!(params.get());
+        let id = pry!(params.get_id());
+
+        if let Some(resource) = self.resources.get_by_id(id) {
+            let mut builder = result.get();
+            Machine::build(self.session.clone(), resource.clone(), builder);
+        }
+
+        Promise::ok(())
     }
+
     fn get_machine_u_r_n(
         &mut self,
-        _: info::GetMachineURNParams,
-        _: info::GetMachineURNResults,
+        params: info::GetMachineURNParams,
+        mut result: info::GetMachineURNResults,
     ) -> Promise<(), ::capnp::Error> {
-        Promise::err(::capnp::Error::unimplemented(
-            "method not implemented".to_string(),
-        ))
+        let params = pry!(params.get());
+        let urn = pry!(params.get_urn());
+
+        if let Some(resource) = self.resources.get_by_urn(urn) {
+            let mut builder = result.get();
+            Machine::build(self.session.clone(), resource.clone(), builder);
+        }
+
+        Promise::ok(())
     }
 }