Merge pull request #1453 from fwsGonzo/dev

test: Add integration test for LiveUpdate

Author: fwsGonzo

lib/LiveUpdate/liveupdate.hpp

@@ -51,11 +51,15 @@ struct LiveUpdate
   typedef delegate<void(Restore&)> resume_func;
 
   // Register a function to be called when serialization phase begins
+  // Internally it will be stored as its own partition and can be restored using
+  // the same @key value during the resume process
   static void register_serialization_callback(std::string key, storage_func);
 
   // Start a live update process, storing all user-defined data
-  // If no storage function is provided no state will be saved
+  // If no storage functions are registered no state will be saved
   static void exec(const buffer_t& blob);
+  // Same as above, but including the partition [@key, func]
+  static void exec(const buffer_t& blob, std::string key, storage_func func);
 
   // In the event that LiveUpdate::exec() fails,
   // call this function in the C++ exception catch scope:

lib/LiveUpdate/update.cpp

@@ -84,6 +84,12 @@ inline bool validate_header(const Class* hdr)
            hdr->e_ident[3] == 'F';
 }
 
+void LiveUpdate::exec(const buffer_t& blob, std::string key, storage_func func)
+{
+  register_serialization_callback(key, func);
+  LiveUpdate::exec(blob);
+}
+
 void LiveUpdate::exec(const buffer_t& blob)
 {
   void* location = OS::liveupdate_storage_area();

test/kernel/integration/LiveUpdate/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required(VERSION 2.8.9)
+if (NOT DEFINED ENV{INCLUDEOS_PREFIX})
+  set(ENV{INCLUDEOS_PREFIX} /usr/local)
+endif()
+include($ENV{INCLUDEOS_PREFIX}/includeos/pre.service.cmake)
+project (service)
+
+# Human-readable name of your service
+set(SERVICE_NAME "LiveUpdate integration test")
+
+# Name of your service binary
+set(BINARY       "service")
+
+# Source files to be linked with OS library parts to form bootable image
+set(SOURCES
+  service.cpp test_boot.cpp
+  )
+
+# DRIVERS / PLUGINS:
+set(DRIVERS
+  virtionet
+  )
+
+set(PLUGINS )
+
+# STATIC LIBRARIES:
+set(LIBRARIES
+  libliveupdate.a
+  )
+
+# include service build script
+include($ENV{INCLUDEOS_PREFIX}/includeos/post.service.cmake)

test/kernel/integration/LiveUpdate/config.json

@@ -0,0 +1,5 @@
+{
+  "net" : [
+    ["10.0.0.49", "255.255.255.0", "10.0.0.1"]
+  ]
+}

test/kernel/integration/LiveUpdate/liu.hpp

@@ -0,0 +1,47 @@
+// This file is a part of the IncludeOS unikernel - www.includeos.org
+//
+// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// and Alfred Bratterud
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#include <liveupdate>
+#include "server.hpp"
+
+void setup_liveupdate_server(net::Inet<net::IP4>& inet,
+                             const uint16_t PORT,
+                             liu::LiveUpdate::storage_func func)
+{
+  static liu::LiveUpdate::storage_func save_function;
+  save_function = func;
+
+  // listen for live updates
+  server(inet, PORT,
+  [] (liu::buffer_t& buffer)
+  {
+    printf("* Live updating from %p (len=%u)\n",
+            buffer.data(), (uint32_t) buffer.size());
+    try
+    {
+      // run live update process
+      liu::LiveUpdate::exec(buffer, "test", save_function);
+    }
+    catch (std::exception& err)
+    {
+      liu::LiveUpdate::restore_environment();
+      printf("Live update failed:\n%s\n", err.what());
+      throw;
+    }
+  });
+}

test/kernel/integration/LiveUpdate/server.hpp

@@ -0,0 +1,39 @@
+/**
+ * Master thesis
+ * by Alf-Andre Walla 2016-2017
+ *
+**/
+#pragma once
+#include <stdexcept>
+
+static inline
+void server(net::Inet<net::IP4>& inet,
+            const uint16_t port,
+            delegate<void(liu::buffer_t&)> callback)
+{
+  auto& server = inet.tcp().listen(port);
+  server.on_connect(
+  net::tcp::Connection::ConnectCallback::make_packed(
+  [callback, port] (auto conn)
+  {
+    auto* buffer = new liu::buffer_t;
+    buffer->reserve(3*1024*1024);
+    printf("Receiving blob on port %u\n", port);
+
+    // retrieve binary
+    conn->on_read(9000,
+    [conn, buffer] (net::tcp::buffer_t buf, size_t n)
+    {
+      buffer->insert(buffer->end(), buf.get(), buf.get() + n);
+    })
+    .on_disconnect(
+    net::tcp::Connection::DisconnectCallback::make_packed(
+    [buffer, callback] (auto conn, auto) {
+      printf("* Blob size: %u b  stored at %p\n",
+            (uint32_t) buffer->size(), buffer->data());
+      callback(*buffer);
+      delete buffer;
+      conn->close();
+    }));
+  }));
+}

test/kernel/integration/LiveUpdate/service.cpp

@@ -0,0 +1,35 @@
+// This file is a part of the IncludeOS unikernel - www.includeos.org
+//
+// Copyright 2015 Oslo and Akershus University College of Applied Sciences
+// and Alfred Bratterud
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <service>
+#include <net/inet4>
+#include <cstdio>
+#include "liu.hpp"
+
+using storage_func_t = liu::LiveUpdate::storage_func;
+extern storage_func_t begin_test_boot();
+
+void Service::start()
+{
+  auto func = begin_test_boot();
+
+  if (liu::LiveUpdate::is_resumable() == false)
+  {
+    auto& inet = net::Super_stack::get<net::IP4>(0);
+    setup_liveupdate_server(inet, 666, func);
+  }
+}

test/kernel/integration/LiveUpdate/test.py

@@ -0,0 +1,23 @@
+#! /usr/bin/env python
+import sys
+import os
+import socket
+
+includeos_src = os.environ.get('INCLUDEOS_SRC',
+                               os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__))).split('/test')[0])
+sys.path.insert(0,includeos_src)
+
+from vmrunner import vmrunner
+vm = vmrunner.vms[0]
+
+
+def begin_test(line):
+    f = open('./service','rb')
+
+    s = socket.socket()
+    s.connect(("10.0.0.49", 666))
+    s.send(f.read())
+    s.close()
+
+vm.on_output("Ready to receive binary blob", begin_test)
+vm.cmake().boot(40).clean()

test/kernel/integration/LiveUpdate/test_boot.cpp

@@ -0,0 +1,61 @@
+#include <kernel/os.hpp>
+#include <liveupdate>
+using namespace liu;
+
+static std::vector<int64_t> timestamps;
+static buffer_t bloberino;
+
+static void boot_save(Storage& storage, const buffer_t* blob)
+{
+  timestamps.push_back(OS::micros_since_boot());
+  storage.add_vector(0, timestamps);
+  assert(blob != nullptr);
+  storage.add_buffer(2, *blob);
+}
+static void boot_resume_all(Restore& thing)
+{
+  timestamps = thing.as_vector<int64_t>(); thing.go_next();
+  // calculate time spent
+  auto t1 = timestamps.back();
+  auto t2 = OS::micros_since_boot();
+  // set final time
+  timestamps.back() = t2 - t1;
+  // retrieve old blob
+  bloberino = thing.as_buffer(); thing.go_next();
+
+  thing.pop_marker();
+}
+
+LiveUpdate::storage_func begin_test_boot()
+{
+  try {
+    LiveUpdate::resume("test", boot_resume_all);
+    // if we are here,
+    // resume() must have succeeded
+    if (timestamps.size() >= 30)
+    {
+      // calculate median by sorting
+      std::sort(timestamps.begin(), timestamps.end());
+      auto median = timestamps[timestamps.size()/2];
+      // show information
+      printf("Median boot time over %lu samples: %llu micros\n",
+              timestamps.size(), median);
+      /*
+      for (auto& stamp : timestamps) {
+        printf("%lld\n", stamp);
+      }
+      */
+      printf("SUCCESS\n");
+      OS::shutdown();
+    }
+    else {
+      // immediately liveupdate
+      LiveUpdate::exec(bloberino, "test", boot_save);
+    }
+  }
+  catch (std::exception& e) {
+    printf("Ready to receive binary blob\n");
+  }
+  // wait for update
+  return boot_save;
+}

test/kernel/integration/LiveUpdate/vm.json

@@ -0,0 +1,7 @@
+{
+  "description" : "VM with interface for testing LiveUpdate",
+  "net" : [
+    {"device" : "virtio"}
+  ],
+  "mem" : 48
+}