@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/hkp-rt/lib/src/types/data.cpp

@@ -0,0 +1,237 @@
+#include <types/data.h>
+
+#include <boost/beast.hpp>
+
+#include <format>
+
+using json = nlohmann::json;
+namespace beast = boost::beast;
+namespace hkp
+{
+struct ControlFlowData::Impl 
+{
+  Data data;
+  Type type;
+};
+
+std::string stringify(const Data& data)
+{
+  if (isUndefined(data))
+  {
+    return "<undefined>";
+  }
+
+  if (isNull(data))
+  {
+    return "<null>";
+  }
+
+  auto json = getJSONFromData(data);
+  if (json)
+  {
+    // error_handler_t::replace: substitute U+FFFD for invalid UTF-8 rather than
+    // throwing. Streamed partial text can end mid-multibyte-character (e.g. a
+    // split emoji), and a throw here propagates out of the event-loop callback
+    // that serializes notifications and terminates the process.
+    return json->dump(-1, ' ', false, nlohmann::json::error_handler_t::replace);
+  }
+  
+  auto rb = getRingBufferFromData(data);
+  if (rb)
+  {
+    return "<ring buffer> s:" + std::to_string(rb->availableCount()) + " (r" + std::to_string(rb->getReadIndex()) + "w" + std::to_string(rb->getWriteIndex()) + ")";
+  }
+
+  auto str = getStringFromData(data);
+  if (str)
+  {
+    return "\"" + *str + "\""; 
+  }
+
+  auto bin = getBinaryFromData(data);
+  if (bin)
+  {
+    return "<binary data with size " + std::to_string(bin->size());
+  }
+
+  auto mixed = getMixedDataFromData(data);
+  if (mixed)
+  {
+    return mixed->meta.dump();
+  }
+
+  return "unknown type";
+}
+
+namespace hkp
+{
+  std::ostream& operator<<(std::ostream& os, const Data& data)
+  {
+    os << "Data.type: " << data.which() << " content: " << stringify(data);
+    return os;
+  }
+}
+
+std::optional<json> getJSONFromData(const Data &data)
+{
+  auto isJSON = data.type() == typeid(json);
+  return isJSON ? std::optional<json>(boost::get<json>(data)) : std::nullopt;
+}
+
+std::shared_ptr<FloatRingBuffer> getRingBufferFromData(const Data &data)
+{
+  auto isBuffer = data.type() == typeid(std::shared_ptr<FloatRingBuffer>);
+  return isBuffer ? boost::get<std::shared_ptr<FloatRingBuffer>>(data) : nullptr;
+}
+
+std::optional<const BinaryData> getBinaryFromData(const Data& data)
+{
+  auto isBinary = data.type() == typeid(const BinaryData);
+  return isBinary ? 
+    std::optional<const BinaryData>(boost::get<const BinaryData>(data)) :
+    std::nullopt;
+}
+
+std::optional<const std::string> getStringFromData(const Data& data)
+{
+  auto isString = data.type() == typeid(const std::string);
+  return isString ? 
+    std::optional<const std::string>(boost::get<const std::string>(data)) :
+    std::nullopt;
+}
+
+std::optional<CustomData> getCustomDataFromData(const Data& data)
+{
+  auto isCustom = data.type() == typeid(CustomData);
+  return isCustom ?
+    std::optional<CustomData>(boost::get<CustomData>(data)) :
+    std::nullopt;
+}
+
+std::optional<MixedData> getMixedDataFromData(const Data& data)
+{
+  auto isMixed = data.type() == typeid(MixedData);
+  return isMixed ?
+    std::optional<MixedData>(boost::get<MixedData>(data)) :
+    std::nullopt;
+}
+
+Data getControlFlowData(const Data &data)
+{
+  auto isCtrlFlow = data.type() == typeid(ControlFlowData);
+  return isCtrlFlow ? boost::get<ControlFlowData>(data).impl->data : Null();
+}
+
+bool isEarlyReturn(const Data& data)
+{
+  auto isCtrlFlow = data.type() == typeid(ControlFlowData);
+  if (isCtrlFlow)
+  {
+    auto cf = boost::get<ControlFlowData>(data);
+    return cf.impl->type == ControlFlowData::Type::kEarlyReturn;
+  }
+  return false;
+}
+
+bool isCustomData(const Data& data)
+{
+  return data.type() == typeid(CustomData);
+}
+
+bool isUndefined(const Data& data)
+{
+  return data.type() == typeid(Undefined);
+}
+
+bool isNull(const Data& data)
+{
+  return data.type() == typeid(Null);
+}
+
+bool isControlFlowData(const Data& data)
+{
+  return data.type() == typeid(ControlFlowData);
+}
+
+Data flatBufferToData(FloatRingBuffer::BufferType& buffer, bool isBinary) 
+{
+  auto data = static_cast<const uint8_t*>(buffer.data().data());
+  if (isBinary)
+  {
+    return Data(std::vector<uint8_t>(data, data + buffer.size()));
+  }
+  
+  std::string ascii(data, data + buffer.size());
+  try {
+    auto j = json::parse(ascii); // TODO: this is kind of brute force -> send the type information with the data
+    return j.is_null() ? Data(ascii) : Data(j);
+  } catch (const std::exception& e) {
+    return Data(ascii);
+  }  
+}
+
+template <>
+std::optional<bool> getProperty(const json& j, const std::string& key)
+{
+  auto it = j.find(key);
+  if (it == j.end() || it->is_null() || !it->is_boolean()) 
+  {
+    return std::nullopt;
+  }
+  return it->get<bool>();
+}
+
+template <>
+std::optional<float> getProperty(const json& j, const std::string& key)
+{
+  auto it = j.find(key);
+  if (it == j.end()) 
+  {
+    return std::nullopt;
+  }
+  return it->get<float>();
+}
+
+template <>
+std::optional<unsigned int> getProperty(const json& j, const std::string& key)
+{
+  auto it = j.find(key);
+  if (it == j.end()) 
+  {
+    return std::nullopt;
+  }
+  return it->get<unsigned int>();
+}
+
+template <>
+std::optional<std::string> getProperty(const json& j, const std::string& key)
+{
+  auto it = j.find(key);
+  if (it == j.end()) 
+  {
+    return std::nullopt;
+  }
+  return it->get<std::string>();
+}
+
+template <>
+std::optional<json> getProperty(const json& j, const std::string& key)
+{
+  auto it = j.find(key);
+  if (it == j.end()) 
+  {
+    return std::nullopt;
+  }
+  return it->get<json>();
+}
+
+ControlFlowData makeEarlyReturn(const Data& data)
+{
+  ControlFlowData cf;
+  cf.impl = std::make_shared<ControlFlowData::Impl>();
+  cf.impl->type = ControlFlowData::Type::kEarlyReturn;
+  cf.impl->data = data;
+  return cf;
+}
+
+}

package/bundle/hkp-rt/lib/src/types/message.cpp

@@ -0,0 +1,148 @@
+#include <types/message.h>
+
+#include <cstring>
+
+#include <yas/buffers.hpp>
+#include <yas/serialize.hpp>
+#include <yas/std_types.hpp>
+
+namespace hkp {
+
+namespace {
+
+// Builds the YAS header + payload buffers for a message. Shared by every
+// serialize variant so the wire format stays identical regardless of transport.
+void buildFrame(const Data& data, MessagePurpose purpose, const std::string& sender,
+                yas::shared_buffer& header, yas::shared_buffer& payload)
+{
+  uint16_t purposeValue = purpose;
+  uint16_t dataType = getTypeId(data);
+  constexpr std::size_t flags = yas::mem | yas::binary;
+
+  auto o = YAS_OBJECT_NVP(nullptr,
+     ("messagePurpose", purposeValue),
+     ("dataType", dataType),
+     ("sender", sender)
+  );
+  header = yas::save<flags>(o);
+
+  if (auto binary = getBinaryFromData(data))
+  {
+    payload.assign(&(*binary)[0], binary->size());
+  }
+  else if (auto rb = getRingBufferFromData(data))
+  {
+    payload = rb->serialise();
+  }
+  else if (isUndefined(data))
+  {
+    payload = yas::shared_buffer("0", 1);
+  }
+  else if (isNull(data))
+  {
+    payload = yas::shared_buffer("0", 1);
+  }
+  else
+  {
+    auto str = stringify(data);
+    payload = yas::save<flags>(YAS_OBJECT_NVP(nullptr, ("value", str)));
+  }
+}
+
+}  // namespace
+
+
+Data Message::deserialize(BufferType& buffer, MessageHeader* outHeader)
+{
+  unsigned int size = static_cast<unsigned int>(buffer.size()); // TODO: check for size limits
+  const char *rawData = reinterpret_cast<const char *>(buffer.data().data());
+  yas::intrusive_buffer buf(rawData, size);
+
+  uint16_t purposeValue;
+  uint16_t dataType;
+  std::string sender;
+  auto iobj = YAS_OBJECT_NVP(
+    nullptr,
+    ("messagePurpose", purposeValue),
+    ("dataType", dataType),
+    ("sender", sender)
+  );
+
+  constexpr std::size_t flags = yas::mem | yas::binary;
+  yas::load<flags>(buf, iobj);
+
+  size_t messageHeaderSize = 7 // YAS header 
+    + sizeof(purposeValue) 
+    + sizeof(dataType) 
+    + 8 // length of type for storing sender string
+    + sender.size();
+  buffer.consume(messageHeaderSize); // consume the header
+
+  if (outHeader)
+  {
+    outHeader->messagePurpose = purposeValue;
+    outHeader->dataType = dataType;
+    outHeader->sender = sender;
+  }
+  
+  if (dataType == getTypeId<FloatRingBuffer>())
+  {
+    auto data = std::make_shared<FloatRingBuffer>("Result.FloatRingBuffer");
+    FloatRingBuffer::createFromSerialised(buffer, size, *data);
+    return data;
+  }
+  else if (dataType == getTypeId<Null>())
+  {
+    return Null();
+  }
+  else if (dataType == getTypeId<BinaryData>())
+  {
+    // No inner YAS object: the bytes run to the end of the frame.
+    auto bytes = buffer.data();
+    auto begin = static_cast<const uint8_t*>(bytes.data());
+    BinaryData binary(begin, begin + bytes.size());
+    buffer.consume(bytes.size());
+    return binary;
+  }
+  
+  std::cerr << "Message::deserialize data type is not suported" << std::endl;
+  return Null();
+}
+
+void Message::serialize(const Data& data, MessagePurpose purpose, const std::string& sender, WebSocketStream& stream)
+{
+  yas::shared_buffer header;
+  yas::shared_buffer payload;
+  buildFrame(data, purpose, sender, header, payload);
+
+  stream.binary(true);
+  std::vector<boost::asio::const_buffer> buffers{
+    boost::asio::const_buffer(header.data.get(), header.size),
+    boost::asio::const_buffer(payload.data.get(), payload.size)
+  };
+  stream.write(buffers);
+}
+
+std::string Message::serializeToString(const Data& data, MessagePurpose purpose, const std::string& sender)
+{
+  yas::shared_buffer header;
+  yas::shared_buffer payload;
+  buildFrame(data, purpose, sender, header, payload);
+
+  std::string out;
+  out.reserve(header.size + payload.size);
+  out.append(reinterpret_cast<const char*>(header.data.get()), header.size);
+  out.append(reinterpret_cast<const char*>(payload.data.get()), payload.size);
+  return out;
+}
+
+Data Message::deserializeFromString(const std::string& bytes, MessageHeader* outHeader)
+{
+  BufferType buffer;
+  auto mutableArea = buffer.prepare(bytes.size());
+  std::memcpy(mutableArea.data(), bytes.data(), bytes.size());
+  buffer.commit(bytes.size());
+  return deserialize(buffer, outHeader);
+}
+
+}

package/bundle/hkp-rt/lib/src/types/models.cpp

@@ -0,0 +1,83 @@
+#include <types/models.h>
+
+namespace hkp {
+
+json jsonSerialise(const RuntimeConfiguration& conf)
+{
+  json j;
+  j["id"] = conf.runtimeId;
+  j["name"] = conf.runtimeName;
+  j["boardName"] = conf.boardName;
+  json services = json::array();
+  for (auto& svc : conf.services)
+  {
+    json service;
+    service["serviceId"] = svc.serviceId;
+    service["serviceName"] = svc.instanceName.empty() ? svc.serviceId : svc.instanceName;
+    service["uuid"] = svc.instanceId;
+    if (!svc.version.empty())
+    {
+      service["version"] = svc.version;
+    }
+    service["capabilities"] = svc.capabilities;
+    service["state"] = svc.state;
+    services.push_back(service);
+  }
+  j["services"] = services;
+  if (!conf.outputUrl.empty())
+  {
+    j["outputUrl"] = conf.outputUrl;
+  }
+  auto inputs = j["inputs"] = json::array();
+  for (auto& input : conf.inputs)
+  {
+    inputs.push_back(jsonSerialise(input));
+  }
+  
+  return j;
+}
+
+json jsonSerialise(const RuntimeInput& input)
+{
+  json j;
+  j["id"] = input.id;
+  j["url"] = input.url;
+  j["type"] = runtimeTypeAsString(input.type);
+  j["runtimeId"] = input.runtimeId;
+  j["runtimeUrl"] = input.runtimeUrl;
+  j["serviceId"] = input.serviceId;
+  return j;
+}
+
+std::string runtimeTypeAsString(RuntimeInput::Type t)
+{
+  switch (t)
+  {
+    case RuntimeInput::PROCESS:
+      return "process";
+    case RuntimeInput::CONFIGURE:
+      return "configure";
+    case RuntimeInput::EXTERNAL:
+      return "external";
+  }
+  return "unknown";
+}
+
+RuntimeInput::Type parseRuntimeType(const std::string& t)
+{
+  if (t == "process")
+  {
+    return RuntimeInput::PROCESS;
+  }
+  if (t == "configure")
+  {
+    return RuntimeInput::CONFIGURE;
+  }
+  if (t == "external")
+  {
+    return RuntimeInput::EXTERNAL;
+  }
+  throw std::runtime_error("Unknown runtime type: " + t);
+}
+
+}