|
|
@@ -1,13 +1,16 @@
|
|
|
-use std::collections::HashMap;
|
|
|
+use std::collections::{HashMap, HashSet};
|
|
|
|
|
|
+use btrun::model::{End, TransKind};
|
|
|
use proc_macro2::{Ident, TokenStream};
|
|
|
use quote::{format_ident, quote, ToTokens};
|
|
|
|
|
|
use crate::{
|
|
|
case_convert::CaseConvert,
|
|
|
model::{
|
|
|
- ActorKind, ActorModel, MethodModel, MsgInfo, OutputKind, ProtocolModel, TypeParamInfo,
|
|
|
+ ActorKind, ActorModel, DestKind, MethodModel, MsgInfo, ProtocolModel, StateModel,
|
|
|
+ TypeParamInfo, ValueKind, ValueModel,
|
|
|
},
|
|
|
+ parsing::DestinationState,
|
|
|
};
|
|
|
|
|
|
impl ToTokens for ProtocolModel {
|
|
|
@@ -30,22 +33,6 @@ impl ProtocolModel {
|
|
|
let all_replies = msg_lookup.msg_iter().all(|msg| msg.is_reply());
|
|
|
let enum_name = self.msg_enum_ident();
|
|
|
let enum_kinds_name = self.msg_enum_kinds_ident();
|
|
|
- let name_decl_vec: Vec<(Ident, TokenStream)> = variants
|
|
|
- .iter()
|
|
|
- .map(|variant| {
|
|
|
- let variant_str = variant_names_map.get(variant.as_ref()).unwrap();
|
|
|
- let name_ident =
|
|
|
- format_ident!("{}_NAME", variant_str.pascal_to_snake().to_uppercase());
|
|
|
- let decl = quote! {
|
|
|
- static #name_ident: Lazy<Arc<String>> = Lazy::new(|| {
|
|
|
- Arc::new(#variant_str.into())
|
|
|
- });
|
|
|
- };
|
|
|
- (name_ident, decl)
|
|
|
- })
|
|
|
- .collect();
|
|
|
- let name_decls = name_decl_vec.iter().map(|(_, decl)| decl);
|
|
|
- let name_idents = name_decl_vec.iter().map(|(ident, _)| ident);
|
|
|
let send_impl = if all_replies {
|
|
|
quote! {}
|
|
|
} else {
|
|
|
@@ -55,6 +42,7 @@ impl ProtocolModel {
|
|
|
};
|
|
|
let proto_name = &self.def().name_def.name;
|
|
|
let doc_comment = format!("Message type for the {proto_name} protocol.");
|
|
|
+ let name_method = self.generate_name_method(|| variant_names_map.keys().copied());
|
|
|
quote! {
|
|
|
#[doc = #doc_comment]
|
|
|
#[derive(::serde::Serialize, ::serde::Deserialize)]
|
|
|
@@ -70,14 +58,7 @@ impl ProtocolModel {
|
|
|
}
|
|
|
|
|
|
impl ::btrun::model::Named for #enum_kinds_name {
|
|
|
- fn name(&self) -> ::std::sync::Arc<String> {
|
|
|
- use ::btrun::model::Lazy;
|
|
|
- use ::std::sync::Arc;
|
|
|
- #( #name_decls )*
|
|
|
- match self {
|
|
|
- #( Self::#variants => #name_idents.clone() ),*
|
|
|
- }
|
|
|
- }
|
|
|
+ #name_method
|
|
|
}
|
|
|
|
|
|
impl Copy for #enum_kinds_name {}
|
|
|
@@ -110,7 +91,7 @@ impl ProtocolModel {
|
|
|
});
|
|
|
let mut tokens = TokenStream::new();
|
|
|
for (trait_ident, methods, is_init_state) in traits {
|
|
|
- let method_tokens = methods.map(|x| x.generate_tokens());
|
|
|
+ let method_tokens = methods.map(|x| x.generate_trait_def());
|
|
|
let actor_impl_method = if is_init_state {
|
|
|
quote! {
|
|
|
#[doc = "The name of the implementation for the actor this state is a part of."]
|
|
|
@@ -153,12 +134,12 @@ impl ProtocolModel {
|
|
|
match actor.kind() {
|
|
|
ActorKind::Service => self.generate_service_spawn_function(actor),
|
|
|
ActorKind::Worker => self.generate_worker_spawn_function(actor),
|
|
|
- ActorKind::Client => TokenStream::default(),
|
|
|
+ ActorKind::Client => self.generate_client_spawn_function(actor),
|
|
|
}
|
|
|
}
|
|
|
|
|
|
fn generate_worker_spawn_function(&self, actor: &ActorModel) -> TokenStream {
|
|
|
- let function_name = actor.spawn_function_ident();
|
|
|
+ let worker_spawn_function_name = actor.spawn_function_ident();
|
|
|
let TypeParamInfo {
|
|
|
type_params,
|
|
|
constraints,
|
|
|
@@ -166,9 +147,9 @@ impl ProtocolModel {
|
|
|
let init_state_type_param = actor.init_state().type_param();
|
|
|
let state_enum_decl = self.generate_state_enum(actor);
|
|
|
let init_state_var = self.init_state_var();
|
|
|
- let server_loop = self.generate_loop(actor);
|
|
|
+ let server_loop = self.generate_actor_loop(actor);
|
|
|
quote! {
|
|
|
- async fn #function_name<#( #type_params ),*>(
|
|
|
+ async fn #worker_spawn_function_name<#( #type_params ),*>(
|
|
|
runtime: &'static ::btrun::Runtime,
|
|
|
owner_name: ::btrun::model::ActorName,
|
|
|
#init_state_var: #init_state_type_param,
|
|
|
@@ -179,13 +160,13 @@ impl ProtocolModel {
|
|
|
#state_enum_decl
|
|
|
|
|
|
let actor = #server_loop ;
|
|
|
- runtime.spawn(None, actor).await
|
|
|
+ runtime.spawn(Some(owner_name), actor).await
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
fn generate_service_spawn_function(&self, actor: &ActorModel) -> TokenStream {
|
|
|
- let function_name = format_ident!("register_{}", actor.def().actor.as_ref());
|
|
|
+ let service_spawn_function_name = format_ident!("register_{}", actor.def().actor.as_ref());
|
|
|
let TypeParamInfo {
|
|
|
type_params,
|
|
|
constraints,
|
|
|
@@ -194,9 +175,9 @@ impl ProtocolModel {
|
|
|
let state_enum_decl = self.generate_state_enum(actor);
|
|
|
let msg_enum = self.msg_enum_ident();
|
|
|
let init_state_var = self.init_state_var();
|
|
|
- let server_loop = self.generate_loop(actor);
|
|
|
+ let server_loop = self.generate_actor_loop(actor);
|
|
|
quote! {
|
|
|
- async fn #function_name<#( #type_params ),*, F>(
|
|
|
+ async fn #service_spawn_function_name<#( #type_params ),*, F>(
|
|
|
runtime: &'static ::btrun::Runtime,
|
|
|
service_id: ::btrun::model::ServiceId,
|
|
|
make_init: F,
|
|
|
@@ -225,13 +206,93 @@ impl ProtocolModel {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- fn generate_loop(&self, actor: &ActorModel) -> TokenStream {
|
|
|
- let init_state = actor.init_state().name();
|
|
|
+ fn generate_client_spawn_function(&self, actor: &ActorModel) -> TokenStream {
|
|
|
+ let init_state_model = actor.init_state();
|
|
|
+ let init_state = init_state_model.name();
|
|
|
+ let init_type_param = init_state_model.type_param();
|
|
|
+ let state_enum = self.generate_client_state_enum(actor);
|
|
|
+ let state_enum_ident = actor.state_enum_ident();
|
|
|
+ let handle_struct = self.generate_client_handle(actor);
|
|
|
+ let handle_struct_ident = actor.handle_struct_ident().unwrap();
|
|
|
+ let client_spawn_function_name = actor.spawn_function_ident().unwrap();
|
|
|
+ let TypeParamInfo {
|
|
|
+ type_params,
|
|
|
+ constraints,
|
|
|
+ } = self.type_param_info_for(actor.name());
|
|
|
+ let init_var = self.init_state_var();
|
|
|
+ let use_statements = self.use_statements();
|
|
|
+ let actor_id_param = self.actor_id_param();
|
|
|
+ let runtime_var = self.runtime_param();
|
|
|
+ let state_var = self.state_var();
|
|
|
+ let actor_name_ident = self.actor_name_ident();
|
|
|
+ let msg_enum = self.msg_enum_ident();
|
|
|
+ let msg = self.msg_ident();
|
|
|
+ let from = self.from_ident();
|
|
|
+ let reply = self.reply_ident();
|
|
|
+ let call_transitions = self.generate_call_transitions(actor);
|
|
|
+ let send_transitions = self.generate_send_transitions(actor);
|
|
|
+ let control_transitions = self.generate_control_transitions(actor);
|
|
|
+ let end_ident = self.end_ident();
|
|
|
+ quote! {
|
|
|
+ #state_enum
|
|
|
+ #handle_struct
|
|
|
+
|
|
|
+ async fn #client_spawn_function_name<#( #type_params ),* >(
|
|
|
+ #init_var: #init_type_param,
|
|
|
+ runtime: &'static ::btrun::Runtime,
|
|
|
+ ) -> #handle_struct_ident<#init_type_param, #init_type_param>
|
|
|
+ where
|
|
|
+ #( #constraints ),*
|
|
|
+ {
|
|
|
+ #use_statements
|
|
|
+ let shared_state = Arc::new(Mutex::new(Some(#state_enum_ident::#init_state(#init_var))));
|
|
|
+ let name = {
|
|
|
+ let shared_state = shared_state.clone();
|
|
|
+ runtime.spawn(None, move |mut mailbox: Mailbox<#msg_enum>, #actor_id_param, #runtime_var| async move {
|
|
|
+ let #actor_name_ident = runtime.actor_name(#actor_id_param);
|
|
|
+ while let Some(envelope) = mailbox.recv().await {
|
|
|
+ let mut guard = shared_state.lock().await;
|
|
|
+ let #state_var = guard.take()
|
|
|
+ .unwrap_or_else(|| {
|
|
|
+ panic!(
|
|
|
+ "Logic error. The shared state for client {} was not returned.",
|
|
|
+ #init_type_param::actor_impl()
|
|
|
+ )
|
|
|
+ });
|
|
|
+ let new_state = match envelope {
|
|
|
+ Envelope::Call { from: #from, msg: #msg, reply: #reply, .. } => {
|
|
|
+ #call_transitions
|
|
|
+ }
|
|
|
+ Envelope::Send { from: #from, msg: #msg, .. } => {
|
|
|
+ #send_transitions
|
|
|
+ }
|
|
|
+ Envelope::Control(#msg) => {
|
|
|
+ #control_transitions
|
|
|
+ }
|
|
|
+ };
|
|
|
+ *guard = Some(new_state);
|
|
|
+ if let Some(state) = &*guard {
|
|
|
+ if let #state_enum_ident::#end_ident(_) = state {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Ok(#actor_id_param)
|
|
|
+ }).await.unwrap()
|
|
|
+ };
|
|
|
+ #handle_struct_ident::new(runtime, shared_state, name)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn generate_actor_loop(&self, actor: &ActorModel) -> TokenStream {
|
|
|
+ let init_state = actor.init_state();
|
|
|
+ let startup = self.generate_startup_method_calls(actor);
|
|
|
+ let init_type_param = init_state.type_param();
|
|
|
let state_enum_ident = actor.state_enum_ident();
|
|
|
let msg_enum = self.msg_enum_ident();
|
|
|
let init_state_var = self.init_state_var();
|
|
|
let end_ident = self.end_ident();
|
|
|
- let mailbox = self.mailbox_param();
|
|
|
let actor_id = self.actor_id_param();
|
|
|
let runtime = self.runtime_param();
|
|
|
let from = self.from_ident();
|
|
|
@@ -241,38 +302,85 @@ impl ProtocolModel {
|
|
|
let call_transitions = self.generate_call_transitions(actor);
|
|
|
let send_transitions = self.generate_send_transitions(actor);
|
|
|
let control_transitions = self.generate_control_transitions(actor);
|
|
|
- quote! {
|
|
|
- move |
|
|
|
- mut #mailbox: ::btrun::Mailbox<#msg_enum>,
|
|
|
- #actor_id: ::btrun::model::ActorId,
|
|
|
- #runtime: &'static ::btrun::Runtime
|
|
|
- | async move {
|
|
|
- use ::btlib::bterr;
|
|
|
- use ::btrun::{
|
|
|
- log,
|
|
|
- model::{
|
|
|
- Envelope, ControlMsg, Named, TransResult, ActorError, ActorErrorPayload,
|
|
|
- TransKind,
|
|
|
- }
|
|
|
- };
|
|
|
- let #actor_name = #runtime . actor_name(#actor_id);
|
|
|
- let mut state = #state_enum_ident :: #init_state (#init_state_var);
|
|
|
- while let Some(envelope) = #mailbox.recv().await {
|
|
|
- let new_state = match envelope {
|
|
|
+ let use_statements = self.use_statements();
|
|
|
+ let state_var = self.state_var();
|
|
|
+ let state_after_startup_name = actor.state_after_startup();
|
|
|
+ let actor_loop = if state_after_startup_name == End::ident() {
|
|
|
+ quote! {}
|
|
|
+ } else {
|
|
|
+ quote! {
|
|
|
+ let mut #state_var = #state_enum_ident::<#init_type_param>::#state_after_startup_name(#state_var);
|
|
|
+ while let Some(envelope) = mailbox.recv().await {
|
|
|
+ state = match envelope {
|
|
|
Envelope::Call { #msg, #from, mut #reply, .. } => #call_transitions
|
|
|
Envelope::Send { #msg, #from, .. } => #send_transitions
|
|
|
Envelope::Control(#msg) => #control_transitions
|
|
|
};
|
|
|
- state = new_state;
|
|
|
if let #state_enum_ident::#end_ident(_) = &state {
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
+ }
|
|
|
+ };
|
|
|
+ quote! {
|
|
|
+ move |
|
|
|
+ mut mailbox: ::btrun::Mailbox<#msg_enum>,
|
|
|
+ #actor_id: ::btrun::model::ActorId,
|
|
|
+ #runtime: &'static ::btrun::Runtime
|
|
|
+ | async move {
|
|
|
+ #use_statements
|
|
|
+ let #actor_name = #runtime.actor_name(#actor_id);
|
|
|
+ let #state_var = #init_state_var;
|
|
|
+ #( #startup )*
|
|
|
+ #actor_loop
|
|
|
Ok(#actor_id)
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+ fn generate_startup_method_calls<'a>(
|
|
|
+ &'a self,
|
|
|
+ actor: &'a ActorModel,
|
|
|
+ ) -> impl 'a + Iterator<Item = TokenStream> {
|
|
|
+ let state_var = self.state_var();
|
|
|
+ actor.startup_methods().map(move |method| {
|
|
|
+ let output_vars = method.output_vars().skip(1);
|
|
|
+ let input_vars = method.inputs().iter().map(|input| input.var_name());
|
|
|
+ let state_name = method.def().in_state.state_trait.as_ref();
|
|
|
+ let state = actor.states().get(state_name).unwrap();
|
|
|
+ let method_name = method.name();
|
|
|
+ let dispatch_msgs = method
|
|
|
+ .outputs()
|
|
|
+ .iter()
|
|
|
+ .flat_map(|output| self.generate_client_handle_msg_dispatch(actor, state, method, output));
|
|
|
+ let spawn_actors = method.outputs().iter().skip(1).flat_map(|output| {
|
|
|
+ if let ValueKind::State { def: _, .. } = output.kind() {
|
|
|
+ Some(quote! {
|
|
|
+ todo!("Spawn actor returned by startup method.");
|
|
|
+ })
|
|
|
+ } else {
|
|
|
+ None
|
|
|
+ }
|
|
|
+ });
|
|
|
+ let error_ident = format_ident!("err");
|
|
|
+ let error = self.generate_actor_error(actor, state, method, quote! { #error_ident });
|
|
|
+ quote! {
|
|
|
+ let (#state_var, #( #output_vars ),*) = {
|
|
|
+ match #state_var.#method_name(#( #input_vars ),*).await {
|
|
|
+ TransResult::Ok(tuple) => {
|
|
|
+ tuple
|
|
|
+ }
|
|
|
+ TransResult::Abort { #error_ident, .. } | TransResult::Fatal { err, .. } => {
|
|
|
+ return Err(#error)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ #( #dispatch_msgs )*
|
|
|
+ #( #spawn_actors )*
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+
|
|
|
fn generate_call_transitions(&self, actor: &ActorModel) -> TokenStream {
|
|
|
self.generate_transitions(actor, |msg_info| msg_info.is_call())
|
|
|
}
|
|
|
@@ -288,9 +396,6 @@ impl ProtocolModel {
|
|
|
) -> TokenStream {
|
|
|
let state_enum_ident = actor.state_enum_ident();
|
|
|
let msg_enum_ident = self.msg_enum_ident();
|
|
|
- let init_state_type_param = actor.init_state().type_param();
|
|
|
- let msg_enum_kinds = self.msg_enum_kinds_ident();
|
|
|
- let actor_id = self.actor_id_param();
|
|
|
let transitions = actor.states().values().flat_map(|state| {
|
|
|
state.methods().values().filter(|method| {
|
|
|
if let Some(in_msg) = method.def().in_msg() {
|
|
|
@@ -301,116 +406,16 @@ impl ProtocolModel {
|
|
|
}
|
|
|
})
|
|
|
.map(|method| {
|
|
|
- let state_type_param = state.type_param();
|
|
|
- let mut output_iter = method.outputs().iter();
|
|
|
- let next_state = output_iter.next()
|
|
|
- .unwrap_or_else(|| panic!("There are no outputs for method {} in state {}.", method.name(), state.name()));
|
|
|
- let next_state_name = if let OutputKind::State { def, .. } = next_state.kind() {
|
|
|
- def.state_trait.as_ref()
|
|
|
- } else {
|
|
|
- panic!("First output of {} method was not a state.", method.name());
|
|
|
- };
|
|
|
- let next_state_var = next_state.var_name();
|
|
|
- let out_states = output_iter
|
|
|
- .flat_map(|output| {
|
|
|
- if let OutputKind::State { def, .. } = output.kind() {
|
|
|
- Some((output.var_name(), def))
|
|
|
- } else {
|
|
|
- None
|
|
|
- }
|
|
|
- })
|
|
|
- .map(|(var_name, def)| {
|
|
|
- let spawning_actor = self.actor_lookup().actor_with_state(&def.state_trait);
|
|
|
- let spawning_model = self.actors().get(spawning_actor)
|
|
|
- .unwrap_or_else(|| panic!("There was no actor named {spawning_actor}."));
|
|
|
- let spawn_function = spawning_model.spawn_function_ident()
|
|
|
- .unwrap_or_else(|| panic!("Actor {spawning_actor} of kind {:?} has no spawn function.", spawning_model.kind()));
|
|
|
- let from = self.from_ident();
|
|
|
- let runtime = self.runtime_param();
|
|
|
- let method_name = method.name();
|
|
|
- quote! {
|
|
|
- if let Err(err) = #spawn_function(#runtime, #from, #var_name).await {
|
|
|
- log::error!(
|
|
|
- "Failed to spawn {} actor after the {} method: {err}",
|
|
|
- stringify!(#spawning_actor),
|
|
|
- stringify!(#method_name)
|
|
|
- )
|
|
|
- }
|
|
|
- }
|
|
|
- });
|
|
|
- let out_msgs = method.outputs().iter()
|
|
|
- .flat_map(|output| {
|
|
|
- if let OutputKind::Msg { def, .. } = output.kind() {
|
|
|
- Some((output.var_name(), def))
|
|
|
- } else {
|
|
|
- None
|
|
|
- }
|
|
|
- })
|
|
|
- .map(|(var_name, dest)| {
|
|
|
- if dest.msg.is_reply() {
|
|
|
- let reply = self.reply_ident();
|
|
|
- let msg_type = &dest.msg.msg_type;
|
|
|
- let reply_variant = self.msg_lookup().lookup(&dest.msg).msg_name();
|
|
|
- let error_msg = format!("Failed to send {} reply.", msg_type);
|
|
|
- quote! {
|
|
|
- if let Some(mut reply) = #reply.take() {
|
|
|
- if let Err(_) = reply.send(#msg_enum_ident :: #reply_variant (#var_name)) {
|
|
|
- return Err(ActorError::new(
|
|
|
- bterr!(#error_msg),
|
|
|
- ActorErrorPayload {
|
|
|
- actor_id: #actor_id,
|
|
|
- actor_impl: #init_state_type_param :: actor_impl(),
|
|
|
- state: #state_type_param :: state_name(),
|
|
|
- message: #msg_enum_kinds :: #msg_type .name(),
|
|
|
- kind: TransKind::Receive,
|
|
|
- }
|
|
|
- ));
|
|
|
- }
|
|
|
- } else {
|
|
|
- log::error!(
|
|
|
- "Reply to {} message has already been sent.",
|
|
|
- #msg_enum_kinds :: #msg_type .name()
|
|
|
- );
|
|
|
- }
|
|
|
- }
|
|
|
- } else {
|
|
|
- todo!("Send message to an owned state or to a service.");
|
|
|
- }
|
|
|
- });
|
|
|
- let method_name = method.name();
|
|
|
let state_name = state.name();
|
|
|
- let msg_name = method.msg_received_input().unwrap().msg_name();
|
|
|
- let out_vars = method.outputs().iter().map(|output| output.var_name());
|
|
|
+ let msg_name = method.msg_received_input()
|
|
|
+ .unwrap_or_else(|| panic!("Method '{}' does not handle any messages.", method.name()))
|
|
|
+ .msg_type
|
|
|
+ .as_ref();
|
|
|
+ let args = std::iter::once(self.msg_ident());
|
|
|
+ let method_call = self.generate_method_call(actor, state, method, args);
|
|
|
quote! {
|
|
|
(#state_enum_ident :: #state_name(state), #msg_enum_ident :: #msg_name(msg)) => {
|
|
|
- match state.#method_name(msg).await {
|
|
|
- TransResult::Ok(( #( #out_vars ),* )) => {
|
|
|
- #( #out_states )*
|
|
|
- #( #out_msgs )*
|
|
|
- #state_enum_ident :: #next_state_name (#next_state_var)
|
|
|
- }
|
|
|
- TransResult::Abort { from, err, .. } => {
|
|
|
- log::warn!(
|
|
|
- "Aborted transition from the {} state while handling the {} message: {}",
|
|
|
- stringify!(#state_name),
|
|
|
- stringify!(#msg_name),
|
|
|
- err
|
|
|
- );
|
|
|
- #state_enum_ident :: #state_name(from)
|
|
|
- }
|
|
|
- TransResult::Fatal { err, .. } => {
|
|
|
- return Err(ActorError::new(
|
|
|
- err,
|
|
|
- ActorErrorPayload {
|
|
|
- actor_id: #actor_id,
|
|
|
- actor_impl: #init_state_type_param :: actor_impl(),
|
|
|
- state: #state_type_param :: state_name(),
|
|
|
- message: #msg_enum_kinds :: #msg_name . name(),
|
|
|
- kind: TransKind::Receive
|
|
|
- }
|
|
|
- ));
|
|
|
- }
|
|
|
- }
|
|
|
+ #method_call
|
|
|
},
|
|
|
}
|
|
|
})
|
|
|
@@ -428,6 +433,144 @@ impl ProtocolModel {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+ fn generate_method_call<TTokens: ToTokens>(
|
|
|
+ &self,
|
|
|
+ actor: &ActorModel,
|
|
|
+ state: &StateModel,
|
|
|
+ method: &MethodModel,
|
|
|
+ args: impl Iterator<Item = TTokens>,
|
|
|
+ ) -> TokenStream {
|
|
|
+ let msg_enum_ident = self.msg_enum_ident();
|
|
|
+ let msg_enum_kinds = self.msg_enum_kinds_ident();
|
|
|
+ let init_state_type_param = actor.init_state().type_param();
|
|
|
+ let state_enum_ident = actor.state_enum_ident();
|
|
|
+
|
|
|
+ let next_state = method.outputs().first().unwrap_or_else(|| {
|
|
|
+ panic!(
|
|
|
+ "There are no outputs for method {} in state {}.",
|
|
|
+ method.name(),
|
|
|
+ state.name()
|
|
|
+ )
|
|
|
+ });
|
|
|
+ let next_state_name = if let ValueKind::State { def, .. } = next_state.kind() {
|
|
|
+ def.state_trait.as_ref()
|
|
|
+ } else {
|
|
|
+ panic!("First output of {} method was not a state.", method.name());
|
|
|
+ };
|
|
|
+ let next_state_var = next_state.var_name();
|
|
|
+ let out_states = self.generate_out_state_spawns(actor, state, method);
|
|
|
+ let out_msgs = method.outputs().iter()
|
|
|
+ .flat_map(|output| {
|
|
|
+ if let ValueKind::Dest { def, .. } = output.kind() {
|
|
|
+ Some((output, def))
|
|
|
+ } else {
|
|
|
+ None
|
|
|
+ }
|
|
|
+ })
|
|
|
+ .map(|(output, def)| {
|
|
|
+ let msg_info = self.msg_lookup().lookup(&def.msg);
|
|
|
+ let msg_name = msg_info.msg_name();
|
|
|
+ let var_name = output.var_name();
|
|
|
+ if msg_info.is_reply() {
|
|
|
+ let reply_ident = self.reply_ident();
|
|
|
+ let reply_variant = self.msg_lookup().lookup(&def.msg).msg_name();
|
|
|
+ let error_msg = format!("Failed to send '{}'.", msg_name);
|
|
|
+ let inner_error = quote! { bterr!(#error_msg) };
|
|
|
+ let error = self.generate_actor_error(actor, state, method, inner_error);
|
|
|
+ quote! {
|
|
|
+ if let Some(mut reply) = #reply_ident.take() {
|
|
|
+ if let Err(_) = reply.send(#msg_enum_ident :: #reply_variant (#var_name)) {
|
|
|
+ return Err(#error);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ log::error!(
|
|
|
+ "Reply to '{}' has already been sent.",
|
|
|
+ #msg_enum_kinds :: #msg_name .name()
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ match &def.state {
|
|
|
+ DestinationState::Service(_state) => {
|
|
|
+ quote! {
|
|
|
+ todo!("dispatch message to service");
|
|
|
+ }
|
|
|
+ }
|
|
|
+ DestinationState::Individual(state) => {
|
|
|
+ match method.dest_kind(state) {
|
|
|
+ DestKind::Owner => {
|
|
|
+ quote! { todo!("dispatch message to current owner"); }
|
|
|
+ }
|
|
|
+ DestKind::Owned(_name_var) => {
|
|
|
+ quote! { todo!("dispatch message to owned state"); }
|
|
|
+ }
|
|
|
+ DestKind::Sender => {
|
|
|
+ quote! { todo!("dispatch message to sender"); }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ let method_name = method.name();
|
|
|
+ let state_name = state.name();
|
|
|
+ let out_vars = method.output_vars();
|
|
|
+ let error_ident = format_ident!("err");
|
|
|
+ let error = self.generate_actor_error(actor, state, method, quote! { #error_ident });
|
|
|
+ quote! {
|
|
|
+ match state.#method_name(#( #args ),*).await {
|
|
|
+ TransResult::Ok(( #( #out_vars ),* )) => {
|
|
|
+ #( #out_states )*
|
|
|
+ #( #out_msgs )*
|
|
|
+ #state_enum_ident :: #next_state_name (#next_state_var)
|
|
|
+ }
|
|
|
+ TransResult::Abort { from, err, .. } => {
|
|
|
+ log::warn!(
|
|
|
+ "Method {} for actor {} aborted: {}",
|
|
|
+ stringify!(#method_name),
|
|
|
+ #init_state_type_param :: actor_impl(),
|
|
|
+ err
|
|
|
+ );
|
|
|
+ #state_enum_ident :: #state_name(from)
|
|
|
+ }
|
|
|
+ TransResult::Fatal { #error_ident, .. } => {
|
|
|
+ return Err(#error);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn generate_actor_error(
|
|
|
+ &self,
|
|
|
+ actor: &ActorModel,
|
|
|
+ state: &StateModel,
|
|
|
+ method: &MethodModel,
|
|
|
+ inner_error: TokenStream,
|
|
|
+ ) -> TokenStream {
|
|
|
+ let actor_id = self.actor_id_param();
|
|
|
+ let init_state_type_param = actor.init_state().type_param();
|
|
|
+ let state_type_param = state.type_param();
|
|
|
+ let msg_enum_kinds = self.msg_enum_kinds_ident();
|
|
|
+ let attribution = method.attribution();
|
|
|
+ let msg_name = attribution.message().msg_type.as_ref();
|
|
|
+ let trans_kind = match attribution.kind() {
|
|
|
+ TransKind::Receive => quote! { TransKind::Receive },
|
|
|
+ TransKind::Send => quote! { TransKind::Send },
|
|
|
+ };
|
|
|
+ quote! {
|
|
|
+ ActorError::new(
|
|
|
+ #inner_error,
|
|
|
+ ActorErrorPayload {
|
|
|
+ actor_id: #actor_id,
|
|
|
+ actor_impl: #init_state_type_param :: actor_impl(),
|
|
|
+ state: #state_type_param :: state_name(),
|
|
|
+ message: #msg_enum_kinds :: #msg_name . name(),
|
|
|
+ kind: #trans_kind,
|
|
|
+ }
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
fn generate_control_transitions(&self, _actor: &ActorModel) -> TokenStream {
|
|
|
quote! {
|
|
|
todo!()
|
|
|
@@ -460,45 +603,559 @@ impl ProtocolModel {
|
|
|
quote! { #end_ident(::btrun::model::#end_ident) },
|
|
|
));
|
|
|
let type_params = pairs.iter().flat_map(|(_, type_param)| type_param);
|
|
|
- let name_pairs: Vec<_> = pairs
|
|
|
- .iter()
|
|
|
- .map(|(trait_type, _)| {
|
|
|
- let trait_type_string = trait_type.to_string();
|
|
|
- let name_ident = format_ident!("{}_NAME", trait_type_string.pascal_to_snake().to_uppercase());
|
|
|
- let name_decl = quote! {
|
|
|
- static #name_ident: ::btrun::model::Lazy<::std::sync::Arc<String>> =
|
|
|
- ::btrun::model::Lazy::new(|| ::std::sync::Arc::new(#trait_type_string.into()));
|
|
|
- };
|
|
|
- let match_branch = quote! {
|
|
|
- Self::#trait_type(_) => #name_ident.clone(),
|
|
|
- };
|
|
|
- (name_decl, match_branch)
|
|
|
- })
|
|
|
- .collect();
|
|
|
- let name_decls = name_pairs.iter().map(|(name_decl, _)| name_decl);
|
|
|
- let name_match_branches = name_pairs.iter().map(|(_, match_branch)| match_branch);
|
|
|
+ let name_method = self.generate_name_method(|| self.state_idents(actor));
|
|
|
quote! {
|
|
|
enum #enum_ident #decl_type_params {
|
|
|
#( #variants ),*
|
|
|
}
|
|
|
|
|
|
impl #decl_type_params ::btrun::model::Named for #enum_ident<#( #type_params ),*> {
|
|
|
- fn name(&self) -> ::std::sync::Arc<String> {
|
|
|
- #( #name_decls )*
|
|
|
- match self {
|
|
|
- #( #name_match_branches )*
|
|
|
+ #name_method
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn generate_client_state_enum(&self, actor: &ActorModel) -> TokenStream {
|
|
|
+ let init_state = actor.init_state();
|
|
|
+ let init_type_param = self.init_type_param();
|
|
|
+ let paths = {
|
|
|
+ let mut paths = HashMap::<&Ident, TokenStream>::new();
|
|
|
+ let mut visited = HashSet::<&Ident>::new();
|
|
|
+ let mut path = Vec::<&Ident>::new();
|
|
|
+ path.push(init_type_param);
|
|
|
+ self.make_assoc_type_paths(&mut paths, &mut visited, &mut path, init_state);
|
|
|
+ paths
|
|
|
+ };
|
|
|
+ let end_ident = self.end_ident();
|
|
|
+ let variant_decls = actor
|
|
|
+ .states()
|
|
|
+ .values()
|
|
|
+ .map(|state| {
|
|
|
+ let variant = state.name();
|
|
|
+ let path = paths.get(state.name()).unwrap_or_else(|| {
|
|
|
+ panic!(
|
|
|
+ "Failed to build a path for state {variant} in actor {}.",
|
|
|
+ actor.name()
|
|
|
+ )
|
|
|
+ });
|
|
|
+ quote! { #variant(#path), }
|
|
|
+ })
|
|
|
+ .chain(std::iter::once(
|
|
|
+ quote! { #end_ident(::btrun::model::#end_ident) },
|
|
|
+ ));
|
|
|
+ let enum_name = actor.state_enum_ident();
|
|
|
+ let init_state_name = init_state.name();
|
|
|
+ let name_method = self.generate_name_method(|| self.state_idents(actor));
|
|
|
+ quote! {
|
|
|
+ enum #enum_name<#init_type_param: #init_state_name> {
|
|
|
+ #( #variant_decls )*
|
|
|
+ }
|
|
|
+
|
|
|
+ impl<#init_type_param: #init_state_name> ::btrun::model::Named for #enum_name<#init_type_param> {
|
|
|
+ #name_method
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn generate_name_method<'a, I, F>(&'a self, get_names: F) -> TokenStream
|
|
|
+ where
|
|
|
+ I: Iterator<Item = &'a Ident>,
|
|
|
+ F: Fn() -> I,
|
|
|
+ {
|
|
|
+ let var_names: Vec<_> = get_names()
|
|
|
+ .map(|name| format_ident!("{}_NAME", name.pascal_to_snake().to_uppercase()))
|
|
|
+ .collect();
|
|
|
+ let decls = get_names().zip(var_names.iter()).map(|(name, var_name)| {
|
|
|
+ quote! {
|
|
|
+ static #var_name: Lazy<Arc<String>> = Lazy::new(|| {
|
|
|
+ Arc::new(stringify!(#name).into())
|
|
|
+ });
|
|
|
+ }
|
|
|
+ });
|
|
|
+ let names = get_names();
|
|
|
+ quote! {
|
|
|
+ fn name(&self) -> ::std::sync::Arc<String> {
|
|
|
+ use ::std::sync::Arc;
|
|
|
+ use ::btrun::model::Lazy;
|
|
|
+ #( #decls )*
|
|
|
+ match self {
|
|
|
+ #( Self::#names {..} => #var_names.clone() ),*
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn make_assoc_type_paths<'b, 'a: 'b>(
|
|
|
+ &'a self,
|
|
|
+ paths: &'b mut HashMap<&'a Ident, TokenStream>,
|
|
|
+ visited: &'b mut HashSet<&'a Ident>,
|
|
|
+ path: &'b mut Vec<&'a Ident>,
|
|
|
+ current: &'a StateModel,
|
|
|
+ ) {
|
|
|
+ visited.insert(current.name());
|
|
|
+ paths.insert(current.name(), quote! { #( #path )::* });
|
|
|
+ for output in self.next_states(current) {
|
|
|
+ let state_trait = output.kind().state_trait().unwrap().as_ref();
|
|
|
+ if visited.contains(state_trait) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ let next = self.get_state(state_trait);
|
|
|
+ path.push(output.assoc_type().unwrap());
|
|
|
+ self.make_assoc_type_paths(paths, visited, path, next);
|
|
|
+ path.pop();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn generate_client_handle(&self, actor: &ActorModel) -> TokenStream {
|
|
|
+ let struct_ident = actor.handle_struct_ident().unwrap();
|
|
|
+ let state_enum_ident = actor.state_enum_ident();
|
|
|
+ let init_type_param = actor.init_state().type_param();
|
|
|
+ let init_name = actor.init_state().name();
|
|
|
+ let current_type_param = self.state_type_param();
|
|
|
+ let new_type_param = self.new_state_type_param();
|
|
|
+ let new_state_method = self.new_state_method();
|
|
|
+ let state_field = self.state_field();
|
|
|
+ let transitions = actor.states().values().flat_map(|current_state| {
|
|
|
+ current_state
|
|
|
+ .methods()
|
|
|
+ .values()
|
|
|
+ .filter(|method| method.msg_received_input().is_none())
|
|
|
+ .map(|method| self.generate_client_method(actor, current_state, method))
|
|
|
+ });
|
|
|
+ quote! {
|
|
|
+ struct #struct_ident<#init_type_param: #init_name, #current_type_param> {
|
|
|
+ runtime: &'static ::btrun::Runtime,
|
|
|
+ #state_field: ::std::sync::Arc<::btrun::model::Mutex<Option<#state_enum_ident<#init_type_param>>>>,
|
|
|
+ actor_name: ::btrun::model::ActorName,
|
|
|
+ type_state: ::std::marker::PhantomData<#current_type_param>,
|
|
|
+ }
|
|
|
+
|
|
|
+ impl<#init_type_param: #init_name> #struct_ident<#init_type_param, #init_type_param> {
|
|
|
+ fn new(
|
|
|
+ runtime: &'static ::btrun::Runtime,
|
|
|
+ #state_field: ::std::sync::Arc<::btrun::model::Mutex<Option<#state_enum_ident<#init_type_param>>>>,
|
|
|
+ actor_name: ::btrun::model::ActorName,
|
|
|
+ ) -> Self {
|
|
|
+ Self {
|
|
|
+ runtime,
|
|
|
+ #state_field,
|
|
|
+ actor_name,
|
|
|
+ type_state: ::std::marker::PhantomData,
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ impl<#init_type_param: #init_name, #current_type_param> #struct_ident<#init_type_param, #current_type_param> {
|
|
|
+ fn #new_state_method<#new_type_param>(self) -> #struct_ident<#init_type_param, #new_type_param> {
|
|
|
+ #struct_ident {
|
|
|
+ runtime: self.runtime,
|
|
|
+ #state_field: self.#state_field,
|
|
|
+ actor_name: self.actor_name,
|
|
|
+ type_state: ::std::marker::PhantomData,
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ #( #transitions )*
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn generate_client_method(
|
|
|
+ &self,
|
|
|
+ actor: &ActorModel,
|
|
|
+ current_state: &StateModel,
|
|
|
+ method: &MethodModel,
|
|
|
+ ) -> TokenStream {
|
|
|
+ let init_state = actor.init_state();
|
|
|
+ let init_name = init_state.name();
|
|
|
+ let init_type_param = init_state.type_param();
|
|
|
+ let new_type_param = self.new_state_type_param();
|
|
|
+
|
|
|
+ let current_name = current_state.name();
|
|
|
+ let current_type_param = current_state.type_param();
|
|
|
+ let new_state_out = method.next_state();
|
|
|
+ let new_name = new_state_out.kind().state_trait().unwrap().as_ref();
|
|
|
+ let new_type_param = if new_name == End::ident() {
|
|
|
+ self.end_ident()
|
|
|
+ } else {
|
|
|
+ new_type_param
|
|
|
+ };
|
|
|
+
|
|
|
+ fn current_constraint(
|
|
|
+ current_type_param: &Ident,
|
|
|
+ current_name: &Ident,
|
|
|
+ new_type_param: &Ident,
|
|
|
+ new_state_out: &ValueModel,
|
|
|
+ ) -> TokenStream {
|
|
|
+ new_state_out
|
|
|
+ .assoc_type()
|
|
|
+ .map(|new_assoc_type| {
|
|
|
+ quote! {
|
|
|
+ #current_type_param: #current_name<#new_assoc_type = #new_type_param>,
|
|
|
+ }
|
|
|
+ })
|
|
|
+ .unwrap_or_else(|| {
|
|
|
+ quote! {
|
|
|
+ #current_type_param: #current_name,
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+
|
|
|
+ fn new_constraint(new_type_param: &Ident, new_name: &Ident) -> Option<TokenStream> {
|
|
|
+ if new_name == End::ident() {
|
|
|
+ None
|
|
|
+ } else {
|
|
|
+ Some(quote! { #new_type_param: #new_name, })
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // We start by assuming that init, current, and new are all different.
|
|
|
+ // This means including type constraints for all three.
|
|
|
+ let type_constraints = {
|
|
|
+ let current_constraint = current_constraint(
|
|
|
+ current_type_param,
|
|
|
+ current_name,
|
|
|
+ new_type_param,
|
|
|
+ new_state_out,
|
|
|
+ );
|
|
|
+ let new_constraint = new_constraint(new_type_param, new_name);
|
|
|
+ quote! {
|
|
|
+ #init_type_param: #init_name,
|
|
|
+ #current_constraint
|
|
|
+ #new_constraint
|
|
|
+ }
|
|
|
+ };
|
|
|
+ #[allow(clippy::collapsible_else_if)]
|
|
|
+ let (type_constraints, current_type_param, new_type_param) = if init_name == current_name {
|
|
|
+ let current_type_param = init_type_param;
|
|
|
+ if current_name == new_name {
|
|
|
+ // All three are the same, so we mut omit the init and new constraints.
|
|
|
+ let new_type_param = init_type_param;
|
|
|
+ let type_constraints = current_constraint(
|
|
|
+ current_type_param,
|
|
|
+ current_name,
|
|
|
+ new_type_param,
|
|
|
+ new_state_out,
|
|
|
+ );
|
|
|
+ (type_constraints, current_type_param, new_type_param)
|
|
|
+ } else {
|
|
|
+ // init and current are the same, so we must omit the init constraint.
|
|
|
+ let current_constraint = current_constraint(
|
|
|
+ current_type_param,
|
|
|
+ current_name,
|
|
|
+ new_type_param,
|
|
|
+ new_state_out,
|
|
|
+ );
|
|
|
+ let new_constraint = new_constraint(new_type_param, new_name);
|
|
|
+ let type_constraints = quote! {
|
|
|
+ #current_constraint
|
|
|
+ #new_constraint
|
|
|
+ };
|
|
|
+ (type_constraints, current_type_param, new_type_param)
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if current_name == new_name {
|
|
|
+ // current and new are the same, so we must omit the new constraint.
|
|
|
+ let new_type_param = current_type_param;
|
|
|
+ let current_constraint = current_constraint(
|
|
|
+ current_type_param,
|
|
|
+ current_name,
|
|
|
+ new_type_param,
|
|
|
+ new_state_out,
|
|
|
+ );
|
|
|
+ let type_constraints = quote! {
|
|
|
+ #init_type_param: #init_name,
|
|
|
+ #current_constraint
|
|
|
+ };
|
|
|
+ (type_constraints, current_type_param, new_type_param)
|
|
|
+ } else {
|
|
|
+ // All three are different, so we must not omit any constraints.
|
|
|
+ (type_constraints, current_type_param, new_type_param)
|
|
|
+ }
|
|
|
+ };
|
|
|
+ // If the new type is End then it must be fully qualified.
|
|
|
+ let end_ident = self.end_ident();
|
|
|
+ let new_type_param = if new_type_param == end_ident {
|
|
|
+ quote! { ::btrun::model::#end_ident}
|
|
|
+ } else {
|
|
|
+ quote! { #new_type_param }
|
|
|
+ };
|
|
|
+
|
|
|
+ let params = method.inputs().iter().map(|input| input.as_handle_param());
|
|
|
+ let actor_name_ident = self.actor_name_ident();
|
|
|
+ let actor_id_param = self.actor_id_param();
|
|
|
+ let struct_ident = actor.handle_struct_ident().unwrap_or_else(|| {
|
|
|
+ panic!(
|
|
|
+ "Attempted to generate client method for non-client actor '{}'.",
|
|
|
+ actor.name()
|
|
|
+ )
|
|
|
+ });
|
|
|
+ let use_statements = self.use_statements();
|
|
|
+ let state_field = self.state_field();
|
|
|
+ let state_enum_ident = actor.state_enum_ident();
|
|
|
+ let new_state_method = self.new_state_method();
|
|
|
+ let runtime_param = self.runtime_param();
|
|
|
+ let from_ident = self.from_ident();
|
|
|
+ let actor_name = self.actor_name_ident();
|
|
|
+ let return_assoc_type = method
|
|
|
+ .outputs()
|
|
|
+ .iter()
|
|
|
+ .find(|output| matches!(output.kind(), ValueKind::Return { .. }))
|
|
|
+ .map(|output| {
|
|
|
+ output
|
|
|
+ .assoc_type()
|
|
|
+ .unwrap_or_else(|| panic!("Return value has no associated type."))
|
|
|
+ })
|
|
|
+ .unwrap_or_else(|| panic!("Client method has no return output."));
|
|
|
+ let state_var = self.state_var();
|
|
|
+ let guard_var = self.guard_var();
|
|
|
+ let give_back_current = self.give_back(actor, current_name);
|
|
|
+ let give_back_new = self.give_back(actor, new_name);
|
|
|
+ let to_var = self.to_var();
|
|
|
+ let dispatch_msgs =
|
|
|
+ self.generate_client_handle_msg_dispatches(actor, current_state, method);
|
|
|
+ let handle_method_name = method.handle_name().unwrap_or_else(|| {
|
|
|
+ panic!(
|
|
|
+ "Method '{}' in client '{}' had no handle method name.",
|
|
|
+ method.name(),
|
|
|
+ actor.name()
|
|
|
+ )
|
|
|
+ });
|
|
|
+ let method_to_call = method.name();
|
|
|
+ let call_args = method
|
|
|
+ .inputs()
|
|
|
+ .iter()
|
|
|
+ .map(|input| input.as_client_method_call(self));
|
|
|
+ let out_state_vars = method
|
|
|
+ .outputs()
|
|
|
+ .iter()
|
|
|
+ .flat_map(|output| {
|
|
|
+ if let ValueKind::State { .. } = output.kind() {
|
|
|
+ let var_name = output.var_name();
|
|
|
+ Some(quote! { #var_name, })
|
|
|
+ } else {
|
|
|
+ None
|
|
|
+ }
|
|
|
+ })
|
|
|
+ .skip(1);
|
|
|
+ quote! {
|
|
|
+ impl<#type_constraints> #struct_ident<#init_type_param, #current_type_param> {
|
|
|
+ async fn #handle_method_name(
|
|
|
+ self,
|
|
|
+ #to_var: ::btrun::model::ServiceAddr,
|
|
|
+ #( #params ),*
|
|
|
+ ) -> ::btrun::model::TransResult<
|
|
|
+ Self,
|
|
|
+ (
|
|
|
+ #struct_ident<#init_type_param, #new_type_param>,
|
|
|
+ #init_type_param::#return_assoc_type
|
|
|
+ )
|
|
|
+ > {
|
|
|
+ #use_statements
|
|
|
+ let #actor_id_param = self.#actor_name_ident.actor_id();
|
|
|
+ let #runtime_param = self.#runtime_param;
|
|
|
+ let #from_ident = &self.#actor_name;
|
|
|
+ let mut #guard_var = self.#state_field.lock().await;
|
|
|
+ let state = if let Some(state) = #guard_var.take() {
|
|
|
+ state
|
|
|
+ } else {
|
|
|
+ let err = bterr!(
|
|
|
+ "Handle is no longer usable. Client shared state was not returned."
|
|
|
+ );
|
|
|
+ return TransResult::Fatal { err };
|
|
|
+ };
|
|
|
+ match state {
|
|
|
+ #state_enum_ident::#current_name(#state_var) => {
|
|
|
+ #( #dispatch_msgs )*
|
|
|
+ let result = #state_var.#method_to_call(#( #call_args ),*).await;
|
|
|
+ match result {
|
|
|
+ TransResult::Ok((#state_var, #( #out_state_vars )* return_val)) => {
|
|
|
+ #give_back_new
|
|
|
+ TransResult::Ok((self.#new_state_method(), return_val))
|
|
|
+ }
|
|
|
+ TransResult::Abort { from: #state_var, err, .. } => {
|
|
|
+ #give_back_current
|
|
|
+ TransResult::Abort { from: self, err }
|
|
|
+ }
|
|
|
+ TransResult::Fatal { err, .. } => TransResult::Fatal { err },
|
|
|
+ }
|
|
|
+ },
|
|
|
+ state => {
|
|
|
+ let name = state.name();
|
|
|
+ *#guard_var = Some(state);
|
|
|
+ drop(#guard_var);
|
|
|
+ let err = bterr!("Client is in an unexpected state: '{name}'.");
|
|
|
+ TransResult::Abort { from: self, err }
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
+
|
|
|
+ fn generate_client_handle_msg_dispatches<'a>(
|
|
|
+ &'a self,
|
|
|
+ actor: &'a ActorModel,
|
|
|
+ state: &'a StateModel,
|
|
|
+ method: &'a MethodModel,
|
|
|
+ ) -> impl 'a + Iterator<Item = TokenStream> {
|
|
|
+ method.inputs().iter().flat_map(move |input| {
|
|
|
+ self.generate_client_handle_msg_dispatch(actor, state, method, input)
|
|
|
+ })
|
|
|
+ }
|
|
|
+
|
|
|
+ fn generate_client_handle_msg_dispatch(
|
|
|
+ &self,
|
|
|
+ actor: &ActorModel,
|
|
|
+ state: &StateModel,
|
|
|
+ method: &MethodModel,
|
|
|
+ value: &ValueModel,
|
|
|
+ ) -> Option<TokenStream> {
|
|
|
+ let msg_enum_ident = self.msg_enum_ident();
|
|
|
+ let runtime_param = self.runtime_param();
|
|
|
+ let to_var = self.to_var();
|
|
|
+ let from_ident = self.from_ident();
|
|
|
+ let give_back_current = self.give_back(actor, state.name());
|
|
|
+ let actor_id = self.actor_id_param();
|
|
|
+ if let ValueKind::Dest { def, msg_type, .. } = value.kind() {
|
|
|
+ let var_name = value.var_name();
|
|
|
+ let msg_info = self.msg_lookup().lookup(&def.msg);
|
|
|
+ if let Some(reply) = msg_info.reply() {
|
|
|
+ let reply_name = reply.msg_name();
|
|
|
+ Some(quote! {
|
|
|
+ let #var_name = {
|
|
|
+ let arg = #msg_enum_ident::#msg_type(#var_name);
|
|
|
+ let result = #runtime_param
|
|
|
+ .call_service(#to_var, #from_ident.clone(), arg)
|
|
|
+ .await;
|
|
|
+ match result {
|
|
|
+ Ok(value) => {
|
|
|
+ match value {
|
|
|
+ #msg_enum_ident::#reply_name(value) => value,
|
|
|
+ value => {
|
|
|
+ #give_back_current
|
|
|
+ let err = bterr!("Unexpected message of type '{}' sent in response '{}' message.", value.name(), stringify!(#msg_type));
|
|
|
+ return TransResult::Abort { from: self, err };
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Err(err) => {
|
|
|
+ #give_back_current
|
|
|
+ return TransResult::Abort { from: self, err };
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ })
|
|
|
+ } else {
|
|
|
+ match &def.state {
|
|
|
+ DestinationState::Service(_) => Some(quote! {
|
|
|
+ let #var_name = {
|
|
|
+ let arg = #msg_enum_ident::#msg_type(#var_name);
|
|
|
+ let result = #runtime_param
|
|
|
+ .send_service(#to_var, #from_ident.clone(), arg)
|
|
|
+ .await;
|
|
|
+ match result {
|
|
|
+ Ok(()) => (),
|
|
|
+ Err(err) => {
|
|
|
+ #give_back_current
|
|
|
+ return TransResult::Abort { from: self, err };
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ }),
|
|
|
+ DestinationState::Individual(state) => match method.dest_kind(state) {
|
|
|
+ DestKind::Owner => {
|
|
|
+ let actor_name = actor.name();
|
|
|
+ Some(quote! {
|
|
|
+ {
|
|
|
+ let msg = #msg_enum_ident::#msg_type(#var_name);
|
|
|
+ if let Err(err) = #runtime_param.send_owner(#actor_id, msg).await {
|
|
|
+ log::error!("Failed to send message to owner of actor '{}': {err}", stringify!(#actor_name));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
+ DestKind::Owned(_name_var) => {
|
|
|
+ Some(quote! { todo!("Dispatch to owned state."); })
|
|
|
+ }
|
|
|
+ DestKind::Sender => Some(quote! { todo!("Dispatch to sender.") }),
|
|
|
+ },
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ None
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fn generate_out_state_spawns<'a>(
|
|
|
+ &'a self,
|
|
|
+ actor: &'a ActorModel,
|
|
|
+ state: &'a StateModel,
|
|
|
+ method: &'a MethodModel,
|
|
|
+ ) -> impl 'a + Iterator<Item = TokenStream> {
|
|
|
+ method
|
|
|
+ .outputs()
|
|
|
+ .iter()
|
|
|
+ .skip(1)
|
|
|
+ .flat_map(|output| {
|
|
|
+ if let ValueKind::State { def, .. } = output.kind() {
|
|
|
+ Some((output.var_name(), def))
|
|
|
+ } else {
|
|
|
+ None
|
|
|
+ }
|
|
|
+ })
|
|
|
+ .map(|(var_name, def)| {
|
|
|
+ let actor_to_spawn = self.actor_lookup().actor_with_state(&def.state_trait);
|
|
|
+ let model_to_spawn = self
|
|
|
+ .actors()
|
|
|
+ .get(actor_to_spawn)
|
|
|
+ .unwrap_or_else(|| panic!("There was no actor named {actor_to_spawn}."));
|
|
|
+ let spawn_function = model_to_spawn.spawn_function_ident().unwrap_or_else(|| {
|
|
|
+ panic!(
|
|
|
+ "Actor {actor_to_spawn} of kind {:?} has no spawn function.",
|
|
|
+ model_to_spawn.kind()
|
|
|
+ )
|
|
|
+ });
|
|
|
+ let runtime = self.runtime_param();
|
|
|
+ let method_name = method.name();
|
|
|
+ // If the state has an owner specified, then given ownership to the caller,
|
|
|
+ // otherwise retain ownership.
|
|
|
+ if def.states_array_owner().is_some() {
|
|
|
+ let from = self.from_ident();
|
|
|
+ let owner = quote! { #from };
|
|
|
+ quote! {
|
|
|
+ if let Err(err) = #spawn_function(#runtime, #owner, #var_name).await {
|
|
|
+ log::error!(
|
|
|
+ "Failed to spawn {} actor after the {} method: {err}",
|
|
|
+ stringify!(#actor_to_spawn),
|
|
|
+ stringify!(#method_name)
|
|
|
+ )
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ let actor_name = self.actor_name_ident();
|
|
|
+ let owner = quote! { #actor_name.clone() };
|
|
|
+ let error_ident = format_ident!("err");
|
|
|
+ let error =
|
|
|
+ self.generate_actor_error(actor, state, method, quote! { #error_ident });
|
|
|
+ quote! {
|
|
|
+ let #var_name = match #spawn_function(#runtime, #owner, #var_name).await {
|
|
|
+ Ok(name) => name,
|
|
|
+ Err(#error_ident) => {
|
|
|
+ return Err(#error);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ }
|
|
|
+ }
|
|
|
+ })
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
impl MethodModel {
|
|
|
- /// Generates the tokens for the code which implements this transition.
|
|
|
- fn generate_tokens(&self) -> TokenStream {
|
|
|
+ /// Returns the code which defines this method in its state trait.
|
|
|
+ fn generate_trait_def(&self) -> TokenStream {
|
|
|
let method_ident = self.name().as_ref();
|
|
|
- let msg_args = self.inputs().iter();
|
|
|
+ let msg_args = self.inputs().iter().map(|input| input.in_method_decl());
|
|
|
let output_decls = self.outputs().iter().flat_map(|output| output.decl());
|
|
|
let output_types = self.outputs().iter().flat_map(|output| output.type_name());
|
|
|
let future_name = self.future();
|
Matthew Carr