Struct OpenOptions

pub struct OpenOptions { /* private fields */ }

Flags and parameters which control how a PosixMq message queue is opened or created.

Implementations

impl OpenOptions

pub fn readonly() -> Self

Open message queue for receiving only.

Examples found in repository

examples/receive.rs (line 27)

fn main() {
    let mut args = args_os().skip(1);
    let name = args.next().expect("argument required");
    let timeout = args.next().map(|arg| {
        let arg = arg.into_string().expect("invalid timeout");
        if arg == "nonblocking" || arg == "drain" || arg == "available" || arg == "empty" {
            None
        } else if arg.ends_with("ms") {
            Some(Duration::from_millis(arg[..arg.len()-2].parse().expect("invalid duration")))
        } else if arg.ends_with("s") {
            Some(Duration::from_secs(arg[..arg.len()-1].parse().expect("invalid duration")))
        } else {
            Some(Duration::from_secs(arg.parse().expect("invalid duration")))
        }
    });

    let mut opts = posixmq::OpenOptions::readonly();
    if timeout == Some(None) {
        opts = *opts.nonblocking();
    }
    let mq = opts.open(name.as_bytes()).expect("opening failed");

    if let Some(Some(timeout)) = timeout {
        let mut buf = vec![0; mq.attributes().unwrap_or_default().max_msg_len];
        while let Ok((priority, len)) = mq.recv_timeout(&mut buf, timeout) {
            print!("{:3}\t", priority);
            stdout().write_all(&buf[..len]).expect("writing to stdout failed");
            println!();
        }
    } else {
        for (priority, msg) in mq {
            print!("{:3}\t", priority);
            stdout().write_all(&msg).expect("writing to stdout failed");
            println!();
        }
    }
}

examples/merge.rs (line 19)

fn main() {
    use std::env::args;
    use std::io::ErrorKind;

    use mio::{Poll, Events, Interest, Token};

    let mut queues = args().skip(1).collect::<Vec<_>>();
    let dst = queues.pop().expect("arguments required");
    
    // open source queues
    let mut src = Vec::new();
    for name in queues {
        match posixmq::OpenOptions::readonly().nonblocking().open(&name) {
            Ok(mq) => src.push((mq, name)),
            Err(e) => panic!("Cannot open {:?} for receiving: {}", name, e),
        }
    }

    // open destination queue
    let mut dst = match posixmq::OpenOptions::writeonly().nonblocking().create().open(&dst) {
        Ok(mq) => (mq, dst),
        Err(e) => panic!("Cannot open or create {:?} for sending: {}", dst, e),
    };

    let mut poll = Poll::new().expect("Cannot create selector");
    poll.registry()
        .register(&mut dst.0, Token(0), Interest::WRITABLE)
        .expect("registering destination failed");
    for (i, &mut(ref mut src, _)) in src.iter_mut().enumerate() {
        poll.registry()
            .register(src, Token(i+1), Interest::READABLE)
            .expect("registering a source failed");
    }

    let mut unsent = Vec::<(u32, Box<[u8]>, &str)>::new();
    let mut buf = [0; 8192];
    let mut events = Events::with_capacity(1024);
    loop {
        poll.poll(&mut events, None).expect("Cannot poll selector");

        // receive all available messages from queues that are ready
        for event in events.iter() {
            if event.token() == Token(0) {
                // dst; will try to send below even without this event
                continue;
            }

            let &(ref mq, ref name) = &src[event.token().0-1];
            loop {
                match mq.recv(&mut buf) {
                    Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
                    Err(e) => panic!("Error receiving from {}: {}", name, e),
                    Ok((priority, len)) => unsent.push((priority, Box::from(&buf[..len]), name)),
                }
            }
        }

        // send as many messages as possible
        while let Some(&(priority, ref msg, ref src)) = unsent.last() {
            if let Err(e) = dst.0.send(priority, msg) {
                if e.kind() == ErrorKind::WouldBlock {
                    break;
                }
                panic!("Error sending to {}: {}", dst.1, e);
            }
            println!("message of priority {} with {} bytes from {} sent to {}", 
                priority, msg.len(), src, dst.1
            );
            let _ = unsent.pop();
        }
    }
}

pub fn writeonly() -> Self

Open message queue for sending only.

Examples found in repository

examples/send.rs (line 17)

fn main() {
    let args = args_os().skip(1).collect::<Vec<_>>();
    if args.len() % 2 == 0 {
        eprintln!("Usage: cargo run --example send /queue-name [priority message] ...");
        return;
    }

    // open the message queue
    let mq = posixmq::OpenOptions::writeonly()
        .create()
        .mode(0o666) // FIXME set umask to actually make it sendable for others
        .open(args[0].as_bytes())
        .expect("opening failed");

    if args.len() == 1 {
        // read from stdin
        for line in stdin().lock().lines() {
            let line = line.expect("input must be UTF-8, sorry");
            let line = line.trim_start();
            let num_end = line.find(' ').expect("no space in line");
            let priority = line[..num_end].parse::<u32>().expect("priority is not a number");
            let msg = line[num_end+1..].trim_start();
            mq.send(priority, msg.as_bytes()).expect("sending failed");
        }
    } else {
        // read from the command line
        for i in (1..args.len()).step_by(2) {
            let priority = args[i].to_str()
                .and_then(|s| s.parse::<u32>().ok() )
                .expect("priority is not a number");
            let msg = args[i+1].as_bytes();
            mq.send(priority, msg).expect("sending failed");
        }
    }
}

examples/merge.rs (line 26)

fn main() {
    use std::env::args;
    use std::io::ErrorKind;

    use mio::{Poll, Events, Interest, Token};

    let mut queues = args().skip(1).collect::<Vec<_>>();
    let dst = queues.pop().expect("arguments required");
    
    // open source queues
    let mut src = Vec::new();
    for name in queues {
        match posixmq::OpenOptions::readonly().nonblocking().open(&name) {
            Ok(mq) => src.push((mq, name)),
            Err(e) => panic!("Cannot open {:?} for receiving: {}", name, e),
        }
    }

    // open destination queue
    let mut dst = match posixmq::OpenOptions::writeonly().nonblocking().create().open(&dst) {
        Ok(mq) => (mq, dst),
        Err(e) => panic!("Cannot open or create {:?} for sending: {}", dst, e),
    };

    let mut poll = Poll::new().expect("Cannot create selector");
    poll.registry()
        .register(&mut dst.0, Token(0), Interest::WRITABLE)
        .expect("registering destination failed");
    for (i, &mut(ref mut src, _)) in src.iter_mut().enumerate() {
        poll.registry()
            .register(src, Token(i+1), Interest::READABLE)
            .expect("registering a source failed");
    }

    let mut unsent = Vec::<(u32, Box<[u8]>, &str)>::new();
    let mut buf = [0; 8192];
    let mut events = Events::with_capacity(1024);
    loop {
        poll.poll(&mut events, None).expect("Cannot poll selector");

        // receive all available messages from queues that are ready
        for event in events.iter() {
            if event.token() == Token(0) {
                // dst; will try to send below even without this event
                continue;
            }

            let &(ref mq, ref name) = &src[event.token().0-1];
            loop {
                match mq.recv(&mut buf) {
                    Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
                    Err(e) => panic!("Error receiving from {}: {}", name, e),
                    Ok((priority, len)) => unsent.push((priority, Box::from(&buf[..len]), name)),
                }
            }
        }

        // send as many messages as possible
        while let Some(&(priority, ref msg, ref src)) = unsent.last() {
            if let Err(e) = dst.0.send(priority, msg) {
                if e.kind() == ErrorKind::WouldBlock {
                    break;
                }
                panic!("Error sending to {}: {}", dst.1, e);
            }
            println!("message of priority {} with {} bytes from {} sent to {}", 
                priority, msg.len(), src, dst.1
            );
            let _ = unsent.pop();
        }
    }
}

pub fn readwrite() -> Self

Open message queue both for sending and receiving.

Examples found in repository

examples/sort.rs (line 24)

fn main() {
    let args = args_os()
        .skip(1)
        .map(|osstring| osstring.into_vec() )
        .collect::<Vec<Vec<u8>>>();
    if args.is_empty() {
        return; // nothing to do
    }

    let mut recv_buf = vec![0; args.iter().map(Vec::len).max().unwrap()];

    let name = CStr::from_bytes_with_nul(b"/sort\0").unwrap();

    // create queue with the necessary permissions and open it
    let mq = posixmq::OpenOptions::readwrite()
        .nonblocking() // use WouldBlock to detect that the queue is empty
        .create_new()
        .mode(0o000) // only affects future attempts at opening it
        .capacity(args.len())
        .max_msg_len(recv_buf.len())
        .open_c(name)
        .expect("opening queue failed");

    // write arguments to the queue
    for arg in args {
        mq.send(arg.len() as u32, &arg).expect("sending failed");
    }

    // read until the queue is empty
    let stdout = stdout();
    let mut stdout = stdout.lock();
    loop {
        match mq.recv(&mut recv_buf) {
            Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
            Err(e) => panic!("receiving failed: {}", e),
            Ok((_priority, len)) => {
                stdout.write_all(&recv_buf[..len])
                    .and_then(|()| stdout.write_all(b"\n") )
                    .expect("writing to stdout failed");
            }
        }
    }

    // clean up
    posixmq::remove_queue_c(name).expect("deleting queue failed")
}

examples/limits.rs (line 31)

fn main() {
    println!("{}:", std::env::consts::OS);

    let mq = posixmq::OpenOptions::readwrite()
        .create_new()
        .open("/default_capacities")
        .expect("Cannot create new posix message queue /default_capacities");
    posixmq::remove_queue("/default_capacities")
        .expect("Cannot delete posix message queue /default_capacities");

    let attrs = mq.attributes().expect("Cannot get attributes for queue");
    println!("default queue capacity:         {}", attrs.capacity);
    println!("default maximum message length: {}", attrs.max_msg_len);

    println!("max message priority:           {}", btry(0xff_ff_ff_ff, |priority| {
        mq.send(priority as u32, b"b")
            .map(|_| mq.recv(&mut vec![0; attrs.max_msg_len]).unwrap() )
            .is_ok()
    }));
    println!("allows empty messages:          {}", mq.send(0, b"").is_ok());
    drop(mq);

    println!("max queue capacity:             {}", btry(1_000_000, |capacity| {
        posixmq::OpenOptions::readwrite()
            .capacity(capacity)
            .max_msg_len(1)
            .create_new()
            .open("/max_capacity")
            .map(|_| posixmq::remove_queue("/max_capacity").unwrap() )
            .is_ok()
    }));

    println!("max message length:             {}", btry(1_000_000, |length| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(length)
            .capacity(1)
            .create_new()
            .open("/max_length")
            .map(|_| posixmq::remove_queue("/max_length").unwrap() )
            .is_ok()
    }));

    println!("max equal:                      {}", btry(1_000_000, |equal| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(equal)
            .capacity(equal)
            .create_new()
            .open("/max_equal")
            .map(|_| posixmq::remove_queue("/max_equal").unwrap() )
            .is_ok()
    }));

    println!("allows just \"/\":                {}", {
        let result = posixmq::PosixMq::create("/");
        let _ = posixmq::remove_queue("/");
        result.is_ok()
    });
    println!("enforces name rules:            {}", {
        let noslash = std::ffi::CStr::from_bytes_with_nul(b"noslash\0").unwrap();
        let result = posixmq::OpenOptions::readwrite().create().open_c(noslash);
        let _ = posixmq::remove_queue_c(noslash);
        result.is_err()
    });
}

pub fn mode(&mut self, mode: u32) -> &mut Self

Set permissions to create the queue with.

Some bits might be cleared by the process’s umask when creating the queue, and unknown bits are ignored.

This field is ignored if the queue already exists or should not be created. If this method is not called, queues are created with mode 600.

Examples found in repository

examples/send.rs (line 19)

fn main() {
    let args = args_os().skip(1).collect::<Vec<_>>();
    if args.len() % 2 == 0 {
        eprintln!("Usage: cargo run --example send /queue-name [priority message] ...");
        return;
    }

    // open the message queue
    let mq = posixmq::OpenOptions::writeonly()
        .create()
        .mode(0o666) // FIXME set umask to actually make it sendable for others
        .open(args[0].as_bytes())
        .expect("opening failed");

    if args.len() == 1 {
        // read from stdin
        for line in stdin().lock().lines() {
            let line = line.expect("input must be UTF-8, sorry");
            let line = line.trim_start();
            let num_end = line.find(' ').expect("no space in line");
            let priority = line[..num_end].parse::<u32>().expect("priority is not a number");
            let msg = line[num_end+1..].trim_start();
            mq.send(priority, msg.as_bytes()).expect("sending failed");
        }
    } else {
        // read from the command line
        for i in (1..args.len()).step_by(2) {
            let priority = args[i].to_str()
                .and_then(|s| s.parse::<u32>().ok() )
                .expect("priority is not a number");
            let msg = args[i+1].as_bytes();
            mq.send(priority, msg).expect("sending failed");
        }
    }
}

examples/sort.rs (line 27)

fn main() {
    let args = args_os()
        .skip(1)
        .map(|osstring| osstring.into_vec() )
        .collect::<Vec<Vec<u8>>>();
    if args.is_empty() {
        return; // nothing to do
    }

    let mut recv_buf = vec![0; args.iter().map(Vec::len).max().unwrap()];

    let name = CStr::from_bytes_with_nul(b"/sort\0").unwrap();

    // create queue with the necessary permissions and open it
    let mq = posixmq::OpenOptions::readwrite()
        .nonblocking() // use WouldBlock to detect that the queue is empty
        .create_new()
        .mode(0o000) // only affects future attempts at opening it
        .capacity(args.len())
        .max_msg_len(recv_buf.len())
        .open_c(name)
        .expect("opening queue failed");

    // write arguments to the queue
    for arg in args {
        mq.send(arg.len() as u32, &arg).expect("sending failed");
    }

    // read until the queue is empty
    let stdout = stdout();
    let mut stdout = stdout.lock();
    loop {
        match mq.recv(&mut recv_buf) {
            Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
            Err(e) => panic!("receiving failed: {}", e),
            Ok((_priority, len)) => {
                stdout.write_all(&recv_buf[..len])
                    .and_then(|()| stdout.write_all(b"\n") )
                    .expect("writing to stdout failed");
            }
        }
    }

    // clean up
    posixmq::remove_queue_c(name).expect("deleting queue failed")
}

pub fn max_msg_len(&mut self, max_msg_len: usize) -> &mut Self

Set the maximum size of each message.

recv() will fail if given a buffer smaller than this value.

If max_msg_len and capacity are both zero (or not set), the queue will be created with a maximum length and capacity decided by the operating system.
If this value is specified, capacity should also be, or opening the message queue might fail.

Examples found in repository

examples/sort.rs (line 29)

fn main() {
    let args = args_os()
        .skip(1)
        .map(|osstring| osstring.into_vec() )
        .collect::<Vec<Vec<u8>>>();
    if args.is_empty() {
        return; // nothing to do
    }

    let mut recv_buf = vec![0; args.iter().map(Vec::len).max().unwrap()];

    let name = CStr::from_bytes_with_nul(b"/sort\0").unwrap();

    // create queue with the necessary permissions and open it
    let mq = posixmq::OpenOptions::readwrite()
        .nonblocking() // use WouldBlock to detect that the queue is empty
        .create_new()
        .mode(0o000) // only affects future attempts at opening it
        .capacity(args.len())
        .max_msg_len(recv_buf.len())
        .open_c(name)
        .expect("opening queue failed");

    // write arguments to the queue
    for arg in args {
        mq.send(arg.len() as u32, &arg).expect("sending failed");
    }

    // read until the queue is empty
    let stdout = stdout();
    let mut stdout = stdout.lock();
    loop {
        match mq.recv(&mut recv_buf) {
            Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
            Err(e) => panic!("receiving failed: {}", e),
            Ok((_priority, len)) => {
                stdout.write_all(&recv_buf[..len])
                    .and_then(|()| stdout.write_all(b"\n") )
                    .expect("writing to stdout failed");
            }
        }
    }

    // clean up
    posixmq::remove_queue_c(name).expect("deleting queue failed")
}

examples/limits.rs (line 53)

fn main() {
    println!("{}:", std::env::consts::OS);

    let mq = posixmq::OpenOptions::readwrite()
        .create_new()
        .open("/default_capacities")
        .expect("Cannot create new posix message queue /default_capacities");
    posixmq::remove_queue("/default_capacities")
        .expect("Cannot delete posix message queue /default_capacities");

    let attrs = mq.attributes().expect("Cannot get attributes for queue");
    println!("default queue capacity:         {}", attrs.capacity);
    println!("default maximum message length: {}", attrs.max_msg_len);

    println!("max message priority:           {}", btry(0xff_ff_ff_ff, |priority| {
        mq.send(priority as u32, b"b")
            .map(|_| mq.recv(&mut vec![0; attrs.max_msg_len]).unwrap() )
            .is_ok()
    }));
    println!("allows empty messages:          {}", mq.send(0, b"").is_ok());
    drop(mq);

    println!("max queue capacity:             {}", btry(1_000_000, |capacity| {
        posixmq::OpenOptions::readwrite()
            .capacity(capacity)
            .max_msg_len(1)
            .create_new()
            .open("/max_capacity")
            .map(|_| posixmq::remove_queue("/max_capacity").unwrap() )
            .is_ok()
    }));

    println!("max message length:             {}", btry(1_000_000, |length| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(length)
            .capacity(1)
            .create_new()
            .open("/max_length")
            .map(|_| posixmq::remove_queue("/max_length").unwrap() )
            .is_ok()
    }));

    println!("max equal:                      {}", btry(1_000_000, |equal| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(equal)
            .capacity(equal)
            .create_new()
            .open("/max_equal")
            .map(|_| posixmq::remove_queue("/max_equal").unwrap() )
            .is_ok()
    }));

    println!("allows just \"/\":                {}", {
        let result = posixmq::PosixMq::create("/");
        let _ = posixmq::remove_queue("/");
        result.is_ok()
    });
    println!("enforces name rules:            {}", {
        let noslash = std::ffi::CStr::from_bytes_with_nul(b"noslash\0").unwrap();
        let result = posixmq::OpenOptions::readwrite().create().open_c(noslash);
        let _ = posixmq::remove_queue_c(noslash);
        result.is_err()
    });
}

pub fn capacity(&mut self, capacity: usize) -> &mut Self

Set the maximum number of messages in the queue.

When the queue is full, further send()s will either block or fail with an error of type ErrorKind::WouldBlock.

If both capacity and max_msg_len are zero (or not set), the queue will be created with a maximum length and capacity decided by the operating system.
If this value is specified, max_msg_len should also be, or opening the message queue might fail.

Examples found in repository

examples/sort.rs (line 28)

fn main() {
    let args = args_os()
        .skip(1)
        .map(|osstring| osstring.into_vec() )
        .collect::<Vec<Vec<u8>>>();
    if args.is_empty() {
        return; // nothing to do
    }

    let mut recv_buf = vec![0; args.iter().map(Vec::len).max().unwrap()];

    let name = CStr::from_bytes_with_nul(b"/sort\0").unwrap();

    // create queue with the necessary permissions and open it
    let mq = posixmq::OpenOptions::readwrite()
        .nonblocking() // use WouldBlock to detect that the queue is empty
        .create_new()
        .mode(0o000) // only affects future attempts at opening it
        .capacity(args.len())
        .max_msg_len(recv_buf.len())
        .open_c(name)
        .expect("opening queue failed");

    // write arguments to the queue
    for arg in args {
        mq.send(arg.len() as u32, &arg).expect("sending failed");
    }

    // read until the queue is empty
    let stdout = stdout();
    let mut stdout = stdout.lock();
    loop {
        match mq.recv(&mut recv_buf) {
            Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
            Err(e) => panic!("receiving failed: {}", e),
            Ok((_priority, len)) => {
                stdout.write_all(&recv_buf[..len])
                    .and_then(|()| stdout.write_all(b"\n") )
                    .expect("writing to stdout failed");
            }
        }
    }

    // clean up
    posixmq::remove_queue_c(name).expect("deleting queue failed")
}

examples/limits.rs (line 52)

fn main() {
    println!("{}:", std::env::consts::OS);

    let mq = posixmq::OpenOptions::readwrite()
        .create_new()
        .open("/default_capacities")
        .expect("Cannot create new posix message queue /default_capacities");
    posixmq::remove_queue("/default_capacities")
        .expect("Cannot delete posix message queue /default_capacities");

    let attrs = mq.attributes().expect("Cannot get attributes for queue");
    println!("default queue capacity:         {}", attrs.capacity);
    println!("default maximum message length: {}", attrs.max_msg_len);

    println!("max message priority:           {}", btry(0xff_ff_ff_ff, |priority| {
        mq.send(priority as u32, b"b")
            .map(|_| mq.recv(&mut vec![0; attrs.max_msg_len]).unwrap() )
            .is_ok()
    }));
    println!("allows empty messages:          {}", mq.send(0, b"").is_ok());
    drop(mq);

    println!("max queue capacity:             {}", btry(1_000_000, |capacity| {
        posixmq::OpenOptions::readwrite()
            .capacity(capacity)
            .max_msg_len(1)
            .create_new()
            .open("/max_capacity")
            .map(|_| posixmq::remove_queue("/max_capacity").unwrap() )
            .is_ok()
    }));

    println!("max message length:             {}", btry(1_000_000, |length| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(length)
            .capacity(1)
            .create_new()
            .open("/max_length")
            .map(|_| posixmq::remove_queue("/max_length").unwrap() )
            .is_ok()
    }));

    println!("max equal:                      {}", btry(1_000_000, |equal| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(equal)
            .capacity(equal)
            .create_new()
            .open("/max_equal")
            .map(|_| posixmq::remove_queue("/max_equal").unwrap() )
            .is_ok()
    }));

    println!("allows just \"/\":                {}", {
        let result = posixmq::PosixMq::create("/");
        let _ = posixmq::remove_queue("/");
        result.is_ok()
    });
    println!("enforces name rules:            {}", {
        let noslash = std::ffi::CStr::from_bytes_with_nul(b"noslash\0").unwrap();
        let result = posixmq::OpenOptions::readwrite().create().open_c(noslash);
        let _ = posixmq::remove_queue_c(noslash);
        result.is_err()
    });
}

pub fn create(&mut self) -> &mut Self

Create message queue if it doesn’t exist.

Examples found in repository

examples/send.rs (line 18)

fn main() {
    let args = args_os().skip(1).collect::<Vec<_>>();
    if args.len() % 2 == 0 {
        eprintln!("Usage: cargo run --example send /queue-name [priority message] ...");
        return;
    }

    // open the message queue
    let mq = posixmq::OpenOptions::writeonly()
        .create()
        .mode(0o666) // FIXME set umask to actually make it sendable for others
        .open(args[0].as_bytes())
        .expect("opening failed");

    if args.len() == 1 {
        // read from stdin
        for line in stdin().lock().lines() {
            let line = line.expect("input must be UTF-8, sorry");
            let line = line.trim_start();
            let num_end = line.find(' ').expect("no space in line");
            let priority = line[..num_end].parse::<u32>().expect("priority is not a number");
            let msg = line[num_end+1..].trim_start();
            mq.send(priority, msg.as_bytes()).expect("sending failed");
        }
    } else {
        // read from the command line
        for i in (1..args.len()).step_by(2) {
            let priority = args[i].to_str()
                .and_then(|s| s.parse::<u32>().ok() )
                .expect("priority is not a number");
            let msg = args[i+1].as_bytes();
            mq.send(priority, msg).expect("sending failed");
        }
    }
}

examples/limits.rs (line 87)

fn main() {
    println!("{}:", std::env::consts::OS);

    let mq = posixmq::OpenOptions::readwrite()
        .create_new()
        .open("/default_capacities")
        .expect("Cannot create new posix message queue /default_capacities");
    posixmq::remove_queue("/default_capacities")
        .expect("Cannot delete posix message queue /default_capacities");

    let attrs = mq.attributes().expect("Cannot get attributes for queue");
    println!("default queue capacity:         {}", attrs.capacity);
    println!("default maximum message length: {}", attrs.max_msg_len);

    println!("max message priority:           {}", btry(0xff_ff_ff_ff, |priority| {
        mq.send(priority as u32, b"b")
            .map(|_| mq.recv(&mut vec![0; attrs.max_msg_len]).unwrap() )
            .is_ok()
    }));
    println!("allows empty messages:          {}", mq.send(0, b"").is_ok());
    drop(mq);

    println!("max queue capacity:             {}", btry(1_000_000, |capacity| {
        posixmq::OpenOptions::readwrite()
            .capacity(capacity)
            .max_msg_len(1)
            .create_new()
            .open("/max_capacity")
            .map(|_| posixmq::remove_queue("/max_capacity").unwrap() )
            .is_ok()
    }));

    println!("max message length:             {}", btry(1_000_000, |length| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(length)
            .capacity(1)
            .create_new()
            .open("/max_length")
            .map(|_| posixmq::remove_queue("/max_length").unwrap() )
            .is_ok()
    }));

    println!("max equal:                      {}", btry(1_000_000, |equal| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(equal)
            .capacity(equal)
            .create_new()
            .open("/max_equal")
            .map(|_| posixmq::remove_queue("/max_equal").unwrap() )
            .is_ok()
    }));

    println!("allows just \"/\":                {}", {
        let result = posixmq::PosixMq::create("/");
        let _ = posixmq::remove_queue("/");
        result.is_ok()
    });
    println!("enforces name rules:            {}", {
        let noslash = std::ffi::CStr::from_bytes_with_nul(b"noslash\0").unwrap();
        let result = posixmq::OpenOptions::readwrite().create().open_c(noslash);
        let _ = posixmq::remove_queue_c(noslash);
        result.is_err()
    });
}

examples/merge.rs (line 26)

fn main() {
    use std::env::args;
    use std::io::ErrorKind;

    use mio::{Poll, Events, Interest, Token};

    let mut queues = args().skip(1).collect::<Vec<_>>();
    let dst = queues.pop().expect("arguments required");
    
    // open source queues
    let mut src = Vec::new();
    for name in queues {
        match posixmq::OpenOptions::readonly().nonblocking().open(&name) {
            Ok(mq) => src.push((mq, name)),
            Err(e) => panic!("Cannot open {:?} for receiving: {}", name, e),
        }
    }

    // open destination queue
    let mut dst = match posixmq::OpenOptions::writeonly().nonblocking().create().open(&dst) {
        Ok(mq) => (mq, dst),
        Err(e) => panic!("Cannot open or create {:?} for sending: {}", dst, e),
    };

    let mut poll = Poll::new().expect("Cannot create selector");
    poll.registry()
        .register(&mut dst.0, Token(0), Interest::WRITABLE)
        .expect("registering destination failed");
    for (i, &mut(ref mut src, _)) in src.iter_mut().enumerate() {
        poll.registry()
            .register(src, Token(i+1), Interest::READABLE)
            .expect("registering a source failed");
    }

    let mut unsent = Vec::<(u32, Box<[u8]>, &str)>::new();
    let mut buf = [0; 8192];
    let mut events = Events::with_capacity(1024);
    loop {
        poll.poll(&mut events, None).expect("Cannot poll selector");

        // receive all available messages from queues that are ready
        for event in events.iter() {
            if event.token() == Token(0) {
                // dst; will try to send below even without this event
                continue;
            }

            let &(ref mq, ref name) = &src[event.token().0-1];
            loop {
                match mq.recv(&mut buf) {
                    Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
                    Err(e) => panic!("Error receiving from {}: {}", name, e),
                    Ok((priority, len)) => unsent.push((priority, Box::from(&buf[..len]), name)),
                }
            }
        }

        // send as many messages as possible
        while let Some(&(priority, ref msg, ref src)) = unsent.last() {
            if let Err(e) = dst.0.send(priority, msg) {
                if e.kind() == ErrorKind::WouldBlock {
                    break;
                }
                panic!("Error sending to {}: {}", dst.1, e);
            }
            println!("message of priority {} with {} bytes from {} sent to {}", 
                priority, msg.len(), src, dst.1
            );
            let _ = unsent.pop();
        }
    }
}

pub fn create_new(&mut self) -> &mut Self

Create a new queue, failing if the queue already exists.

Examples found in repository

examples/sort.rs (line 26)

fn main() {
    let args = args_os()
        .skip(1)
        .map(|osstring| osstring.into_vec() )
        .collect::<Vec<Vec<u8>>>();
    if args.is_empty() {
        return; // nothing to do
    }

    let mut recv_buf = vec![0; args.iter().map(Vec::len).max().unwrap()];

    let name = CStr::from_bytes_with_nul(b"/sort\0").unwrap();

    // create queue with the necessary permissions and open it
    let mq = posixmq::OpenOptions::readwrite()
        .nonblocking() // use WouldBlock to detect that the queue is empty
        .create_new()
        .mode(0o000) // only affects future attempts at opening it
        .capacity(args.len())
        .max_msg_len(recv_buf.len())
        .open_c(name)
        .expect("opening queue failed");

    // write arguments to the queue
    for arg in args {
        mq.send(arg.len() as u32, &arg).expect("sending failed");
    }

    // read until the queue is empty
    let stdout = stdout();
    let mut stdout = stdout.lock();
    loop {
        match mq.recv(&mut recv_buf) {
            Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
            Err(e) => panic!("receiving failed: {}", e),
            Ok((_priority, len)) => {
                stdout.write_all(&recv_buf[..len])
                    .and_then(|()| stdout.write_all(b"\n") )
                    .expect("writing to stdout failed");
            }
        }
    }

    // clean up
    posixmq::remove_queue_c(name).expect("deleting queue failed")
}

examples/limits.rs (line 32)

fn main() {
    println!("{}:", std::env::consts::OS);

    let mq = posixmq::OpenOptions::readwrite()
        .create_new()
        .open("/default_capacities")
        .expect("Cannot create new posix message queue /default_capacities");
    posixmq::remove_queue("/default_capacities")
        .expect("Cannot delete posix message queue /default_capacities");

    let attrs = mq.attributes().expect("Cannot get attributes for queue");
    println!("default queue capacity:         {}", attrs.capacity);
    println!("default maximum message length: {}", attrs.max_msg_len);

    println!("max message priority:           {}", btry(0xff_ff_ff_ff, |priority| {
        mq.send(priority as u32, b"b")
            .map(|_| mq.recv(&mut vec![0; attrs.max_msg_len]).unwrap() )
            .is_ok()
    }));
    println!("allows empty messages:          {}", mq.send(0, b"").is_ok());
    drop(mq);

    println!("max queue capacity:             {}", btry(1_000_000, |capacity| {
        posixmq::OpenOptions::readwrite()
            .capacity(capacity)
            .max_msg_len(1)
            .create_new()
            .open("/max_capacity")
            .map(|_| posixmq::remove_queue("/max_capacity").unwrap() )
            .is_ok()
    }));

    println!("max message length:             {}", btry(1_000_000, |length| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(length)
            .capacity(1)
            .create_new()
            .open("/max_length")
            .map(|_| posixmq::remove_queue("/max_length").unwrap() )
            .is_ok()
    }));

    println!("max equal:                      {}", btry(1_000_000, |equal| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(equal)
            .capacity(equal)
            .create_new()
            .open("/max_equal")
            .map(|_| posixmq::remove_queue("/max_equal").unwrap() )
            .is_ok()
    }));

    println!("allows just \"/\":                {}", {
        let result = posixmq::PosixMq::create("/");
        let _ = posixmq::remove_queue("/");
        result.is_ok()
    });
    println!("enforces name rules:            {}", {
        let noslash = std::ffi::CStr::from_bytes_with_nul(b"noslash\0").unwrap();
        let result = posixmq::OpenOptions::readwrite().create().open_c(noslash);
        let _ = posixmq::remove_queue_c(noslash);
        result.is_err()
    });
}

pub fn existing(&mut self) -> &mut Self

Require the queue to already exist, failing if it doesn’t.

pub fn nonblocking(&mut self) -> &mut Self

Open the message queue in non-blocking mode.

This must be done if you want to use the message queue with mio.

Examples found in repository

examples/receive.rs (line 29)

fn main() {
    let mut args = args_os().skip(1);
    let name = args.next().expect("argument required");
    let timeout = args.next().map(|arg| {
        let arg = arg.into_string().expect("invalid timeout");
        if arg == "nonblocking" || arg == "drain" || arg == "available" || arg == "empty" {
            None
        } else if arg.ends_with("ms") {
            Some(Duration::from_millis(arg[..arg.len()-2].parse().expect("invalid duration")))
        } else if arg.ends_with("s") {
            Some(Duration::from_secs(arg[..arg.len()-1].parse().expect("invalid duration")))
        } else {
            Some(Duration::from_secs(arg.parse().expect("invalid duration")))
        }
    });

    let mut opts = posixmq::OpenOptions::readonly();
    if timeout == Some(None) {
        opts = *opts.nonblocking();
    }
    let mq = opts.open(name.as_bytes()).expect("opening failed");

    if let Some(Some(timeout)) = timeout {
        let mut buf = vec![0; mq.attributes().unwrap_or_default().max_msg_len];
        while let Ok((priority, len)) = mq.recv_timeout(&mut buf, timeout) {
            print!("{:3}\t", priority);
            stdout().write_all(&buf[..len]).expect("writing to stdout failed");
            println!();
        }
    } else {
        for (priority, msg) in mq {
            print!("{:3}\t", priority);
            stdout().write_all(&msg).expect("writing to stdout failed");
            println!();
        }
    }
}

examples/sort.rs (line 25)

fn main() {
    let args = args_os()
        .skip(1)
        .map(|osstring| osstring.into_vec() )
        .collect::<Vec<Vec<u8>>>();
    if args.is_empty() {
        return; // nothing to do
    }

    let mut recv_buf = vec![0; args.iter().map(Vec::len).max().unwrap()];

    let name = CStr::from_bytes_with_nul(b"/sort\0").unwrap();

    // create queue with the necessary permissions and open it
    let mq = posixmq::OpenOptions::readwrite()
        .nonblocking() // use WouldBlock to detect that the queue is empty
        .create_new()
        .mode(0o000) // only affects future attempts at opening it
        .capacity(args.len())
        .max_msg_len(recv_buf.len())
        .open_c(name)
        .expect("opening queue failed");

    // write arguments to the queue
    for arg in args {
        mq.send(arg.len() as u32, &arg).expect("sending failed");
    }

    // read until the queue is empty
    let stdout = stdout();
    let mut stdout = stdout.lock();
    loop {
        match mq.recv(&mut recv_buf) {
            Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
            Err(e) => panic!("receiving failed: {}", e),
            Ok((_priority, len)) => {
                stdout.write_all(&recv_buf[..len])
                    .and_then(|()| stdout.write_all(b"\n") )
                    .expect("writing to stdout failed");
            }
        }
    }

    // clean up
    posixmq::remove_queue_c(name).expect("deleting queue failed")
}

examples/merge.rs (line 19)

fn main() {
    use std::env::args;
    use std::io::ErrorKind;

    use mio::{Poll, Events, Interest, Token};

    let mut queues = args().skip(1).collect::<Vec<_>>();
    let dst = queues.pop().expect("arguments required");
    
    // open source queues
    let mut src = Vec::new();
    for name in queues {
        match posixmq::OpenOptions::readonly().nonblocking().open(&name) {
            Ok(mq) => src.push((mq, name)),
            Err(e) => panic!("Cannot open {:?} for receiving: {}", name, e),
        }
    }

    // open destination queue
    let mut dst = match posixmq::OpenOptions::writeonly().nonblocking().create().open(&dst) {
        Ok(mq) => (mq, dst),
        Err(e) => panic!("Cannot open or create {:?} for sending: {}", dst, e),
    };

    let mut poll = Poll::new().expect("Cannot create selector");
    poll.registry()
        .register(&mut dst.0, Token(0), Interest::WRITABLE)
        .expect("registering destination failed");
    for (i, &mut(ref mut src, _)) in src.iter_mut().enumerate() {
        poll.registry()
            .register(src, Token(i+1), Interest::READABLE)
            .expect("registering a source failed");
    }

    let mut unsent = Vec::<(u32, Box<[u8]>, &str)>::new();
    let mut buf = [0; 8192];
    let mut events = Events::with_capacity(1024);
    loop {
        poll.poll(&mut events, None).expect("Cannot poll selector");

        // receive all available messages from queues that are ready
        for event in events.iter() {
            if event.token() == Token(0) {
                // dst; will try to send below even without this event
                continue;
            }

            let &(ref mq, ref name) = &src[event.token().0-1];
            loop {
                match mq.recv(&mut buf) {
                    Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
                    Err(e) => panic!("Error receiving from {}: {}", name, e),
                    Ok((priority, len)) => unsent.push((priority, Box::from(&buf[..len]), name)),
                }
            }
        }

        // send as many messages as possible
        while let Some(&(priority, ref msg, ref src)) = unsent.last() {
            if let Err(e) = dst.0.send(priority, msg) {
                if e.kind() == ErrorKind::WouldBlock {
                    break;
                }
                panic!("Error sending to {}: {}", dst.1, e);
            }
            println!("message of priority {} with {} bytes from {} sent to {}", 
                priority, msg.len(), src, dst.1
            );
            let _ = unsent.pop();
        }
    }
}

pub fn open<N: AsRef<[u8]> + ?Sized>(&self, name: &N) -> Result<PosixMq, Error>

Open a queue with the specified options.

If the name doesn’t start with a ‘/’, one will be prepended.

Errors

• Queue doesn’t exist (ENOENT) => ErrorKind::NotFound
• Name is just “/” (ENOENT) or is empty => ErrorKind::NotFound
• Queue already exists (EEXISTS) => ErrorKind::AlreadyExists
• Not permitted to open in this mode (EACCESS) => ErrorKind::PermissionDenied
• More than one ‘/’ in name (EACCESS) => ErrorKind::PermissionDenied
• Invalid capacities (EINVAL) => ErrorKind::InvalidInput
• Capacities too high (EMFILE) => ErrorKind::Other
• Posix message queues are disabled (ENOSYS) => ErrorKind::Other
• Name contains ‘\0’ => ErrorKind::InvalidInput
• Name is too long (ENAMETOOLONG) => ErrorKind::Other
• Unlikely (ENFILE, EMFILE, ENOMEM, ENOSPC) => ErrorKind::Other
• Possibly other

Examples found in repository

examples/send.rs (line 20)

fn main() {
    let args = args_os().skip(1).collect::<Vec<_>>();
    if args.len() % 2 == 0 {
        eprintln!("Usage: cargo run --example send /queue-name [priority message] ...");
        return;
    }

    // open the message queue
    let mq = posixmq::OpenOptions::writeonly()
        .create()
        .mode(0o666) // FIXME set umask to actually make it sendable for others
        .open(args[0].as_bytes())
        .expect("opening failed");

    if args.len() == 1 {
        // read from stdin
        for line in stdin().lock().lines() {
            let line = line.expect("input must be UTF-8, sorry");
            let line = line.trim_start();
            let num_end = line.find(' ').expect("no space in line");
            let priority = line[..num_end].parse::<u32>().expect("priority is not a number");
            let msg = line[num_end+1..].trim_start();
            mq.send(priority, msg.as_bytes()).expect("sending failed");
        }
    } else {
        // read from the command line
        for i in (1..args.len()).step_by(2) {
            let priority = args[i].to_str()
                .and_then(|s| s.parse::<u32>().ok() )
                .expect("priority is not a number");
            let msg = args[i+1].as_bytes();
            mq.send(priority, msg).expect("sending failed");
        }
    }
}

examples/receive.rs (line 31)

fn main() {
    let mut args = args_os().skip(1);
    let name = args.next().expect("argument required");
    let timeout = args.next().map(|arg| {
        let arg = arg.into_string().expect("invalid timeout");
        if arg == "nonblocking" || arg == "drain" || arg == "available" || arg == "empty" {
            None
        } else if arg.ends_with("ms") {
            Some(Duration::from_millis(arg[..arg.len()-2].parse().expect("invalid duration")))
        } else if arg.ends_with("s") {
            Some(Duration::from_secs(arg[..arg.len()-1].parse().expect("invalid duration")))
        } else {
            Some(Duration::from_secs(arg.parse().expect("invalid duration")))
        }
    });

    let mut opts = posixmq::OpenOptions::readonly();
    if timeout == Some(None) {
        opts = *opts.nonblocking();
    }
    let mq = opts.open(name.as_bytes()).expect("opening failed");

    if let Some(Some(timeout)) = timeout {
        let mut buf = vec![0; mq.attributes().unwrap_or_default().max_msg_len];
        while let Ok((priority, len)) = mq.recv_timeout(&mut buf, timeout) {
            print!("{:3}\t", priority);
            stdout().write_all(&buf[..len]).expect("writing to stdout failed");
            println!();
        }
    } else {
        for (priority, msg) in mq {
            print!("{:3}\t", priority);
            stdout().write_all(&msg).expect("writing to stdout failed");
            println!();
        }
    }
}

examples/limits.rs (line 33)

fn main() {
    println!("{}:", std::env::consts::OS);

    let mq = posixmq::OpenOptions::readwrite()
        .create_new()
        .open("/default_capacities")
        .expect("Cannot create new posix message queue /default_capacities");
    posixmq::remove_queue("/default_capacities")
        .expect("Cannot delete posix message queue /default_capacities");

    let attrs = mq.attributes().expect("Cannot get attributes for queue");
    println!("default queue capacity:         {}", attrs.capacity);
    println!("default maximum message length: {}", attrs.max_msg_len);

    println!("max message priority:           {}", btry(0xff_ff_ff_ff, |priority| {
        mq.send(priority as u32, b"b")
            .map(|_| mq.recv(&mut vec![0; attrs.max_msg_len]).unwrap() )
            .is_ok()
    }));
    println!("allows empty messages:          {}", mq.send(0, b"").is_ok());
    drop(mq);

    println!("max queue capacity:             {}", btry(1_000_000, |capacity| {
        posixmq::OpenOptions::readwrite()
            .capacity(capacity)
            .max_msg_len(1)
            .create_new()
            .open("/max_capacity")
            .map(|_| posixmq::remove_queue("/max_capacity").unwrap() )
            .is_ok()
    }));

    println!("max message length:             {}", btry(1_000_000, |length| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(length)
            .capacity(1)
            .create_new()
            .open("/max_length")
            .map(|_| posixmq::remove_queue("/max_length").unwrap() )
            .is_ok()
    }));

    println!("max equal:                      {}", btry(1_000_000, |equal| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(equal)
            .capacity(equal)
            .create_new()
            .open("/max_equal")
            .map(|_| posixmq::remove_queue("/max_equal").unwrap() )
            .is_ok()
    }));

    println!("allows just \"/\":                {}", {
        let result = posixmq::PosixMq::create("/");
        let _ = posixmq::remove_queue("/");
        result.is_ok()
    });
    println!("enforces name rules:            {}", {
        let noslash = std::ffi::CStr::from_bytes_with_nul(b"noslash\0").unwrap();
        let result = posixmq::OpenOptions::readwrite().create().open_c(noslash);
        let _ = posixmq::remove_queue_c(noslash);
        result.is_err()
    });
}

examples/merge.rs (line 19)

fn main() {
    use std::env::args;
    use std::io::ErrorKind;

    use mio::{Poll, Events, Interest, Token};

    let mut queues = args().skip(1).collect::<Vec<_>>();
    let dst = queues.pop().expect("arguments required");
    
    // open source queues
    let mut src = Vec::new();
    for name in queues {
        match posixmq::OpenOptions::readonly().nonblocking().open(&name) {
            Ok(mq) => src.push((mq, name)),
            Err(e) => panic!("Cannot open {:?} for receiving: {}", name, e),
        }
    }

    // open destination queue
    let mut dst = match posixmq::OpenOptions::writeonly().nonblocking().create().open(&dst) {
        Ok(mq) => (mq, dst),
        Err(e) => panic!("Cannot open or create {:?} for sending: {}", dst, e),
    };

    let mut poll = Poll::new().expect("Cannot create selector");
    poll.registry()
        .register(&mut dst.0, Token(0), Interest::WRITABLE)
        .expect("registering destination failed");
    for (i, &mut(ref mut src, _)) in src.iter_mut().enumerate() {
        poll.registry()
            .register(src, Token(i+1), Interest::READABLE)
            .expect("registering a source failed");
    }

    let mut unsent = Vec::<(u32, Box<[u8]>, &str)>::new();
    let mut buf = [0; 8192];
    let mut events = Events::with_capacity(1024);
    loop {
        poll.poll(&mut events, None).expect("Cannot poll selector");

        // receive all available messages from queues that are ready
        for event in events.iter() {
            if event.token() == Token(0) {
                // dst; will try to send below even without this event
                continue;
            }

            let &(ref mq, ref name) = &src[event.token().0-1];
            loop {
                match mq.recv(&mut buf) {
                    Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
                    Err(e) => panic!("Error receiving from {}: {}", name, e),
                    Ok((priority, len)) => unsent.push((priority, Box::from(&buf[..len]), name)),
                }
            }
        }

        // send as many messages as possible
        while let Some(&(priority, ref msg, ref src)) = unsent.last() {
            if let Err(e) = dst.0.send(priority, msg) {
                if e.kind() == ErrorKind::WouldBlock {
                    break;
                }
                panic!("Error sending to {}: {}", dst.1, e);
            }
            println!("message of priority {} with {} bytes from {} sent to {}", 
                priority, msg.len(), src, dst.1
            );
            let _ = unsent.pop();
        }
    }
}

pub fn open_c(&self, name: &CStr) -> Result<PosixMq, Error>

Open a queue with the specified options and without inspecting name or allocating.

This can on NetBSD be used to access message queues with names that doesn’t start with a ‘/’.

Errors

• Queue doesn’t exist (ENOENT) => ErrorKind::NotFound
• Name is just “/” (ENOENT) => ErrorKind::NotFound
• Queue already exists (EEXISTS) => ErrorKind::AlreadyExists
• Not permitted to open in this mode (EACCESS) => ErrorKind::PermissionDenied
• More than one ‘/’ in name (EACCESS) => ErrorKind::PermissionDenied
• Invalid capacities (EINVAL) => ErrorKind::InvalidInput
• Posix message queues are disabled (ENOSYS) => ErrorKind::Other
• Name is empty (EINVAL) => ErrorKind::InvalidInput
• Name is too long (ENAMETOOLONG) => ErrorKind::Other
• Unlikely (ENFILE, EMFILE, ENOMEM, ENOSPC) => ErrorKind::Other
• Possibly other

Examples found in repository

examples/sort.rs (line 30)

fn main() {
    let args = args_os()
        .skip(1)
        .map(|osstring| osstring.into_vec() )
        .collect::<Vec<Vec<u8>>>();
    if args.is_empty() {
        return; // nothing to do
    }

    let mut recv_buf = vec![0; args.iter().map(Vec::len).max().unwrap()];

    let name = CStr::from_bytes_with_nul(b"/sort\0").unwrap();

    // create queue with the necessary permissions and open it
    let mq = posixmq::OpenOptions::readwrite()
        .nonblocking() // use WouldBlock to detect that the queue is empty
        .create_new()
        .mode(0o000) // only affects future attempts at opening it
        .capacity(args.len())
        .max_msg_len(recv_buf.len())
        .open_c(name)
        .expect("opening queue failed");

    // write arguments to the queue
    for arg in args {
        mq.send(arg.len() as u32, &arg).expect("sending failed");
    }

    // read until the queue is empty
    let stdout = stdout();
    let mut stdout = stdout.lock();
    loop {
        match mq.recv(&mut recv_buf) {
            Err(ref e) if e.kind() == ErrorKind::WouldBlock => break,
            Err(e) => panic!("receiving failed: {}", e),
            Ok((_priority, len)) => {
                stdout.write_all(&recv_buf[..len])
                    .and_then(|()| stdout.write_all(b"\n") )
                    .expect("writing to stdout failed");
            }
        }
    }

    // clean up
    posixmq::remove_queue_c(name).expect("deleting queue failed")
}

examples/limits.rs (line 87)

fn main() {
    println!("{}:", std::env::consts::OS);

    let mq = posixmq::OpenOptions::readwrite()
        .create_new()
        .open("/default_capacities")
        .expect("Cannot create new posix message queue /default_capacities");
    posixmq::remove_queue("/default_capacities")
        .expect("Cannot delete posix message queue /default_capacities");

    let attrs = mq.attributes().expect("Cannot get attributes for queue");
    println!("default queue capacity:         {}", attrs.capacity);
    println!("default maximum message length: {}", attrs.max_msg_len);

    println!("max message priority:           {}", btry(0xff_ff_ff_ff, |priority| {
        mq.send(priority as u32, b"b")
            .map(|_| mq.recv(&mut vec![0; attrs.max_msg_len]).unwrap() )
            .is_ok()
    }));
    println!("allows empty messages:          {}", mq.send(0, b"").is_ok());
    drop(mq);

    println!("max queue capacity:             {}", btry(1_000_000, |capacity| {
        posixmq::OpenOptions::readwrite()
            .capacity(capacity)
            .max_msg_len(1)
            .create_new()
            .open("/max_capacity")
            .map(|_| posixmq::remove_queue("/max_capacity").unwrap() )
            .is_ok()
    }));

    println!("max message length:             {}", btry(1_000_000, |length| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(length)
            .capacity(1)
            .create_new()
            .open("/max_length")
            .map(|_| posixmq::remove_queue("/max_length").unwrap() )
            .is_ok()
    }));

    println!("max equal:                      {}", btry(1_000_000, |equal| {
        posixmq::OpenOptions::readwrite()
            .max_msg_len(equal)
            .capacity(equal)
            .create_new()
            .open("/max_equal")
            .map(|_| posixmq::remove_queue("/max_equal").unwrap() )
            .is_ok()
    }));

    println!("allows just \"/\":                {}", {
        let result = posixmq::PosixMq::create("/");
        let _ = posixmq::remove_queue("/");
        result.is_ok()
    });
    println!("enforces name rules:            {}", {
        let noslash = std::ffi::CStr::from_bytes_with_nul(b"noslash\0").unwrap();
        let result = posixmq::OpenOptions::readwrite().create().open_c(noslash);
        let _ = posixmq::remove_queue_c(noslash);
        result.is_err()
    });
}

Trait Implementations

impl Clone for OpenOptions

fn clone(&self) -> OpenOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OpenOptions

fn fmt(&self, fmtr: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for OpenOptions

fn eq(&self, other: &OpenOptions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for OpenOptions

impl Eq for OpenOptions

impl StructuralPartialEq for OpenOptions