diff --git a/rust-bindings/rust/conf/ostree.toml b/rust-bindings/rust/conf/ostree.toml index 7e50b71f..b531bcfa 100644 --- a/rust-bindings/rust/conf/ostree.toml +++ b/rust-bindings/rust/conf/ostree.toml @@ -12,6 +12,9 @@ girs_dir = "../gir-files" generate = [ "OSTree.AsyncProgress", + "OSTree.BootconfigParser", + "OSTree.Deployment", + "OSTree.DeploymentUnlockedState", "OSTree.GpgSignatureFormatFlags", "OSTree.GpgVerifyResult", "OSTree.MutableTree", @@ -33,6 +36,11 @@ generate = [ "OSTree.SePolicy", "OSTree.SePolicyRestoreconFlags", "OSTree.StaticDeltaGenerateOpt", + "OSTree.Sysroot", + "OSTree.SysrootSimpleWriteDeploymentFlags", + "OSTree.SysrootUpgrader", + "OSTree.SysrootUpgraderFlags", + "OSTree.SysrootUpgraderPullFlags", #"OSTree.RepoPruneOptions", #"OSTree.RepoExportArchiveOptions", diff --git a/rust-bindings/rust/gir-files/OSTree-1.0.gir b/rust-bindings/rust/gir-files/OSTree-1.0.gir index 2ef66686..41f7e57d 100644 --- a/rust-bindings/rust/gir-files/OSTree-1.0.gir +++ b/rust-bindings/rust/gir-files/OSTree-1.0.gir @@ -10133,15 +10133,20 @@ rootfs @self. + #OstreeSysroot - + + Cancellable diff --git a/rust-bindings/rust/src/auto/bootconfig_parser.rs b/rust-bindings/rust/src/auto/bootconfig_parser.rs new file mode 100644 index 00000000..6b2507ee --- /dev/null +++ b/rust-bindings/rust/src/auto/bootconfig_parser.rs @@ -0,0 +1,111 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from gir-files (https://github.com/gtk-rs/gir-files) +// DO NOT EDIT + +use Error; +use ffi; +use gio; +use glib::object::IsA; +use glib::translate::*; +use glib_ffi; +use gobject_ffi; +use std::mem; +use std::ptr; + +glib_wrapper! { + pub struct BootconfigParser(Object); + + match fn { + get_type => || ffi::ostree_bootconfig_parser_get_type(), + } +} + +impl BootconfigParser { + pub fn new() -> BootconfigParser { + unsafe { + from_glib_full(ffi::ostree_bootconfig_parser_new()) + } + } +} + +impl Default for BootconfigParser { + fn default() -> Self { + Self::new() + } +} + +pub trait BootconfigParserExt { + fn clone(&self) -> Option; + + fn get(&self, key: &str) -> Option; + + fn parse<'a, P: IsA, Q: Into>>(&self, path: &P, cancellable: Q) -> Result<(), Error>; + + fn parse_at<'a, P: Into>>(&self, dfd: i32, path: &str, cancellable: P) -> Result<(), Error>; + + fn set(&self, key: &str, value: &str); + + fn write<'a, P: IsA, Q: Into>>(&self, output: &P, cancellable: Q) -> Result<(), Error>; + + fn write_at<'a, P: Into>>(&self, dfd: i32, path: &str, cancellable: P) -> Result<(), Error>; +} + +impl> BootconfigParserExt for O { + fn clone(&self) -> Option { + unsafe { + from_glib_full(ffi::ostree_bootconfig_parser_clone(self.to_glib_none().0)) + } + } + + fn get(&self, key: &str) -> Option { + unsafe { + from_glib_none(ffi::ostree_bootconfig_parser_get(self.to_glib_none().0, key.to_glib_none().0)) + } + } + + fn parse<'a, P: IsA, Q: Into>>(&self, path: &P, cancellable: Q) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_bootconfig_parser_parse(self.to_glib_none().0, path.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn parse_at<'a, P: Into>>(&self, dfd: i32, path: &str, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_bootconfig_parser_parse_at(self.to_glib_none().0, dfd, path.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn set(&self, key: &str, value: &str) { + unsafe { + ffi::ostree_bootconfig_parser_set(self.to_glib_none().0, key.to_glib_none().0, value.to_glib_none().0); + } + } + + fn write<'a, P: IsA, Q: Into>>(&self, output: &P, cancellable: Q) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_bootconfig_parser_write(self.to_glib_none().0, output.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn write_at<'a, P: Into>>(&self, dfd: i32, path: &str, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_bootconfig_parser_write_at(self.to_glib_none().0, dfd, path.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } +} diff --git a/rust-bindings/rust/src/auto/deployment.rs b/rust-bindings/rust/src/auto/deployment.rs new file mode 100644 index 00000000..2c7ec27e --- /dev/null +++ b/rust-bindings/rust/src/auto/deployment.rs @@ -0,0 +1,205 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from gir-files (https://github.com/gtk-rs/gir-files) +// DO NOT EDIT + +use BootconfigParser; +#[cfg(any(feature = "v2016_4", feature = "dox"))] +use DeploymentUnlockedState; +use ffi; +use glib; +use glib::object::IsA; +use glib::translate::*; +use glib_ffi; +use gobject_ffi; +use std::mem; +use std::ptr; + +glib_wrapper! { + pub struct Deployment(Object); + + match fn { + get_type => || ffi::ostree_deployment_get_type(), + } +} + +impl Deployment { + pub fn new(index: i32, osname: &str, csum: &str, deployserial: i32, bootcsum: &str, bootserial: i32) -> Deployment { + unsafe { + from_glib_full(ffi::ostree_deployment_new(index, osname.to_glib_none().0, csum.to_glib_none().0, deployserial, bootcsum.to_glib_none().0, bootserial)) + } + } + + pub fn hash(&self) -> u32 { + unsafe { + ffi::ostree_deployment_hash(ToGlibPtr::<*mut ffi::OstreeDeployment>::to_glib_none(self).0 as glib_ffi::gconstpointer) + } + } + + #[cfg(any(feature = "v2018_3", feature = "dox"))] + pub fn origin_remove_transient_state(origin: &glib::KeyFile) { + unsafe { + ffi::ostree_deployment_origin_remove_transient_state(origin.to_glib_none().0); + } + } + + #[cfg(any(feature = "v2016_4", feature = "dox"))] + pub fn unlocked_state_to_string(state: DeploymentUnlockedState) -> Option { + unsafe { + from_glib_none(ffi::ostree_deployment_unlocked_state_to_string(state.to_glib())) + } + } +} + +pub trait DeploymentExt { + fn clone(&self) -> Option; + + fn equal(&self, bp: &Deployment) -> bool; + + fn get_bootconfig(&self) -> Option; + + fn get_bootcsum(&self) -> Option; + + fn get_bootserial(&self) -> i32; + + fn get_csum(&self) -> Option; + + fn get_deployserial(&self) -> i32; + + fn get_index(&self) -> i32; + + fn get_origin(&self) -> Option; + + fn get_origin_relpath(&self) -> Option; + + fn get_osname(&self) -> Option; + + #[cfg(any(feature = "v2016_4", feature = "dox"))] + fn get_unlocked(&self) -> DeploymentUnlockedState; + + #[cfg(any(feature = "v2018_3", feature = "dox"))] + fn is_pinned(&self) -> bool; + + #[cfg(any(feature = "v2018_3", feature = "dox"))] + fn is_staged(&self) -> bool; + + fn set_bootconfig(&self, bootconfig: &BootconfigParser); + + fn set_bootserial(&self, index: i32); + + fn set_index(&self, index: i32); + + fn set_origin(&self, origin: &glib::KeyFile); +} + +impl> DeploymentExt for O { + fn clone(&self) -> Option { + unsafe { + from_glib_full(ffi::ostree_deployment_clone(self.to_glib_none().0)) + } + } + + fn equal(&self, bp: &Deployment) -> bool { + unsafe { + from_glib(ffi::ostree_deployment_equal(ToGlibPtr::<*mut ffi::OstreeDeployment>::to_glib_none(self).0 as glib_ffi::gconstpointer, ToGlibPtr::<*mut ffi::OstreeDeployment>::to_glib_none(bp).0 as glib_ffi::gconstpointer)) + } + } + + fn get_bootconfig(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_deployment_get_bootconfig(self.to_glib_none().0)) + } + } + + fn get_bootcsum(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_deployment_get_bootcsum(self.to_glib_none().0)) + } + } + + fn get_bootserial(&self) -> i32 { + unsafe { + ffi::ostree_deployment_get_bootserial(self.to_glib_none().0) + } + } + + fn get_csum(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_deployment_get_csum(self.to_glib_none().0)) + } + } + + fn get_deployserial(&self) -> i32 { + unsafe { + ffi::ostree_deployment_get_deployserial(self.to_glib_none().0) + } + } + + fn get_index(&self) -> i32 { + unsafe { + ffi::ostree_deployment_get_index(self.to_glib_none().0) + } + } + + fn get_origin(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_deployment_get_origin(self.to_glib_none().0)) + } + } + + fn get_origin_relpath(&self) -> Option { + unsafe { + from_glib_full(ffi::ostree_deployment_get_origin_relpath(self.to_glib_none().0)) + } + } + + fn get_osname(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_deployment_get_osname(self.to_glib_none().0)) + } + } + + #[cfg(any(feature = "v2016_4", feature = "dox"))] + fn get_unlocked(&self) -> DeploymentUnlockedState { + unsafe { + from_glib(ffi::ostree_deployment_get_unlocked(self.to_glib_none().0)) + } + } + + #[cfg(any(feature = "v2018_3", feature = "dox"))] + fn is_pinned(&self) -> bool { + unsafe { + from_glib(ffi::ostree_deployment_is_pinned(self.to_glib_none().0)) + } + } + + #[cfg(any(feature = "v2018_3", feature = "dox"))] + fn is_staged(&self) -> bool { + unsafe { + from_glib(ffi::ostree_deployment_is_staged(self.to_glib_none().0)) + } + } + + fn set_bootconfig(&self, bootconfig: &BootconfigParser) { + unsafe { + ffi::ostree_deployment_set_bootconfig(self.to_glib_none().0, bootconfig.to_glib_none().0); + } + } + + fn set_bootserial(&self, index: i32) { + unsafe { + ffi::ostree_deployment_set_bootserial(self.to_glib_none().0, index); + } + } + + fn set_index(&self, index: i32) { + unsafe { + ffi::ostree_deployment_set_index(self.to_glib_none().0, index); + } + } + + fn set_origin(&self, origin: &glib::KeyFile) { + unsafe { + ffi::ostree_deployment_set_origin(self.to_glib_none().0, origin.to_glib_none().0); + } + } +} diff --git a/rust-bindings/rust/src/auto/enums.rs b/rust-bindings/rust/src/auto/enums.rs index 191c1330..c016888a 100644 --- a/rust-bindings/rust/src/auto/enums.rs +++ b/rust-bindings/rust/src/auto/enums.rs @@ -5,6 +5,42 @@ use ffi; use glib::translate::*; +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] +#[derive(Clone, Copy)] +pub enum DeploymentUnlockedState { + None, + Development, + Hotfix, + #[doc(hidden)] + __Unknown(i32), +} + +#[doc(hidden)] +impl ToGlib for DeploymentUnlockedState { + type GlibType = ffi::OstreeDeploymentUnlockedState; + + fn to_glib(&self) -> ffi::OstreeDeploymentUnlockedState { + match *self { + DeploymentUnlockedState::None => ffi::OSTREE_DEPLOYMENT_UNLOCKED_NONE, + DeploymentUnlockedState::Development => ffi::OSTREE_DEPLOYMENT_UNLOCKED_DEVELOPMENT, + DeploymentUnlockedState::Hotfix => ffi::OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX, + DeploymentUnlockedState::__Unknown(value) => value + } + } +} + +#[doc(hidden)] +impl FromGlib for DeploymentUnlockedState { + fn from_glib(value: ffi::OstreeDeploymentUnlockedState) -> Self { + match value { + 0 => DeploymentUnlockedState::None, + 1 => DeploymentUnlockedState::Development, + 2 => DeploymentUnlockedState::Hotfix, + value => DeploymentUnlockedState::__Unknown(value), + } + } +} + #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] #[derive(Clone, Copy)] pub enum GpgSignatureFormatFlags { diff --git a/rust-bindings/rust/src/auto/flags.rs b/rust-bindings/rust/src/auto/flags.rs index ccbad10f..ea60ba83 100644 --- a/rust-bindings/rust/src/auto/flags.rs +++ b/rust-bindings/rust/src/auto/flags.rs @@ -3,7 +3,14 @@ // DO NOT EDIT use ffi; +use glib::StaticType; +use glib::Type; use glib::translate::*; +use glib::value::FromValue; +use glib::value::FromValueOptional; +use glib::value::SetValue; +use glib::value::Value; +use gobject_ffi; #[cfg(any(feature = "v2015_7", feature = "dox"))] bitflags! { @@ -130,3 +137,100 @@ impl FromGlib for SePolicyRestoreconFlags { } } +bitflags! { + pub struct SysrootSimpleWriteDeploymentFlags: u32 { + const NONE = 0; + const RETAIN = 1; + const NOT_DEFAULT = 2; + const NO_CLEAN = 4; + const RETAIN_PENDING = 8; + const RETAIN_ROLLBACK = 16; + } +} + +#[doc(hidden)] +impl ToGlib for SysrootSimpleWriteDeploymentFlags { + type GlibType = ffi::OstreeSysrootSimpleWriteDeploymentFlags; + + fn to_glib(&self) -> ffi::OstreeSysrootSimpleWriteDeploymentFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib for SysrootSimpleWriteDeploymentFlags { + fn from_glib(value: ffi::OstreeSysrootSimpleWriteDeploymentFlags) -> SysrootSimpleWriteDeploymentFlags { + SysrootSimpleWriteDeploymentFlags::from_bits_truncate(value) + } +} + +bitflags! { + pub struct SysrootUpgraderFlags: u32 { + const IGNORE_UNCONFIGURED = 2; + } +} + +#[doc(hidden)] +impl ToGlib for SysrootUpgraderFlags { + type GlibType = ffi::OstreeSysrootUpgraderFlags; + + fn to_glib(&self) -> ffi::OstreeSysrootUpgraderFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib for SysrootUpgraderFlags { + fn from_glib(value: ffi::OstreeSysrootUpgraderFlags) -> SysrootUpgraderFlags { + SysrootUpgraderFlags::from_bits_truncate(value) + } +} + +impl StaticType for SysrootUpgraderFlags { + fn static_type() -> Type { + unsafe { from_glib(ffi::ostree_sysroot_upgrader_flags_get_type()) } + } +} + +impl<'a> FromValueOptional<'a> for SysrootUpgraderFlags { + unsafe fn from_value_optional(value: &Value) -> Option { + Some(FromValue::from_value(value)) + } +} + +impl<'a> FromValue<'a> for SysrootUpgraderFlags { + unsafe fn from_value(value: &Value) -> Self { + from_glib(gobject_ffi::g_value_get_flags(value.to_glib_none().0)) + } +} + +impl SetValue for SysrootUpgraderFlags { + unsafe fn set_value(value: &mut Value, this: &Self) { + gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, this.to_glib()) + } +} + +bitflags! { + pub struct SysrootUpgraderPullFlags: u32 { + const NONE = 0; + const ALLOW_OLDER = 1; + const SYNTHETIC = 2; + } +} + +#[doc(hidden)] +impl ToGlib for SysrootUpgraderPullFlags { + type GlibType = ffi::OstreeSysrootUpgraderPullFlags; + + fn to_glib(&self) -> ffi::OstreeSysrootUpgraderPullFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib for SysrootUpgraderPullFlags { + fn from_glib(value: ffi::OstreeSysrootUpgraderPullFlags) -> SysrootUpgraderPullFlags { + SysrootUpgraderPullFlags::from_bits_truncate(value) + } +} + diff --git a/rust-bindings/rust/src/auto/mod.rs b/rust-bindings/rust/src/auto/mod.rs index 9673664b..f6d31a39 100644 --- a/rust-bindings/rust/src/auto/mod.rs +++ b/rust-bindings/rust/src/auto/mod.rs @@ -6,6 +6,14 @@ mod async_progress; pub use self::async_progress::AsyncProgress; pub use self::async_progress::AsyncProgressExt; +mod bootconfig_parser; +pub use self::bootconfig_parser::BootconfigParser; +pub use self::bootconfig_parser::BootconfigParserExt; + +mod deployment; +pub use self::deployment::Deployment; +pub use self::deployment::DeploymentExt; + mod gpg_verify_result; pub use self::gpg_verify_result::GpgVerifyResult; pub use self::gpg_verify_result::GpgVerifyResultExt; @@ -26,6 +34,14 @@ mod se_policy; pub use self::se_policy::SePolicy; pub use self::se_policy::SePolicyExt; +mod sysroot; +pub use self::sysroot::Sysroot; +pub use self::sysroot::SysrootExt; + +mod sysroot_upgrader; +pub use self::sysroot_upgrader::SysrootUpgrader; +pub use self::sysroot_upgrader::SysrootUpgraderExt; + #[cfg(any(feature = "v2018_6", feature = "dox"))] mod remote; #[cfg(any(feature = "v2018_6", feature = "dox"))] @@ -41,6 +57,7 @@ mod repo_transaction_stats; pub use self::repo_transaction_stats::RepoTransactionStats; mod enums; +pub use self::enums::DeploymentUnlockedState; pub use self::enums::GpgSignatureFormatFlags; pub use self::enums::ObjectType; pub use self::enums::RepoCheckoutMode; @@ -57,6 +74,9 @@ pub use self::flags::RepoListRefsExtFlags; pub use self::flags::RepoPullFlags; pub use self::flags::RepoResolveRevExtFlags; pub use self::flags::SePolicyRestoreconFlags; +pub use self::flags::SysrootSimpleWriteDeploymentFlags; +pub use self::flags::SysrootUpgraderFlags; +pub use self::flags::SysrootUpgraderPullFlags; pub mod functions; @@ -89,9 +109,13 @@ pub use self::constants::TREE_GVARIANT_STRING; #[doc(hidden)] pub mod traits { pub use super::AsyncProgressExt; + pub use super::BootconfigParserExt; + pub use super::DeploymentExt; pub use super::GpgVerifyResultExt; pub use super::MutableTreeExt; pub use super::RepoExt; pub use super::RepoFileExt; pub use super::SePolicyExt; + pub use super::SysrootExt; + pub use super::SysrootUpgraderExt; } diff --git a/rust-bindings/rust/src/auto/sysroot.rs b/rust-bindings/rust/src/auto/sysroot.rs new file mode 100644 index 00000000..087b2694 --- /dev/null +++ b/rust-bindings/rust/src/auto/sysroot.rs @@ -0,0 +1,515 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from gir-files (https://github.com/gtk-rs/gir-files) +// DO NOT EDIT + +use Deployment; +#[cfg(any(feature = "v2016_4", feature = "dox"))] +use DeploymentUnlockedState; +use Error; +use Repo; +use SysrootSimpleWriteDeploymentFlags; +use ffi; +#[cfg(feature = "futures")] +use futures_core; +use gio; +use gio_ffi; +use glib; +#[cfg(any(feature = "v2017_10", feature = "dox"))] +use glib::object::Downcast; +use glib::object::IsA; +#[cfg(any(feature = "v2017_10", feature = "dox"))] +use glib::signal::SignalHandlerId; +#[cfg(any(feature = "v2017_10", feature = "dox"))] +use glib::signal::connect; +use glib::translate::*; +use glib_ffi; +use gobject_ffi; +#[cfg(any(feature = "v2017_10", feature = "dox"))] +use libc; +use std::boxed::Box as Box_; +use std::mem; +#[cfg(any(feature = "v2017_10", feature = "dox"))] +use std::mem::transmute; +use std::ptr; + +glib_wrapper! { + pub struct Sysroot(Object); + + match fn { + get_type => || ffi::ostree_sysroot_get_type(), + } +} + +impl Sysroot { + pub fn new<'a, P: IsA + 'a, Q: Into>>(path: Q) -> Sysroot { + let path = path.into(); + let path = path.to_glib_none(); + unsafe { + from_glib_full(ffi::ostree_sysroot_new(path.0)) + } + } + + pub fn new_default() -> Sysroot { + unsafe { + from_glib_full(ffi::ostree_sysroot_new_default()) + } + } + + pub fn get_deployment_origin_path>(deployment_path: &P) -> Option { + unsafe { + from_glib_full(ffi::ostree_sysroot_get_deployment_origin_path(deployment_path.to_glib_none().0)) + } + } +} + +pub trait SysrootExt: Sized { + fn cleanup<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error>; + + //#[cfg(any(feature = "v2018_6", feature = "dox"))] + //fn cleanup_prune_repo<'a, P: Into>>(&self, options: /*Ignored*/&mut RepoPruneOptions, cancellable: P) -> Result<(i32, i32, u64), Error>; + + fn deploy_tree<'a, 'b, 'c, 'd, P: Into>, Q: Into>, R: Into>, S: Into>>(&self, osname: P, revision: &str, origin: Q, provided_merge_deployment: R, override_kernel_argv: &[&str], cancellable: S) -> Result; + + fn deployment_set_kargs<'a, P: Into>>(&self, deployment: &Deployment, new_kargs: &[&str], cancellable: P) -> Result<(), Error>; + + fn deployment_set_mutable<'a, P: Into>>(&self, deployment: &Deployment, is_mutable: bool, cancellable: P) -> Result<(), Error>; + + #[cfg(any(feature = "v2018_3", feature = "dox"))] + fn deployment_set_pinned(&self, deployment: &Deployment, is_pinned: bool) -> Result<(), Error>; + + #[cfg(any(feature = "v2016_4", feature = "dox"))] + fn deployment_unlock<'a, P: Into>>(&self, deployment: &Deployment, unlocked_state: DeploymentUnlockedState, cancellable: P) -> Result<(), Error>; + + fn ensure_initialized<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error>; + + fn get_booted_deployment(&self) -> Option; + + fn get_bootversion(&self) -> i32; + + fn get_deployment_directory(&self, deployment: &Deployment) -> Option; + + fn get_deployment_dirpath(&self, deployment: &Deployment) -> Option; + + //fn get_deployments(&self) -> /*Unknown conversion*//*Unimplemented*/PtrArray TypeId { ns_id: 1, id: 19 }; + + fn get_fd(&self) -> i32; + + fn get_merge_deployment<'a, P: Into>>(&self, osname: P) -> Option; + + fn get_path(&self) -> Option; + + fn get_repo<'a, P: Into>>(&self, cancellable: P) -> Result; + + #[cfg(any(feature = "v2018_5", feature = "dox"))] + fn get_staged_deployment(&self) -> Option; + + fn get_subbootversion(&self) -> i32; + + #[cfg(any(feature = "v2016_4", feature = "dox"))] + fn init_osname<'a, P: Into>>(&self, osname: &str, cancellable: P) -> Result<(), Error>; + + fn load<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error>; + + #[cfg(any(feature = "v2016_4", feature = "dox"))] + fn load_if_changed<'a, P: Into>>(&self, cancellable: P) -> Result; + + fn lock(&self) -> Result<(), Error>; + + fn lock_async<'a, P: Into>, Q: FnOnce(Result<(), Error>) + Send + 'static>(&self, cancellable: P, callback: Q); + + #[cfg(feature = "futures")] + fn lock_async_future(&self) -> Box_>; + + fn origin_new_from_refspec(&self, refspec: &str) -> Option; + + fn prepare_cleanup<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error>; + + #[cfg(any(feature = "v2017_7", feature = "dox"))] + fn query_deployments_for<'a, P: Into>>(&self, osname: P) -> (Deployment, Deployment); + + #[cfg(any(feature = "v2017_7", feature = "dox"))] + fn repo(&self) -> Option; + + fn simple_write_deployment<'a, 'b, 'c, P: Into>, Q: Into>, R: Into>>(&self, osname: P, new_deployment: &Deployment, merge_deployment: Q, flags: SysrootSimpleWriteDeploymentFlags, cancellable: R) -> Result<(), Error>; + + #[cfg(any(feature = "v2018_5", feature = "dox"))] + fn stage_tree<'a, 'b, 'c, 'd, P: Into>, Q: Into>, R: Into>, S: Into>>(&self, osname: P, revision: &str, origin: Q, merge_deployment: R, override_kernel_argv: &[&str], cancellable: S) -> Result; + + fn try_lock(&self) -> Result; + + fn unload(&self); + + fn unlock(&self); + + //fn write_deployments<'a, P: Into>>(&self, new_deployments: /*Unknown conversion*//*Unimplemented*/PtrArray TypeId { ns_id: 1, id: 19 }, cancellable: P) -> Result<(), Error>; + + //#[cfg(any(feature = "v2017_4", feature = "dox"))] + //fn write_deployments_with_options<'a, P: Into>>(&self, new_deployments: /*Unknown conversion*//*Unimplemented*/PtrArray TypeId { ns_id: 1, id: 19 }, opts: /*Ignored*/&mut SysrootWriteDeploymentsOpts, cancellable: P) -> Result<(), Error>; + + fn write_origin_file<'a, 'b, P: Into>, Q: Into>>(&self, deployment: &Deployment, new_origin: P, cancellable: Q) -> Result<(), Error>; + + #[cfg(any(feature = "v2017_10", feature = "dox"))] + fn connect_journal_msg(&self, f: F) -> SignalHandlerId; +} + +impl + IsA + Clone + 'static> SysrootExt for O { + fn cleanup<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_cleanup(self.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + //#[cfg(any(feature = "v2018_6", feature = "dox"))] + //fn cleanup_prune_repo<'a, P: Into>>(&self, options: /*Ignored*/&mut RepoPruneOptions, cancellable: P) -> Result<(i32, i32, u64), Error> { + // unsafe { TODO: call ffi::ostree_sysroot_cleanup_prune_repo() } + //} + + fn deploy_tree<'a, 'b, 'c, 'd, P: Into>, Q: Into>, R: Into>, S: Into>>(&self, osname: P, revision: &str, origin: Q, provided_merge_deployment: R, override_kernel_argv: &[&str], cancellable: S) -> Result { + let osname = osname.into(); + let osname = osname.to_glib_none(); + let origin = origin.into(); + let origin = origin.to_glib_none(); + let provided_merge_deployment = provided_merge_deployment.into(); + let provided_merge_deployment = provided_merge_deployment.to_glib_none(); + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut out_new_deployment = ptr::null_mut(); + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_deploy_tree(self.to_glib_none().0, osname.0, revision.to_glib_none().0, origin.0, provided_merge_deployment.0, override_kernel_argv.to_glib_none().0, &mut out_new_deployment, cancellable.0, &mut error); + if error.is_null() { Ok(from_glib_full(out_new_deployment)) } else { Err(from_glib_full(error)) } + } + } + + fn deployment_set_kargs<'a, P: Into>>(&self, deployment: &Deployment, new_kargs: &[&str], cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_deployment_set_kargs(self.to_glib_none().0, deployment.to_glib_none().0, new_kargs.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn deployment_set_mutable<'a, P: Into>>(&self, deployment: &Deployment, is_mutable: bool, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_deployment_set_mutable(self.to_glib_none().0, deployment.to_glib_none().0, is_mutable.to_glib(), cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + #[cfg(any(feature = "v2018_3", feature = "dox"))] + fn deployment_set_pinned(&self, deployment: &Deployment, is_pinned: bool) -> Result<(), Error> { + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_deployment_set_pinned(self.to_glib_none().0, deployment.to_glib_none().0, is_pinned.to_glib(), &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + #[cfg(any(feature = "v2016_4", feature = "dox"))] + fn deployment_unlock<'a, P: Into>>(&self, deployment: &Deployment, unlocked_state: DeploymentUnlockedState, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_deployment_unlock(self.to_glib_none().0, deployment.to_glib_none().0, unlocked_state.to_glib(), cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn ensure_initialized<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_ensure_initialized(self.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn get_booted_deployment(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_sysroot_get_booted_deployment(self.to_glib_none().0)) + } + } + + fn get_bootversion(&self) -> i32 { + unsafe { + ffi::ostree_sysroot_get_bootversion(self.to_glib_none().0) + } + } + + fn get_deployment_directory(&self, deployment: &Deployment) -> Option { + unsafe { + from_glib_full(ffi::ostree_sysroot_get_deployment_directory(self.to_glib_none().0, deployment.to_glib_none().0)) + } + } + + fn get_deployment_dirpath(&self, deployment: &Deployment) -> Option { + unsafe { + from_glib_full(ffi::ostree_sysroot_get_deployment_dirpath(self.to_glib_none().0, deployment.to_glib_none().0)) + } + } + + //fn get_deployments(&self) -> /*Unknown conversion*//*Unimplemented*/PtrArray TypeId { ns_id: 1, id: 19 } { + // unsafe { TODO: call ffi::ostree_sysroot_get_deployments() } + //} + + fn get_fd(&self) -> i32 { + unsafe { + ffi::ostree_sysroot_get_fd(self.to_glib_none().0) + } + } + + fn get_merge_deployment<'a, P: Into>>(&self, osname: P) -> Option { + let osname = osname.into(); + let osname = osname.to_glib_none(); + unsafe { + from_glib_full(ffi::ostree_sysroot_get_merge_deployment(self.to_glib_none().0, osname.0)) + } + } + + fn get_path(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_sysroot_get_path(self.to_glib_none().0)) + } + } + + fn get_repo<'a, P: Into>>(&self, cancellable: P) -> Result { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut out_repo = ptr::null_mut(); + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_get_repo(self.to_glib_none().0, &mut out_repo, cancellable.0, &mut error); + if error.is_null() { Ok(from_glib_full(out_repo)) } else { Err(from_glib_full(error)) } + } + } + + #[cfg(any(feature = "v2018_5", feature = "dox"))] + fn get_staged_deployment(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_sysroot_get_staged_deployment(self.to_glib_none().0)) + } + } + + fn get_subbootversion(&self) -> i32 { + unsafe { + ffi::ostree_sysroot_get_subbootversion(self.to_glib_none().0) + } + } + + #[cfg(any(feature = "v2016_4", feature = "dox"))] + fn init_osname<'a, P: Into>>(&self, osname: &str, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_init_osname(self.to_glib_none().0, osname.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn load<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_load(self.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + #[cfg(any(feature = "v2016_4", feature = "dox"))] + fn load_if_changed<'a, P: Into>>(&self, cancellable: P) -> Result { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut out_changed = mem::uninitialized(); + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_load_if_changed(self.to_glib_none().0, &mut out_changed, cancellable.0, &mut error); + if error.is_null() { Ok(from_glib(out_changed)) } else { Err(from_glib_full(error)) } + } + } + + fn lock(&self) -> Result<(), Error> { + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_lock(self.to_glib_none().0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn lock_async<'a, P: Into>, Q: FnOnce(Result<(), Error>) + Send + 'static>(&self, cancellable: P, callback: Q) { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + let user_data: Box> = Box::new(Box::new(callback)); + unsafe extern "C" fn lock_async_trampoline) + Send + 'static>(_source_object: *mut gobject_ffi::GObject, res: *mut gio_ffi::GAsyncResult, user_data: glib_ffi::gpointer) + { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_lock_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) }; + let callback: Box> = Box::from_raw(user_data as *mut _); + callback(result); + } + let callback = lock_async_trampoline::; + unsafe { + ffi::ostree_sysroot_lock_async(self.to_glib_none().0, cancellable.0, Some(callback), Box::into_raw(user_data) as *mut _); + } + } + + #[cfg(feature = "futures")] + fn lock_async_future(&self) -> Box_> { + use gio::GioFuture; + use fragile::Fragile; + + GioFuture::new(self, move |obj, send| { + let cancellable = gio::Cancellable::new(); + let send = Fragile::new(send); + let obj_clone = Fragile::new(obj.clone()); + obj.lock_async( + Some(&cancellable), + move |res| { + let obj = obj_clone.into_inner(); + let res = res.map(|v| (obj.clone(), v)).map_err(|v| (obj.clone(), v)); + let _ = send.into_inner().send(res); + }, + ); + + cancellable + }) + } + + fn origin_new_from_refspec(&self, refspec: &str) -> Option { + unsafe { + from_glib_full(ffi::ostree_sysroot_origin_new_from_refspec(self.to_glib_none().0, refspec.to_glib_none().0)) + } + } + + fn prepare_cleanup<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_prepare_cleanup(self.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + #[cfg(any(feature = "v2017_7", feature = "dox"))] + fn query_deployments_for<'a, P: Into>>(&self, osname: P) -> (Deployment, Deployment) { + let osname = osname.into(); + let osname = osname.to_glib_none(); + unsafe { + let mut out_pending = ptr::null_mut(); + let mut out_rollback = ptr::null_mut(); + ffi::ostree_sysroot_query_deployments_for(self.to_glib_none().0, osname.0, &mut out_pending, &mut out_rollback); + (from_glib_full(out_pending), from_glib_full(out_rollback)) + } + } + + #[cfg(any(feature = "v2017_7", feature = "dox"))] + fn repo(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_sysroot_repo(self.to_glib_none().0)) + } + } + + fn simple_write_deployment<'a, 'b, 'c, P: Into>, Q: Into>, R: Into>>(&self, osname: P, new_deployment: &Deployment, merge_deployment: Q, flags: SysrootSimpleWriteDeploymentFlags, cancellable: R) -> Result<(), Error> { + let osname = osname.into(); + let osname = osname.to_glib_none(); + let merge_deployment = merge_deployment.into(); + let merge_deployment = merge_deployment.to_glib_none(); + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_simple_write_deployment(self.to_glib_none().0, osname.0, new_deployment.to_glib_none().0, merge_deployment.0, flags.to_glib(), cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + #[cfg(any(feature = "v2018_5", feature = "dox"))] + fn stage_tree<'a, 'b, 'c, 'd, P: Into>, Q: Into>, R: Into>, S: Into>>(&self, osname: P, revision: &str, origin: Q, merge_deployment: R, override_kernel_argv: &[&str], cancellable: S) -> Result { + let osname = osname.into(); + let osname = osname.to_glib_none(); + let origin = origin.into(); + let origin = origin.to_glib_none(); + let merge_deployment = merge_deployment.into(); + let merge_deployment = merge_deployment.to_glib_none(); + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut out_new_deployment = ptr::null_mut(); + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_stage_tree(self.to_glib_none().0, osname.0, revision.to_glib_none().0, origin.0, merge_deployment.0, override_kernel_argv.to_glib_none().0, &mut out_new_deployment, cancellable.0, &mut error); + if error.is_null() { Ok(from_glib_full(out_new_deployment)) } else { Err(from_glib_full(error)) } + } + } + + fn try_lock(&self) -> Result { + unsafe { + let mut out_acquired = mem::uninitialized(); + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_try_lock(self.to_glib_none().0, &mut out_acquired, &mut error); + if error.is_null() { Ok(from_glib(out_acquired)) } else { Err(from_glib_full(error)) } + } + } + + fn unload(&self) { + unsafe { + ffi::ostree_sysroot_unload(self.to_glib_none().0); + } + } + + fn unlock(&self) { + unsafe { + ffi::ostree_sysroot_unlock(self.to_glib_none().0); + } + } + + //fn write_deployments<'a, P: Into>>(&self, new_deployments: /*Unknown conversion*//*Unimplemented*/PtrArray TypeId { ns_id: 1, id: 19 }, cancellable: P) -> Result<(), Error> { + // unsafe { TODO: call ffi::ostree_sysroot_write_deployments() } + //} + + //#[cfg(any(feature = "v2017_4", feature = "dox"))] + //fn write_deployments_with_options<'a, P: Into>>(&self, new_deployments: /*Unknown conversion*//*Unimplemented*/PtrArray TypeId { ns_id: 1, id: 19 }, opts: /*Ignored*/&mut SysrootWriteDeploymentsOpts, cancellable: P) -> Result<(), Error> { + // unsafe { TODO: call ffi::ostree_sysroot_write_deployments_with_options() } + //} + + fn write_origin_file<'a, 'b, P: Into>, Q: Into>>(&self, deployment: &Deployment, new_origin: P, cancellable: Q) -> Result<(), Error> { + let new_origin = new_origin.into(); + let new_origin = new_origin.to_glib_none(); + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_write_origin_file(self.to_glib_none().0, deployment.to_glib_none().0, new_origin.0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + #[cfg(any(feature = "v2017_10", feature = "dox"))] + fn connect_journal_msg(&self, f: F) -> SignalHandlerId { + unsafe { + let f: Box_> = Box_::new(Box_::new(f)); + connect(self.to_glib_none().0, "journal-msg", + transmute(journal_msg_trampoline:: as usize), Box_::into_raw(f) as *mut _) + } + } +} + +#[cfg(any(feature = "v2017_10", feature = "dox"))] +unsafe extern "C" fn journal_msg_trampoline

(this: *mut ffi::OstreeSysroot, msg: *mut libc::c_char, f: glib_ffi::gpointer) +where P: IsA { + let f: &&(Fn(&P, &str) + 'static) = transmute(f); + f(&Sysroot::from_glib_borrow(this).downcast_unchecked(), &String::from_glib_none(msg)) +} diff --git a/rust-bindings/rust/src/auto/sysroot_upgrader.rs b/rust-bindings/rust/src/auto/sysroot_upgrader.rs new file mode 100644 index 00000000..4b504848 --- /dev/null +++ b/rust-bindings/rust/src/auto/sysroot_upgrader.rs @@ -0,0 +1,188 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from gir-files (https://github.com/gtk-rs/gir-files) +// DO NOT EDIT + +use AsyncProgress; +use Error; +use Repo; +use RepoPullFlags; +use Sysroot; +use SysrootUpgraderFlags; +use SysrootUpgraderPullFlags; +use ffi; +use gio; +use glib; +use glib::StaticType; +use glib::Value; +use glib::object::IsA; +use glib::translate::*; +use glib_ffi; +use gobject_ffi; +use std::mem; +use std::ptr; + +glib_wrapper! { + pub struct SysrootUpgrader(Object); + + match fn { + get_type => || ffi::ostree_sysroot_upgrader_get_type(), + } +} + +impl SysrootUpgrader { + pub fn new<'a, P: Into>>(sysroot: &Sysroot, cancellable: P) -> Result { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let ret = ffi::ostree_sysroot_upgrader_new(sysroot.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } + } + } + + pub fn new_for_os<'a, 'b, P: Into>, Q: Into>>(sysroot: &Sysroot, osname: P, cancellable: Q) -> Result { + let osname = osname.into(); + let osname = osname.to_glib_none(); + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let ret = ffi::ostree_sysroot_upgrader_new_for_os(sysroot.to_glib_none().0, osname.0, cancellable.0, &mut error); + if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } + } + } + + pub fn new_for_os_with_flags<'a, 'b, P: Into>, Q: Into>>(sysroot: &Sysroot, osname: P, flags: SysrootUpgraderFlags, cancellable: Q) -> Result { + let osname = osname.into(); + let osname = osname.to_glib_none(); + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let ret = ffi::ostree_sysroot_upgrader_new_for_os_with_flags(sysroot.to_glib_none().0, osname.0, flags.to_glib(), cancellable.0, &mut error); + if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) } + } + } + + pub fn check_timestamps(repo: &Repo, from_rev: &str, to_rev: &str) -> Result<(), Error> { + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_upgrader_check_timestamps(repo.to_glib_none().0, from_rev.to_glib_none().0, to_rev.to_glib_none().0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } +} + +pub trait SysrootUpgraderExt { + fn deploy<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error>; + + fn dup_origin(&self) -> Option; + + fn get_origin(&self) -> Option; + + fn get_origin_description(&self) -> Option; + + fn pull<'a, 'b, P: Into>, Q: Into>>(&self, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: P, cancellable: Q) -> Result; + + fn pull_one_dir<'a, 'b, P: Into>, Q: Into>>(&self, dir_to_pull: &str, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: P, cancellable: Q) -> Result; + + fn set_origin<'a, 'b, P: Into>, Q: Into>>(&self, origin: P, cancellable: Q) -> Result<(), Error>; + + fn get_property_flags(&self) -> SysrootUpgraderFlags; + + fn get_property_osname(&self) -> Option; + + fn get_property_sysroot(&self) -> Option; +} + +impl + IsA> SysrootUpgraderExt for O { + fn deploy<'a, P: Into>>(&self, cancellable: P) -> Result<(), Error> { + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_upgrader_deploy(self.to_glib_none().0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn dup_origin(&self) -> Option { + unsafe { + from_glib_full(ffi::ostree_sysroot_upgrader_dup_origin(self.to_glib_none().0)) + } + } + + fn get_origin(&self) -> Option { + unsafe { + from_glib_none(ffi::ostree_sysroot_upgrader_get_origin(self.to_glib_none().0)) + } + } + + fn get_origin_description(&self) -> Option { + unsafe { + from_glib_full(ffi::ostree_sysroot_upgrader_get_origin_description(self.to_glib_none().0)) + } + } + + fn pull<'a, 'b, P: Into>, Q: Into>>(&self, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: P, cancellable: Q) -> Result { + let progress = progress.into(); + let progress = progress.to_glib_none(); + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut out_changed = mem::uninitialized(); + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_upgrader_pull(self.to_glib_none().0, flags.to_glib(), upgrader_flags.to_glib(), progress.0, &mut out_changed, cancellable.0, &mut error); + if error.is_null() { Ok(from_glib(out_changed)) } else { Err(from_glib_full(error)) } + } + } + + fn pull_one_dir<'a, 'b, P: Into>, Q: Into>>(&self, dir_to_pull: &str, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: P, cancellable: Q) -> Result { + let progress = progress.into(); + let progress = progress.to_glib_none(); + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut out_changed = mem::uninitialized(); + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_upgrader_pull_one_dir(self.to_glib_none().0, dir_to_pull.to_glib_none().0, flags.to_glib(), upgrader_flags.to_glib(), progress.0, &mut out_changed, cancellable.0, &mut error); + if error.is_null() { Ok(from_glib(out_changed)) } else { Err(from_glib_full(error)) } + } + } + + fn set_origin<'a, 'b, P: Into>, Q: Into>>(&self, origin: P, cancellable: Q) -> Result<(), Error> { + let origin = origin.into(); + let origin = origin.to_glib_none(); + let cancellable = cancellable.into(); + let cancellable = cancellable.to_glib_none(); + unsafe { + let mut error = ptr::null_mut(); + let _ = ffi::ostree_sysroot_upgrader_set_origin(self.to_glib_none().0, origin.0, cancellable.0, &mut error); + if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } + } + } + + fn get_property_flags(&self) -> SysrootUpgraderFlags { + unsafe { + let mut value = Value::from_type(::static_type()); + gobject_ffi::g_object_get_property(self.to_glib_none().0, "flags".to_glib_none().0, value.to_glib_none_mut().0); + value.get().unwrap() + } + } + + fn get_property_osname(&self) -> Option { + unsafe { + let mut value = Value::from_type(::static_type()); + gobject_ffi::g_object_get_property(self.to_glib_none().0, "osname".to_glib_none().0, value.to_glib_none_mut().0); + value.get() + } + } + + fn get_property_sysroot(&self) -> Option { + unsafe { + let mut value = Value::from_type(::static_type()); + gobject_ffi::g_object_get_property(self.to_glib_none().0, "sysroot".to_glib_none().0, value.to_glib_none_mut().0); + value.get() + } + } +}