lib: Remove LiveUpdate deprecated on_resume events

Author: fwsGonzo

lib/LiveUpdate/liveupdate.hpp

@@ -71,13 +71,8 @@ struct LiveUpdate
   static bool is_resumable();
   static bool is_resumable(void* location);
 
-  // Register a user-defined handler for what to do with @id from storage
-  static void on_resume(uint16_t id, resume_func custom_handler);
-
-  // Attempt to restore existing stored entries.
-  // Returns false if there was nothing there. or if the process failed
-  // to be sure that only failure can return false, use is_resumable first
-  static void resume(std::string key, resume_func default_handler);
+  // Restore existing state for a partition named @key.
+  static void resume(std::string key, resume_func handler);
 
   // When explicitly resuming from heap, heap overrun checks are disabled
   static void resume_from_heap(void* location, std::string key, resume_func);
@@ -199,20 +194,15 @@ struct Restore
   // if the end is reached, @id is not used
   void pop_marker(uint16_t id);
 
-  // cancel and exit state restoration process
-  // NOTE: resume() will still return true
-  void cancel();  // pseudo: "while (!is_end()) go_next()"
-
   // NOTE:
   // it is safe to immediately use is_end() after any call to:
-  // go_next(), pop_marker(), pop_marker(uint16_t), cancel()
+  // go_next(), pop_marker(), pop_marker(uint16_t)
 
-  Restore(storage_entry*& ptr) : ent(ptr) {}
-  Restore(const Restore&);
+  Restore(storage_entry* ptr) : ent(ptr) {}
 private:
   const void* get_segment(size_t, size_t&) const;
   std::vector<std::string> rebuild_string_vector() const;
-  storage_entry*& ent;
+  storage_entry* ent;
 };
 
 /// various inline functions

lib/LiveUpdate/resume.cpp

@@ -35,7 +35,6 @@ extern char* heap_end;
 namespace liu
 {
 static void resume_begin(storage_header&, std::string, LiveUpdate::resume_func);
-static std::map<uint16_t, LiveUpdate::resume_func> resume_funcs;
 
 bool LiveUpdate::is_resumable()
 {
@@ -82,40 +81,19 @@ void resume_begin(storage_header& storage, std::string key, LiveUpdate::resume_f
   LPRINT("* Resuming from partition %d at %p from %p\n",
         p, storage.begin(p), &storage);
 
-  /// restore each entry one by one, calling registered handlers
-  for (auto* ptr = storage.begin(p); ptr->type != TYPE_END;)
-  {
-    auto* oldptr = ptr;
-    // resume wrapper
-    Restore wrapper {ptr};
-    // use registered functions when we can, otherwise, use normal
-    auto it = resume_funcs.find(ptr->id);
-    if (it != resume_funcs.end())
-    {
-      it->second(wrapper);
-    } else {
-      func(wrapper);
-    }
-    // if we are already at the end due calls to go_next, break early
-    if (ptr->type == TYPE_END) break;
-    // call next manually only when no one called go_next
-    if (oldptr == ptr) ptr = storage.next(ptr);
-  }
+  // resume wrapper
+  Restore wrapper(storage.begin(p));
+  // use registered functions when we can, otherwise, use normal
+  func(wrapper);
+
   // wake all the slumbering IP stacks
   serialized_tcp::wakeup_ip_networks();
-  // clear registered resume callbacks
-  resume_funcs.clear();
   // zero out the partition for security reasons
   storage.zero_partition(p);
   // if there are no more partitions, clear everything
   storage.try_zero();
 }
 
-void LiveUpdate::on_resume(uint16_t id, resume_func func)
-{
-  resume_funcs[id] = func;
-}
-
 /// struct Restore
 
 bool Restore::is_end() const noexcept
@@ -136,13 +114,13 @@ int Restore::as_int() const
   // this type uses the length field directly as value to save space
   if (ent->type == TYPE_INTEGER)
       return ent->len;
-  throw std::runtime_error("Incorrect type: " + std::to_string(ent->type));
+  throw std::runtime_error("LiveUpdate: Incorrect type " + std::to_string(ent->type));
 }
 std::string Restore::as_string() const
 {
   if (ent->type == TYPE_STRING)
       return std::string(ent->data(), ent->len);
-  throw std::runtime_error("Incorrect type: " + std::to_string(ent->type));
+  throw std::runtime_error("LiveUpdate: Incorrect type " + std::to_string(ent->type));
 }
 buffer_t  Restore::as_buffer() const
 {
@@ -151,7 +129,7 @@ buffer_t  Restore::as_buffer() const
       buffer.assign(ent->data(), ent->data() + ent->len);
       return buffer;
   }
-  throw std::runtime_error("Incorrect type: " + std::to_string(ent->type));
+  throw std::runtime_error("LiveUpdate: Incorrect type " + std::to_string(ent->type));
 }
 Restore::Connection_ptr Restore::as_tcp_connection(net::TCP& tcp) const
 {
@@ -177,19 +155,19 @@ const void* Restore::data() const noexcept
 const void* Restore::get_segment(size_t size, size_t& count) const
 {
   if (ent->type != TYPE_VECTOR)
-      throw std::runtime_error("Incorrect type: " + std::to_string(ent->type));
+      throw std::runtime_error("LiveUpdate: Incorrect type " + std::to_string(ent->type));
 
   auto& segs = ent->get_segs();
   if (size != segs.esize)
-      throw std::runtime_error("Incorrect type size: " + std::to_string(size) + " vs " + std::to_string(segs.esize));
+      throw std::runtime_error("LiveUpdate: Incorrect type size " + std::to_string(size) + " vs " + std::to_string(segs.esize));
 
   count = segs.count;
   return (const void*) segs.vla;
 }
 std::vector<std::string> Restore::rebuild_string_vector() const
 {
   if (ent->type != TYPE_STR_VECTOR)
-      throw std::runtime_error("Incorrect type: " + std::to_string(ent->type));
+      throw std::runtime_error("LiveUpdate: Incorrect type " + std::to_string(ent->type));
   std::vector<std::string> retv;
   // reserve just enough room
   auto* begin = (varseg_begin*) ent->vla;
@@ -210,7 +188,7 @@ std::vector<std::string> Restore::rebuild_string_vector() const
 void     Restore::go_next()
 {
   if (is_end())
-      throw std::runtime_error("Already reached end of storage");
+      throw std::out_of_range("Already reached end of partition");
   // increase the counter, so the resume loop skips entries properly
   ent = ent->next();
 }
@@ -236,18 +214,9 @@ void Restore::pop_marker(uint16_t id)
       && is_end() == false) go_next();
   if (is_marker()) {
     if (get_id() != id)
-        throw std::runtime_error("Ran past marker with another id: " + std::to_string(get_id()));
+        throw std::out_of_range("Ran past marker with another id: " + std::to_string(get_id()));
     go_next();
   }
 }
 
-void Restore::cancel()
-{
-  while (is_end() == false) go_next();
-}
-
-// copy operator
-Restore::Restore(const Restore& other)
-  : ent(other.ent)  {}
-
-}
+} // liu