3:44 p.m.
This set of patches will add more functions to the Rust bindings.
Newly mapped functions from C library: virStreamNew virStreamEventUpdateCallback
virStreamEventRemoveCallback virStreamEventAddCallback.
virStreamEventAddCallback can accept normal fn functions or closures (can capture
variables outside)
The changes are not very thoroughly tested since event module is not implemented at all so
the virStreamEventAddCallback will always return "unsupported by the connection
driver".
Also the changes have run though the rustfmt to ensure the format conforms to Rust
officially recommended code style.
Zixing Liu (4):
libvirt-rust: stream: add more functions in stream
libvirt-rust: stream: add more functions in stream
libvirt-rust: stream: automated lint
libvirt-rust: use reference instead of moving
src/domain.rs | 2 +-
src/stream.rs | 128 ++++++++++++++++++++++++++++++++++++++++++------
tests/stream.rs | 40 +++++++++++++++
3 files changed, 153 insertions(+), 17 deletions(-)
create mode 100644 tests/stream.rs
--
2.24.0
3:44 p.m.
New subject: [libvirt] [PATCH Rust 1/4] libvirt-rust: stream: add more functions in stream
* added new functions: virStreamNew virStreamEventUpdateCallback
virStreamEventRemoveCallback
* added new constants: VIR_STREAM_NONBLOCK
* added new types/aliases: StreamFlags
* changed the previous `new` associate function to `from_ptr` to avoid
naming conflicts
* added basic tests to test the creation of Stream struct (can not test
the correctness of virStreamEventRemoveCallback and
virStreamEventUpdateCallback due to "unsupported by the connection
driver")
Signed-off-by: Zixing Liu <liushuyu(a)aosc.io>
---
src/stream.rs | 43 +++++++++++++++++++++++++++++++++++++++++--
tests/stream.rs | 40 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 81 insertions(+), 2 deletions(-)
create mode 100644 tests/stream.rs
diff --git a/src/stream.rs b/src/stream.rs
index 2ca5d0b..de272ab 100644
--- a/src/stream.rs
+++ b/src/stream.rs
@@ -18,8 +18,9 @@
extern crate libc;
+use connect::Connect;
+use connect::sys::virConnectPtr;
use std::convert::TryFrom;
-use std::str;
use error::Error;
@@ -32,6 +33,9 @@ pub mod sys {
#[link(name = "virt")]
extern "C" {
+ fn virStreamNew(c: virConnectPtr,
+ flags: libc::c_uint)
+ -> sys::virStreamPtr;
fn virStreamSend(c: sys::virStreamPtr,
data: *const libc::c_char,
nbytes: libc::size_t)
@@ -43,6 +47,9 @@ extern "C" {
fn virStreamFree(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamAbort(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamFinish(c: sys::virStreamPtr) -> libc::c_int;
+ fn virStreamEventUpdateCallback(c: sys::virStreamPtr,
+ events: libc::c_int) -> libc::c_int;
+ fn virStreamEventRemoveCallback(c: sys::virStreamPtr) -> libc::c_int;
}
pub type StreamEventType = self::libc::c_uint;
@@ -51,6 +58,9 @@ pub const VIR_STREAM_EVENT_WRITABLE: StreamEventType = (1 << 1);
pub const VIR_STREAM_EVENT_ERROR: StreamEventType = (1 << 2);
pub const VIR_STREAM_EVENT_HANGUP: StreamEventType = (1 << 3);
+pub type StreamFlags = self::libc::c_uint;
+pub const VIR_STREAM_NONBLOCK: StreamFlags = (1 << 0);
+
#[derive(Debug)]
pub struct Stream {
ptr: Option<sys::virStreamPtr>,
@@ -69,7 +79,17 @@ impl Drop for Stream {
}
impl Stream {
- pub fn new(ptr: sys::virStreamPtr) -> Stream {
+ pub fn new(conn: &Connect, flags: StreamFlags) -> Result<Stream, Error>
{
+ unsafe {
+ let ptr = virStreamNew(conn.as_ptr(), flags as libc::c_uint);
+ if ptr.is_null() {
+ return Err(Error::new());
+ }
+ return Ok(Stream::from_ptr(ptr));
+ }
+ }
+
+ pub fn from_ptr(ptr: sys::virStreamPtr) -> Stream {
Stream { ptr: Some(ptr) }
}
@@ -126,4 +146,23 @@ impl Stream {
};
usize::try_from(ret).map_err(|_| Error::new())
}
+
+ pub fn event_update_callback(&self, events: StreamEventType) -> Result<(),
Error> {
+ let ret = unsafe {
+ virStreamEventUpdateCallback(self.as_ptr(), events as libc::c_int)
+ };
+ if ret == -1 {
+ return Err(Error::new());
+ }
+ return Ok(());
+ }
+
+ pub fn event_remove_callback(&self) -> Result<(), Error> {
+ unsafe {
+ if virStreamEventRemoveCallback(self.as_ptr()) == -1 {
+ return Err(Error::new());
+ }
+ return Ok(());
+ }
+ }
}
diff --git a/tests/stream.rs b/tests/stream.rs
new file mode 100644
index 0000000..16531b3
--- /dev/null
+++ b/tests/stream.rs
@@ -0,0 +1,40 @@
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>;.
+ *
+ * Sahid Orentino Ferdjaoui <sahid.ferdjaoui(a)redhat.com>
+ */
+
+extern crate virt;
+
+mod common;
+
+use virt::stream::Stream;
+use virt::stream::VIR_STREAM_NONBLOCK;
+
+#[test]
+fn test_create_blocking() {
+ let c = common::conn();
+ let s = Stream::new(&c, 0).unwrap();
+ drop(s);
+ common::close(c);
+}
+
+#[test]
+fn test_create_non_blocking() {
+ let c = common::conn();
+ let s = Stream::new(&c, VIR_STREAM_NONBLOCK).unwrap();
+ drop(s);
+ common::close(c);
+}
--
2.24.0
6:50 a.m.
New subject: [libvirt] [PATCH Rust 1/4] libvirt-rust: stream: add more functions in stream
On Tue, Nov 12, 2019 at 02:44:42PM -0700, Zixing Liu wrote:
* added new functions: virStreamNew virStreamEventUpdateCallback
virStreamEventRemoveCallback
* added new constants: VIR_STREAM_NONBLOCK
* added new types/aliases: StreamFlags
* changed the previous `new` associate function to `from_ptr` to avoid
naming conflicts
* added basic tests to test the creation of Stream struct (can not test
the correctness of virStreamEventRemoveCallback and
virStreamEventUpdateCallback due to "unsupported by the connection
driver")
Signed-off-by: Zixing Liu <liushuyu(a)aosc.io>
---
src/stream.rs | 43 +++++++++++++++++++++++++++++++++++++++++--
tests/stream.rs | 40 ++++++++++++++++++++++++++++++++++++++++
2 files changed, 81 insertions(+), 2 deletions(-)
create mode 100644 tests/stream.rs
diff --git a/src/stream.rs b/src/stream.rs
index 2ca5d0b..de272ab 100644
--- a/src/stream.rs
+++ b/src/stream.rs
@@ -18,8 +18,9 @@
extern crate libc;
+use connect::Connect;
+use connect::sys::virConnectPtr;
use std::convert::TryFrom;
-use std::str;
use error::Error;
@@ -32,6 +33,9 @@ pub mod sys {
#[link(name = "virt")]
extern "C" {
+ fn virStreamNew(c: virConnectPtr,
+ flags: libc::c_uint)
+ -> sys::virStreamPtr;
fn virStreamSend(c: sys::virStreamPtr,
data: *const libc::c_char,
nbytes: libc::size_t)
@@ -43,6 +47,9 @@ extern "C" {
fn virStreamFree(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamAbort(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamFinish(c: sys::virStreamPtr) -> libc::c_int;
+ fn virStreamEventUpdateCallback(c: sys::virStreamPtr,
+ events: libc::c_int) -> libc::c_int;
+ fn virStreamEventRemoveCallback(c: sys::virStreamPtr) -> libc::c_int;
}
pub type StreamEventType = self::libc::c_uint;
@@ -51,6 +58,9 @@ pub const VIR_STREAM_EVENT_WRITABLE: StreamEventType = (1 << 1);
pub const VIR_STREAM_EVENT_ERROR: StreamEventType = (1 << 2);
pub const VIR_STREAM_EVENT_HANGUP: StreamEventType = (1 << 3);
+pub type StreamFlags = self::libc::c_uint;
+pub const VIR_STREAM_NONBLOCK: StreamFlags = (1 << 0);
+
#[derive(Debug)]
pub struct Stream {
ptr: Option<sys::virStreamPtr>,
@@ -69,7 +79,17 @@ impl Drop for Stream {
}
impl Stream {
- pub fn new(ptr: sys::virStreamPtr) -> Stream {
+ pub fn new(conn: &Connect, flags: StreamFlags) -> Result<Stream, Error>
{
+ unsafe {
We probably just want to use unsafe when calling virStreamNew, and we
should try the most as possible to explain why it is safe to use
"unsafe". Basically here, we are safe because we specifically
allocated conn at Rust level.
+ let ptr = virStreamNew(conn.as_ptr(), flags as
libc::c_uint);
+ if ptr.is_null() {
+ return Err(Error::new());
+ }
+ return Ok(Stream::from_ptr(ptr));
+ }
+ }
+
+ pub fn from_ptr(ptr: sys::virStreamPtr) -> Stream {
Stream { ptr: Some(ptr) }
}
Yes I think using 'from_ptr' would make more sense. We probably have
to update that everywhere also I don't think we want have that as
public.
Can you just remove the 'pub' flag of that function?
@@ -126,4 +146,23 @@ impl Stream {
};
usize::try_from(ret).map_err(|_| Error::new())
}
+
+ pub fn event_update_callback(&self, events: StreamEventType) -> Result<(),
Error> {
+ let ret = unsafe {
Same comment about usage of 'unsafe'.
+ virStreamEventUpdateCallback(self.as_ptr(), events as
libc::c_int)
We defined StreamEventType as unsigned.
+ };
+ if ret == -1 {
+ return Err(Error::new());
+ }
+ return Ok(());
+ }
+
+ pub fn event_remove_callback(&self) -> Result<(), Error> {
+ unsafe {
Same about unsafe.
+ if virStreamEventRemoveCallback(self.as_ptr()) == -1 {
+ return Err(Error::new());
+ }
+ return Ok(());
+ }
+ }
}
diff --git a/tests/stream.rs b/tests/stream.rs
new file mode 100644
index 0000000..16531b3
--- /dev/null
+++ b/tests/stream.rs
@@ -0,0 +1,40 @@
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>;.
+ *
+ * Sahid Orentino Ferdjaoui <sahid.ferdjaoui(a)redhat.com>
+ */
+
+extern crate virt;
+
+mod common;
+
+use virt::stream::Stream;
+use virt::stream::VIR_STREAM_NONBLOCK;
+
+#[test]
+fn test_create_blocking() {
+ let c = common::conn();
+ let s = Stream::new(&c, 0).unwrap();
+ drop(s);
+ common::close(c);
+}
+
+#[test]
+fn test_create_non_blocking() {
+ let c = common::conn();
+ let s = Stream::new(&c, VIR_STREAM_NONBLOCK).unwrap();
+ drop(s);
+ common::close(c);
+}
--
2.24.0
3:44 p.m.
New subject: [libvirt] [PATCH Rust 2/4] libvirt-rust: stream: add more functions in stream
* added virStreamEventAddCallback function
* added new types: StreamEventCallback and FreeCallback
* added new field: callback for storing event callback
* drop: will drop the Box<callback> if any
* added wrapper event_callback for easier callback authoring for the
user (so that closures with Fn or FnMut references could be used)
* added padding function event_free to just makes it compile (Rust
should not need this, because Rust sticks to RAII)
Signed-off-by: Zixing Liu <liushuyu(a)aosc.io>
---
src/stream.rs | 46 ++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 44 insertions(+), 2 deletions(-)
diff --git a/src/stream.rs b/src/stream.rs
index de272ab..1ffd186 100644
--- a/src/stream.rs
+++ b/src/stream.rs
@@ -47,6 +47,12 @@ extern "C" {
fn virStreamFree(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamAbort(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamFinish(c: sys::virStreamPtr) -> libc::c_int;
+ fn virStreamEventAddCallback(c: sys::virStreamPtr,
+ event: libc::c_int,
+ callback: StreamEventCallback,
+ opaque: *const libc::c_void,
+ ff: FreeCallback)
+ -> libc::c_int;
fn virStreamEventUpdateCallback(c: sys::virStreamPtr,
events: libc::c_int) -> libc::c_int;
fn virStreamEventRemoveCallback(c: sys::virStreamPtr) -> libc::c_int;
@@ -61,9 +67,26 @@ pub const VIR_STREAM_EVENT_HANGUP: StreamEventType = (1 << 3);
pub type StreamFlags = self::libc::c_uint;
pub const VIR_STREAM_NONBLOCK: StreamFlags = (1 << 0);
-#[derive(Debug)]
+pub type StreamEventCallback = extern "C" fn(sys::virStreamPtr, libc::c_int,
*const libc::c_void);
+pub type FreeCallback = extern "C" fn(*mut libc::c_void);
+
+// wrapper for callbacks
+extern "C" fn event_callback(c: sys::virStreamPtr, flags: libc::c_int, opaque:
*const libc::c_void) {
+ let flags = flags as StreamFlags;
+ let shadow_self = unsafe {
+ &mut*(opaque as *mut Stream)
+ };
+ if let Some(callback) = &mut shadow_self.callback {
+ callback(&Stream::from_ptr(c), flags);
+ }
+}
+
+extern "C" fn event_free(_opaque: *mut libc::c_void) {}
+
+// #[derive(Debug)]
pub struct Stream {
ptr: Option<sys::virStreamPtr>,
+ callback: Option<Box<dyn FnMut(&Stream, StreamEventType)>>,
}
impl Drop for Stream {
@@ -75,6 +98,13 @@ impl Drop for Stream {
e.message)
}
}
+ if self.callback.is_some() {
+ if let Err(e) = self.event_remove_callback() {
+ panic!("Unable to remove event callback for Stream, code {},
message: {}",
+ e.code,
+ e.message)
+ }
+ }
}
}
@@ -90,7 +120,7 @@ impl Stream {
}
pub fn from_ptr(ptr: sys::virStreamPtr) -> Stream {
- Stream { ptr: Some(ptr) }
+ Stream { ptr: Some(ptr), callback: None }
}
pub fn as_ptr(&self) -> sys::virStreamPtr {
@@ -147,6 +177,18 @@ impl Stream {
usize::try_from(ret).map_err(|_| Error::new())
}
+ pub fn event_add_callback<F: 'static + FnMut(&Stream,
StreamEventType)>(&mut self, events: StreamEventType, cb: F) -> Result<(),
Error> {
+ let ret = unsafe {
+ let ptr = &*self as *const _ as *const _;
+ virStreamEventAddCallback(self.as_ptr(), events as libc::c_int,
event_callback, ptr, event_free)
+ };
+ if ret == -1 {
+ return Err(Error::new());
+ }
+ self.callback = Some(Box::new(cb));
+ return Ok(());
+ }
+
pub fn event_update_callback(&self, events: StreamEventType) -> Result<(),
Error> {
let ret = unsafe {
virStreamEventUpdateCallback(self.as_ptr(), events as libc::c_int)
--
2.24.0
3:44 p.m.
New subject: [libvirt] [PATCH Rust 3/4] libvirt-rust: stream: automated lint
* used rustfmt to clean up the code
Signed-off-by: Zixing Liu <liushuyu(a)aosc.io>
---
src/stream.rs | 97 +++++++++++++++++++++++++++++----------------------
1 file changed, 56 insertions(+), 41 deletions(-)
diff --git a/src/stream.rs b/src/stream.rs
index 1ffd186..0d84fd7 100644
--- a/src/stream.rs
+++ b/src/stream.rs
@@ -18,8 +18,8 @@
extern crate libc;
-use connect::Connect;
use connect::sys::virConnectPtr;
+use connect::Connect;
use std::convert::TryFrom;
use error::Error;
@@ -33,28 +33,28 @@ pub mod sys {
#[link(name = "virt")]
extern "C" {
- fn virStreamNew(c: virConnectPtr,
- flags: libc::c_uint)
- -> sys::virStreamPtr;
- fn virStreamSend(c: sys::virStreamPtr,
- data: *const libc::c_char,
- nbytes: libc::size_t)
- -> libc::c_int;
- fn virStreamRecv(c: sys::virStreamPtr,
- data: *mut libc::c_char,
- nbytes: libc::size_t)
- -> libc::c_int;
+ fn virStreamNew(c: virConnectPtr, flags: libc::c_uint) -> sys::virStreamPtr;
+ fn virStreamSend(
+ c: sys::virStreamPtr,
+ data: *const libc::c_char,
+ nbytes: libc::size_t,
+ ) -> libc::c_int;
+ fn virStreamRecv(
+ c: sys::virStreamPtr,
+ data: *mut libc::c_char,
+ nbytes: libc::size_t,
+ ) -> libc::c_int;
fn virStreamFree(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamAbort(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamFinish(c: sys::virStreamPtr) -> libc::c_int;
- fn virStreamEventAddCallback(c: sys::virStreamPtr,
- event: libc::c_int,
- callback: StreamEventCallback,
- opaque: *const libc::c_void,
- ff: FreeCallback)
- -> libc::c_int;
- fn virStreamEventUpdateCallback(c: sys::virStreamPtr,
- events: libc::c_int) -> libc::c_int;
+ fn virStreamEventAddCallback(
+ c: sys::virStreamPtr,
+ event: libc::c_int,
+ callback: StreamEventCallback,
+ opaque: *const libc::c_void,
+ ff: FreeCallback,
+ ) -> libc::c_int;
+ fn virStreamEventUpdateCallback(c: sys::virStreamPtr, events: libc::c_int) ->
libc::c_int;
fn virStreamEventRemoveCallback(c: sys::virStreamPtr) -> libc::c_int;
}
@@ -71,14 +71,16 @@ pub type StreamEventCallback = extern "C"
fn(sys::virStreamPtr, libc::c_int, *co
pub type FreeCallback = extern "C" fn(*mut libc::c_void);
// wrapper for callbacks
-extern "C" fn event_callback(c: sys::virStreamPtr, flags: libc::c_int, opaque:
*const libc::c_void) {
- let flags = flags as StreamFlags;
- let shadow_self = unsafe {
- &mut*(opaque as *mut Stream)
- };
- if let Some(callback) = &mut shadow_self.callback {
- callback(&Stream::from_ptr(c), flags);
- }
+extern "C" fn event_callback(
+ c: sys::virStreamPtr,
+ flags: libc::c_int,
+ opaque: *const libc::c_void,
+) {
+ let flags = flags as StreamFlags;
+ let shadow_self = unsafe { &mut *(opaque as *mut Stream) };
+ if let Some(callback) = &mut shadow_self.callback {
+ callback(&Stream::from_ptr(c), flags);
+ }
}
extern "C" fn event_free(_opaque: *mut libc::c_void) {}
@@ -93,16 +95,18 @@ impl Drop for Stream {
fn drop(&mut self) {
if self.ptr.is_some() {
if let Err(e) = self.free() {
- panic!("Unable to drop memory for Stream, code {}, message:
{}",
- e.code,
- e.message)
+ panic!(
+ "Unable to drop memory for Stream, code {}, message: {}",
+ e.code, e.message
+ )
}
}
if self.callback.is_some() {
if let Err(e) = self.event_remove_callback() {
- panic!("Unable to remove event callback for Stream, code {},
message: {}",
- e.code,
- e.message)
+ panic!(
+ "Unable to remove event callback for Stream, code {}, message:
{}",
+ e.code, e.message
+ )
}
}
}
@@ -120,7 +124,10 @@ impl Stream {
}
pub fn from_ptr(ptr: sys::virStreamPtr) -> Stream {
- Stream { ptr: Some(ptr), callback: None }
+ Stream {
+ ptr: Some(ptr),
+ callback: None,
+ }
}
pub fn as_ptr(&self) -> sys::virStreamPtr {
@@ -160,7 +167,7 @@ impl Stream {
virStreamSend(
self.as_ptr(),
data.as_ptr() as *mut libc::c_char,
- data.len()
+ data.len(),
)
};
usize::try_from(ret).map_err(|_| Error::new())
@@ -177,10 +184,20 @@ impl Stream {
usize::try_from(ret).map_err(|_| Error::new())
}
- pub fn event_add_callback<F: 'static + FnMut(&Stream,
StreamEventType)>(&mut self, events: StreamEventType, cb: F) -> Result<(),
Error> {
+ pub fn event_add_callback<F: 'static + FnMut(&Stream,
StreamEventType)>(
+ &mut self,
+ events: StreamEventType,
+ cb: F,
+ ) -> Result<(), Error> {
let ret = unsafe {
let ptr = &*self as *const _ as *const _;
- virStreamEventAddCallback(self.as_ptr(), events as libc::c_int,
event_callback, ptr, event_free)
+ virStreamEventAddCallback(
+ self.as_ptr(),
+ events as libc::c_int,
+ event_callback,
+ ptr,
+ event_free,
+ )
};
if ret == -1 {
return Err(Error::new());
@@ -190,9 +207,7 @@ impl Stream {
}
pub fn event_update_callback(&self, events: StreamEventType) -> Result<(),
Error> {
- let ret = unsafe {
- virStreamEventUpdateCallback(self.as_ptr(), events as libc::c_int)
- };
+ let ret = unsafe { virStreamEventUpdateCallback(self.as_ptr(), events as
libc::c_int) };
if ret == -1 {
return Err(Error::new());
}
--
2.24.0
3:26 a.m.
New subject: [libvirt] [PATCH Rust 3/4] libvirt-rust: stream: automated lint
On Tue, Nov 12, 2019 at 02:44:44PM -0700, Zixing Liu wrote:
* used rustfmt to clean up the code
Signed-off-by: Zixing Liu <liushuyu(a)aosc.io>
---
src/stream.rs | 97 +++++++++++++++++++++++++++++----------------------
1 file changed, 56 insertions(+), 41 deletions(-)
NACK, We don't have any rules for that so far. I think that would make
sense at some point but we will probably have to do that in one
iteration and document somewhere our desires.
Thanks,
s.
diff --git a/src/stream.rs b/src/stream.rs
index 1ffd186..0d84fd7 100644
--- a/src/stream.rs
+++ b/src/stream.rs
@@ -18,8 +18,8 @@
extern crate libc;
-use connect::Connect;
use connect::sys::virConnectPtr;
+use connect::Connect;
use std::convert::TryFrom;
use error::Error;
@@ -33,28 +33,28 @@ pub mod sys {
#[link(name = "virt")]
extern "C" {
- fn virStreamNew(c: virConnectPtr,
- flags: libc::c_uint)
- -> sys::virStreamPtr;
- fn virStreamSend(c: sys::virStreamPtr,
- data: *const libc::c_char,
- nbytes: libc::size_t)
- -> libc::c_int;
- fn virStreamRecv(c: sys::virStreamPtr,
- data: *mut libc::c_char,
- nbytes: libc::size_t)
- -> libc::c_int;
+ fn virStreamNew(c: virConnectPtr, flags: libc::c_uint) -> sys::virStreamPtr;
+ fn virStreamSend(
+ c: sys::virStreamPtr,
+ data: *const libc::c_char,
+ nbytes: libc::size_t,
+ ) -> libc::c_int;
+ fn virStreamRecv(
+ c: sys::virStreamPtr,
+ data: *mut libc::c_char,
+ nbytes: libc::size_t,
+ ) -> libc::c_int;
fn virStreamFree(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamAbort(c: sys::virStreamPtr) -> libc::c_int;
fn virStreamFinish(c: sys::virStreamPtr) -> libc::c_int;
- fn virStreamEventAddCallback(c: sys::virStreamPtr,
- event: libc::c_int,
- callback: StreamEventCallback,
- opaque: *const libc::c_void,
- ff: FreeCallback)
- -> libc::c_int;
- fn virStreamEventUpdateCallback(c: sys::virStreamPtr,
- events: libc::c_int) -> libc::c_int;
+ fn virStreamEventAddCallback(
+ c: sys::virStreamPtr,
+ event: libc::c_int,
+ callback: StreamEventCallback,
+ opaque: *const libc::c_void,
+ ff: FreeCallback,
+ ) -> libc::c_int;
+ fn virStreamEventUpdateCallback(c: sys::virStreamPtr, events: libc::c_int) ->
libc::c_int;
fn virStreamEventRemoveCallback(c: sys::virStreamPtr) -> libc::c_int;
}
@@ -71,14 +71,16 @@ pub type StreamEventCallback = extern "C"
fn(sys::virStreamPtr, libc::c_int, *co
pub type FreeCallback = extern "C" fn(*mut libc::c_void);
// wrapper for callbacks
-extern "C" fn event_callback(c: sys::virStreamPtr, flags: libc::c_int, opaque:
*const libc::c_void) {
- let flags = flags as StreamFlags;
- let shadow_self = unsafe {
- &mut*(opaque as *mut Stream)
- };
- if let Some(callback) = &mut shadow_self.callback {
- callback(&Stream::from_ptr(c), flags);
- }
+extern "C" fn event_callback(
+ c: sys::virStreamPtr,
+ flags: libc::c_int,
+ opaque: *const libc::c_void,
+) {
+ let flags = flags as StreamFlags;
+ let shadow_self = unsafe { &mut *(opaque as *mut Stream) };
+ if let Some(callback) = &mut shadow_self.callback {
+ callback(&Stream::from_ptr(c), flags);
+ }
}
extern "C" fn event_free(_opaque: *mut libc::c_void) {}
@@ -93,16 +95,18 @@ impl Drop for Stream {
fn drop(&mut self) {
if self.ptr.is_some() {
if let Err(e) = self.free() {
- panic!("Unable to drop memory for Stream, code {}, message:
{}",
- e.code,
- e.message)
+ panic!(
+ "Unable to drop memory for Stream, code {}, message: {}",
+ e.code, e.message
+ )
}
}
if self.callback.is_some() {
if let Err(e) = self.event_remove_callback() {
- panic!("Unable to remove event callback for Stream, code {},
message: {}",
- e.code,
- e.message)
+ panic!(
+ "Unable to remove event callback for Stream, code {}, message:
{}",
+ e.code, e.message
+ )
}
}
}
@@ -120,7 +124,10 @@ impl Stream {
}
pub fn from_ptr(ptr: sys::virStreamPtr) -> Stream {
- Stream { ptr: Some(ptr), callback: None }
+ Stream {
+ ptr: Some(ptr),
+ callback: None,
+ }
}
pub fn as_ptr(&self) -> sys::virStreamPtr {
@@ -160,7 +167,7 @@ impl Stream {
virStreamSend(
self.as_ptr(),
data.as_ptr() as *mut libc::c_char,
- data.len()
+ data.len(),
)
};
usize::try_from(ret).map_err(|_| Error::new())
@@ -177,10 +184,20 @@ impl Stream {
usize::try_from(ret).map_err(|_| Error::new())
}
- pub fn event_add_callback<F: 'static + FnMut(&Stream,
StreamEventType)>(&mut self, events: StreamEventType, cb: F) -> Result<(),
Error> {
+ pub fn event_add_callback<F: 'static + FnMut(&Stream,
StreamEventType)>(
+ &mut self,
+ events: StreamEventType,
+ cb: F,
+ ) -> Result<(), Error> {
let ret = unsafe {
let ptr = &*self as *const _ as *const _;
- virStreamEventAddCallback(self.as_ptr(), events as libc::c_int,
event_callback, ptr, event_free)
+ virStreamEventAddCallback(
+ self.as_ptr(),
+ events as libc::c_int,
+ event_callback,
+ ptr,
+ event_free,
+ )
};
if ret == -1 {
return Err(Error::new());
@@ -190,9 +207,7 @@ impl Stream {
}
pub fn event_update_callback(&self, events: StreamEventType) -> Result<(),
Error> {
- let ret = unsafe {
- virStreamEventUpdateCallback(self.as_ptr(), events as libc::c_int)
- };
+ let ret = unsafe { virStreamEventUpdateCallback(self.as_ptr(), events as
libc::c_int) };
if ret == -1 {
return Err(Error::new());
}
--
2.24.0
3:44 p.m.
New subject: [libvirt] [PATCH Rust 4/4] libvirt-rust: use reference instead of moving
Signed-off-by: Zixing Liu <liushuyu(a)aosc.io>
---
src/domain.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/domain.rs b/src/domain.rs
index acb9e6e..4d4f593 100644
--- a/src/domain.rs
+++ b/src/domain.rs
@@ -1397,7 +1397,7 @@ impl Domain {
}
}
- pub fn open_console(&self, name: &str, stream: Stream, flags: u32) ->
Result<u32, Error> {
+ pub fn open_console(&self, name: &str, stream: &Stream, flags: u32) ->
Result<u32, Error> {
unsafe {
let ret = virDomainOpenConsole(self.as_ptr(),
string_to_c_chars!(name),
--
2.24.0
3:27 a.m.
New subject: [libvirt] [PATCH Rust 4/4] libvirt-rust: use reference instead of moving
On Tue, Nov 12, 2019 at 02:44:45PM -0700, Zixing Liu wrote:
Signed-off-by: Zixing Liu <liushuyu(a)aosc.io>
---
src/domain.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
Reviewed-by: Sahid Orentino Ferdjaoui <sahid.ferdjaoui(a)canonical.com>
diff --git a/src/domain.rs b/src/domain.rs
index acb9e6e..4d4f593 100644
--- a/src/domain.rs
+++ b/src/domain.rs
@@ -1397,7 +1397,7 @@ impl Domain {
}
}
- pub fn open_console(&self, name: &str, stream: Stream, flags: u32) ->
Result<u32, Error> {
+ pub fn open_console(&self, name: &str, stream: &Stream, flags: u32)
-> Result<u32, Error> {
unsafe {
let ret = virDomainOpenConsole(self.as_ptr(),
string_to_c_chars!(name),
--
2.24.0
1835
days inactive
1837
days old
7 comments
2 participants
participants (2)
-
Sahid Orentino Ferdjaoui -
Zixing Liu