[Yunq] Add serialization tests for Types message.

lib/glacier/string/string.cpp

@@ -32,7 +32,7 @@ String::String(const String& other) : String(other.cstr_, other.length_) {}
 
 String& String::operator=(const String& other) {
   if (cstr_) {
-    delete cstr_;
+    delete[] cstr_;
   }
   length_ = other.length_;
   cstr_ = new char[length_ + 1];
@@ -51,7 +51,7 @@ String::String(String&& other) : cstr_(other.cstr_), length_(other.length_) {
 
 String& String::operator=(String&& other) {
   if (cstr_) {
-    delete cstr_;
+    delete[] cstr_;
   }
   cstr_ = other.cstr_;
   length_ = other.length_;
@@ -64,7 +64,7 @@ String& String::operator=(String&& other) {
 
 String::~String() {
   if (cstr_) {
-    delete cstr_;
+    delete[] cstr_;
   }
 }
 

lib/yunq/message_view.cpp

@@ -29,6 +29,12 @@ glcr::ErrorOr<uint64_t> MessageView::ReadField<uint64_t>(
   return buffer_.At<uint64_t>(field_offset(field_index));
 }
 
+template <>
+glcr::ErrorOr<int64_t> MessageView::ReadField<int64_t>(
+    uint64_t field_index) const {
+  return buffer_.At<int64_t>(field_offset(field_index));
+}
+
 template <>
 glcr::ErrorOr<glcr::String> MessageView::ReadField<glcr::String>(
     uint64_t field_index) const {

lib/yunq/message_view.h

@@ -49,6 +49,10 @@ template <>
 glcr::ErrorOr<uint64_t> MessageView::ReadField<uint64_t>(
     uint64_t field_index) const;
 
+template <>
+glcr::ErrorOr<int64_t> MessageView::ReadField<int64_t>(
+    uint64_t field_index) const;
+
 template <>
 glcr::ErrorOr<glcr::String> MessageView::ReadField<glcr::String>(
     uint64_t field_index) const;

lib/yunq/serialize.cpp

@@ -20,6 +20,12 @@ void Serializer::WriteField<uint64_t>(uint64_t field_index,
   buffer_.WriteAt<uint64_t>(field_offset(field_index), value);
 }
 
+template <>
+void Serializer::WriteField<int64_t>(uint64_t field_index,
+                                     const int64_t& value) {
+  buffer_.WriteAt<int64_t>(field_offset(field_index), value);
+}
+
 template <>
 void Serializer::WriteField<glcr::String>(uint64_t field_index,
                                           const glcr::String& value) {

lib/yunq/serialize.h

@@ -26,7 +26,6 @@ class Serializer {
         next_extension_(kHeaderSize + (8 * num_fields)),
         core_size_(next_extension_),
         caps_(caps) {}
-
   template <typename T>
   void WriteField(uint64_t field_index, const T& value);
 
@@ -65,6 +64,10 @@ template <>
 void Serializer::WriteField<uint64_t>(uint64_t field_index,
                                       const uint64_t& value);
 
+template <>
+void Serializer::WriteField<int64_t>(uint64_t field_index,
+                                     const int64_t& value);
+
 template <>
 void Serializer::WriteField<glcr::String>(uint64_t field_index,
                                           const glcr::String& value);

lib/yunq/test/CMakeLists.txt

@@ -15,7 +15,7 @@ add_dependencies(build_test
     yunq_test)
 
 
-# Build the yunq manualy rather than using the generator
+# Build the yunq manually rather than using the generator
 # because we don't want to link against mammoth and overrite new.
 set(target example_yunq)
 add_library(example_yunq
@@ -36,7 +36,9 @@ set(PYTHON "${CMAKE_SOURCE_DIR}/yunq/venv/bin/python")
 set(YUNQ "${CMAKE_SOURCE_DIR}/yunq/yunq.py")
 
 add_custom_command(
- OUTPUT example/example.yunq.cpp
+  OUTPUT 
+    ${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq.cpp 
+    ${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq.h
  COMMAND ${PYTHON} ${YUNQ} ${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq
  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/example/example.yunq
 )

lib/yunq/test/example/example.yunq

@@ -3,3 +3,13 @@ package ex;
 message Basic {
   u64 field;
 }
+
+message Types {
+  u64 unsigned_int;
+  i64 signed_int;
+  string str;
+}
+
+message Cap {
+  capability cap;
+}

lib/yunq/test/example/example.yunq.cpp

@@ -53,6 +53,89 @@ uint64_t Basic::SerializeInternal(yunq::Serializer& serializer) const {
 
   return serializer.size();
 }
+glcr::Status Types::ParseFromBytes(const yunq::MessageView& message) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  return glcr::Status::Ok();
+}
+
+glcr::Status Types::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  return glcr::Status::Ok();
+}
+
+glcr::Status Types::ParseFromBytesInternal(const yunq::MessageView& message) {
+  RETURN_ERROR(message.CheckHeader());
+  // Parse unsigned_int.
+  ASSIGN_OR_RETURN(unsigned_int_, message.ReadField<uint64_t>(0));
+  // Parse signed_int.
+  ASSIGN_OR_RETURN(signed_int_, message.ReadField<int64_t>(1));
+  // Parse str.
+  ASSIGN_OR_RETURN(str_, message.ReadField<glcr::String>(2));
+
+  return glcr::Status::Ok();
+}
+
+uint64_t Types::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
+  yunq::Serializer serializer(bytes, offset, 3);
+  return SerializeInternal(serializer);
+}
+
+uint64_t Types::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
+  yunq::Serializer serializer(bytes, offset, 3, caps);
+  return SerializeInternal(serializer);
+}
+  
+uint64_t Types::SerializeInternal(yunq::Serializer& serializer) const {
+  // Write unsigned_int.
+  serializer.WriteField<uint64_t>(0, unsigned_int_);
+  // Write signed_int.
+  serializer.WriteField<int64_t>(1, signed_int_);
+  // Write str.
+  serializer.WriteField<glcr::String>(2, str_);
+
+  serializer.WriteHeader();
+
+  return serializer.size();
+}
+glcr::Status Cap::ParseFromBytes(const yunq::MessageView& message) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  // Parse cap.
+  ASSIGN_OR_RETURN(cap_, message.ReadCapability(0));
+  return glcr::Status::Ok();
+}
+
+glcr::Status Cap::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  // Parse cap.
+  ASSIGN_OR_RETURN(cap_, message.ReadCapability(0, caps));
+  return glcr::Status::Ok();
+}
+
+glcr::Status Cap::ParseFromBytesInternal(const yunq::MessageView& message) {
+  RETURN_ERROR(message.CheckHeader());
+  // Parse cap.
+
+  return glcr::Status::Ok();
+}
+
+uint64_t Cap::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
+  yunq::Serializer serializer(bytes, offset, 1);
+  return SerializeInternal(serializer);
+}
+
+uint64_t Cap::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
+  yunq::Serializer serializer(bytes, offset, 1, caps);
+  return SerializeInternal(serializer);
+}
+  
+uint64_t Cap::SerializeInternal(yunq::Serializer& serializer) const {
+  // Write cap.
+  serializer.WriteCapability(0, cap_);
+
+  serializer.WriteHeader();
+
+  return serializer.size();
+}
 
 
 }  // namepace ex

lib/yunq/test/example/example.yunq.h

@@ -38,6 +38,66 @@ class Basic {
 
   uint64_t SerializeInternal(yunq::Serializer& serializer) const;
 };
+class Types {
+ public:
+  Types() {}
+  // Delete copy and move until implemented.
+  Types(const Types&) = delete;
+  Types(Types&&) = default;
+  Types& operator=(Types&&) = default;
+
+  [[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message);
+  [[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&);
+  uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
+  uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; 
+
+  const uint64_t& unsigned_int() const { return unsigned_int_; }
+  uint64_t& mutable_unsigned_int() { return unsigned_int_; }
+  void set_unsigned_int(const uint64_t& value) { unsigned_int_ = value; } 
+
+  const int64_t& signed_int() const { return signed_int_; }
+  int64_t& mutable_signed_int() { return signed_int_; }
+  void set_signed_int(const int64_t& value) { signed_int_ = value; } 
+
+  const glcr::String& str() const { return str_; }
+  glcr::String& mutable_str() { return str_; }
+  void set_str(const glcr::String& value) { str_ = value; }
+
+ private:
+  uint64_t unsigned_int_;
+  int64_t signed_int_;
+  glcr::String str_;
+
+  // Parses everything except for caps.
+  glcr::Status ParseFromBytesInternal(const yunq::MessageView& message);
+
+  uint64_t SerializeInternal(yunq::Serializer& serializer) const;
+};
+class Cap {
+ public:
+  Cap() {}
+  // Delete copy and move until implemented.
+  Cap(const Cap&) = delete;
+  Cap(Cap&&) = default;
+  Cap& operator=(Cap&&) = default;
+
+  [[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message);
+  [[nodiscard]] glcr::Status ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer&);
+  uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset) const;
+  uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const; 
+
+  const z_cap_t& cap() const { return cap_; }
+  z_cap_t& mutable_cap() { return cap_; }
+  void set_cap(const z_cap_t& value) { cap_ = value; }
+
+ private:
+  z_cap_t cap_;
+
+  // Parses everything except for caps.
+  glcr::Status ParseFromBytesInternal(const yunq::MessageView& message);
+
+  uint64_t SerializeInternal(yunq::Serializer& serializer) const;
+};
 
 
 }  // namepace ex

lib/yunq/test/yunq_test.cpp

@@ -21,3 +21,32 @@ TEST_CASE("Basic serialization", "[yunq]") {
 
   REQUIRE(b.field() == 1);
 }
+
+TEST_CASE("Types Setter/Getter", "[yunq]") {
+  ex::Types t;
+  t.set_unsigned_int(1);
+  t.set_signed_int(-1);
+  t.set_str("test");
+
+  REQUIRE(t.unsigned_int() == 1);
+  REQUIRE(t.signed_int() == -1);
+  REQUIRE(t.str() == "test");
+}
+
+TEST_CASE("Types Serialization", "[yunq]") {
+  ex::Types a;
+  a.set_unsigned_int(1);
+  a.set_signed_int(-1);
+  a.set_str("test");
+
+  glcr::ByteBuffer buf(1024);
+  a.SerializeToBytes(buf, 0);
+
+  ex::Types b;
+  yunq::MessageView v(buf, 0);
+  REQUIRE(b.ParseFromBytes(v).ok() == true);
+
+  REQUIRE(b.unsigned_int() == 1);
+  REQUIRE(b.signed_int() == -1);
+  REQUIRE(b.str() == "test");
+}

sys/denali/lib/denali/denali.yunq.client.cpp

@@ -0,0 +1,100 @@
+// Generated file - DO NOT MODIFY
+#include "denali.yunq.client.h"
+
+#include <glacier/buffer/byte_buffer.h>
+#include <glacier/buffer/cap_buffer.h>
+#include <mammoth/util/debug.h>
+#include <zcall.h>
+
+
+
+
+DenaliClient::~DenaliClient() {
+  if (endpoint_ != 0) {
+    check(ZCapRelease(endpoint_));
+    }
+}
+
+
+
+
+glcr::Status DenaliClient::Read(const ReadRequest& request, ReadResponse& response) {
+
+  uint64_t buffer_size = kBufferSize;
+  uint64_t cap_size = kCapBufferSize;
+
+  const uint32_t kSentinel = 0xBEEFDEAD;
+  buffer_.WriteAt<uint32_t>(0, kSentinel);
+  buffer_.WriteAt<uint64_t>(8, 0);
+
+  cap_buffer_.Reset();
+
+  uint64_t length = request.SerializeToBytes(buffer_, /*offset=*/16, cap_buffer_);
+
+
+  buffer_.WriteAt<uint32_t>(4, 16 + length);
+
+  z_cap_t reply_port_cap;
+  RET_ERR(ZEndpointSend(endpoint_, 16 + length, buffer_.RawPtr(), cap_buffer_.UsedSlots(), cap_buffer_.RawPtr(), &reply_port_cap)); 
+
+  // FIXME: Add a way to zero out the first buffer.
+  RET_ERR(ZReplyPortRecv(reply_port_cap, &buffer_size, buffer_.RawPtr(), &cap_size, cap_buffer_.RawPtr()));
+
+  if (buffer_.At<uint32_t>(0) != kSentinel) {
+    return glcr::InvalidResponse("Got an invalid response from server.");
+  }
+
+  // Check Response Code.
+  RET_ERR(buffer_.At<uint64_t>(8));
+
+
+  yunq::MessageView resp_view(buffer_, 16);
+  RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
+
+
+  return glcr::OK;
+}
+
+
+
+
+glcr::Status DenaliClient::ReadMany(const ReadManyRequest& request, ReadResponse& response) {
+
+  uint64_t buffer_size = kBufferSize;
+  uint64_t cap_size = kCapBufferSize;
+
+  const uint32_t kSentinel = 0xBEEFDEAD;
+  buffer_.WriteAt<uint32_t>(0, kSentinel);
+  buffer_.WriteAt<uint64_t>(8, 1);
+
+  cap_buffer_.Reset();
+
+  uint64_t length = request.SerializeToBytes(buffer_, /*offset=*/16, cap_buffer_);
+
+
+  buffer_.WriteAt<uint32_t>(4, 16 + length);
+
+  z_cap_t reply_port_cap;
+  RET_ERR(ZEndpointSend(endpoint_, 16 + length, buffer_.RawPtr(), cap_buffer_.UsedSlots(), cap_buffer_.RawPtr(), &reply_port_cap)); 
+
+  // FIXME: Add a way to zero out the first buffer.
+  RET_ERR(ZReplyPortRecv(reply_port_cap, &buffer_size, buffer_.RawPtr(), &cap_size, cap_buffer_.RawPtr()));
+
+  if (buffer_.At<uint32_t>(0) != kSentinel) {
+    return glcr::InvalidResponse("Got an invalid response from server.");
+  }
+
+  // Check Response Code.
+  RET_ERR(buffer_.At<uint64_t>(8));
+
+
+  yunq::MessageView resp_view(buffer_, 16);
+  RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
+
+
+  return glcr::OK;
+}
+
+
+
+

sys/denali/lib/denali/denali.yunq.cpp

@@ -0,0 +1,186 @@
+// Generated file -- DO NOT MODIFY.
+#include "denali.yunq.h"
+
+#include <yunq/message_view.h>
+#include <yunq/serialize.h>
+
+
+namespace {
+
+const uint64_t header_size = 24;  // 4x uint32, 1x uint64
+
+struct ExtPointer {
+  uint32_t offset;
+  uint32_t length;
+};
+
+}  // namespace
+glcr::Status DiskBlock::ParseFromBytes(const yunq::MessageView& message) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  return glcr::Status::Ok();
+}
+
+glcr::Status DiskBlock::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  return glcr::Status::Ok();
+}
+
+glcr::Status DiskBlock::ParseFromBytesInternal(const yunq::MessageView& message) {
+  RETURN_ERROR(message.CheckHeader());
+  // Parse lba.
+  ASSIGN_OR_RETURN(lba_, message.ReadField<uint64_t>(0));
+  // Parse size.
+  ASSIGN_OR_RETURN(size_, message.ReadField<uint64_t>(1));
+
+  return glcr::Status::Ok();
+}
+
+uint64_t DiskBlock::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
+  yunq::Serializer serializer(bytes, offset, 2);
+  return SerializeInternal(serializer);
+}
+
+uint64_t DiskBlock::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
+  yunq::Serializer serializer(bytes, offset, 2, caps);
+  return SerializeInternal(serializer);
+}
+  
+uint64_t DiskBlock::SerializeInternal(yunq::Serializer& serializer) const {
+  // Write lba.
+  serializer.WriteField<uint64_t>(0, lba_);
+  // Write size.
+  serializer.WriteField<uint64_t>(1, size_);
+
+  serializer.WriteHeader();
+
+  return serializer.size();
+}
+glcr::Status ReadRequest::ParseFromBytes(const yunq::MessageView& message) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  return glcr::Status::Ok();
+}
+
+glcr::Status ReadRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  return glcr::Status::Ok();
+}
+
+glcr::Status ReadRequest::ParseFromBytesInternal(const yunq::MessageView& message) {
+  RETURN_ERROR(message.CheckHeader());
+  // Parse device_id.
+  ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(0));
+  // Parse block.
+  message.ReadMessage<DiskBlock>(1, block_);
+
+  return glcr::Status::Ok();
+}
+
+uint64_t ReadRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
+  yunq::Serializer serializer(bytes, offset, 2);
+  return SerializeInternal(serializer);
+}
+
+uint64_t ReadRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
+  yunq::Serializer serializer(bytes, offset, 2, caps);
+  return SerializeInternal(serializer);
+}
+  
+uint64_t ReadRequest::SerializeInternal(yunq::Serializer& serializer) const {
+  // Write device_id.
+  serializer.WriteField<uint64_t>(0, device_id_);
+  // Write block.
+  serializer.WriteMessage<DiskBlock>(1, block_);
+
+  serializer.WriteHeader();
+
+  return serializer.size();
+}
+glcr::Status ReadManyRequest::ParseFromBytes(const yunq::MessageView& message) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  return glcr::Status::Ok();
+}
+
+glcr::Status ReadManyRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  return glcr::Status::Ok();
+}
+
+glcr::Status ReadManyRequest::ParseFromBytesInternal(const yunq::MessageView& message) {
+  RETURN_ERROR(message.CheckHeader());
+  // Parse device_id.
+  ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(0));
+  // Parse blocks.
+  message.ReadRepeatedMessage<DiskBlock>(1, blocks_);
+
+
+  return glcr::Status::Ok();
+}
+
+uint64_t ReadManyRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
+  yunq::Serializer serializer(bytes, offset, 2);
+  return SerializeInternal(serializer);
+}
+
+uint64_t ReadManyRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
+  yunq::Serializer serializer(bytes, offset, 2, caps);
+  return SerializeInternal(serializer);
+}
+  
+uint64_t ReadManyRequest::SerializeInternal(yunq::Serializer& serializer) const {
+  // Write device_id.
+  serializer.WriteField<uint64_t>(0, device_id_);
+  // Write blocks.
+  serializer.WriteRepeatedMessage<DiskBlock>(1, blocks_);
+
+  serializer.WriteHeader();
+
+  return serializer.size();
+}
+glcr::Status ReadResponse::ParseFromBytes(const yunq::MessageView& message) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  // Parse memory.
+  ASSIGN_OR_RETURN(memory_, message.ReadCapability(2));
+  return glcr::Status::Ok();
+}
+
+glcr::Status ReadResponse::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
+  RETURN_ERROR(ParseFromBytesInternal(message));
+  // Parse memory.
+  ASSIGN_OR_RETURN(memory_, message.ReadCapability(2, caps));
+  return glcr::Status::Ok();
+}
+
+glcr::Status ReadResponse::ParseFromBytesInternal(const yunq::MessageView& message) {
+  RETURN_ERROR(message.CheckHeader());
+  // Parse device_id.
+  ASSIGN_OR_RETURN(device_id_, message.ReadField<uint64_t>(0));
+  // Parse size.
+  ASSIGN_OR_RETURN(size_, message.ReadField<uint64_t>(1));
+  // Parse memory.
+
+  return glcr::Status::Ok();
+}
+
+uint64_t ReadResponse::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
+  yunq::Serializer serializer(bytes, offset, 3);
+  return SerializeInternal(serializer);
+}
+
+uint64_t ReadResponse::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
+  yunq::Serializer serializer(bytes, offset, 3, caps);
+  return SerializeInternal(serializer);
+}
+  
+uint64_t ReadResponse::SerializeInternal(yunq::Serializer& serializer) const {
+  // Write device_id.
+  serializer.WriteField<uint64_t>(0, device_id_);
+  // Write size.
+  serializer.WriteField<uint64_t>(1, size_);
+  // Write memory.
+  serializer.WriteCapability(2, memory_);
+
+  serializer.WriteHeader();
+
+  return serializer.size();
+}
+

sys/denali/lib/denali/denali.yunq.server.cpp

@@ -0,0 +1,152 @@
+// Generated file -- DO NOT MODIFY.
+#include "denali.yunq.server.h"
+
+#include <mammoth/util/debug.h>
+#include <zcall.h>
+
+
+namespace {
+
+const uint32_t kSentinel = 0xBEEFDEAD;
+const uint32_t kHeaderSize = 0x10;
+
+void WriteError(glcr::ByteBuffer& buffer, glcr::ErrorCode err) {
+  buffer.WriteAt<uint32_t>(0, kSentinel);
+  buffer.WriteAt<uint32_t>(4, kHeaderSize);
+  buffer.WriteAt<uint64_t>(8, err); 
+}
+
+void WriteHeader(glcr::ByteBuffer& buffer, uint64_t message_length) {
+  buffer.WriteAt<uint32_t>(0, kSentinel);
+  buffer.WriteAt<uint32_t>(4, kHeaderSize + message_length);
+  buffer.WriteAt<uint64_t>(8, glcr::OK); 
+}
+
+}  // namespace
+
+
+
+void DenaliServerBaseThreadBootstrap(void* server_base) {
+  ((DenaliServerBase*)server_base)->ServerThread();
+}
+
+DenaliServerBase::~DenaliServerBase() {
+  if (endpoint_ != 0) {
+    check(ZCapRelease(endpoint_));
+  }
+}
+
+glcr::ErrorOr<z_cap_t> DenaliServerBase::CreateClientCap() {
+  uint64_t client_cap;
+  RET_ERR(ZCapDuplicate(endpoint_, ~(kZionPerm_Read), &client_cap));
+  return client_cap;
+}
+
+glcr::ErrorOr<DenaliClient> DenaliServerBase::CreateClient() {
+  uint64_t client_cap;
+  RET_ERR(ZCapDuplicate(endpoint_, ~(kZionPerm_Read), &client_cap));
+  return DenaliClient(client_cap);
+}
+
+Thread DenaliServerBase::RunServer() {
+  return Thread(DenaliServerBaseThreadBootstrap, this);
+}
+
+void DenaliServerBase::ServerThread() {
+  glcr::ByteBuffer recv_buffer(0x1000);
+  glcr::CapBuffer recv_cap(0x10);
+  glcr::ByteBuffer resp_buffer(0x1000);
+  glcr::CapBuffer resp_cap(0x10);
+  z_cap_t reply_port_cap;
+
+  while (true) {
+    uint64_t recv_cap_size = 0x10;
+    uint64_t recv_buf_size = 0x1000;
+    recv_cap.Reset();
+    glcr::ErrorCode recv_err = static_cast<glcr::ErrorCode>(ZEndpointRecv(endpoint_, &recv_buf_size, recv_buffer.RawPtr(), &recv_cap_size, recv_cap.RawPtr(), &reply_port_cap));
+    if (recv_err != glcr::OK) {
+      dbgln("Error in receive: {x}", recv_err);
+      continue;
+    }
+
+    uint64_t resp_length = 0;
+    
+    glcr::ErrorCode reply_err = glcr::OK;
+    resp_cap.Reset();
+    glcr::Status err = HandleRequest(recv_buffer, recv_cap, resp_buffer, resp_length, resp_cap);
+    if (!err) {
+      WriteError(resp_buffer, err.code());
+      dbgln("Responding Error {}", err.message());
+      reply_err = static_cast<glcr::ErrorCode>(ZReplyPortSend(reply_port_cap, kHeaderSize, resp_buffer.RawPtr(), 0, nullptr));
+    } else {
+      WriteHeader(resp_buffer, resp_length);
+      reply_err = static_cast<glcr::ErrorCode>(ZReplyPortSend(reply_port_cap, kHeaderSize + resp_length, resp_buffer.RawPtr(), resp_cap.UsedSlots(), resp_cap.RawPtr()));
+    }
+    if (reply_err != glcr::OK) {
+      dbgln("Error in reply: {x}", reply_err);
+    }
+  }
+
+}
+
+glcr::Status DenaliServerBase::HandleRequest(const glcr::ByteBuffer& request,
+                                                         const glcr::CapBuffer& req_caps,
+                                                         glcr::ByteBuffer& response, uint64_t& resp_length,
+                                                         glcr::CapBuffer& resp_caps) {
+  if (request.At<uint32_t>(0) != kSentinel) {
+    return glcr::InvalidArgument("Request Not Valid");
+  } 
+  
+  uint64_t method_select = request.At<uint64_t>(8);
+
+  switch(method_select) {
+    case 0: {
+
+  
+      ReadRequest yunq_request;
+      yunq::MessageView request_view(request, kHeaderSize);
+      RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));
+  
+
+  
+      ReadResponse yunq_response;
+  
+
+  
+      RETURN_ERROR(HandleRead(yunq_request, yunq_response));
+  
+
+  
+      resp_length = yunq_response.SerializeToBytes(response, kHeaderSize, resp_caps);
+  
+      break;
+    }
+    case 1: {
+
+  
+      ReadManyRequest yunq_request;
+      yunq::MessageView request_view(request, kHeaderSize);
+      RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));
+  
+
+  
+      ReadResponse yunq_response;
+  
+
+  
+      RETURN_ERROR(HandleReadMany(yunq_request, yunq_response));
+  
+
+  
+      resp_length = yunq_response.SerializeToBytes(response, kHeaderSize, resp_caps);
+  
+      break;
+    }
+    default: {
+      return glcr::Unimplemented("Method unimplemented by server.");
+    }
+  }
+  return glcr::Status::Ok();
+}
+
+

yunq/yunq.py

@@ -45,6 +45,9 @@ def main():
         message_impl =  message_impl_tmpl.render(file=filebase, messages=messages, package=package)
         f.write(message_impl)
 
+    if len(interfaces) == 0:
+        return
+
     client_header_tmpl = jinja_env.get_template("client.h.jinja")
     with open(filename + '.client.h', mode='w') as f:
         client_header = client_header_tmpl.render(file=filebase, interfaces=interfaces, package=package)

zion/CMakeLists.txt

@@ -99,3 +99,10 @@ add_library(zion_stub STATIC
 target_include_directories(zion_stub
   PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
   PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+set_target_properties(zion_stub
+  PROPERTIES
+  COMPILE_FLAGS "${BASE_COMPILE_FLAGS} -nostdlib -c"
+  LINK_FLAGS "${BASE_LINK_FLAGS} -nostartfiles -static -lgcc"
+  )
+