1use std::fmt;
17use std::sync::mpsc;
18use std::time::Duration;
19
20use crate::{
21 Any, CompletionStatus, Exception, InStream, ObjectRef, Orb, Reply, Servant, ServerReply,
22 SystemException, SystemExceptionKind, TCKind, TypeCode, UserException, Value,
23};
24
25#[derive(Debug, Clone, Copy, PartialEq, Eq)]
27pub enum ArgMode {
28 In,
29 Out,
30 InOut,
31}
32
33impl ArgMode {
34 pub fn flags(self) -> u32 {
36 match self {
37 ArgMode::In => 1,
38 ArgMode::Out => 2,
39 ArgMode::InOut => 3,
40 }
41 }
42
43 pub fn from_flags(flags: u32) -> Option<ArgMode> {
45 match flags & 3 {
46 1 => Some(ArgMode::In),
47 2 => Some(ArgMode::Out),
48 3 => Some(ArgMode::InOut),
49 _ => None,
50 }
51 }
52
53 pub(crate) fn is_in(self) -> bool {
54 self != ArgMode::Out
55 }
56
57 pub(crate) fn is_out(self) -> bool {
58 self != ArgMode::In
59 }
60}
61
62#[derive(Debug, Clone, PartialEq)]
66pub struct NamedValue {
67 pub name: String,
68 pub value: Any,
69 pub mode: ArgMode,
70}
71
72impl NamedValue {
73 pub fn new(name: impl Into<String>, value: Any, mode: ArgMode) -> NamedValue {
74 NamedValue {
75 name: name.into(),
76 value,
77 mode,
78 }
79 }
80
81 pub fn out(name: impl Into<String>, tc: TypeCode) -> NamedValue {
83 NamedValue::new(name, Any::new(tc, Value::Void), ArgMode::Out)
84 }
85}
86
87fn sys(kind: SystemExceptionKind, completed: CompletionStatus) -> SystemException {
88 SystemException::new(kind, 0, completed)
89}
90
91fn bad_inv_order() -> SystemException {
92 sys(SystemExceptionKind::BAD_INV_ORDER, CompletionStatus::No)
93}
94
95type Pending = mpsc::Receiver<Result<Reply, Exception>>;
99
100pub struct DiiRequest {
109 target: ObjectRef,
110 operation: String,
111 arguments: Vec<NamedValue>,
112 result: Any,
113 exceptions: Vec<TypeCode>,
114 timeout: Option<Option<Duration>>,
115 pending: Option<Pending>,
116}
117
118impl fmt::Debug for DiiRequest {
119 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
120 f.debug_struct("DiiRequest")
121 .field("operation", &self.operation)
122 .field("arguments", &self.arguments)
123 .field("result", &self.result)
124 .field("pending", &self.pending.is_some())
125 .finish_non_exhaustive()
126 }
127}
128
129impl ObjectRef {
130 pub fn create_request(&self, operation: &str) -> DiiRequest {
133 DiiRequest {
134 target: self.clone(),
135 operation: operation.to_owned(),
136 arguments: Vec::new(),
137 result: Any::new(TypeCode::void(), Value::Void),
138 exceptions: Vec::new(),
139 timeout: None,
140 pending: None,
141 }
142 }
143}
144
145impl DiiRequest {
146 pub fn target(&self) -> &ObjectRef {
147 &self.target
148 }
149
150 pub fn operation(&self) -> &str {
151 &self.operation
152 }
153
154 pub fn arguments(&self) -> &[NamedValue] {
156 &self.arguments
157 }
158
159 pub fn arguments_mut(&mut self) -> &mut Vec<NamedValue> {
161 &mut self.arguments
162 }
163
164 pub fn add_in_arg(&mut self, name: &str, value: Any) -> &mut DiiRequest {
165 self.arguments
166 .push(NamedValue::new(name, value, ArgMode::In));
167 self
168 }
169
170 pub fn add_inout_arg(&mut self, name: &str, value: Any) -> &mut DiiRequest {
171 self.arguments
172 .push(NamedValue::new(name, value, ArgMode::InOut));
173 self
174 }
175
176 pub fn add_out_arg(&mut self, name: &str, tc: TypeCode) -> &mut DiiRequest {
177 self.arguments.push(NamedValue::out(name, tc));
178 self
179 }
180
181 pub fn set_return_type(&mut self, tc: TypeCode) -> &mut DiiRequest {
183 self.result = Any::new(tc, Value::Void);
184 self
185 }
186
187 pub fn result(&self) -> &Any {
189 &self.result
190 }
191
192 pub fn add_exception(&mut self, tc: TypeCode) -> &mut DiiRequest {
194 self.exceptions.push(tc);
195 self
196 }
197
198 pub fn exceptions(&self) -> &[TypeCode] {
199 &self.exceptions
200 }
201
202 pub fn set_timeout(&mut self, timeout: Option<Duration>) -> &mut DiiRequest {
205 self.timeout = Some(timeout);
206 self
207 }
208
209 fn in_values(&self) -> Vec<(TypeCode, Value)> {
211 self.arguments
212 .iter()
213 .filter(|nv| nv.mode.is_in())
214 .map(|nv| (nv.value.typecode().clone(), nv.value.value().clone()))
215 .collect()
216 }
217
218 fn pi_params(&self) -> Option<crate::pi::DiiParams> {
221 let pi = self.target.orb().interceptors()?;
222 pi.has_client().then(|| crate::pi::DiiParams {
223 arguments: self.arguments.clone(),
224 result: self.result.typecode().clone(),
225 exceptions: self.exceptions.clone(),
226 })
227 }
228
229 fn check_idle(&self) -> Result<(), SystemException> {
230 match self.pending {
231 Some(_) => Err(bad_inv_order()),
232 None => Ok(()),
233 }
234 }
235
236 pub fn invoke(&mut self) -> Result<(), Exception> {
238 self.check_idle()?;
239 let values = self.in_values();
240 let mut request = self
241 .target
242 .request(&self.operation)
243 .args(move |out| write_values(out, &values));
244 if let Some(t) = self.timeout {
245 request = request.timeout(t);
246 }
247 if let Some(params) = self.pi_params() {
248 request = request.dii(params);
249 }
250 let reply = request.invoke()?;
251 self.take_reply(&reply)
252 }
253
254 pub async fn invoke_async(&mut self) -> Result<(), Exception> {
257 self.check_idle()?;
258 let values = self.in_values();
259 let mut request = self
260 .target
261 .request_async(&self.operation)
262 .args(move |out| write_values(out, &values));
263 if let Some(t) = self.timeout {
264 request = request.timeout(t);
265 }
266 if let Some(params) = self.pi_params() {
267 request = request.dii(params);
268 }
269 let reply = request.invoke().await?;
270 self.take_reply(&reply)
271 }
272
273 pub fn send_oneway(&self) -> Result<(), SystemException> {
275 self.check_idle()?;
276 let values = self.in_values();
277 let mut request = self
278 .target
279 .request(&self.operation)
280 .args(move |out| write_values(out, &values));
281 if let Some(t) = self.timeout {
282 request = request.timeout(t);
283 }
284 if let Some(params) = self.pi_params() {
285 request = request.dii(params);
286 }
287 request.send_oneway()
288 }
289
290 pub fn send_deferred(&mut self) -> Result<(), SystemException> {
296 self.check_idle()?;
297 let orb: Orb = self.target.orb().clone();
298 orb.check_running()?;
299 let values = self.in_values();
300 let target = self.target.clone();
301 let operation = self.operation.clone();
302 let timeout = self.timeout;
303 let (tx, rx) = mpsc::channel();
304 let timeout = timeout.unwrap_or_else(|| target.effective_timeout());
306 let params = self.pi_params();
307 let slots = target.request_slots();
309 orb.runtime_handle().spawn(async move {
310 let mut request = target
311 .request_async(&operation)
312 .args(move |out| write_values(out, &values))
313 .timeout(timeout)
314 .slots(slots);
315 if let Some(params) = params {
316 request = request.dii(params);
317 }
318 let result = request.invoke().await;
319 let _ = tx.send(result);
320 });
321 self.pending = Some(rx);
322 Ok(())
323 }
324
325 pub fn poll_response(&mut self) -> Result<bool, SystemException> {
328 let Some(rx) = &self.pending else {
329 return Err(bad_inv_order());
330 };
331 match rx.try_recv() {
332 Ok(result) => {
333 let (tx, ready) = mpsc::channel();
335 let _ = tx.send(result);
336 self.pending = Some(ready);
337 Ok(true)
338 }
339 Err(mpsc::TryRecvError::Empty) => Ok(false),
340 Err(mpsc::TryRecvError::Disconnected) => Ok(true),
341 }
342 }
343
344 pub fn get_response(&mut self) -> Result<(), Exception> {
348 let Some(rx) = self.pending.take() else {
349 return Err(bad_inv_order().into());
350 };
351 let result = rx.recv().unwrap_or_else(|_| {
353 Err(sys(SystemExceptionKind::COMM_FAILURE, CompletionStatus::Maybe).into())
354 });
355 self.take_reply(&result?)
356 }
357
358 fn take_reply(&mut self, reply: &Reply) -> Result<(), Exception> {
360 let mut input = reply.input();
361 let tc = self.result.typecode().clone();
362 let value = input.read_value(&tc)?;
363 self.result = Any::new(tc, value);
364 for nv in self.arguments.iter_mut().filter(|nv| nv.mode.is_out()) {
365 let tc = nv.value.typecode().clone();
366 let value = input.read_value(&tc)?;
367 nv.value = Any::new(tc, value);
368 }
369 Ok(())
370 }
371
372 pub fn exception_value(&self, e: &UserException) -> Result<Any, SystemException> {
377 exception_any(&self.exceptions, e)
378 }
379}
380
381pub(crate) fn exception_any(
384 exceptions: &[TypeCode],
385 e: &UserException,
386) -> Result<Any, SystemException> {
387 let tc = exceptions
388 .iter()
389 .find(|tc| tc.unaliased().id().ok() == Some(e.repository_id()))
390 .ok_or_else(|| sys(SystemExceptionKind::UNKNOWN, CompletionStatus::Yes))?;
391 let mut input = e.reply.input();
392 let value = input.read_value(tc)?;
393 Ok(Any::new(tc.clone(), value))
394}
395
396fn write_values(
397 out: &mut crate::OutStream<'_>,
398 values: &[(TypeCode, Value)],
399) -> Result<(), SystemException> {
400 for (tc, v) in values {
401 out.write_value(tc, v)?;
402 }
403 Ok(())
404}
405
406pub trait DynamicImplementation: Send + Sync {
412 fn primary_interface(&self) -> &str;
415
416 fn is_a(&self, repository_id: &str) -> bool {
419 repository_id == self.primary_interface()
420 }
421
422 fn invoke(&self, request: &mut ServerRequest) -> Result<(), SystemException>;
429}
430
431#[derive(Debug)]
433pub struct DynamicServant<T>(pub T);
434
435impl<T: DynamicImplementation> Servant for DynamicServant<T> {
436 fn repository_id(&self) -> &str {
437 self.0.primary_interface()
438 }
439
440 fn is_a(&self, repository_id: &str) -> bool {
441 self.0.is_a(repository_id)
442 }
443
444 fn dispatch(
445 &self,
446 operation: &str,
447 input: &mut InStream<'_>,
448 reply: &mut ServerReply,
449 ) -> Result<(), SystemException> {
450 let mut request = ServerRequest::new(operation, input)?;
451 self.0.invoke(&mut request)?;
452 request.write_reply(reply)
453 }
454}
455
456pub struct ServerRequest {
461 operation: String,
462 input: Option<crate::stream::DetachedInput>,
463 arguments: Option<Vec<NamedValue>>,
464 result: Option<Any>,
465 exception: Option<Any>,
466}
467
468impl fmt::Debug for ServerRequest {
469 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
470 f.debug_struct("ServerRequest")
471 .field("operation", &self.operation)
472 .field("arguments", &self.arguments)
473 .field("result", &self.result)
474 .field("exception", &self.exception)
475 .finish_non_exhaustive()
476 }
477}
478
479impl ServerRequest {
480 pub fn new(operation: &str, input: &InStream<'_>) -> Result<ServerRequest, SystemException> {
484 let input = input
485 .detach()
486 .ok_or_else(|| sys(SystemExceptionKind::INTERNAL, CompletionStatus::No))?;
487 Ok(ServerRequest {
488 operation: operation.to_owned(),
489 input: Some(input),
490 arguments: None,
491 result: None,
492 exception: None,
493 })
494 }
495
496 pub fn operation(&self) -> &str {
497 &self.operation
498 }
499
500 pub fn arguments(
508 &mut self,
509 mut parameters: Vec<NamedValue>,
510 ) -> Result<&mut [NamedValue], SystemException> {
511 let Some(input) = self.input.take() else {
512 return Err(bad_inv_order());
513 };
514 {
515 let mut stream = input.stream();
516 for nv in parameters.iter_mut().filter(|nv| nv.mode.is_in()) {
517 let tc = nv.value.typecode().clone();
518 let value = stream.read_value(&tc)?;
519 nv.value = Any::new(tc, value);
520 }
521 }
522 Ok(self.arguments.insert(parameters))
523 }
524
525 pub fn parameters_mut(&mut self) -> Option<&mut [NamedValue]> {
527 self.arguments.as_deref_mut()
528 }
529
530 pub fn set_result(&mut self, value: Any) -> Result<(), SystemException> {
535 if self.arguments.is_none() || self.exception.is_some() {
536 return Err(bad_inv_order());
537 }
538 self.result = Some(value);
539 Ok(())
540 }
541
542 pub fn set_exception(&mut self, value: Any) -> Result<(), SystemException> {
546 if value.typecode().unaliased().kind() != TCKind::Except {
547 return Err(sys(SystemExceptionKind::BAD_PARAM, CompletionStatus::No));
548 }
549 self.exception = Some(value);
550 Ok(())
551 }
552
553 pub fn write_reply(self, reply: &mut ServerReply) -> Result<(), SystemException> {
557 if crate::pi::wants_dsi_params() {
560 crate::pi::leave_dsi_params(crate::pi::DsiParams {
561 arguments: self.arguments.clone(),
562 result: self.result.clone(),
563 exception: self.exception.clone(),
564 });
565 }
566 if let Some(exception) = &self.exception {
567 let tc = exception.typecode().unaliased();
568 let id = tc.id().unwrap_or_default().to_owned();
569 let Value::List(members) = exception.value() else {
570 return Err(sys(SystemExceptionKind::BAD_PARAM, CompletionStatus::Maybe));
571 };
572 let mut out = reply.user_exception(&id)?;
573 for (i, member) in members.iter().enumerate() {
574 let member_tc = tc
575 .member_type(i as u32)
576 .map_err(|_| sys(SystemExceptionKind::BAD_PARAM, CompletionStatus::Maybe))?;
577 out.write_value(&member_tc, member)?;
578 }
579 return Ok(());
580 }
581 let mut out = reply.output();
582 if let Some(result) = &self.result {
583 out.write_value(result.typecode(), result.value())?;
584 }
585 for nv in self
586 .arguments
587 .iter()
588 .flatten()
589 .filter(|nv| nv.mode.is_out())
590 {
591 out.write_value(nv.value.typecode(), nv.value.value())?;
592 }
593 Ok(())
594 }
595}