Split machine_manifest into machine_header_manifest and machine_manifest

2 files changed, 23 insertions, 81 deletions

diff --git a/bbot/manifest b/bbot/manifest
index 4a5d449..c5a321a 100644
--- a/bbot/manifest
+++ b/bbot/manifest
@@ -21,35 +21,29 @@
 
 namespace bbot
 {
-  enum class machine_type {kvm, nspawn};
-
-  class LIBBBOT_EXPORT machine_manifest
+  class LIBBBOT_EXPORT machine_header_manifest
   {
   public:
-    // A "machine header".
-    //
     std::string id;
     std::string name;
     std::string summary;
 
-    butl::optional<machine_type> type;
-
-    machine_manifest (std::string i, std::string n, std::string s)
+    machine_header_manifest (std::string i, std::string n, std::string s)
         : id (std::move (i)), name (std::move (n)), summary (std::move (s)) {}
 
   public:
-    machine_manifest () = default; // VC export.
-    machine_manifest (butl::manifest_parser&, bool ignore_unknown = false);
-    machine_manifest (butl::manifest_parser&,
-                      butl::manifest_name_value start,
-                      bool header_only = false,
-                      bool ignore_unknown = false);
+    machine_header_manifest () = default; // VC export.
+    machine_header_manifest (butl::manifest_parser&,
+                             bool ignore_unknown = false);
+    machine_header_manifest (butl::manifest_parser&,
+                             butl::manifest_name_value start,
+                             bool ignore_unknown = false);
 
     void
     serialize (butl::manifest_serializer&) const;
   };
 
-  using machine_manifests = std::vector<machine_manifest>;
+  using machine_header_manifests = std::vector<machine_header_manifest>;
 
   class LIBBBOT_EXPORT task_request_manifest
   {
@@ -66,7 +60,7 @@ namespace bbot
     //
     std::string fingerprint;
 
-    machine_manifests machines; // Only machine headers.
+    machine_header_manifests machines;
 
   public:
     task_request_manifest () = default; // VC export.
diff --git a/bbot/manifest.cxx b/bbot/manifest.cxx
index b18389e..52841f3 100644
--- a/bbot/manifest.cxx
+++ b/bbot/manifest.cxx
@@ -61,29 +61,6 @@ namespace bbot
     else throw invalid_argument ("invalid result status '" + s + "'");
   }
 
-  // machine_type
-  //
-  static string
-  to_string (machine_type t)
-  {
-    switch (t)
-    {
-    case machine_type::kvm:    return "kvm";
-    case machine_type::nspawn: return "nspawn";
-    }
-
-    assert (false);
-    return string ();
-  }
-
-  machine_type
-  to_machine_type (const string& t)
-  {
-         if (t == "kvm")    return machine_type::kvm;
-    else if (t == "nspawn") return machine_type::nspawn;
-    else throw invalid_argument ("invalid machine type '" + t + "'");
-  }
-
   // Utility functions
   //
   inline static bool
@@ -101,22 +78,22 @@ namespace bbot
     return true;
   }
 
-  // machine_manifest
+  // machine_header_manifest
   //
-  machine_manifest::
-  machine_manifest (parser& p, bool iu)
-      : machine_manifest (p, p.next (), false, iu)
+  machine_header_manifest::
+  machine_header_manifest (parser& p, bool iu)
+      : machine_header_manifest (p, p.next (), iu)
   {
     // Make sure this is the end.
     //
     name_value nv (p.next ());
     if (!nv.empty ())
       throw parsing (p.name (), nv.name_line, nv.name_column,
-                     "single machine manifest expected");
+                     "single machine header manifest expected");
   }
 
-  machine_manifest::
-  machine_manifest (parser& p, name_value nv, bool ho, bool iu)
+  machine_header_manifest::
+  machine_header_manifest (parser& p, name_value nv, bool iu)
   {
     auto bad_name = [&p, &nv] (const string& d)
     {
@@ -131,7 +108,7 @@ namespace bbot
     // Make sure this is the start and we support the version.
     //
     if (!nv.name.empty ())
-      bad_name ("start of machine manifest expected");
+      bad_name ("start of machine header manifest expected");
 
     if (nv.value != "1")
       bad_value ("unsupported format version");
@@ -171,25 +148,8 @@ namespace bbot
 
         summary = move (v);
       }
-      else if (n == "type")
-      {
-        if (ho)
-          bad_name ("machine type not allowed");
-
-        if (type)
-          bad_name ("machine type redefinition");
-
-        try
-        {
-          type = to_machine_type (v);
-        }
-        catch (const invalid_argument&)
-        {
-          bad_value ("invalid machine type");
-        }
-      }
       else if (!iu)
-        bad_name ("unknown name '" + n + "' in machine manifest");
+        bad_name ("unknown name '" + n + "' in machine header manifest");
     }
 
     // Verify all non-optional values were specified.
@@ -202,12 +162,9 @@ namespace bbot
 
     if (summary.empty ())
       bad_value ("no machine summary specified");
-
-    if (!ho && !type)
-      bad_value ("no machine type specified");
   }
 
-  void machine_manifest::
+  void machine_header_manifest::
   serialize (serializer& s) const
   {
     // @@ Should we check that all non-optional values are specified and all
@@ -217,10 +174,6 @@ namespace bbot
     s.next ("id", id);
     s.next ("name", name);
     s.next ("summary", summary);
-
-    if (type)
-      s.next ("type", to_string (*type));
-
     s.next ("", ""); // End of manifest.
   }
 
@@ -288,10 +241,10 @@ namespace bbot
     if (fingerprint.empty ())
       bad_value ("no task request fingerprint specified");
 
-    // Parse machine manifests.
+    // Parse machine header manifests.
     //
     for (nv = p.next (); !nv.empty (); nv = p.next ())
-      machines.emplace_back (machine_manifest (p, nv, true, iu));
+      machines.emplace_back (machine_header_manifest (p, nv, iu));
 
     if (machines.empty ())
       bad_value ("no task request machines specified");
@@ -308,13 +261,8 @@ namespace bbot
     s.next ("fingerprint", fingerprint);
     s.next ("", "");  // End of manifest.
 
-    for (const machine_manifest& m: machines)
-    {
-      if (m.type)
-        throw serialization (s.name (), "machine type is forbidden");
-
+    for (const machine_header_manifest& m: machines)
       m.serialize (s);
-    }
 
     s.next ("", ""); // End of stream.
   }