diff --git a/rust/src/sysroot_upgrade.rs b/rust/src/sysroot_upgrade.rs
index 0985ca38fb..c27c1ac64d 100644
--- a/rust/src/sysroot_upgrade.rs
+++ b/rust/src/sysroot_upgrade.rs
@@ -56,12 +56,20 @@ async fn layer_progress_print(mut r: Receiver<ImportProgress>) {
     }
 }
 
-fn default_container_pull_config() -> Result<ImageProxyConfig> {
+fn default_container_pull_config(imgref: &OstreeImageReference) -> Result<ImageProxyConfig> {
     let mut cfg = ImageProxyConfig::default();
-    let isolation_systemd = crate::utils::running_in_systemd().then(|| "rpm-ostree");
-    let isolation_default = rustix::process::getuid().is_root().then(|| "nobody");
-    let isolation_user = isolation_systemd.or(isolation_default);
-    ostree_container::merge_default_container_proxy_opts_with_isolation(&mut cfg, isolation_user)?;
+    if imgref.imgref.transport == ostree_container::Transport::ContainerStorage {
+        // Fetching from containers-storage, may require privileges to read files
+        ostree_container::merge_default_container_proxy_opts_with_isolation(&mut cfg, None)?;
+    } else {
+        let isolation_systemd = crate::utils::running_in_systemd().then(|| "rpm-ostree");
+        let isolation_default = rustix::process::getuid().is_root().then(|| "nobody");
+        let isolation_user = isolation_systemd.or(isolation_default);
+        ostree_container::merge_default_container_proxy_opts_with_isolation(
+            &mut cfg,
+            isolation_user,
+        )?;
+    }
     Ok(cfg)
 }
 
@@ -70,7 +78,7 @@ async fn pull_container_async(
     imgref: &OstreeImageReference,
 ) -> Result<ContainerImageState> {
     output_message(&format!("Pulling manifest: {}", &imgref));
-    let config = default_container_pull_config()?;
+    let config = default_container_pull_config(imgref)?;
     let mut imp = ImageImporter::new(repo, imgref, config).await?;
     let layer_progress = imp.request_progress();
     let prep = match imp.prepare().await? {
@@ -220,14 +228,15 @@ pub async fn get_container_manifest_diff(
 ) -> Result<String> {
     use ostree_ext::container::ImageReference;
     use ostree_ext::container::ManifestDiff;
-    use ostree_ext::container::OstreeImageReference;
     use ostree_ext::container::SignatureSource;
     use ostree_ext::container::Transport;
-    use ostree_ext::oci_spec::image::ImageManifest;
 
-    let previous_state = ostree_ext::container::store::query_image_ref(&repo, &imgref.imgref)
-        .unwrap()
-        .unwrap();
+    let previous_state =
+        if let Some(r) = ostree_ext::container::store::query_image_ref(&repo, &imgref.imgref)? {
+            r
+        } else {
+            return Ok("".to_string())
+        };
 
     let sigverify = SignatureSource::OstreeRemote(String::from(remote_repo));
     let transport = Transport::Registry;
@@ -239,11 +248,13 @@ pub async fn get_container_manifest_diff(
         sigverify,
         imgref: new_imgref,
     };
-    let manifest = ostree_ext::container::fetch_manifest(&container)
-        .await
-        .unwrap();
+    let (manifest, _) = if let r = ostree_ext::container::fetch_manifest(&container).await? {
+        r
+    } else {
+        return Ok("".to_string())
+    };
 
-    let diff = ManifestDiff::new(&previous_state.manifest, &manifest.0);
+    let diff = ManifestDiff::new(&previous_state.manifest, &manifest);
 
     Ok(diff.export_as_string())
 }
diff --git a/src/app/rpmostree-builtin-upgrade.cxx b/src/app/rpmostree-builtin-upgrade.cxx
index 626880637f..a0fa3f9e63 100644
--- a/src/app/rpmostree-builtin-upgrade.cxx
+++ b/src/app/rpmostree-builtin-upgrade.cxx
@@ -205,14 +205,9 @@ rpmostree_builtin_upgrade (int argc, char **argv, RpmOstreeCommandInvocation *in
       g_print ("Note: --check and --preview may be unreliable.  See "
                "https://github.com/coreos/rpm-ostree/issues/1579\n");
       g_autoptr (GVariant) cached_update = NULL;
-      if (rpmostree_os_get_has_cached_update_rpm_diff (os_proxy))
+      if (rpmostree_os_get_has_cached_update_rpm_diff (os_proxy)) {
         cached_update = rpmostree_os_dup_cached_update (os_proxy);
-
-      gboolean manifest_diff = FALSE;
-      // if (rpmostree_os_get_has_cached_update_manifest_diff (os_proxy)) {
-        manifest_diff = TRUE;
-        cached_update = rpmostree_os_dup_cached_update (os_proxy);
-      // }
+      }
 
       if (!cached_update)
         {
@@ -222,54 +217,9 @@ rpmostree_builtin_upgrade (int argc, char **argv, RpmOstreeCommandInvocation *in
       else
         {
           /* preview --> verbose (i.e. we want the diff) */
-          if (!manifest_diff) {
-            if (!rpmostree_print_cached_update (cached_update, opt_preview, FALSE, cancellable,
-                                              error))
-            return FALSE;
-          }
-          else {
-            std::string test = "total:51,total_size:714.8 MB,total_removed:0,removed_size:0 bytes,total_added:0,added_size:0 bytes";
-            manifest_diff_add_db_diff (test, cancellable, error);
-
-
-
-            glnx_autofd int fd = -1;
-            g_autoptr (GError) local_error = NULL;
-            if (!glnx_openat_rdonly (AT_FDCWD, RPMOSTREE_AUTOUPDATES_CACHE_FILE, TRUE, &fd, &local_error))
-              {
-                if (!g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
-                  return g_propagate_error (error, util::move_nullify (local_error)), FALSE;
-                return TRUE; /* Note early return */
-              }
-
-            /* sanity check there isn't something fishy going on before even reading it in */
-            struct stat stbuf;
-            if (!glnx_fstat (fd, &stbuf, error))
-              return FALSE;
-
-            if (!rpmostree_check_size_within_limit (stbuf.st_size, OSTREE_MAX_METADATA_SIZE,
-                                                    RPMOSTREE_AUTOUPDATES_CACHE_FILE, error))
-              return FALSE;
-
-            g_autoptr (GBytes) data = glnx_fd_readall_bytes (fd, NULL, error);
-            if (!data)
-              return FALSE;
-
-            cached_update
-                = g_variant_ref_sink (g_variant_new_from_bytes (G_VARIANT_TYPE_VARDICT, data, FALSE));
-
-
-
-
-            // cached_update = rpmostree_os_dup_cached_update (os_proxy);
-            if (!rpmostree_print_cached_update_container (cached_update, opt_preview, FALSE, cancellable,
-                                              error))
-            {
-              return FALSE;
-            }
-            
-          }
-          
+          if (!rpmostree_print_cached_update (cached_update, opt_preview, FALSE, cancellable,
+                                            error))
+          return FALSE;
         }
     }
   else if (!opt_reboot)
diff --git a/src/app/rpmostree-clientlib.cxx b/src/app/rpmostree-clientlib.cxx
index 91fce5245c..77bb7e12fc 100644
--- a/src/app/rpmostree-clientlib.cxx
+++ b/src/app/rpmostree-clientlib.cxx
@@ -1243,6 +1243,77 @@ rpmostree_print_diff_advisories (GVariant *rpm_diff, GVariant *advisories, gbool
   return TRUE;
 }
 
+/* print "manifest-diff" */
+gboolean
+rpmostree_print_manifest_diff (GVariant *manifest_diff, guint maxkeylen, GError **error)
+{
+  const gchar *total_str;
+  const gchar *total_size_str;
+  const gchar *total_removed_str;
+  const gchar *removed_size_str;
+  const gchar *total_added_str;
+  const gchar *added_size_str;
+
+  g_auto (GVariantDict) manifest_diff_dict;
+  g_variant_dict_init (&manifest_diff_dict, manifest_diff);
+
+  g_autoptr (GVariant) total
+      = g_variant_dict_lookup_value (&manifest_diff_dict, "total", G_VARIANT_TYPE ("s"));
+  if (!total)
+    return FALSE;
+
+  g_variant_get (total, "s", &total_str);
+  printf ("  %*s%s %s", maxkeylen, "Total layers", strlen ("Total layers") ? ":" : " ", total_str);
+  printf("\n");
+
+  g_autoptr (GVariant) total_size
+      = g_variant_dict_lookup_value (&manifest_diff_dict, "total_size", G_VARIANT_TYPE ("s"));
+  if (!total_size)
+    return FALSE;
+
+  g_variant_get (total_size, "s", &total_size_str);
+  printf ("  %*s%s %s", maxkeylen, "Size", strlen ("Size") ? ":" : " ", total_size_str);
+  printf("\n");
+
+  g_autoptr (GVariant) total_removed
+      = g_variant_dict_lookup_value (&manifest_diff_dict, "total_removed", G_VARIANT_TYPE ("s"));
+  if (!total_removed)
+    return FALSE;
+
+  g_variant_get (total_removed, "s", &total_removed_str);
+  printf (" %*s%s %s", maxkeylen, "Removed layers", strlen ("Removed layers") ? ":" : " ", total_removed_str);
+  printf("\n");
+
+   g_autoptr (GVariant) removed_size
+      = g_variant_dict_lookup_value (&manifest_diff_dict, "removed_size", G_VARIANT_TYPE ("s"));
+  if (!removed_size)
+    return FALSE;
+
+  g_variant_get (removed_size, "s", &removed_size_str);
+  printf ("  %*s%s %s", maxkeylen, "Size", strlen ("Size") ? ":" : " ", removed_size_str);
+  printf("\n");
+
+   g_autoptr (GVariant) total_added
+      = g_variant_dict_lookup_value (&manifest_diff_dict, "total_added", G_VARIANT_TYPE ("s"));
+  if (!total_added)
+    return FALSE;
+
+  g_variant_get (total_added, "s", &total_added_str);
+  printf ("  %*s%s %s", maxkeylen, "Added layers", strlen ("Added layers") ? ":" : " ", total_added_str);
+  printf("\n");
+
+   g_autoptr (GVariant) added_size
+      = g_variant_dict_lookup_value (&manifest_diff_dict, "added_size", G_VARIANT_TYPE ("s"));
+  if (!added_size)
+    return FALSE;
+
+  g_variant_get (added_size, "s", &added_size_str);
+  printf ("  %*s%s %s", maxkeylen, "Size", strlen ("Size") ? ":" : " ", added_size_str);
+  printf("\n");
+
+  return TRUE;
+}
+
 /* this is used by both `status` and `upgrade --check/--preview` */
 gboolean
 rpmostree_print_cached_update (GVariant *cached_update, gboolean verbose,
@@ -1285,6 +1356,9 @@ rpmostree_print_cached_update (GVariant *cached_update, gboolean verbose,
   g_autoptr (GVariant) rpm_diff
       = g_variant_dict_lookup_value (&dict, "rpm-diff", G_VARIANT_TYPE ("a{sv}"));
 
+  g_autoptr (GVariant) manifest_diff
+      = g_variant_dict_lookup_value (&dict, "manifest-diff", G_VARIANT_TYPE ("a{sv}"));
+
   g_autoptr (GVariant) advisories
       = g_variant_dict_lookup_value (&dict, "advisories", G_VARIANT_TYPE ("a(suuasa{sv})"));
 
@@ -1306,128 +1380,14 @@ rpmostree_print_cached_update (GVariant *cached_update, gboolean verbose,
   if (!rpmostree_print_diff_advisories (rpm_diff, advisories, verbose, verbose_advisories,
                                         max_key_len, error))
     return FALSE;
-
-  return TRUE;
-}
-
-gboolean
-rpmostree_print_cached_update_container (GVariant *cached_update, gboolean verbose,
-                               gboolean verbose_advisories, GCancellable *cancellable,
-                               GError **error)
-{
-  GLNX_AUTO_PREFIX_ERROR ("Retrieving cached update", error);
-  g_print("Enter Print Func\n");
-
-  g_auto (GVariantDict) dict;
-  g_variant_dict_init (&dict, cached_update);
-  if (cached_update == NULL)
-    g_print("Failure\n");
-  g_print("Not failure\n");
-
-  /* let's just extract 📤 all the info ahead of time */
-
-  // const char *total;
-  // if (!g_variant_dict_lookup (&dict, "total", "&s", &total))
-  //   return glnx_throw (error, "Missing \"total\" key");
-
-  if (!g_variant_dict_lookup_value (&dict, "manifest-diff", G_VARIANT_TYPE ("a{sv}")))
-    return glnx_throw (error, "Missing \"manifest-diff\" key");
   
-  g_autoptr (GVariant) mainfest_diff
-      = g_variant_dict_lookup_value (&dict, "manifest-diff", G_VARIANT_TYPE ("a{sv}"));
-
-  g_auto (GVariantDict) manifest_diff_dict;
-  g_variant_dict_init (&manifest_diff_dict, mainfest_diff);
-
-  g_autoptr (GVariant) total
-      = g_variant_dict_lookup_value (&manifest_diff_dict, "total", G_VARIANT_TYPE ("s"));
-  if (!total)
+  if (!rpmostree_print_manifest_diff (manifest_diff, max_key_len, error))
     return FALSE;
 
-  const gchar *tmp1;
-  g_variant_get (total, "s", &tmp1);
-  g_print("%s\n", tmp1);
-
-  // g_auto (GVariantDict) dict;
-  // g_variant_dict_init (&dict, cached_update);
-
-  // /* let's just extract 📤 all the info ahead of time */
-
-  // g_autoptr (GVariant) manifest_diff
-  //     = g_variant_dict_lookup_value (&dict, "manifest-diff", G_VARIANT_TYPE ("a{sv}"));
-
-  // g_autoptr (GVariantIter) iter1 = NULL;
-  // g_variant_get (manifest_diff, "a{sv}", &iter1);
-
-  // if (!manifest_diff)
-  //   g_print("WE Failed");
-
-  // const gchar *key;
-  // const gchar *value;
-  // while (g_variant_iter_loop (iter1, "{sv}", &key, &value))
-  //   {
-  //     g_print("%s", key);
-    // }
-
-  // g_auto (GVariantDict) rpm_diff_dict;
-  // g_variant_dict_init (&rpm_diff_dict, rpm_diff);
-
-  // g_autoptr (GVariant) total
-  //     = g_variant_dict_lookup_value (manifest_diff, "total", G_VARIANT_TYPE ("s"));
-  // if (!total) {
-  //   g_print("WE Failed");
-  //   return FALSE;
-  // }
-
-  // g_autoptr (GVariant) total_size = _rpmostree_vardict_lookup_value_required (
-  //     &rpm_diff_dict, "total_size", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
-  // if (!total_size)
-  //   return FALSE;
-
-  // g_autoptr (GVariant) total_removed = _rpmostree_vardict_lookup_value_required (
-  //     &rpm_diff_dict, "total_removed", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
-  // if (!total_removed)
-  //   return FALSE;
-
-  // g_autoptr (GVariant) removed_size = _rpmostree_vardict_lookup_value_required (
-  //     &rpm_diff_dict, "removed_size", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
-  // if (!removed_size)
-  //   return FALSE;
-
-  // g_autoptr (GVariant) total_added = _rpmostree_vardict_lookup_value_required (
-  //     &rpm_diff_dict, "total_added", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
-  // if (!total_added)
-  //   return FALSE;
-
-  // g_autoptr (GVariant) added_size = _rpmostree_vardict_lookup_value_required (
-  //     &rpm_diff_dict, "added_size", RPMOSTREE_DIFF_MODIFIED_GVARIANT_FORMAT, error);
-  // if (!added_size)
-  //   return FALSE;
-
-  // const gchar *tmp1;
-  // const gchar *tmp2;
-  // const gchar *tmp3;
-  // const gchar *tmp4;
-  // const gchar *tmp5;
-  // const gchar *tmp6;
-
-  // g_variant_get (total, "s", &tmp1);
-  // g_variant_get (total_size, "s", &tmp2);
-  // g_variant_get (total_removed, "s", &tmp3);
-  // g_variant_get (removed_size, "s", &tmp4);
-  // g_variant_get (total_added, "s", &tmp5);
-  // g_variant_get (added_size, "s", &tmp6);
-
-  // g_print("%s", tmp1);
-  // g_print("%s", tmp2);
-  // g_print("%s", tmp3);
-  // g_print("%s", tmp4);
-  // g_print("%s", tmp5);
-  // g_print("%s", tmp6);
-
   return TRUE;
 }
 
+
 /* Query systemd for systemd unit's object path using method_name provided with
  * parameters. The reply_type of method_name must be G_VARIANT_TYPE_TUPLE. */
 gboolean
diff --git a/src/app/rpmostree-clientlib.h b/src/app/rpmostree-clientlib.h
index 08d7a2a5f0..a47e672d62 100644
--- a/src/app/rpmostree-clientlib.h
+++ b/src/app/rpmostree-clientlib.h
@@ -111,11 +111,9 @@ gboolean rpmostree_print_diff_advisories (GVariant *rpm_diff, GVariant *advisori
                                           gboolean verbose, gboolean verbose_advisories,
                                           guint max_key_len, GError **error);
 
-gboolean rpmostree_print_cached_update (GVariant *cached_update, gboolean verbose,
-                                        gboolean verbose_advisories, GCancellable *cancellable,
-                                        GError **error);
+gboolean rpmostree_print_manifest_diff (GVariant *manifest_diff, guint maxkeylen, GError **error);
 
-gboolean rpmostree_print_cached_update_container (GVariant *cached_update, gboolean verbose,
+gboolean rpmostree_print_cached_update (GVariant *cached_update, gboolean verbose,
                                         gboolean verbose_advisories, GCancellable *cancellable,
                                         GError **error);
 
diff --git a/src/daemon/org.projectatomic.rpmostree1.xml b/src/daemon/org.projectatomic.rpmostree1.xml
index efd61cca71..b11ff5dfd2 100644
--- a/src/daemon/org.projectatomic.rpmostree1.xml
+++ b/src/daemon/org.projectatomic.rpmostree1.xml
@@ -106,7 +106,6 @@
       <annotation name="org.qtproject.QtDBus.QtTypeName" value="QVariantMap"/>
     </property>
     <property name="HasCachedUpdateRpmDiff" type="b" access="read"/>
-    <property name="HasCachedUpdateManifestDiff" type="b" access="read"/>
 
     <!-- Available options:
          "mode" (type 's')
diff --git a/src/daemon/rpmostree-sysroot-upgrader.cxx b/src/daemon/rpmostree-sysroot-upgrader.cxx
index 55cfb6ac20..ac666b0b03 100644
--- a/src/daemon/rpmostree-sysroot-upgrader.cxx
+++ b/src/daemon/rpmostree-sysroot-upgrader.cxx
@@ -401,167 +401,167 @@ rpmostree_sysroot_upgrader_get_sack (RpmOstreeSysrootUpgrader *self, GError **er
   return self->rpmmd_sack;
 }
 
-#include <iostream>
-#include <fstream>
-#include <rpmostreed-os.cxx>
-
-gboolean
-rpm_ostree_db_diff_ext_container (gchar* manifest_diff, GVariant **total,
-                        GVariant **total_size, GVariant **total_removed,
-                        GVariant **removed_size, GVariant **total_added,
-                        GVariant **added_size, GError **error)
-{
-  char *end_str;
-  char *outer_token = strtok_r(manifest_diff, ",", &end_str);
-
-  while (outer_token != NULL) {
-      char *end_token;
-      char *inner_token = strtok_r(outer_token, ":", &end_token);
-
-      while (inner_token != NULL) {
-
-        if (!strcmp(inner_token, "total")) {
-          inner_token = strtok_r(NULL, ":", &end_token);
-          *total = g_variant_new("s", inner_token);
-        }
-        else if (!strcmp(inner_token, "total_size")) {
-          inner_token = strtok_r(NULL, ":", &end_token);
-          *total_size = g_variant_new("s", inner_token);
-        }
-        else if (!strcmp(inner_token, "total_removed")) {
-          inner_token = strtok_r(NULL, ":", &end_token);
-          *total_removed = g_variant_new("s", inner_token);
-        }
-        else if (!strcmp(inner_token, "removed_size")) {
-          inner_token = strtok_r(NULL, ":", &end_token);
-          *removed_size = g_variant_new("s", inner_token);
-        }
-        else if (!strcmp(inner_token, "total_added")) {
-          inner_token = strtok_r(NULL, ":", &end_token);
-          *total_added = g_variant_new("s", inner_token);
-        }
-        else if (!strcmp(inner_token, "added_size")) {
-          inner_token = strtok_r(NULL, ":", &end_token);
-          *added_size = g_variant_new("s", inner_token);
-        }
-        inner_token = strtok_r(NULL, ":", &end_token);
-      }
-      outer_token = strtok_r(NULL, ",", &end_str);
-  }
-
-  if (*total == NULL || *total_size == NULL || *total_removed == NULL || *removed_size == NULL || *total_added == NULL || *added_size == NULL) {
-    return FALSE;
-  }
-  return TRUE;
-}
-
-static gboolean
-manifest_diff_add_db_diff (std::string manifest_diff, GCancellable *cancellable, GError **error)
-{
-
-  g_autoptr (GVariant) total = NULL;
-  g_autoptr (GVariant) total_size = NULL;
-  g_autoptr (GVariant) total_removed = NULL;
-  g_autoptr (GVariant) removed_size = NULL;
-  g_autoptr (GVariant) total_added = NULL;
-  g_autoptr (GVariant) added_size = NULL;
+// #include <iostream>
+// #include <fstream>
+// #include <rpmostreed-os.cxx>
+
+// gboolean
+// rpm_ostree_db_diff_ext_container (gchar* manifest_diff, GVariant **total,
+//                         GVariant **total_size, GVariant **total_removed,
+//                         GVariant **removed_size, GVariant **total_added,
+//                         GVariant **added_size, GError **error)
+// {
+//   char *end_str;
+//   char *outer_token = strtok_r(manifest_diff, ",", &end_str);
+
+//   while (outer_token != NULL) {
+//       char *end_token;
+//       char *inner_token = strtok_r(outer_token, ":", &end_token);
+
+//       while (inner_token != NULL) {
+
+//         if (!strcmp(inner_token, "total")) {
+//           inner_token = strtok_r(NULL, ":", &end_token);
+//           *total = g_variant_new("s", inner_token);
+//         }
+//         else if (!strcmp(inner_token, "total_size")) {
+//           inner_token = strtok_r(NULL, ":", &end_token);
+//           *total_size = g_variant_new("s", inner_token);
+//         }
+//         else if (!strcmp(inner_token, "total_removed")) {
+//           inner_token = strtok_r(NULL, ":", &end_token);
+//           *total_removed = g_variant_new("s", inner_token);
+//         }
+//         else if (!strcmp(inner_token, "removed_size")) {
+//           inner_token = strtok_r(NULL, ":", &end_token);
+//           *removed_size = g_variant_new("s", inner_token);
+//         }
+//         else if (!strcmp(inner_token, "total_added")) {
+//           inner_token = strtok_r(NULL, ":", &end_token);
+//           *total_added = g_variant_new("s", inner_token);
+//         }
+//         else if (!strcmp(inner_token, "added_size")) {
+//           inner_token = strtok_r(NULL, ":", &end_token);
+//           *added_size = g_variant_new("s", inner_token);
+//         }
+//         inner_token = strtok_r(NULL, ":", &end_token);
+//       }
+//       outer_token = strtok_r(NULL, ",", &end_str);
+//   }
+
+//   if (*total == NULL || *total_size == NULL || *total_removed == NULL || *removed_size == NULL || *total_added == NULL || *added_size == NULL) {
+//     return FALSE;
+//   }
+//   return TRUE;
+// }
+
+// static gboolean
+// manifest_diff_add_db_diff (std::string manifest_diff, GCancellable *cancellable, GError **error)
+// {
+
+//   g_autoptr (GVariant) total = NULL;
+//   g_autoptr (GVariant) total_size = NULL;
+//   g_autoptr (GVariant) total_removed = NULL;
+//   g_autoptr (GVariant) removed_size = NULL;
+//   g_autoptr (GVariant) total_added = NULL;
+//   g_autoptr (GVariant) added_size = NULL;
   
-  rpmostree_output_message ("Before copy");
-  gchar *converted_manifest_diff = strcpy(new char[manifest_diff.length() + 1], manifest_diff.c_str());
-  // manifest_diff = "total:51,total_size:714.8 MB,total_removed:0,removed_size:0 bytes,total_added:0,added_size:0 bytes";
-  rpmostree_output_message ("Before pop");
-  if (!rpm_ostree_db_diff_ext_container (converted_manifest_diff, &total, &total_size,
-                              &total_removed, &removed_size, &total_added, &added_size, error))
-    return FALSE;
+//   rpmostree_output_message ("Before copy");
+//   gchar *converted_manifest_diff = strcpy(new char[manifest_diff.length() + 1], manifest_diff.c_str());
+//   // manifest_diff = "total:51,total_size:714.8 MB,total_removed:0,removed_size:0 bytes,total_added:0,added_size:0 bytes";
+//   rpmostree_output_message ("Before pop");
+//   if (!rpm_ostree_db_diff_ext_container (converted_manifest_diff, &total, &total_size,
+//                               &total_removed, &removed_size, &total_added, &added_size, error))
+//     return FALSE;
   
-  rpmostree_output_message ("After pop");
-
-  const gchar *tmp1;
-  const gchar *tmp2;
-  const gchar *tmp3;
-  const gchar *tmp4;
-  const gchar *tmp5;
-  const gchar *tmp6;
-
-
-  g_variant_get (total, "s", &tmp1);
-  rpmostree_output_message ("%s", tmp1);
-  g_variant_get (total_size, "s", &tmp2);
-  rpmostree_output_message ("%s", tmp2);
-  g_variant_get (total_removed, "s", &tmp3);
-  rpmostree_output_message ("%s", tmp3);
-  g_variant_get (removed_size, "s", &tmp4);
-  rpmostree_output_message ("%s", tmp4);
-  g_variant_get (total_added, "s", &tmp5);
-  rpmostree_output_message ("%s", tmp5);
-  g_variant_get (added_size, "s", &tmp6);
-  rpmostree_output_message ("%s", tmp6);
-
-  rpmostree_output_message ("Before dict pop");
-  g_auto (GVariantDict) manifest_dict;
-  g_variant_dict_init (&manifest_dict, NULL);
-  g_variant_dict_insert (&manifest_dict, "total", "s", tmp1);
-  g_variant_dict_insert (&manifest_dict, "total_size", "s", tmp2);
-  g_variant_dict_insert (&manifest_dict, "total_removed", "s", tmp3);
-  g_variant_dict_insert (&manifest_dict, "removed_size", "s", tmp4);
-  g_variant_dict_insert (&manifest_dict, "total_added", "s", tmp5);
-  g_variant_dict_insert (&manifest_dict, "added_size", "s", tmp6);
-
-  rpmostree_output_message ("After dict pop");
-
-
-  // rpmostree_output_message ("Empty dict initialized");
-  // g_auto (GVariantBuilder) manifest_diff_dict;
-  // g_variant_builder_init (&manifest_diff_dict, G_VARIANT_TYPE ("{sv}"));
-
-  // g_variant_builder_add (&manifest_diff_dict, "{sv}", "total", total);
-  // rpmostree_output_message ("Add total to builder");
-  // g_variant_builder_add (&manifest_diff_dict, "{sv}", "total_size", total_size);
-  // rpmostree_output_message ("Add total_size to builder");
-  // g_variant_builder_add (&manifest_diff_dict, "{sv}", "total_removed", total_removed);
-  // rpmostree_output_message ("Add total_removed to builder");
-  // g_variant_builder_add (&manifest_diff_dict, "{sv}", "removed_size", removed_size);
-  // rpmostree_output_message ("Add removed_size to builder");
-  // g_variant_builder_add (&manifest_diff_dict, "{sv}", "total_added", total_added);
-  // rpmostree_output_message ("Add total_added to builder");
-  // g_variant_builder_add (&manifest_diff_dict, "{sv}", "added_size", added_size);
-  // rpmostree_output_message ("Add added_size to builder");
-  // rpmostree_output_message ("Dict created");
-  // g_variant_builder_unref(manifest_diff_dict);
-
-  g_auto (GVariantDict) dict;
-  g_variant_dict_init (&dict, NULL);
-  g_variant_dict_insert (&dict, "manifest-diff", "@a{sv}", g_variant_dict_end (&manifest_dict));
-
-  g_autoptr (GVariant) update = NULL;
-  update = g_variant_ref_sink (g_variant_dict_end (&dict));
-
-  if (update != NULL)
-    {
-      rpmostree_output_message ("Update not NULL");
-      if (!glnx_file_replace_contents_at (AT_FDCWD, RPMOSTREE_AUTOUPDATES_CACHE_FILE,
-                                          static_cast<const guint8 *> (g_variant_get_data (update)),
-                                          g_variant_get_size (update),
-                                          static_cast<GLnxFileReplaceFlags> (0), cancellable,
-                                          error))
-        return FALSE;
-    }
-
-  rpmostree_output_message ("before file check");
-  std::ifstream infile("/var/cache/rpm-ostree/cached-update.gv");
-  rpmostree_output_message ("%d", infile.good());
-  // rpmoZ
-  // g_variant_builder_unref(manifest_diff_dict);
+//   rpmostree_output_message ("After pop");
+
+//   const gchar *tmp1;
+//   const gchar *tmp2;
+//   const gchar *tmp3;
+//   const gchar *tmp4;
+//   const gchar *tmp5;
+//   const gchar *tmp6;
+
+
+//   g_variant_get (total, "s", &tmp1);
+//   rpmostree_output_message ("%s", tmp1);
+//   g_variant_get (total_size, "s", &tmp2);
+//   rpmostree_output_message ("%s", tmp2);
+//   g_variant_get (total_removed, "s", &tmp3);
+//   rpmostree_output_message ("%s", tmp3);
+//   g_variant_get (removed_size, "s", &tmp4);
+//   rpmostree_output_message ("%s", tmp4);
+//   g_variant_get (total_added, "s", &tmp5);
+//   rpmostree_output_message ("%s", tmp5);
+//   g_variant_get (added_size, "s", &tmp6);
+//   rpmostree_output_message ("%s", tmp6);
+
+//   rpmostree_output_message ("Before dict pop");
+//   g_auto (GVariantDict) manifest_dict;
+//   g_variant_dict_init (&manifest_dict, NULL);
+//   g_variant_dict_insert (&manifest_dict, "total", "s", tmp1);
+//   g_variant_dict_insert (&manifest_dict, "total_size", "s", tmp2);
+//   g_variant_dict_insert (&manifest_dict, "total_removed", "s", tmp3);
+//   g_variant_dict_insert (&manifest_dict, "removed_size", "s", tmp4);
+//   g_variant_dict_insert (&manifest_dict, "total_added", "s", tmp5);
+//   g_variant_dict_insert (&manifest_dict, "added_size", "s", tmp6);
+
+//   rpmostree_output_message ("After dict pop");
+
+
+//   // rpmostree_output_message ("Empty dict initialized");
+//   // g_auto (GVariantBuilder) manifest_diff_dict;
+//   // g_variant_builder_init (&manifest_diff_dict, G_VARIANT_TYPE ("{sv}"));
+
+//   // g_variant_builder_add (&manifest_diff_dict, "{sv}", "total", total);
+//   // rpmostree_output_message ("Add total to builder");
+//   // g_variant_builder_add (&manifest_diff_dict, "{sv}", "total_size", total_size);
+//   // rpmostree_output_message ("Add total_size to builder");
+//   // g_variant_builder_add (&manifest_diff_dict, "{sv}", "total_removed", total_removed);
+//   // rpmostree_output_message ("Add total_removed to builder");
+//   // g_variant_builder_add (&manifest_diff_dict, "{sv}", "removed_size", removed_size);
+//   // rpmostree_output_message ("Add removed_size to builder");
+//   // g_variant_builder_add (&manifest_diff_dict, "{sv}", "total_added", total_added);
+//   // rpmostree_output_message ("Add total_added to builder");
+//   // g_variant_builder_add (&manifest_diff_dict, "{sv}", "added_size", added_size);
+//   // rpmostree_output_message ("Add added_size to builder");
+//   // rpmostree_output_message ("Dict created");
+//   // g_variant_builder_unref(manifest_diff_dict);
+
+//   g_auto (GVariantDict) dict;
+//   g_variant_dict_init (&dict, NULL);
+//   g_variant_dict_insert (&dict, "manifest-diff", "@a{sv}", g_variant_dict_end (&manifest_dict));
+
+//   g_autoptr (GVariant) update = NULL;
+//   update = g_variant_ref_sink (g_variant_dict_end (&dict));
+
+//   if (update != NULL)
+//     {
+//       rpmostree_output_message ("Update not NULL");
+//       if (!glnx_file_replace_contents_at (AT_FDCWD, RPMOSTREE_AUTOUPDATES_CACHE_FILE,
+//                                           static_cast<const guint8 *> (g_variant_get_data (update)),
+//                                           g_variant_get_size (update),
+//                                           static_cast<GLnxFileReplaceFlags> (0), cancellable,
+//                                           error))
+//         return FALSE;
+//     }
+
+//   rpmostree_output_message ("before file check");
+//   std::ifstream infile("/var/cache/rpm-ostree/cached-update.gv");
+//   rpmostree_output_message ("%d", infile.good());
+//   // rpmoZ
+//   // g_variant_builder_unref(manifest_diff_dict);
         
-  rpmostree_output_message ("Cache file updated");
-  // diff->total = total;
-  // diff->total_size = total_size;
-  // diff->total_removed = total_removed;
-  // diff->removed_size = removed_size;
-  // diff->total_added = total_added;
-  // diff->added_size = added_size;
-  return TRUE;
-}
+//   rpmostree_output_message ("Cache file updated");
+//   // diff->total = total;
+//   // diff->total_size = total_size;
+//   // diff->total_removed = total_removed;
+//   // diff->removed_size = removed_size;
+//   // diff->total_added = total_added;
+//   // diff->added_size = added_size;
+//   return TRUE;
+// }
 
 
 
@@ -600,6 +600,10 @@ rpmostree_sysroot_upgrader_pull_base (RpmOstreeSysrootUpgrader *self, const char
 
         if (check)
           {
+            // the use of this function might just be a red hearing, because it might have only
+            // been introduced to output the error message. Potential next step, just update
+            // all the cached update (existing and with the new manifest-diff) and the `check`
+            // part will just be on the builtin-upgrade side
             g_autofree char *origin_remote = NULL;
             g_autofree char *origin_ref = NULL;
             if (!ostree_parse_refspec (r.refspec.c_str (), &origin_remote, &origin_ref, error))
@@ -612,9 +616,10 @@ rpmostree_sysroot_upgrader_pull_base (RpmOstreeSysrootUpgrader *self, const char
                 error);
 
             rpmostree_output_message ("%s", res.c_str ());
-            manifest_diff_add_db_diff (res.c_str (), cancellable, error);
+            // manifest_diff_add_db_diff (res.c_str (), cancellable, error);
+
+            // rpmostree_output_message ("%s", self->osname);
 
-            rpmostree_output_message ("%s", self->osname);
             // auto obj = (RpmostreedOS *)g_object_new (RPMOSTREED_TYPE_OS, "name", self->osname, NULL);
             // g_autoptr (GError) local_error = NULL;
             // if (!refresh_cached_update (obj, &local_error))
diff --git a/src/daemon/rpmostreed-deployment-utils.cxx b/src/daemon/rpmostreed-deployment-utils.cxx
index 4848050942..50ba789297 100644
--- a/src/daemon/rpmostreed-deployment-utils.cxx
+++ b/src/daemon/rpmostreed-deployment-utils.cxx
@@ -399,6 +399,46 @@ rpm_diff_clear (RpmDiff *diff)
 
 G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (RpmDiff, rpm_diff_clear);
 
+typedef struct
+{
+  gboolean initialized;
+  GVariant *total;
+  GVariant *total_size;
+  GVariant *total_removed;
+  GVariant *removed_size;
+  GVariant *total_added;
+  GVariant *added_size;
+} ManifestDiff;
+
+static void
+manifest_diff_init (ManifestDiff *diff)
+{
+  g_assert (!diff->initialized);
+  diff->total = g_variant_new ("s", "");
+  diff->total_size = g_variant_new ("s", "");
+  diff->total_removed = g_variant_new ("s", "");
+  diff->removed_size = g_variant_new ("s", "");
+  diff->total_added = g_variant_new ("s", "");
+  diff->added_size = g_variant_new ("s", "");
+  diff->initialized = TRUE;
+}
+
+static void
+manifest_diff_clear (ManifestDiff *diff)
+{
+  if (!diff->initialized)
+    return;
+  g_variant_ref(diff->total);
+  g_variant_ref(diff->total_size);
+  g_variant_ref(diff->total_removed);
+  g_variant_ref(diff->removed_size);
+  g_variant_ref(diff->total_added);
+  g_variant_ref(diff->added_size);
+  diff->initialized = FALSE;
+}
+
+G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (ManifestDiff, manifest_diff_clear);
+
 static GVariant *
 single_pkg_variant_new (RpmOstreePkgTypes type, RpmOstreePackage *pkg)
 {
@@ -474,6 +514,25 @@ rpm_diff_add_db_diff (RpmDiff *diff, OstreeRepo *repo, RpmOstreePkgTypes type,
   return TRUE;
 }
 
+#include <iostream>
+#include <fstream>
+
+static gboolean
+manifest_diff_add_db_diff (ManifestDiff *diff, std::string manifest_diff, GCancellable *cancellable, GError **error)
+{
+  rpmostree_output_message ("Before copy");
+  gchar *converted_manifest_diff = strcpy(new char[manifest_diff.length() + 1], manifest_diff.c_str());
+  // manifest_diff = "total:51,total_size:714.8 MB,total_removed:0,removed_size:0 bytes,total_added:0,added_size:0 bytes";
+  rpmostree_output_message ("Before pop");
+  if (!rpm_ostree_db_diff_ext_container (converted_manifest_diff, &diff->total, &diff->total_size,
+                              &diff->total_removed, &diff->removed_size, &diff->total_added, &diff->added_size, error))
+    return FALSE;
+  
+  rpmostree_output_message ("After pop");
+
+  return TRUE;
+}
+
 static void
 rpm_diff_add_layered_diff (RpmDiff *diff, RpmOstreePackage *old_pkg, DnfPackage *new_pkg)
 {
@@ -519,6 +578,25 @@ rpm_diff_is_empty (RpmDiff *diff)
   return !diff->upgraded->len && !diff->downgraded->len && !diff->removed->len && !diff->added->len;
 }
 
+static gboolean
+manifest_diff_is_empty (ManifestDiff *diff)
+{
+  g_assert (diff->initialized);
+  const gchar *added;
+  const gchar *removed;
+  g_variant_get (diff->total_removed, "s", &removed);
+  g_variant_get (diff->total_added, "s", &added);
+  rpmostree_output_message ("%s", removed);
+  rpmostree_output_message ("%s", added);
+
+  if (!strcmp(removed, "0") && !strcmp(added, "0")) {
+    rpmostree_output_message ("hello");
+    return TRUE;
+  }
+
+  return !diff->total && !diff->total_size && !diff->total_removed && !diff->removed_size && !diff->total_added && !diff->added_size;
+}
+
 static GVariant *
 rpm_diff_variant_new (RpmDiff *diff)
 {
@@ -539,6 +617,41 @@ rpm_diff_variant_new (RpmDiff *diff)
   return g_variant_dict_end (&dict);
 }
 
+static GVariant *
+manifest_diff_variant_new (ManifestDiff *diff)
+{
+  const gchar *tmp1;
+  const gchar *tmp2;
+  const gchar *tmp3;
+  const gchar *tmp4;
+  const gchar *tmp5;
+  const gchar *tmp6;
+
+  g_variant_get (diff->total, "s", &tmp1);
+  rpmostree_output_message ("%s", tmp1);
+  g_variant_get (diff->total_size, "s", &tmp2);
+  rpmostree_output_message ("%s", tmp2);
+  g_variant_get (diff->total_removed, "s", &tmp3);
+  rpmostree_output_message ("%s", tmp3);
+  g_variant_get (diff->removed_size, "s", &tmp4);
+  rpmostree_output_message ("%s", tmp4);
+  g_variant_get (diff->total_added, "s", &tmp5);
+  rpmostree_output_message ("%s", tmp5);
+  g_variant_get (diff->added_size, "s", &tmp6);
+  rpmostree_output_message ("%s", tmp6);
+
+  g_auto (GVariantDict) manifest_dict;
+  g_variant_dict_init (&manifest_dict, NULL);
+  g_variant_dict_insert (&manifest_dict, "total", "s", tmp1);
+  g_variant_dict_insert (&manifest_dict, "total_size", "s", tmp2);
+  g_variant_dict_insert (&manifest_dict, "total_removed", "s", tmp3);
+  g_variant_dict_insert (&manifest_dict, "removed_size", "s", tmp4);
+  g_variant_dict_insert (&manifest_dict, "total_added", "s", tmp5);
+  g_variant_dict_insert (&manifest_dict, "added_size", "s", tmp6);
+
+  return g_variant_dict_end (&manifest_dict);
+}
+
 static DnfPackage *
 find_package (DnfSack *sack, gboolean newer, RpmOstreePackage *pkg)
 {
@@ -667,6 +780,7 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
   /* let's start with the ostree side of things */
 
   const char *current_checksum = ostree_deployment_get_csum (booted_deployment);
+  rpmostree_output_message("Current check sum: %s", current_checksum);
   g_autofree char *current_base_checksum_owned = NULL;
   if (!rpmostree_deployment_get_base_layer (repo, booted_deployment, &current_base_checksum_owned,
                                             error))
@@ -687,10 +801,30 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
     }
   else
     {
+      // resolve refspec does not work for containers, so in this case, we need to make our own function to return the new_base_checksum
+      rpmostree_output_message("Not staged");
       if (!ostree_repo_resolve_rev_ext (repo, r.refspec.c_str (), TRUE,
                                         static_cast<OstreeRepoResolveRevExtFlags> (0),
                                         &new_base_checksum_owned, error))
-        return FALSE;
+        {
+          rpmostree_output_message("No ostree checksum");
+          return FALSE;
+        }
+
+      // if (new_base_checksum == NULL) {
+      //   const OstreeRepo &tmp_repo = *repo;
+      //   const GCancellable &tmp_cancellable = *cancellable;
+      //   CXX_TRY_VAR (
+      //         import,
+      //         rpmostreecxx::pull_container (tmp_repo, tmp_cancellable, r.refspec.c_str ()),
+      //         error);
+
+      //   rpmostree_output_message("Before container checksum");
+      //   new_base_checksum_owned = g_strdup (import->merge_commit.c_str ());
+      //   rpmostree_output_message("new_base_checksum_owned: %s", new_base_checksum_owned);
+      // }
+
+      // rpmostree_output_message("Exit ostree checksum");
       new_base_checksum = new_base_checksum_owned;
       /* just assume that the hypothetical new deployment would also be layered if we are */
       is_new_layered = (current_base_checksum_owned != NULL);
@@ -725,6 +859,11 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
   };
   rpm_diff_init (&rpm_diff);
 
+  g_auto (ManifestDiff) manifest_diff = {
+    0,
+  };
+  manifest_diff_init (&manifest_diff);
+
   /* we'll need these later for advisories, so just keep them around */
   g_autoptr (GPtrArray) ostree_modified_new = NULL;
   g_autoptr (GPtrArray) rpmmd_modified_new = NULL;
@@ -744,13 +883,50 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
        *  - if a new base checksum was pulled, do a db diff of the old and new bases
        *  - if there are currently any layered pkgs, lookup in sack for newer versions
        */
+      gboolean rpm_diff_fail = FALSE;
       if (is_new_checksum)
         {
+          rpmostree_output_message("is_new_checksum");
+
           if (!rpm_diff_add_db_diff (&rpm_diff, repo, RPM_OSTREE_PKG_TYPE_BASE,
                                      current_base_checksum, new_base_checksum, &ostree_modified_new,
                                      cancellable, error))
-            return FALSE;
+            {
+              rpmostree_output_message("rpm diff failed");
+              rpm_diff_fail = TRUE;
+            }
         }
+      rpmostree_output_message("exit new checksum check");
+
+      const OstreeRepo &tmp_repo = *repo;
+      const GCancellable &tmp_cancellable = *cancellable;
+
+      g_autofree char *origin_remote = NULL;
+      g_autofree char *origin_ref = NULL;
+      if (!ostree_parse_refspec (r.refspec.c_str (), &origin_remote, &origin_ref, error))
+        return FALSE;
+
+      CXX_TRY_VAR (
+            res,
+            rpmostreecxx::compare_local_to_remote_container (
+                tmp_repo, tmp_cancellable, r.refspec.c_str (), origin_remote, origin_ref),
+            error);
+
+      rpmostree_output_message("%s", origin_remote);
+      rpmostree_output_message("%s", origin_ref);
+      rpmostree_output_message("%s", res.c_str());
+
+      gboolean manifest_diff_fail = FALSE;
+
+      if (!manifest_diff_add_db_diff (&manifest_diff, res.c_str (), cancellable, error)) {
+        rpmostree_output_message("manifest diff failed");
+        manifest_diff_fail = TRUE;
+      }
+
+      if (rpm_diff_fail && manifest_diff_fail) {
+        rpmostree_output_message("both updates failed");
+        return FALSE;
+      }
 
       /* now we look at the rpm-md/layering side */
 
@@ -767,6 +943,15 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
   if (!rpm_diff_is_empty (&rpm_diff))
     g_variant_dict_insert (dict, "rpm-diff", "@a{sv}", rpm_diff_variant_new (&rpm_diff));
 
+  gboolean check_container_manifest_diff = FALSE;
+  if (!manifest_diff_is_empty (&manifest_diff)) {
+    // if (!is_new_checksum) {
+      // g_variant_dict_insert (dict, "update-sha256", "s", "container_update_check_case");
+      g_variant_dict_insert (dict, "manifest-diff", "@a{sv}", manifest_diff_variant_new (&manifest_diff));
+      check_container_manifest_diff = TRUE;
+    // }
+  }
+
   /* now we look for advisories */
 
   if (sack && (ostree_modified_new || rpmmd_modified_new))
@@ -802,7 +987,7 @@ rpmostreed_update_generate_variant (OstreeDeployment *booted_deployment,
     }
 
   /* but if there are no updates, then just ditch the whole thing and return NULL */
-  if (is_new_checksum || rpmmd_modified_new)
+  if (is_new_checksum || rpmmd_modified_new || check_container_manifest_diff)
     {
       /* include a "state" checksum for cache invalidation; for now this is just the
        * checksum of the deployment against which we ran, though we could base it off more
diff --git a/src/daemon/rpmostreed-os.cxx b/src/daemon/rpmostreed-os.cxx
index 6c1dabe3f9..090c2dfd13 100644
--- a/src/daemon/rpmostreed-os.cxx
+++ b/src/daemon/rpmostreed-os.cxx
@@ -1730,7 +1730,6 @@ refresh_cached_update (RpmostreedOS *self, GError **error)
 
   rpmostree_os_set_cached_update (RPMOSTREE_OS (self), cached_update);
   rpmostree_os_set_has_cached_update_rpm_diff (RPMOSTREE_OS (self), cached_update != NULL);
-  rpmostree_os_set_has_cached_update_manifest_diff (RPMOSTREE_OS (self), cached_update != NULL);
   return TRUE;
 }
 
diff --git a/src/lib/rpmostree-db.c b/src/lib/rpmostree-db.c
index d9ceb74970..e986398e5b 100644
--- a/src/lib/rpmostree-db.c
+++ b/src/lib/rpmostree-db.c
@@ -155,3 +155,53 @@ rpm_ostree_db_diff_ext (OstreeRepo *repo, const char *orig_ref, const char *new_
   return _rpm_ostree_diff_package_lists (orig_pkglist, new_pkglist, out_removed, out_added,
                                          out_modified_old, out_modified_new, NULL);
 }
+
+gboolean
+rpm_ostree_db_diff_ext_container (gchar* manifest_diff, GVariant **total,
+                        GVariant **total_size, GVariant **total_removed,
+                        GVariant **removed_size, GVariant **total_added,
+                        GVariant **added_size, GError **error)
+{
+  char *end_str;
+  char *outer_token = strtok_r(manifest_diff, ",", &end_str);
+
+  while (outer_token != NULL) {
+      char *end_token;
+      char *inner_token = strtok_r(outer_token, ":", &end_token);
+
+      while (inner_token != NULL) {
+
+        if (!strcmp(inner_token, "total")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *total = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "total_size")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *total_size = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "total_removed")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *total_removed = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "removed_size")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *removed_size = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "total_added")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *total_added = g_variant_new("s", inner_token);
+        }
+        else if (!strcmp(inner_token, "added_size")) {
+          inner_token = strtok_r(NULL, ":", &end_token);
+          *added_size = g_variant_new("s", inner_token);
+        }
+        inner_token = strtok_r(NULL, ":", &end_token);
+      }
+      outer_token = strtok_r(NULL, ",", &end_str);
+  }
+
+  if (*total == NULL || *total_size == NULL || *total_removed == NULL || *removed_size == NULL || *total_added == NULL || *added_size == NULL) {
+    return FALSE;
+  }
+  return TRUE;
+}
diff --git a/src/lib/rpmostree-db.h b/src/lib/rpmostree-db.h
index 839ad832be..a25912a36e 100644
--- a/src/lib/rpmostree-db.h
+++ b/src/lib/rpmostree-db.h
@@ -52,4 +52,9 @@ _RPMOSTREE_EXTERN gboolean rpm_ostree_db_diff_ext (
     OstreeRepo *repo, const char *orig_ref, const char *new_ref, RpmOstreeDbDiffExtFlags flags,
     GPtrArray **out_removed, GPtrArray **out_added, GPtrArray **out_modified_old,
     GPtrArray **out_modified_new, GCancellable *cancellable, GError **error);
+
+_RPMOSTREE_EXTERN gboolean rpm_ostree_db_diff_ext_container (gchar* manifest_diff, GVariant **total,
+                        GVariant **total_size, GVariant **total_removed,
+                        GVariant **removed_size, GVariant **total_added,
+                        GVariant **added_size, GError **error);
 G_END_DECLS