Add more boilerplate code for the actual api

Author: mathisloge

cppesphomeapi/api.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-
+package cppesphomeapi.proto;
 import "api_options.proto";
 
 service APIConnection {

cppesphomeapi/api_options.proto

@@ -1,4 +1,5 @@
 syntax = "proto2";
+package cppesphomeapi.proto;
 import "google/protobuf/descriptor.proto";
 
 enum APISourceType {

cppesphomeapi/include/cppesphomeapi/api_client.hpp

@@ -4,23 +4,27 @@
 #include <memory>
 #include <string>
 #include <cppesphomeapi/cppesphomeapi_export.hpp>
+#include "async_result.hpp"
 
 namespace cppesphomeapi
 {
+class ApiConnection;
+
 class CPPESPHOMEAPI_EXPORT ApiClient
 {
   public:
-    ApiClient(std::string hostname, std::uint16_t port = 6053, std::string password = "");
+    explicit ApiClient(const boost::asio::any_io_executor &executor, std::string hostname, std::uint16_t port = 6053, std::string password = "");
     ~ApiClient();
 
+    AsyncResult<void> connect();
+
     ApiClient(const ApiClient &) = delete;
     ApiClient(ApiClient &&) = delete;
     ApiClient &operator=(const ApiClient &) = delete;
     ApiClient &operator=(ApiClient &&) = delete;
 
   private:
-    class Impl;
-    std::unique_ptr<Impl> impl_;
+    std::unique_ptr<ApiConnection> connection_;
 };
 } // namespace cppesphomeapi
 #endif

cppesphomeapi/include/cppesphomeapi/result.hpp

@@ -8,8 +8,10 @@ namespace cppesphomeapi
 
 enum ApiErrorCode
 {
+    SerializeError,
     ParseError,
-    UnexpectedMessage
+    UnexpectedMessage,
+    SendError
 };
 
 struct ApiError

cppesphomeapi/src/CMakeLists.txt

@@ -1,4 +1,6 @@
 target_sources(cppesphomeapi PRIVATE
     api_client.cpp
     make_unexpected_result.cpp
+    plain_text_protocol.cpp
+    api_connection.cpp
 )

cppesphomeapi/src/api_client.cpp

@@ -1,12 +1,18 @@
 #include "cppesphomeapi/api_client.hpp"
+#include "api_connection.hpp"
 namespace cppesphomeapi
 {
-class ApiClient::Impl
-{};
-
-ApiClient::ApiClient(std::string hostname, std::uint16_t port, std::string password)
-    : impl_{std::make_unique<Impl>()}
+ApiClient::ApiClient(const boost::asio::any_io_executor &executor,
+                     std::string hostname,
+                     std::uint16_t port,
+                     std::string password)
+    : connection_{std::make_unique<ApiConnection>(std::move(hostname), port, std::move(password), executor)}
 {}
 
 ApiClient::~ApiClient() = default;
+
+AsyncResult<void> ApiClient::connect()
+{
+    co_return co_await connection_->connect();
+}
 } // namespace cppesphomeapi

cppesphomeapi/src/api_connection.cpp

@@ -0,0 +1,71 @@
+#include "api_connection.hpp"
+#include <print>
+#include "api.pb.h"
+#include "make_unexpected_result.hpp"
+
+namespace asio = boost::asio;
+namespace this_coro = asio::this_coro;
+
+namespace cppesphomeapi
+{
+ApiConnection::ApiConnection(std::string hostname,
+                             std::uint16_t port,
+                             std::string password,
+                             const asio::any_io_executor &executor)
+    : hostname_{std::move(hostname)}
+    , port_{port}
+    , password_{std::move(password)}
+    , strand_{asio::make_strand(executor)}
+    , socket_{strand_}
+{}
+
+AsyncResult<void> ApiConnection::connect()
+{
+    auto executor = co_await this_coro::executor;
+    tcp::resolver resolver{executor};
+    const auto resolved = co_await resolver.async_resolve(hostname_, std::to_string(port_));
+
+    co_await socket_.async_connect(resolved->endpoint());
+    socket_.set_option(asio::socket_base::keep_alive{true});
+
+    auto send_result = co_await send_message_hello();
+
+    co_return send_result;
+}
+
+AsyncResult<void> ApiConnection::send_message_hello()
+{
+    cppesphomeapi::proto::HelloRequest hello_request;
+
+    hello_request.ParseFromArray(nullptr, 0);
+    hello_request.set_client_info(std::string{"cppapi"});
+    co_await send_message(hello_request);
+    const auto msg_promise = co_await receive_message<cppesphomeapi::proto::HelloResponse>();
+
+    std::println("Got esphome device \"{}\": Version {}.{}",
+                 msg_promise->name(),
+                 msg_promise->api_version_major(),
+                 msg_promise->api_version_minor());
+    // todo: do something with the message.
+    co_return Result<void>{};
+}
+
+AsyncResult<void> ApiConnection::send_message(const google::protobuf::Message &message)
+{
+    const auto packet = plain_text_serialize(message);
+    if (packet.has_value())
+    {
+        const auto written = co_await socket_.async_write_some(asio::buffer(packet.value()));
+        if (written != packet->size())
+        {
+            co_return make_unexpected_result(
+                ApiErrorCode::SendError,
+                std::format("Could not send message. Bytes written are different: expected={}, written={}",
+                            packet->size(),
+                            written));
+        }
+        co_return Result<void>{};
+    }
+    co_return std::unexpected(packet.error());
+}
+} // namespace cppesphomeapi

cppesphomeapi/src/api_connection.hpp

@@ -0,0 +1,48 @@
+#pragma once
+#include <cstdint>
+#include <string>
+#include <boost/asio/executor.hpp>
+#include <boost/asio/strand.hpp>
+#include <google/protobuf/message.h>
+#include "cppesphomeapi/async_result.hpp"
+#include "make_unexpected_result.hpp"
+#include "plain_text_protocol.hpp"
+#include "tcp.hpp"
+namespace cppesphomeapi
+{
+class ApiConnection
+{
+  public:
+    explicit ApiConnection(std::string hostname,
+                           std::uint16_t port,
+                           std::string password,
+                           const boost::asio::any_io_executor &executor);
+
+    AsyncResult<void> connect();
+    AsyncResult<void> send_message_hello();
+
+  private:
+    AsyncResult<void> send_message(const google::protobuf::Message &message);
+
+    template <typename TMsg>
+    AsyncResult<TMsg> receive_message()
+    {
+        namespace asio = boost::asio;
+        std::array<std::uint8_t, 512> buffer{};
+        const auto received_bytes = co_await socket_.async_receive(asio::buffer(buffer));
+        if (received_bytes < 3)
+        {
+            co_return make_unexpected_result(ApiErrorCode::ParseError,
+                                             "response does not contain enough bytes for the header");
+        }
+        co_return plain_text_decode<TMsg>(std::span{buffer.begin(), received_bytes});
+    }
+
+  private:
+    std::string hostname_;
+    std::uint16_t port_;
+    std::string password_;
+    boost::asio::strand<boost::asio::any_io_executor> strand_;
+    tcp::socket socket_;
+};
+} // namespace cppesphomeapi

cppesphomeapi/src/plain_text_protocol.cpp

@@ -0,0 +1,97 @@
+#include "plain_text_protocol.hpp"
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+#include "api_options.pb.h"
+#include "make_unexpected_result.hpp"
+
+namespace cppesphomeapi
+{
+Result<void> plain_text_decode(std::span<const std::uint8_t> received_data, ::google::protobuf::Message &message)
+{
+    if (received_data.size() < 3)
+    {
+        return make_unexpected_result(ApiErrorCode::ParseError,
+                                      "response does not contain enough bytes for the header");
+    }
+    google::protobuf::io::CodedInputStream stream{received_data.data(), static_cast<int>(received_data.size())};
+    std::uint32_t preamble{};
+    if (not stream.ReadVarint32(&preamble) or preamble != 0x00)
+    {
+        return make_unexpected_result(ApiErrorCode::ParseError, "response does contain an invalid preamble");
+    }
+
+    std::uint32_t message_size{};
+    if (not stream.ReadVarint32(&message_size))
+    {
+        return make_unexpected_result(ApiErrorCode::ParseError, "got no message size");
+    }
+
+    std::uint32_t message_type{};
+    if (not stream.ReadVarint32(&message_type))
+    {
+        return make_unexpected_result(ApiErrorCode::ParseError, "got no message type");
+    }
+
+    const auto expected_message_id = message.GetDescriptor()->options().GetExtension(proto::id);
+    if (expected_message_id != message_type)
+    {
+        return make_unexpected_result(
+            ApiErrorCode::UnexpectedMessage,
+            std::format("Expected {} but got message id {}", message.GetDescriptor()->name(), message_type));
+    }
+    if (stream.BytesUntilLimit() != message_size)
+    {
+        return make_unexpected_result(
+            ApiErrorCode::ParseError,
+            std::format("Received message size does not match the remaining bytes. Expected {} bytes got {} bytes.",
+                        message_size,
+                        stream.BytesUntilLimit()));
+    }
+    const bool parsed = message.ParseFromCodedStream(std::addressof(stream));
+    if (not parsed)
+    {
+        return make_unexpected_result(
+            ApiErrorCode::ParseError,
+            std::format("Could not parse message \"{}\" from bytes.", message.GetDescriptor()->name()));
+    }
+    return {};
+}
+
+Result<std::vector<std::uint8_t>> plain_text_serialize(const ::google::protobuf::Message &message)
+{
+    constexpr std::uint8_t kPlainTextPreamble = 0x00;
+    auto &&msg_options = message.GetDescriptor()->options();
+    if (not msg_options.HasExtension(proto::id))
+    {
+        return make_unexpected_result(
+            ApiErrorCode::SerializeError,
+            std::format("message \"{}\" does not contain the id field", message.GetDescriptor()->name()));
+    }
+
+    constexpr auto kMaxHeaderLen = 5;
+    std::vector<std::uint8_t> buffer;
+    buffer.resize(message.ByteSizeLong() + kMaxHeaderLen);
+
+    buffer[0] = kPlainTextPreamble;
+
+    google::protobuf::io::ArrayOutputStream zstream{std::next(buffer.data(), 1), static_cast<int>(buffer.size() - 1)};
+    google::protobuf::io::CodedOutputStream output_stream{std::addressof(zstream)};
+
+    output_stream.WriteVarint32(message.ByteSizeLong());
+    output_stream.WriteVarint32(msg_options.GetExtension(proto::id));
+
+    if(output_stream.ByteCount() != (kMaxHeaderLen - 1)) {
+        buffer.resize(1 + message.ByteSizeLong() + output_stream.ByteCount());
+    }
+
+    const bool serialized = message.SerializeToCodedStream(std::addressof(output_stream));
+    if (not serialized)
+    {
+        return make_unexpected_result(
+            ApiErrorCode::SerializeError,
+            std::format("could not serialize message \"{}\"", message.GetDescriptor()->name()));
+    }
+    return buffer;
+}
+} // namespace cppesphomeapi

cppesphomeapi/src/plain_text_protocol.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <cstdint>
+#include <span>
+#include <vector>
+#include <google/protobuf/message.h>
+#include "cppesphomeapi/result.hpp"
+
+namespace cppesphomeapi
+{
+Result<void> plain_text_decode(std::span<const std::uint8_t> received_data, ::google::protobuf::Message &message);
+
+template <typename TMsg>
+Result<TMsg> plain_text_decode(std::span<const std::uint8_t> received_data)
+{
+    TMsg received_message;
+    return plain_text_decode(received_data, received_message)
+        .transform([received_message = std::move(received_message)]() { return received_message; });
+}
+
+Result<std::vector<std::uint8_t>> plain_text_serialize(const ::google::protobuf::Message &message);
+} // namespace cppesphomeapi