drew/acadia
1
0
Fork 0
Code Issues 6 Pull requests Projects Releases Packages Wiki Activity Actions

[Yunq] Add support for nested fields in messages.

Browse source
This commit is contained in:
Drew Galbraith 2024-01-11 21:32:08 -08:00
parent 9e12531651
commit a48d63a664
18 changed files with 257 additions and 219 deletions
Download patch file Download diff file Expand all files Collapse all files

7
yunq/example/example.yunq.client.cpp
View file

@ -20,7 +20,7 @@ VFSClient::~VFSClient() {
glcr::ErrorCode VFSClient::open(const OpenFileRequest& request, File& response) {
glcr::Status VFSClient::open(const OpenFileRequest& request, File& response) {
uint64_t buffer_size = kBufferSize;
uint64_t cap_size = kCapBufferSize;
@ -43,14 +43,15 @@ glcr::ErrorCode VFSClient::open(const OpenFileRequest& request, File& response)
RET_ERR(ZReplyPortRecv(reply_port_cap, &buffer_size, buffer_.RawPtr(), &cap_size, cap_buffer_.RawPtr()));
if (buffer_.At<uint32_t>(0) != kSentinel) {
return glcr::INVALID_RESPONSE;
return glcr::InvalidResponse("Got an invalid response from server.");
}
// Check Response Code.
RET_ERR(buffer_.At<uint64_t>(8));
response.ParseFromBytes(buffer_, 16, cap_buffer_);
yunq::MessageView resp_view(buffer_, 16);
RETURN_ERROR(response.ParseFromBytes(resp_view, cap_buffer_));
return glcr::OK;

2
yunq/example/example.yunq.client.h
View file

@ -22,7 +22,7 @@ class VFSClient {
[[nodiscard]] glcr::ErrorCode open(const OpenFileRequest& request, File& response);
[[nodiscard]] glcr::Status open(const OpenFileRequest& request, File& response);
private:

200
yunq/example/example.yunq.cpp
View file

@ -1,6 +1,9 @@
// Generated file -- DO NOT MODIFY.
#include "example.yunq.h"
#include <yunq/message_view.h>
#include <yunq/serialize.h>
namespace srv::file {
@ -13,197 +16,94 @@ struct ExtPointer {
uint32_t length;
};
void CheckHeader(const glcr::ByteBuffer& bytes) {
// TODO: Check ident.
// TODO: Parse core size.
// TODO: Parse extension size.
// TODO: Check CRC32
// TODO: Parse options.
}
void WriteHeader(glcr::ByteBuffer& bytes, uint64_t offset, uint32_t core_size, uint32_t extension_size) {
bytes.WriteAt<uint32_t>(offset + 0, 0xDEADBEEF); // TODO: Chose a more unique ident sequence.
bytes.WriteAt<uint32_t>(offset + 4, core_size);
bytes.WriteAt<uint32_t>(offset + 8, extension_size);
bytes.WriteAt<uint32_t>(offset + 12, 0); // TODO: Calculate CRC32.
bytes.WriteAt<uint64_t>(offset + 16, 0); // TODO: Add options.
}
} // namespace
void OpenFileRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
ParseFromBytesInternal(bytes, offset);
glcr::Status OpenFileRequest::ParseFromBytes(const yunq::MessageView& message) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
void OpenFileRequest::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
ParseFromBytesInternal(bytes, offset);
glcr::Status OpenFileRequest::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message));
return glcr::Status::Ok();
}
void OpenFileRequest::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
CheckHeader(bytes);
glcr::Status OpenFileRequest::ParseFromBytesInternal(const yunq::MessageView& message) {
RETURN_ERROR(message.CheckHeader());
// Parse path.
auto path_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 0));
set_path(bytes.StringAt(offset + path_pointer.offset, path_pointer.length));
ASSIGN_OR_RETURN(path_, message.ReadField<glcr::String>(0));
// Parse options.
auto options_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 1));
options_.Resize(options_pointer.length / sizeof(uint64_t));
for (uint64_t i = offset + options_pointer.offset;
i < offset + options_pointer.offset + options_pointer.length;
i += sizeof(uint64_t)) {
options_.PushBack(bytes.At<uint64_t>(i));
}
ASSIGN_OR_RETURN(options_, message.ReadRepeated<uint64_t>(1));
return glcr::Status::Ok();
}
uint64_t OpenFileRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
uint32_t next_extension = header_size + 8 * 2;
const uint32_t core_size = next_extension;
// Write path.
ExtPointer path_ptr{
.offset = next_extension,
// FIXME: Check downcast of str length.
.length = (uint32_t)path().length(),
};
bytes.WriteStringAt(offset + next_extension, path());
next_extension += path_ptr.length;
bytes.WriteAt<ExtPointer>(offset + header_size + (8 * 0), path_ptr);
// Write options.
ExtPointer options_ptr{
.offset = next_extension,
.length = (uint32_t)(options().size() * sizeof(uint64_t)),
};
next_extension += options_ptr.length;
bytes.WriteAt<ExtPointer>(offset + header_size + (8 * 1), options_ptr);
for (uint64_t i = 0; i < options().size(); i++) {
uint32_t ext_offset = offset + options_ptr.offset + (i * sizeof(uint64_t));
bytes.WriteAt<uint64_t>(ext_offset, options().at(i));
}
// The next extension pointer is the length of the message.
WriteHeader(bytes, offset, core_size, next_extension);
return next_extension;
yunq::Serializer serializer(bytes, offset, 2);
return SerializeInternal(serializer);
}
uint64_t OpenFileRequest::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
uint32_t next_extension = header_size + 8 * 2;
const uint32_t core_size = next_extension;
uint64_t next_cap = 0;
yunq::Serializer serializer(bytes, offset, 2, caps);
return SerializeInternal(serializer);
}
uint64_t OpenFileRequest::SerializeInternal(yunq::Serializer& serializer) const {
// Write path.
ExtPointer path_ptr{
.offset = next_extension,
// FIXME: Check downcast of str length.
.length = (uint32_t)path().length(),
};
bytes.WriteStringAt(offset + next_extension, path());
next_extension += path_ptr.length;
bytes.WriteAt<ExtPointer>(offset + header_size + (8 * 0), path_ptr);
serializer.WriteField<glcr::String>(0, path_);
// Write options.
ExtPointer options_ptr{
.offset = next_extension,
.length = (uint32_t)(options().size() * sizeof(uint64_t)),
};
serializer.WriteRepeated<uint64_t>(1, options_);
next_extension += options_ptr.length;
bytes.WriteAt<ExtPointer>(offset + header_size + (8 * 1), options_ptr);
serializer.WriteHeader();
for (uint64_t i = 0; i < options().size(); i++) {
uint32_t ext_offset = offset + options_ptr.offset + (i * sizeof(uint64_t));
bytes.WriteAt<uint64_t>(ext_offset, options().at(i));
}
// The next extension pointer is the length of the message.
WriteHeader(bytes, offset, core_size, next_extension);
return next_extension;
return serializer.size();
}
void File::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset) {
ParseFromBytesInternal(bytes, offset);
glcr::Status File::ParseFromBytes(const yunq::MessageView& message) {
RETURN_ERROR(ParseFromBytesInternal(message));
// Parse mem_cap.
// FIXME: Implement in-buffer capabilities for inprocess serialization.
set_mem_cap(0);
ASSIGN_OR_RETURN(mem_cap_, message.ReadCapability(2));
return glcr::Status::Ok();
}
void File::ParseFromBytes(const glcr::ByteBuffer& bytes, uint64_t offset, const glcr::CapBuffer& caps) {
ParseFromBytesInternal(bytes, offset);
glcr::Status File::ParseFromBytes(const yunq::MessageView& message, const glcr::CapBuffer& caps) {
RETURN_ERROR(ParseFromBytesInternal(message));
// Parse mem_cap.
uint64_t mem_cap_ptr = bytes.At<uint64_t>(offset + header_size + (8 * 2));
set_mem_cap(caps.At(mem_cap_ptr));
ASSIGN_OR_RETURN(mem_cap_, message.ReadCapability(2, caps));
return glcr::Status::Ok();
}
void File::ParseFromBytesInternal(const glcr::ByteBuffer& bytes, uint64_t offset) {
CheckHeader(bytes);
glcr::Status File::ParseFromBytesInternal(const yunq::MessageView& message) {
RETURN_ERROR(message.CheckHeader());
// Parse path.
auto path_pointer = bytes.At<ExtPointer>(offset + header_size + (8 * 0));
set_path(bytes.StringAt(offset + path_pointer.offset, path_pointer.length));
ASSIGN_OR_RETURN(path_, message.ReadField<glcr::String>(0));
// Parse attrs.
set_attrs(bytes.At<uint64_t>(offset + header_size + (8 * 1)));
ASSIGN_OR_RETURN(attrs_, message.ReadField<uint64_t>(1));
// Parse mem_cap.
// Skip Cap.
return glcr::Status::Ok();
}
uint64_t File::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset) const {
uint32_t next_extension = header_size + 8 * 3;
const uint32_t core_size = next_extension;
// Write path.
ExtPointer path_ptr{
.offset = next_extension,
// FIXME: Check downcast of str length.
.length = (uint32_t)path().length(),
};
bytes.WriteStringAt(offset + next_extension, path());
next_extension += path_ptr.length;
bytes.WriteAt<ExtPointer>(offset + header_size + (8 * 0), path_ptr);
// Write attrs.
bytes.WriteAt<uint64_t>(offset + header_size + (8 * 1), attrs());
// Write mem_cap.
// FIXME: Implement inbuffer capabilities.
bytes.WriteAt<uint64_t>(offset + header_size + (8 * 2), 0);
// The next extension pointer is the length of the message.
WriteHeader(bytes, offset, core_size, next_extension);
return next_extension;
yunq::Serializer serializer(bytes, offset, 3);
return SerializeInternal(serializer);
}
uint64_t File::SerializeToBytes(glcr::ByteBuffer& bytes, uint64_t offset, glcr::CapBuffer& caps) const {
uint32_t next_extension = header_size + 8 * 3;
const uint32_t core_size = next_extension;
uint64_t next_cap = 0;
yunq::Serializer serializer(bytes, offset, 3, caps);
return SerializeInternal(serializer);
}
uint64_t File::SerializeInternal(yunq::Serializer& serializer) const {
// Write path.
ExtPointer path_ptr{
.offset = next_extension,
// FIXME: Check downcast of str length.
.length = (uint32_t)path().length(),
};
bytes.WriteStringAt(offset + next_extension, path());
next_extension += path_ptr.length;
bytes.WriteAt<ExtPointer>(offset + header_size + (8 * 0), path_ptr);
serializer.WriteField<glcr::String>(0, path_);
// Write attrs.
bytes.WriteAt<uint64_t>(offset + header_size + (8 * 1), attrs());
serializer.WriteField<uint64_t>(1, attrs_);
// Write mem_cap.
caps.WriteAt(next_cap, mem_cap());
bytes.WriteAt<uint64_t>(offset + header_size + (8 * 2), next_cap++);
serializer.WriteCapability(2, mem_cap_);
// The next extension pointer is the length of the message.
WriteHeader(bytes, offset, core_size, next_extension);
serializer.WriteHeader();
return next_extension;
return serializer.size();
}

19
yunq/example/example.yunq.h
View file

@ -3,8 +3,11 @@
#include <glacier/buffer/byte_buffer.h>
#include <glacier/buffer/cap_buffer.h>
#include <glacier/status/status.h>
#include <glacier/container/vector.h>
#include <glacier/string/string.h>
#include <yunq/message_view.h>
#include <yunq/serialize.h>
#include <ztypes.h>
@ -17,8 +20,8 @@ class OpenFileRequest {
OpenFileRequest(const OpenFileRequest&) = delete;
OpenFileRequest(OpenFileRequest&&) = delete;
void ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
void ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
[[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 glcr::String& path() const { return path_; }
@ -31,7 +34,9 @@ class OpenFileRequest {
glcr::Vector<uint64_t> options_;
// Parses everything except for caps.
void ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message);
uint64_t SerializeInternal(yunq::Serializer& serializer) const;
};
class File {
public:
@ -40,8 +45,8 @@ class File {
File(const File&) = delete;
File(File&&) = delete;
void ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset);
void ParseFromBytes(const glcr::ByteBuffer&, uint64_t offset, const glcr::CapBuffer&);
[[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 glcr::String& path() const { return path_; }
@ -57,7 +62,9 @@ class File {
z_cap_t mem_cap_;
// Parses everything except for caps.
void ParseFromBytesInternal(const glcr::ByteBuffer&, uint64_t offset);
glcr::Status ParseFromBytesInternal(const yunq::MessageView& message);
uint64_t SerializeInternal(yunq::Serializer& serializer) const;
};

26
yunq/example/example.yunq.server.cpp
View file

@ -75,9 +75,10 @@ void VFSServerBase::ServerThread() {
glcr::ErrorCode reply_err = glcr::OK;
resp_cap.Reset();
glcr::ErrorCode err = HandleRequest(recv_buffer, recv_cap, resp_buffer, resp_length, resp_cap);
if (err != glcr::OK) {
WriteError(resp_buffer, err);
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);
@ -90,12 +91,12 @@ void VFSServerBase::ServerThread() {
}
glcr::ErrorCode VFSServerBase::HandleRequest(const glcr::ByteBuffer& request,
const glcr::CapBuffer& req_caps,
glcr::ByteBuffer& response, uint64_t& resp_length,
glcr::CapBuffer& resp_caps) {
glcr::Status VFSServerBase::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::INVALID_ARGUMENT;
return glcr::InvalidArgument("Request Not Valid");
}
uint64_t method_select = request.At<uint64_t>(8);
@ -105,7 +106,8 @@ glcr::ErrorCode VFSServerBase::HandleRequest(const glcr::ByteBuffer& request,
OpenFileRequest yunq_request;
yunq_request.ParseFromBytes(request, kHeaderSize, req_caps);
yunq::MessageView request_view(request, kHeaderSize);
RETURN_ERROR(yunq_request.ParseFromBytes(request_view, req_caps));
@ -113,7 +115,7 @@ glcr::ErrorCode VFSServerBase::HandleRequest(const glcr::ByteBuffer& request,
RET_ERR(Handleopen(yunq_request, yunq_response));
RETURN_ERROR(Handleopen(yunq_request, yunq_response));
@ -122,10 +124,10 @@ glcr::ErrorCode VFSServerBase::HandleRequest(const glcr::ByteBuffer& request,
break;
}
default: {
return glcr::UNIMPLEMENTED;
return glcr::Unimplemented("Method unimplemented by server.");
}
}
return glcr::OK;
return glcr::Status::Ok();
}

9
yunq/example/example.yunq.server.h
View file

@ -2,6 +2,7 @@
#pragma once
#include <glacier/status/error_or.h>
#include <glacier/status/status.h>
#include <mammoth/proc/thread.h>
#include <ztypes.h>
@ -28,7 +29,7 @@ class VFSServerBase {
[[nodiscard]] virtual glcr::ErrorCode Handleopen(const OpenFileRequest&, File&) = 0;
[[nodiscard]] virtual glcr::Status Handleopen(const OpenFileRequest&, File&) = 0;
@ -38,9 +39,9 @@ class VFSServerBase {
friend void VFSServerBaseThreadBootstrap(void*);
void ServerThread();
[[nodiscard]] glcr::ErrorCode HandleRequest(const glcr::ByteBuffer& request, const glcr::CapBuffer& req_caps,
glcr::ByteBuffer& response, uint64_t& resp_length,
glcr::CapBuffer& resp_caps);
[[nodiscard]] glcr::Status HandleRequest(const glcr::ByteBuffer& request, const glcr::CapBuffer& req_caps,
glcr::ByteBuffer& response, uint64_t& resp_length,
glcr::CapBuffer& resp_caps);
};

18
yunq/message.cpp.jinja
View file

@ -58,7 +58,15 @@ glcr::Status {{message.name}}::ParseFromBytesInternal(const yunq::MessageView& m
{%- for field in message.fields %}
// Parse {{field.name}}.
{%- if field.type != Type.CAPABILITY %}
{%- if field.type == Type.MESSAGE %}
{%- if not field.repeated %}
message.ReadMessage<{{field.cpp_type()}}>({{field.number}}, {{field.name}}_);
{%- else %}
message.ReadMessageRepeated<{{field.cpp_type()}}>({{field.number}}, {{field.name}}_);
{% endif %}
{%- elif field.type != Type.CAPABILITY %}
{%- if not field.repeated %}
ASSIGN_OR_RETURN({{field.name}}_, message.ReadField<{{field.cpp_type()}}>({{field.number}}));
@ -87,10 +95,12 @@ uint64_t {{message.name}}::SerializeInternal(yunq::Serializer& serializer) const
// Write {{field.name}}.
{%- if not field.repeated %}
{%- if field.type != Type.CAPABILITY %}
serializer.WriteField<{{field.cpp_type()}}>({{field.number}}, {{field.name}}_);
{%- else %}
{%- if field.type == Type.MESSAGE %}
serializer.WriteMessage<{{field.cpp_type()}}>({{field.number}}, {{field.name}}_);
{%- elif field.type == Type.CAPABILITY %}
serializer.WriteCapability({{field.number}}, {{field.name}}_);
{%- else %}
serializer.WriteField<{{field.cpp_type()}}>({{field.number}}, {{field.name}}_);
{%- endif %}
{%- else %}

8
yunq/message.h.jinja
View file

@ -28,6 +28,12 @@ class {{message.name}} {
uint64_t SerializeToBytes(glcr::ByteBuffer&, uint64_t offset, glcr::CapBuffer&) const;
{%- for field in message.fields %}
{%- if field.type == Type.MESSAGE %}
const {{field.cpp_type()}}& {{field.name}}() const { return {{field.name}}_; }
{{field.cpp_type()}}& mutable_{{field.name}}() { return {{field.name}}_; }
{%- else %}
{%- if not field.repeated %}
const {{field.cpp_type()}}& {{field.name}}() const { return {{field.name}}_; }
void set_{{field.name}}(const {{field.cpp_type()}}& value) { {{field.name}}_ = value; }
@ -35,6 +41,8 @@ class {{message.name}} {
const glcr::Vector<{{field.cpp_type()}}>& {{field.name}}() const { return {{field.name}}_; }
void add_{{field.name}}(const {{field.cpp_type()}}& value) { {{field.name}}_.PushBack(value); }
{%- endif %}
{%- endif %}
{%- endfor %}
private:

23
yunq/parser.py
View file

@ -106,6 +106,7 @@ class Type(Enum):
STRING = 3
BYTES = 4
CAPABILITY = 5
MESSAGE = 6
type_str_dict = {
"u64": Type.U64,
@ -124,12 +125,18 @@ type_to_cppstr = {
}
class Field():
def __init__(self, fieldtype: Type, name: str, repeated = False):
self.type = fieldtype
def __init__(self, field_type_str: str, name: str, repeated = False):
if field_type_str in type_str_dict.keys():
self.type = type_str_dict[field_type_str]
else:
self.type = Type.MESSAGE
self.type_str = field_type_str
self.name = name
self.repeated = repeated
def cpp_type(self):
if self.type == Type.MESSAGE:
return self.type_str
return type_to_cppstr[self.type]
class Message():
@ -293,14 +300,10 @@ class Parser():
if field_type_str == "repeated":
repeated = True
field_type_str = self.consume_identifier()
if field_type_str not in type_str_dict.keys():
sys.exit("Expected type got '%s'" % field_type_str)
field_type = type_str_dict[field_type_str]
name = self.consume_identifier()
self.consume_check(LexemeType.SEMICOLON)
return Field(field_type, name, repeated)
return Field(field_type_str, name, repeated)
def type_check(decls: list[Decl]):
if sum(1 for decl in decls if type(decl) is Package) > 1:
@ -320,6 +323,12 @@ def type_check(decls: list[Decl]):
sys.exit("Response type '%s' for '%s.%s' does not exist" % (method.response, decl.name, method.name))
if type(name_dict[method.response]) is not Message:
sys.exit("Response type '%s' for '%s.%s' should be a message" % (method.response, decl.name, method.name))
elif type(decl) is Message:
for field in decl.fields:
if field.type == Type.MESSAGE:
if field.type_str not in name_dict.keys():
sys.exit("Field type '%s' for field '%s' in message '%s' not found." %
(field.type_str, field.name, decl.name))
def print_ast(decls: list[Decl]):
for decl in decls:

1
yunq/yunq.py
View file

@ -34,6 +34,7 @@ def main():
jinja_env = Environment(loader=FileSystemLoader(pathlib.Path(__file__).parent.resolve()))
message_header_tmpl = jinja_env.get_template("message.h.jinja")
message_header_tmpl.globals['Type'] = Type
with open(filename + '.h', mode='w') as f:
message_header = message_header_tmpl.render(messages=messages, package=package)
f.write(message_header)