CSY/reowolf Changeset - 0b5fa1cf6ccf · Centrum Wiskunde & Informatica (CWI)

Changeset - 0b5fa1cf6ccf

Parent rev.

Child rev.

[Not reviewed]

0 1 0

Christopher Esterhuyse - 5 years ago 2020-10-08 12:50:21
christopher.esterhuyse@gmail.com

more detailed doc comments

1 file changed with 15 insertions and 5 deletions:

src/runtime/setup.rs

0 comments (0 inline, 0 general)

src/runtime/setup.rs

➞

Show inline comments

@@ @@ -193,29 +193,34 @@ impl Connector { @@
     /// This single element starts off selected. The selected batch is modified with `put` and `get`,
     /// and new batches are added and selected with `next_batch`. See `sync` for an explanation of the
     /// purpose of these batches.
     pub fn connect(&mut self, timeout: Option<Duration>) -> Result<(), ConnectError> {
         use ConnectError as Ce;
         let Self { unphased: cu, phased } = self;
         match &phased {
             ConnectorPhased::Communication { .. } => {
                 log!(cu.logger, "Call to connecting in connected state");
                 Err(Ce::AlreadyConnected)
+            }
             ConnectorPhased::Setup(setup) => {
                 // Ideally, we'd simply clone `cu` in its entirety, and pass it to
                 // `connect_inner`, such that a successful connection discards the original.
                 // We need to work around the `logger` not being clonable;
                 // solution? create a dummy clone, and use mem-swap to ensure the
                 // single real logger is wherever it needs to be.
                 // Idea: Clone `self.unphased`, and then pass the replica to
                 // `connect_inner` to do the work, attempting to create a new connector structure
                 // in connected state without encountering any errors.
                 // If anything goes wrong during `connect_inner`, we simply keep the original `cu`.
                 // Ideally, we'd simply clone `cu` in its entirety.
                 // However, it isn't clonable, because of the pesky logger.
                 // Solution: the original and clone ConnectorUnphased structures
                 // 'share' the original logger by using `mem::swap` strategically to pass a dummy back and forth,
                 // such that the real logger is wherever we need it to be without violating any invariants.
                 let mut cu_clone = ConnectorUnphased {
                     logger: Box::new(DummyLogger),
                     proto_components: cu.proto_components.clone(),
                     native_component_id: cu.native_component_id.clone(),
                     ips: cu.ips.clone(),
                     proto_description: cu.proto_description.clone(),
                 };
                 // cu has REAL logger...
                 std::mem::swap(&mut cu.logger, &mut cu_clone.logger);
                 // ... cu_clone has REAL logger.
                 match Self::connect_inner(cu_clone, setup, timeout) {
                     Ok(connected_connector) => {
@@ @@ -224,24 +229,29 @@ impl Connector { @@
+                    }
                     Err((err, mut logger)) => {
                         // Put the original logger back in place (in self.unphased, AKA `cu`).
                         // cu_clone has REAL logger...
                         std::mem::swap(&mut cu.logger, &mut logger);
                         // ... cu has REAL logger.
                         Err(err)
+                    }
+                }
+            }
+        }
+    }
     // Given an immutable setup structure, and my own (cloned) ConnetorUnphased,
     // attempt to complete the setup procedure and return a new connector in Connected state.
     // If anything goes wrong, throw everything in the bin, except for the Logger, which is
     // the only structure that sees lasting effects of the failed attempt.
     fn connect_inner(
         mut cu: ConnectorUnphased,
         setup: &ConnectorSetup,
         timeout: Option<Duration>,
     ) -> Result<Self, (ConnectError, Box<dyn Logger>)> {
         log!(cu.logger, "~~~ CONNECT called timeout {:?}", timeout);
         let deadline = timeout.map(|to| Instant::now() + to);
         let mut try_complete = || {
             // connect all endpoints in parallel; send and receive peer ids through ports
             let mut endpoint_manager = setup_endpoints_and_pair_ports(
                 &mut *cu.logger,
                 &setup.net_endpoint_setups,

0 comments (0 inline, 0 general)