Add more types

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",

rust-bindings/rust/gir-files/OSTree-1.0.gir

@@ -10133,15 +10133,20 @@ rootfs @self.</doc>
         </return-value>
         <parameters>
           <instance-parameter name="self" transfer-ownership="none">
+            <doc xml:space="preserve">#OstreeSysroot</doc>
             <type name="Sysroot" c:type="OstreeSysroot*"/>
           </instance-parameter>
-          <parameter name="out_changed" transfer-ownership="none">
+          <parameter name="out_changed"
+                     direction="out"
+                     caller-allocates="1"
+                     transfer-ownership="none">
             <type name="gboolean" c:type="gboolean*"/>
           </parameter>
           <parameter name="cancellable"
                      transfer-ownership="none"
                      nullable="1"
                      allow-none="1">
+            <doc xml:space="preserve">Cancellable</doc>
             <type name="Gio.Cancellable" c:type="GCancellable*"/>
           </parameter>
         </parameters>

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<ffi::OstreeBootconfigParser>);
+
+    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<BootconfigParser>;
+
+    fn get(&self, key: &str) -> Option<String>;
+
+    fn parse<'a, P: IsA<gio::File>, Q: Into<Option<&'a gio::Cancellable>>>(&self, path: &P, cancellable: Q) -> Result<(), Error>;
+
+    fn parse_at<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, dfd: i32, path: &str, cancellable: P) -> Result<(), Error>;
+
+    fn set(&self, key: &str, value: &str);
+
+    fn write<'a, P: IsA<gio::File>, Q: Into<Option<&'a gio::Cancellable>>>(&self, output: &P, cancellable: Q) -> Result<(), Error>;
+
+    fn write_at<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, dfd: i32, path: &str, cancellable: P) -> Result<(), Error>;
+}
+
+impl<O: IsA<BootconfigParser>> BootconfigParserExt for O {
+    fn clone(&self) -> Option<BootconfigParser> {
+        unsafe {
+            from_glib_full(ffi::ostree_bootconfig_parser_clone(self.to_glib_none().0))
+        }
+    }
+
+    fn get(&self, key: &str) -> Option<String> {
+        unsafe {
+            from_glib_none(ffi::ostree_bootconfig_parser_get(self.to_glib_none().0, key.to_glib_none().0))
+        }
+    }
+
+    fn parse<'a, P: IsA<gio::File>, Q: Into<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&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<gio::File>, Q: Into<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&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)) }
+        }
+    }
+}

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<ffi::OstreeDeployment>);
+
+    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<String> {
+        unsafe {
+            from_glib_none(ffi::ostree_deployment_unlocked_state_to_string(state.to_glib()))
+        }
+    }
+}
+
+pub trait DeploymentExt {
+    fn clone(&self) -> Option<Deployment>;
+
+    fn equal(&self, bp: &Deployment) -> bool;
+
+    fn get_bootconfig(&self) -> Option<BootconfigParser>;
+
+    fn get_bootcsum(&self) -> Option<String>;
+
+    fn get_bootserial(&self) -> i32;
+
+    fn get_csum(&self) -> Option<String>;
+
+    fn get_deployserial(&self) -> i32;
+
+    fn get_index(&self) -> i32;
+
+    fn get_origin(&self) -> Option<glib::KeyFile>;
+
+    fn get_origin_relpath(&self) -> Option<String>;
+
+    fn get_osname(&self) -> Option<String>;
+
+    #[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<O: IsA<Deployment>> DeploymentExt for O {
+    fn clone(&self) -> Option<Deployment> {
+        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<BootconfigParser> {
+        unsafe {
+            from_glib_none(ffi::ostree_deployment_get_bootconfig(self.to_glib_none().0))
+        }
+    }
+
+    fn get_bootcsum(&self) -> Option<String> {
+        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<String> {
+        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<glib::KeyFile> {
+        unsafe {
+            from_glib_none(ffi::ostree_deployment_get_origin(self.to_glib_none().0))
+        }
+    }
+
+    fn get_origin_relpath(&self) -> Option<String> {
+        unsafe {
+            from_glib_full(ffi::ostree_deployment_get_origin_relpath(self.to_glib_none().0))
+        }
+    }
+
+    fn get_osname(&self) -> Option<String> {
+        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);
+        }
+    }
+}

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<ffi::OstreeDeploymentUnlockedState> 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 {

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<ffi::OstreeSePolicyRestoreconFlags> 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<ffi::OstreeSysrootSimpleWriteDeploymentFlags> 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<ffi::OstreeSysrootUpgraderFlags> 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<Self> {
+        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<ffi::OstreeSysrootUpgraderPullFlags> for SysrootUpgraderPullFlags {
+    fn from_glib(value: ffi::OstreeSysrootUpgraderPullFlags) -> SysrootUpgraderPullFlags {
+        SysrootUpgraderPullFlags::from_bits_truncate(value)
+    }
+}
+

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;
 }

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<ffi::OstreeSysroot>);
+
+    match fn {
+        get_type => || ffi::ostree_sysroot_get_type(),
+    }
+}
+
+impl Sysroot {
+    pub fn new<'a, P: IsA<gio::File> + 'a, Q: Into<Option<&'a P>>>(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<P: IsA<gio::File>>(deployment_path: &P) -> Option<gio::File> {
+        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<Option<&'a gio::Cancellable>>>(&self, cancellable: P) -> Result<(), Error>;
+
+    //#[cfg(any(feature = "v2018_6", feature = "dox"))]
+    //fn cleanup_prune_repo<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, options: /*Ignored*/&mut RepoPruneOptions, cancellable: P) -> Result<(i32, i32, u64), Error>;
+
+    fn deploy_tree<'a, 'b, 'c, 'd, P: Into<Option<&'a str>>, Q: Into<Option<&'b glib::KeyFile>>, R: Into<Option<&'c Deployment>>, S: Into<Option<&'d gio::Cancellable>>>(&self, osname: P, revision: &str, origin: Q, provided_merge_deployment: R, override_kernel_argv: &[&str], cancellable: S) -> Result<Deployment, Error>;
+
+    fn deployment_set_kargs<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, deployment: &Deployment, new_kargs: &[&str], cancellable: P) -> Result<(), Error>;
+
+    fn deployment_set_mutable<'a, P: Into<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&self, deployment: &Deployment, unlocked_state: DeploymentUnlockedState, cancellable: P) -> Result<(), Error>;
+
+    fn ensure_initialized<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, cancellable: P) -> Result<(), Error>;
+
+    fn get_booted_deployment(&self) -> Option<Deployment>;
+
+    fn get_bootversion(&self) -> i32;
+
+    fn get_deployment_directory(&self, deployment: &Deployment) -> Option<gio::File>;
+
+    fn get_deployment_dirpath(&self, deployment: &Deployment) -> Option<String>;
+
+    //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<Option<&'a str>>>(&self, osname: P) -> Option<Deployment>;
+
+    fn get_path(&self) -> Option<gio::File>;
+
+    fn get_repo<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, cancellable: P) -> Result<Repo, Error>;
+
+    #[cfg(any(feature = "v2018_5", feature = "dox"))]
+    fn get_staged_deployment(&self) -> Option<Deployment>;
+
+    fn get_subbootversion(&self) -> i32;
+
+    #[cfg(any(feature = "v2016_4", feature = "dox"))]
+    fn init_osname<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, osname: &str, cancellable: P) -> Result<(), Error>;
+
+    fn load<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, cancellable: P) -> Result<(), Error>;
+
+    #[cfg(any(feature = "v2016_4", feature = "dox"))]
+    fn load_if_changed<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, cancellable: P) -> Result<bool, Error>;
+
+    fn lock(&self) -> Result<(), Error>;
+
+    fn lock_async<'a, P: Into<Option<&'a gio::Cancellable>>, Q: FnOnce(Result<(), Error>) + Send + 'static>(&self, cancellable: P, callback: Q);
+
+    #[cfg(feature = "futures")]
+    fn lock_async_future(&self) -> Box_<futures_core::Future<Item = (Self, ()), Error = (Self, Error)>>;
+
+    fn origin_new_from_refspec(&self, refspec: &str) -> Option<glib::KeyFile>;
+
+    fn prepare_cleanup<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, cancellable: P) -> Result<(), Error>;
+
+    #[cfg(any(feature = "v2017_7", feature = "dox"))]
+    fn query_deployments_for<'a, P: Into<Option<&'a str>>>(&self, osname: P) -> (Deployment, Deployment);
+
+    #[cfg(any(feature = "v2017_7", feature = "dox"))]
+    fn repo(&self) -> Option<Repo>;
+
+    fn simple_write_deployment<'a, 'b, 'c, P: Into<Option<&'a str>>, Q: Into<Option<&'b Deployment>>, R: Into<Option<&'c gio::Cancellable>>>(&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<Option<&'a str>>, Q: Into<Option<&'b glib::KeyFile>>, R: Into<Option<&'c Deployment>>, S: Into<Option<&'d gio::Cancellable>>>(&self, osname: P, revision: &str, origin: Q, merge_deployment: R, override_kernel_argv: &[&str], cancellable: S) -> Result<Deployment, Error>;
+
+    fn try_lock(&self) -> Result<bool, Error>;
+
+    fn unload(&self);
+
+    fn unlock(&self);
+
+    //fn write_deployments<'a, P: Into<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&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<Option<&'a glib::KeyFile>>, Q: Into<Option<&'b gio::Cancellable>>>(&self, deployment: &Deployment, new_origin: P, cancellable: Q) -> Result<(), Error>;
+
+    #[cfg(any(feature = "v2017_10", feature = "dox"))]
+    fn connect_journal_msg<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId;
+}
+
+impl<O: IsA<Sysroot> + IsA<glib::object::Object> + Clone + 'static> SysrootExt for O {
+    fn cleanup<'a, P: Into<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&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<Option<&'a str>>, Q: Into<Option<&'b glib::KeyFile>>, R: Into<Option<&'c Deployment>>, S: Into<Option<&'d gio::Cancellable>>>(&self, osname: P, revision: &str, origin: Q, provided_merge_deployment: R, override_kernel_argv: &[&str], cancellable: S) -> Result<Deployment, Error> {
+        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<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&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<Deployment> {
+        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<gio::File> {
+        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<String> {
+        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<Option<&'a str>>>(&self, osname: P) -> Option<Deployment> {
+        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<gio::File> {
+        unsafe {
+            from_glib_none(ffi::ostree_sysroot_get_path(self.to_glib_none().0))
+        }
+    }
+
+    fn get_repo<'a, P: Into<Option<&'a gio::Cancellable>>>(&self, cancellable: P) -> Result<Repo, Error> {
+        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<Deployment> {
+        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<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&self, cancellable: P) -> Result<bool, Error> {
+        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<Option<&'a gio::Cancellable>>, 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<Q>> = Box::new(Box::new(callback));
+        unsafe extern "C" fn lock_async_trampoline<Q: FnOnce(Result<(), Error>) + 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<Q>> = Box::from_raw(user_data as *mut _);
+            callback(result);
+        }
+        let callback = lock_async_trampoline::<Q>;
+        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_<futures_core::Future<Item = (Self, ()), Error = (Self, Error)>> {
+        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<glib::KeyFile> {
+        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<Option<&'a gio::Cancellable>>>(&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<Option<&'a str>>>(&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<Repo> {
+        unsafe {
+            from_glib_none(ffi::ostree_sysroot_repo(self.to_glib_none().0))
+        }
+    }
+
+    fn simple_write_deployment<'a, 'b, 'c, P: Into<Option<&'a str>>, Q: Into<Option<&'b Deployment>>, R: Into<Option<&'c gio::Cancellable>>>(&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<Option<&'a str>>, Q: Into<Option<&'b glib::KeyFile>>, R: Into<Option<&'c Deployment>>, S: Into<Option<&'d gio::Cancellable>>>(&self, osname: P, revision: &str, origin: Q, merge_deployment: R, override_kernel_argv: &[&str], cancellable: S) -> Result<Deployment, Error> {
+        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<bool, Error> {
+        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<Option<&'a gio::Cancellable>>>(&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<Option<&'a gio::Cancellable>>>(&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<Option<&'a glib::KeyFile>>, Q: Into<Option<&'b gio::Cancellable>>>(&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<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
+        unsafe {
+            let f: Box_<Box_<Fn(&Self, &str) + 'static>> = Box_::new(Box_::new(f));
+            connect(self.to_glib_none().0, "journal-msg",
+                transmute(journal_msg_trampoline::<Self> as usize), Box_::into_raw(f) as *mut _)
+        }
+    }
+}
+
+#[cfg(any(feature = "v2017_10", feature = "dox"))]
+unsafe extern "C" fn journal_msg_trampoline<P>(this: *mut ffi::OstreeSysroot, msg: *mut libc::c_char, f: glib_ffi::gpointer)
+where P: IsA<Sysroot> {
+    let f: &&(Fn(&P, &str) + 'static) = transmute(f);
+    f(&Sysroot::from_glib_borrow(this).downcast_unchecked(), &String::from_glib_none(msg))
+}

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<ffi::OstreeSysrootUpgrader>);
+
+    match fn {
+        get_type => || ffi::ostree_sysroot_upgrader_get_type(),
+    }
+}
+
+impl SysrootUpgrader {
+    pub fn new<'a, P: Into<Option<&'a gio::Cancellable>>>(sysroot: &Sysroot, cancellable: P) -> Result<SysrootUpgrader, Error> {
+        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<Option<&'a str>>, Q: Into<Option<&'b gio::Cancellable>>>(sysroot: &Sysroot, osname: P, cancellable: Q) -> Result<SysrootUpgrader, Error> {
+        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<Option<&'a str>>, Q: Into<Option<&'b gio::Cancellable>>>(sysroot: &Sysroot, osname: P, flags: SysrootUpgraderFlags, cancellable: Q) -> Result<SysrootUpgrader, Error> {
+        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<Option<&'a gio::Cancellable>>>(&self, cancellable: P) -> Result<(), Error>;
+
+    fn dup_origin(&self) -> Option<glib::KeyFile>;
+
+    fn get_origin(&self) -> Option<glib::KeyFile>;
+
+    fn get_origin_description(&self) -> Option<String>;
+
+    fn pull<'a, 'b, P: Into<Option<&'a AsyncProgress>>, Q: Into<Option<&'b gio::Cancellable>>>(&self, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: P, cancellable: Q) -> Result<bool, Error>;
+
+    fn pull_one_dir<'a, 'b, P: Into<Option<&'a AsyncProgress>>, Q: Into<Option<&'b gio::Cancellable>>>(&self, dir_to_pull: &str, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: P, cancellable: Q) -> Result<bool, Error>;
+
+    fn set_origin<'a, 'b, P: Into<Option<&'a glib::KeyFile>>, Q: Into<Option<&'b gio::Cancellable>>>(&self, origin: P, cancellable: Q) -> Result<(), Error>;
+
+    fn get_property_flags(&self) -> SysrootUpgraderFlags;
+
+    fn get_property_osname(&self) -> Option<String>;
+
+    fn get_property_sysroot(&self) -> Option<Sysroot>;
+}
+
+impl<O: IsA<SysrootUpgrader> + IsA<glib::object::Object>> SysrootUpgraderExt for O {
+    fn deploy<'a, P: Into<Option<&'a gio::Cancellable>>>(&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<glib::KeyFile> {
+        unsafe {
+            from_glib_full(ffi::ostree_sysroot_upgrader_dup_origin(self.to_glib_none().0))
+        }
+    }
+
+    fn get_origin(&self) -> Option<glib::KeyFile> {
+        unsafe {
+            from_glib_none(ffi::ostree_sysroot_upgrader_get_origin(self.to_glib_none().0))
+        }
+    }
+
+    fn get_origin_description(&self) -> Option<String> {
+        unsafe {
+            from_glib_full(ffi::ostree_sysroot_upgrader_get_origin_description(self.to_glib_none().0))
+        }
+    }
+
+    fn pull<'a, 'b, P: Into<Option<&'a AsyncProgress>>, Q: Into<Option<&'b gio::Cancellable>>>(&self, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: P, cancellable: Q) -> Result<bool, Error> {
+        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<Option<&'a AsyncProgress>>, Q: Into<Option<&'b gio::Cancellable>>>(&self, dir_to_pull: &str, flags: RepoPullFlags, upgrader_flags: SysrootUpgraderPullFlags, progress: P, cancellable: Q) -> Result<bool, Error> {
+        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<Option<&'a glib::KeyFile>>, Q: Into<Option<&'b gio::Cancellable>>>(&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(<SysrootUpgraderFlags as StaticType>::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<String> {
+        unsafe {
+            let mut value = Value::from_type(<String as StaticType>::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<Sysroot> {
+        unsafe {
+            let mut value = Value::from_type(<Sysroot as StaticType>::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()
+        }
+    }
+}