target

/.idea

**/*.rs.bk

Cargo.lock

main

examples/*/*.exe

examples/*.dll

examples/reowolf*

        serde_proto_description: SerdeProtocolDescription(

            (A big honkin' protocol description),

        ),

        port_info: PortInfo {

            polarities: {

            },

            peers: {

            },

            routes: {

                    Native,

                ),

                    Native,

                ),

            },

        },

        proto_components: {},

    },

}

	PortId putter, getter;

	connector_add_port_pair(c, &putter, &getter);

	connector_connect(c, -1);

	connector_print_debug(c);

	printf("Let's try to put without get\n");

	connector_put_bytes(c, putter, "hello", 5);

	// connector_get(c, getter);

	int err = connector_sync(c, 5000);

	printf("Error code %d with string `%s`\n", err, reowolf_error_peek(NULL));

	printf("Let's try again, doing both\n");

	connector_put_bytes(c, putter, "hello", 5);

	connector_get(c, getter);

	err = connector_sync(c, 5000);

	printf("Error code %d with string `%s`\n", err, reowolf_error_peek(NULL));

	size_t msg_len;

	const char * msg_ptr = connector_gotten_bytes(c, getter, &msg_len);

	printf("Got msg `%.*s`\n", msg_len, msg_ptr);

	protocol_description_destroy(pd);

	connector_destroy(c);

	free(pdl_ptr);

	return 0;

}

#[macro_use]

mod macros;

mod common;

mod protocol;

mod runtime;

pub use protocol::ProtocolDescription;

pub use runtime::{error, Connector, DummyLogger, FileLogger, VecLogger};

                    "Native submitting solution for batch {} with {:?}",

                    index,

                    &predicate

                );

                solution_storage.submit_and_digest_subtree_solution(

                    &mut *cu.logger,

                    Route::LocalComponent(ComponentId::Native),

                    predicate.clone(),

                );

            }

            let branch = NativeBranch { index, gotten: Default::default(), to_get };

            if let Some(existing) = branching_native.branches.insert(predicate, branch) {

                return Err(Se::IndistinguishableBatches([index, existing.index]));

            }

        }

        let decision = Self::sync_reach_decision(

            cu,

            comm,

            &mut branching_native,

            &mut branching_proto_components,

            solution_storage,

            payloads_to_get,

            deadline,

        )?;

        log!(cu.logger, "Committing to decision {:?}!", &decision);

        // propagate the decision to children

                        Self::request_failure(cu, comm, parent)?

                    } else {

                        log!(cu.logger, "Already requested failure");

                    }

                }

                None => {

                    log!(cu.logger, "No parent. Deciding on failure");

                    return Ok(Decision::Failure);

                }

            }

        }

        log!(cu.logger, "Done translating native batches into branches");

        // run all proto components to their sync blocker

        log!(

            cu.logger,

            "Running all {} proto components to their sync blocker...",

            branching_proto_components.len()

        );

        for (&proto_component_id, proto_component) in branching_proto_components.iter_mut() {

            let BranchingProtoComponent { ports, branches } = proto_component;

            let mut swap = HashMap::default();

            let mut blocked = HashMap::default();

            // drain from branches --> blocked

mod communication;

mod endpoints;

pub mod error;

mod logging;

mod setup;

#[cfg(test)]

mod tests;

use crate::common::*;

use error::*;

#[derive(Debug)]

pub struct RoundOk {

    batch_index: usize,

    gotten: HashMap<PortId, Payload>,

}

pub struct VecSet<T: std::cmp::Ord> {

use std::{fs::File, net::SocketAddr, path::Path, sync::Arc, time::Duration};

//////////////////////////////////////////

fn next_test_addr() -> SocketAddr {

    use std::{

        net::{Ipv4Addr, SocketAddrV4},

        sync::atomic::{AtomicU16, Ordering::SeqCst},

    };

    static TEST_PORT: AtomicU16 = AtomicU16::new(5_000);

    let port = TEST_PORT.fetch_add(1, SeqCst);

    SocketAddrV4::new(Ipv4Addr::LOCALHOST, port).into()

}

fn file_logged_connector(connector_id: ConnectorId, dir_path: &Path) -> Connector {

    let _ = std::fs::create_dir(dir_path); // we will check failure soon

    let path = dir_path.join(format!("cid_{:?}.txt", connector_id));

    let file = File::create(path).unwrap();

    let file_logger = Box::new(FileLogger::new(connector_id, file));

    Connector::new(file_logger, MINIMAL_PROTO.clone(), connector_id, 8)

}

//////////////////////////////////////////

#[test]

fn basic_connector() {

    Connector::new(Box::new(DummyLogger), MINIMAL_PROTO.clone(), 0, 0);

}

#[test]

fn basic_logged_connector() {

    let test_log_path = Path::new("./logs/basic_logged_connector");

    file_logged_connector(0, test_log_path);

}

            c.connect(Some(Duration::from_secs(1))).unwrap();

        });

    })

    .unwrap();

}

#[test]

fn put_no_sync() {

    let test_log_path = Path::new("./logs/put_no_sync");

    let mut c = file_logged_connector(0, test_log_path);

    let [o, _] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

}

#[test]

fn wrong_polarity_bad() {

    let test_log_path = Path::new("./logs/wrong_polarity_bad");

    let mut c = file_logged_connector(0, test_log_path);

    let [_, i] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

}

#[test]

fn dup_put_bad() {

    let test_log_path = Path::new("./logs/dup_put_bad");

    let mut c = file_logged_connector(0, test_log_path);

    let [o, _] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

}

#[test]

fn trivial_sync() {

    let test_log_path = Path::new("./logs/trivial_sync");

    let mut c = file_logged_connector(0, test_log_path);

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.sync(Some(Duration::from_secs(1))).unwrap();

}

#[test]

fn unconnected_gotten_err() {

    c.sync(Some(Duration::from_secs(1))).unwrap();

    assert_eq!(reowolf::error::GottenError::PortDidntGet, c.gotten(i).unwrap_err());

}

#[test]

fn native_polarity_checks() {

    let test_log_path = Path::new("./logs/native_polarity_checks");

    let mut c = file_logged_connector(0, test_log_path);

    let [o, i] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    // fail...

    c.get(o).unwrap_err();

    // succeed..

    c.get(i).unwrap();

}

#[test]

fn native_multiple_gets() {

    let test_log_path = Path::new("./logs/native_multiple_gets");

    let mut c = file_logged_connector(0, test_log_path);

    let [_, i] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.get(i).unwrap();

    c.get(i).unwrap_err();

}

    c.next_batch().unwrap();

    c.next_batch().unwrap();

    c.next_batch().unwrap();

}

#[test]

fn native_self_msg() {

    let test_log_path = Path::new("./logs/native_self_msg");

    let mut c = file_logged_connector(0, test_log_path);

    let [o, i] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.get(i).unwrap();

    c.sync(Some(Duration::from_secs(1))).unwrap();

}

#[test]

fn two_natives_msg() {

    let test_log_path = Path::new("./logs/two_natives_msg");

    let sock_addr = next_test_addr();

    scope(|s| {

        s.spawn(|_| {

            let mut c = file_logged_connector(0, test_log_path);

            let g = c.new_net_port(Getter, sock_addr, Active).unwrap();

            c.connect(Some(Duration::from_secs(1))).unwrap();

            c.get(g).unwrap();

            c.sync(Some(Duration::from_secs(1))).unwrap();

            c.gotten(g).unwrap();

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            let p = c.new_net_port(Putter, sock_addr, Passive).unwrap();

            c.connect(Some(Duration::from_secs(1))).unwrap();

            c.sync(Some(Duration::from_secs(1))).unwrap();

        });

    })

    .unwrap();

}

#[test]

fn trivial_nondet() {

    let test_log_path = Path::new("./logs/trivial_nondet");

    let mut c = file_logged_connector(0, test_log_path);

    let [_, i] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

            let mut c = file_logged_connector(0, test_log_path);

            let g = c.new_net_port(Getter, sock_addr, Active).unwrap();

            c.connect(Some(Duration::from_secs(1))).unwrap();

            c.next_batch().unwrap();

            c.get(g).unwrap();

            assert_eq!(1, c.sync(Some(Duration::from_secs(1))).unwrap());

            c.gotten(g).unwrap();

        });

        s.spawn(|_| {

            let mut c = file_logged_connector(1, test_log_path);

            let p = c.new_net_port(Putter, sock_addr, Passive).unwrap();

            c.connect(Some(Duration::from_secs(1))).unwrap();

            c.sync(Some(Duration::from_secs(1))).unwrap();

        });

    })

    .unwrap();

}

#[test]

fn native_immediately_inconsistent() {

    let test_log_path = Path::new("./logs/native_immediately_inconsistent");

    let mut c = file_logged_connector(0, test_log_path);

    let [_, g] = c.new_port_pair();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.get(g).unwrap();

    c.sync(Some(Duration::from_secs(30))).unwrap_err();

}

#[test]

fn cannot_use_moved_ports() {

    /*

    native p|-->|g sync

    */

    let test_log_path = Path::new("./logs/cannot_use_moved_ports");

    let mut c = file_logged_connector(0, test_log_path);

    let [p, g] = c.new_port_pair();

    c.add_component(b"sync", &[g, p]).unwrap();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.get(g).unwrap_err();

}

#[test]

fn sync_sync() {

    /*

    native p0|-->|g0 sync

           g1|<--|p1

    */

    let test_log_path = Path::new("./logs/sync_sync");

    let mut c = file_logged_connector(0, test_log_path);

    let [p0, g0] = c.new_port_pair();

    let [p1, g1] = c.new_port_pair();

    c.add_component(b"sync", &[g0, p1]).unwrap();

    c.connect(Some(Duration::from_secs(1))).unwrap();

    c.get(g1).unwrap();

    c.sync(Some(Duration::from_secs(1))).unwrap();

    c.gotten(g1).unwrap();

}

#[test]

fn double_net_connect() {

    let test_log_path = Path::new("./logs/double_net_connect");

    let sock_addrs = [next_test_addr(), next_test_addr()];

    scope(|s| {

        s.spawn(|_| {

            let mut c = file_logged_connector(0, test_log_path);

        });

        s.spawn(|_| {

            /*

            native p|-->

                   g|<--

            */

            let mut c = file_logged_connector(1, test_log_path);

            let [g, p] = [

                c.new_net_port(Getter, sock_addrs[0], Passive).unwrap(),

                c.new_net_port(Putter, sock_addrs[1], Passive).unwrap(),

            ];

            c.connect(Some(Duration::from_secs(1))).unwrap();

            c.get(g).unwrap();

            c.sync(Some(Duration::from_secs(1))).unwrap();

            c.gotten(g).unwrap();

        });

    })

    .unwrap();

}

#[test]

fn local_timeout() {

    let test_log_path = Path::new("./logs/local_timeout");

    let mut c = file_logged_connector(0, test_log_path);