use std::fmt;
use std::sync::mpsc;
use std::time::Duration;
use crate::{
Any, CompletionStatus, Exception, InStream, ObjectRef, Orb, Reply, Servant, ServerReply,
SystemException, SystemExceptionKind, TCKind, TypeCode, UserException, Value,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArgMode {
In,
Out,
InOut,
}
impl ArgMode {
pub fn flags(self) -> u32 {
match self {
ArgMode::In => 1,
ArgMode::Out => 2,
ArgMode::InOut => 3,
}
}
pub fn from_flags(flags: u32) -> Option<ArgMode> {
match flags & 3 {
1 => Some(ArgMode::In),
2 => Some(ArgMode::Out),
3 => Some(ArgMode::InOut),
_ => None,
}
}
fn is_in(self) -> bool {
self != ArgMode::Out
}
fn is_out(self) -> bool {
self != ArgMode::In
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct NamedValue {
pub name: String,
pub value: Any,
pub mode: ArgMode,
}
impl NamedValue {
pub fn new(name: impl Into<String>, value: Any, mode: ArgMode) -> NamedValue {
NamedValue {
name: name.into(),
value,
mode,
}
}
pub fn out(name: impl Into<String>, tc: TypeCode) -> NamedValue {
NamedValue::new(name, Any::new(tc, Value::Void), ArgMode::Out)
}
}
fn sys(kind: SystemExceptionKind, completed: CompletionStatus) -> SystemException {
SystemException::new(kind, 0, completed)
}
fn bad_inv_order() -> SystemException {
sys(SystemExceptionKind::BAD_INV_ORDER, CompletionStatus::No)
}
type Pending = mpsc::Receiver<Result<Reply, Exception>>;
pub struct DiiRequest {
target: ObjectRef,
operation: String,
arguments: Vec<NamedValue>,
result: Any,
exceptions: Vec<TypeCode>,
timeout: Option<Option<Duration>>,
pending: Option<Pending>,
}
impl fmt::Debug for DiiRequest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("DiiRequest")
.field("operation", &self.operation)
.field("arguments", &self.arguments)
.field("result", &self.result)
.field("pending", &self.pending.is_some())
.finish_non_exhaustive()
}
}
impl ObjectRef {
pub fn create_request(&self, operation: &str) -> DiiRequest {
DiiRequest {
target: self.clone(),
operation: operation.to_owned(),
arguments: Vec::new(),
result: Any::new(TypeCode::void(), Value::Void),
exceptions: Vec::new(),
timeout: None,
pending: None,
}
}
}
impl DiiRequest {
pub fn target(&self) -> &ObjectRef {
&self.target
}
pub fn operation(&self) -> &str {
&self.operation
}
pub fn arguments(&self) -> &[NamedValue] {
&self.arguments
}
pub fn arguments_mut(&mut self) -> &mut Vec<NamedValue> {
&mut self.arguments
}
pub fn add_in_arg(&mut self, name: &str, value: Any) -> &mut DiiRequest {
self.arguments
.push(NamedValue::new(name, value, ArgMode::In));
self
}
pub fn add_inout_arg(&mut self, name: &str, value: Any) -> &mut DiiRequest {
self.arguments
.push(NamedValue::new(name, value, ArgMode::InOut));
self
}
pub fn add_out_arg(&mut self, name: &str, tc: TypeCode) -> &mut DiiRequest {
self.arguments.push(NamedValue::out(name, tc));
self
}
pub fn set_return_type(&mut self, tc: TypeCode) -> &mut DiiRequest {
self.result = Any::new(tc, Value::Void);
self
}
pub fn result(&self) -> &Any {
&self.result
}
pub fn add_exception(&mut self, tc: TypeCode) -> &mut DiiRequest {
self.exceptions.push(tc);
self
}
pub fn exceptions(&self) -> &[TypeCode] {
&self.exceptions
}
pub fn set_timeout(&mut self, timeout: Option<Duration>) -> &mut DiiRequest {
self.timeout = Some(timeout);
self
}
fn in_values(&self) -> Vec<(TypeCode, Value)> {
self.arguments
.iter()
.filter(|nv| nv.mode.is_in())
.map(|nv| (nv.value.typecode().clone(), nv.value.value().clone()))
.collect()
}
fn check_idle(&self) -> Result<(), SystemException> {
match self.pending {
Some(_) => Err(bad_inv_order()),
None => Ok(()),
}
}
pub fn invoke(&mut self) -> Result<(), Exception> {
self.check_idle()?;
let values = self.in_values();
let mut request = self
.target
.request(&self.operation)
.args(move |out| write_values(out, &values));
if let Some(t) = self.timeout {
request = request.timeout(t);
}
let reply = request.invoke()?;
self.take_reply(&reply)
}
pub async fn invoke_async(&mut self) -> Result<(), Exception> {
self.check_idle()?;
let values = self.in_values();
let mut request = self
.target
.request_async(&self.operation)
.args(move |out| write_values(out, &values));
if let Some(t) = self.timeout {
request = request.timeout(t);
}
let reply = request.invoke().await?;
self.take_reply(&reply)
}
pub fn send_oneway(&self) -> Result<(), SystemException> {
self.check_idle()?;
let values = self.in_values();
let mut request = self
.target
.request(&self.operation)
.args(move |out| write_values(out, &values));
if let Some(t) = self.timeout {
request = request.timeout(t);
}
request.send_oneway()
}
pub fn send_deferred(&mut self) -> Result<(), SystemException> {
self.check_idle()?;
let orb: Orb = self.target.orb().clone();
orb.check_running()?;
let values = self.in_values();
let target = self.target.clone();
let operation = self.operation.clone();
let timeout = self.timeout;
let (tx, rx) = mpsc::channel();
let timeout = timeout.unwrap_or_else(|| target.effective_timeout());
orb.runtime_handle().spawn(async move {
let result = target
.request_async(&operation)
.args(move |out| write_values(out, &values))
.timeout(timeout)
.invoke()
.await;
let _ = tx.send(result);
});
self.pending = Some(rx);
Ok(())
}
pub fn poll_response(&mut self) -> Result<bool, SystemException> {
let Some(rx) = &self.pending else {
return Err(bad_inv_order());
};
match rx.try_recv() {
Ok(result) => {
let (tx, ready) = mpsc::channel();
let _ = tx.send(result);
self.pending = Some(ready);
Ok(true)
}
Err(mpsc::TryRecvError::Empty) => Ok(false),
Err(mpsc::TryRecvError::Disconnected) => Ok(true),
}
}
pub fn get_response(&mut self) -> Result<(), Exception> {
let Some(rx) = self.pending.take() else {
return Err(bad_inv_order().into());
};
let result = rx.recv().unwrap_or_else(|_| {
Err(sys(SystemExceptionKind::COMM_FAILURE, CompletionStatus::Maybe).into())
});
self.take_reply(&result?)
}
fn take_reply(&mut self, reply: &Reply) -> Result<(), Exception> {
let mut input = reply.input();
let tc = self.result.typecode().clone();
let value = input.read_value(&tc)?;
self.result = Any::new(tc, value);
for nv in self.arguments.iter_mut().filter(|nv| nv.mode.is_out()) {
let tc = nv.value.typecode().clone();
let value = input.read_value(&tc)?;
nv.value = Any::new(tc, value);
}
Ok(())
}
pub fn exception_value(&self, e: &UserException) -> Result<Any, SystemException> {
let tc = self
.exceptions
.iter()
.find(|tc| tc.unaliased().id().ok() == Some(e.repository_id()))
.ok_or_else(|| sys(SystemExceptionKind::UNKNOWN, CompletionStatus::Yes))?;
let mut input = e.reply.input();
let value = input.read_value(tc)?;
Ok(Any::new(tc.clone(), value))
}
}
fn write_values(
out: &mut crate::OutStream<'_>,
values: &[(TypeCode, Value)],
) -> Result<(), SystemException> {
for (tc, v) in values {
out.write_value(tc, v)?;
}
Ok(())
}
pub trait DynamicImplementation: Send + Sync {
fn primary_interface(&self) -> &str;
fn is_a(&self, repository_id: &str) -> bool {
repository_id == self.primary_interface()
}
fn invoke(&self, request: &mut ServerRequest) -> Result<(), SystemException>;
}
#[derive(Debug)]
pub struct DynamicServant<T>(pub T);
impl<T: DynamicImplementation> Servant for DynamicServant<T> {
fn repository_id(&self) -> &str {
self.0.primary_interface()
}
fn is_a(&self, repository_id: &str) -> bool {
self.0.is_a(repository_id)
}
fn dispatch(
&self,
operation: &str,
input: &mut InStream<'_>,
reply: &mut ServerReply,
) -> Result<(), SystemException> {
let mut request = ServerRequest::new(operation, input)?;
self.0.invoke(&mut request)?;
request.write_reply(reply)
}
}
pub struct ServerRequest {
operation: String,
input: Option<crate::stream::DetachedInput>,
arguments: Option<Vec<NamedValue>>,
result: Option<Any>,
exception: Option<Any>,
}
impl fmt::Debug for ServerRequest {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ServerRequest")
.field("operation", &self.operation)
.field("arguments", &self.arguments)
.field("result", &self.result)
.field("exception", &self.exception)
.finish_non_exhaustive()
}
}
impl ServerRequest {
pub fn new(operation: &str, input: &InStream<'_>) -> Result<ServerRequest, SystemException> {
let input = input
.detach()
.ok_or_else(|| sys(SystemExceptionKind::INTERNAL, CompletionStatus::No))?;
Ok(ServerRequest {
operation: operation.to_owned(),
input: Some(input),
arguments: None,
result: None,
exception: None,
})
}
pub fn operation(&self) -> &str {
&self.operation
}
pub fn arguments(
&mut self,
mut parameters: Vec<NamedValue>,
) -> Result<&mut [NamedValue], SystemException> {
let Some(input) = self.input.take() else {
return Err(bad_inv_order());
};
{
let mut stream = input.stream();
for nv in parameters.iter_mut().filter(|nv| nv.mode.is_in()) {
let tc = nv.value.typecode().clone();
let value = stream.read_value(&tc)?;
nv.value = Any::new(tc, value);
}
}
Ok(self.arguments.insert(parameters))
}
pub fn parameters_mut(&mut self) -> Option<&mut [NamedValue]> {
self.arguments.as_deref_mut()
}
pub fn set_result(&mut self, value: Any) -> Result<(), SystemException> {
if self.arguments.is_none() || self.exception.is_some() {
return Err(bad_inv_order());
}
self.result = Some(value);
Ok(())
}
pub fn set_exception(&mut self, value: Any) -> Result<(), SystemException> {
if value.typecode().unaliased().kind() != TCKind::Except {
return Err(sys(SystemExceptionKind::BAD_PARAM, CompletionStatus::No));
}
self.exception = Some(value);
Ok(())
}
pub fn write_reply(self, reply: &mut ServerReply) -> Result<(), SystemException> {
if let Some(exception) = &self.exception {
let tc = exception.typecode().unaliased();
let id = tc.id().unwrap_or_default().to_owned();
let Value::List(members) = exception.value() else {
return Err(sys(SystemExceptionKind::BAD_PARAM, CompletionStatus::Maybe));
};
let mut out = reply.user_exception(&id)?;
for (i, member) in members.iter().enumerate() {
let member_tc = tc
.member_type(i as u32)
.map_err(|_| sys(SystemExceptionKind::BAD_PARAM, CompletionStatus::Maybe))?;
out.write_value(&member_tc, member)?;
}
return Ok(());
}
let mut out = reply.output();
if let Some(result) = &self.result {
out.write_value(result.typecode(), result.value())?;
}
for nv in self
.arguments
.iter()
.flatten()
.filter(|nv| nv.mode.is_out())
{
out.write_value(nv.value.typecode(), nv.value.value())?;
}
Ok(())
}
}