diff --git a/src/app/rpmostree-builtin-upgrade.cxx b/src/app/rpmostree-builtin-upgrade.cxx
index 6360cbcfc3..626880637f 100644
--- a/src/app/rpmostree-builtin-upgrade.cxx
+++ b/src/app/rpmostree-builtin-upgrade.cxx
@@ -30,6 +30,7 @@
 #include "rpmostree-rpm-util.h"
 
 #include <libglnx.h>
+#include <rpmostree-sysroot-upgrader.cxx>
 
 static char *opt_osname;
 static gboolean opt_reboot;
@@ -207,6 +208,12 @@ rpmostree_builtin_upgrade (int argc, char **argv, RpmOstreeCommandInvocation *in
       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)
         {
           g_print ("No updates available.\n");
@@ -215,9 +222,54 @@ rpmostree_builtin_upgrade (int argc, char **argv, RpmOstreeCommandInvocation *in
       else
         {
           /* preview --> verbose (i.e. we want the diff) */
-          if (!rpmostree_print_cached_update (cached_update, opt_preview, FALSE, cancellable,
+          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;
+            }
+            
+          }
+          
         }
     }
   else if (!opt_reboot)
diff --git a/src/app/rpmostree-clientlib.cxx b/src/app/rpmostree-clientlib.cxx
index 65aa33cf93..91fce5245c 100644
--- a/src/app/rpmostree-clientlib.cxx
+++ b/src/app/rpmostree-clientlib.cxx
@@ -1310,6 +1310,124 @@ rpmostree_print_cached_update (GVariant *cached_update, gboolean verbose,
   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)
+    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 dd4f22c4c8..08d7a2a5f0 100644
--- a/src/app/rpmostree-clientlib.h
+++ b/src/app/rpmostree-clientlib.h
@@ -115,6 +115,10 @@ gboolean rpmostree_print_cached_update (GVariant *cached_update, gboolean verbos
                                         gboolean verbose_advisories, GCancellable *cancellable,
                                         GError **error);
 
+gboolean rpmostree_print_cached_update_container (GVariant *cached_update, gboolean verbose,
+                                        gboolean verbose_advisories, GCancellable *cancellable,
+                                        GError **error);
+
 void rpmostree_print_advisories (GVariant *advisories, gboolean verbose, guint max_key_len);
 
 gboolean get_sd_unit_objpath (GDBusConnection *connection, const char *method_name,
diff --git a/src/daemon/org.projectatomic.rpmostree1.xml b/src/daemon/org.projectatomic.rpmostree1.xml
index b11ff5dfd2..efd61cca71 100644
--- a/src/daemon/org.projectatomic.rpmostree1.xml
+++ b/src/daemon/org.projectatomic.rpmostree1.xml
@@ -106,6 +106,7 @@
       <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 88b4a0933f..55cfb6ac20 100644
--- a/src/daemon/rpmostree-sysroot-upgrader.cxx
+++ b/src/daemon/rpmostree-sysroot-upgrader.cxx
@@ -401,6 +401,170 @@ 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;
+  
+  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 ("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;
+}
+
+
+
 /*
  * Like ostree_sysroot_upgrader_pull(), but also handles the `baserefspec` we
  * use when doing layered packages.
@@ -448,6 +612,18 @@ 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);
+
+            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))
+            //   {
+            //     sd_journal_print (LOG_WARNING, "Failed to refresh CachedUpdate property: %s",
+            //                       local_error->message);
+
+            // }
+
             *out_changed = TRUE;
             return TRUE;
           }
diff --git a/src/daemon/rpmostree-sysroot-upgrader.h b/src/daemon/rpmostree-sysroot-upgrader.h
index 7a90dfe32a..57b6615886 100644
--- a/src/daemon/rpmostree-sysroot-upgrader.h
+++ b/src/daemon/rpmostree-sysroot-upgrader.h
@@ -98,6 +98,11 @@ const char *rpmostree_sysroot_upgrader_get_base (RpmOstreeSysrootUpgrader *self)
 
 DnfSack *rpmostree_sysroot_upgrader_get_sack (RpmOstreeSysrootUpgrader *self, GError **error);
 
+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);
+
 gboolean rpmostree_sysroot_upgrader_pull_base (RpmOstreeSysrootUpgrader *self,
                                                const char *dir_to_pull, OstreeRepoPullFlags flags,
                                                OstreeAsyncProgress *progress, gboolean *out_changed,
diff --git a/src/daemon/rpmostreed-os.cxx b/src/daemon/rpmostreed-os.cxx
index 090c2dfd13..6c1dabe3f9 100644
--- a/src/daemon/rpmostreed-os.cxx
+++ b/src/daemon/rpmostreed-os.cxx
@@ -1730,6 +1730,7 @@ 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;
 }