added GetInfo request, % progress and speed Kb/s.

Author: serges147

libcyphal_demo/src/file_downloader.hpp

@@ -16,8 +16,13 @@
 #include <libcyphal/types.hpp>
 
 #include <uavcan/file/Error_1_0.hpp>
+#include <uavcan/file/GetInfo_0_2.hpp>
 #include <uavcan/file/Read_1_1.hpp>
+#include <uavcan/primitive/Unstructured_1_0.hpp>
 
+#include <chrono>
+#include <cstddef>
+#include <iostream>
 #include <utility>
 
 class FileDownloader final
@@ -34,9 +39,12 @@ class FileDownloader final
     FileDownloader(FileDownloader&& other) noexcept
         : presentation_{other.presentation_}
         , time_provider_{other.time_provider_}
+        , get_info_client_{std::move(other.get_info_client_)}
+        , get_info_promise_{std::move(other.get_info_promise_)}
         , read_client_{std::move(other.read_client_)}
-        , response_promise_{std::move(other.response_promise_)}
-        , current_request_{std::move(other.current_request_)}
+        , read_promise_{std::move(other.read_promise_)}
+        , read_request_{std::move(other.read_request_)}
+        , file_stats_{other.file_stats_}
     {
     }
 
@@ -48,88 +56,243 @@ class FileDownloader final
 
     bool start(const libcyphal::transport::NodeId remote_node_id, const cetl::string_view file_path)
     {
-        response_promise_.reset();
+        get_info_promise_.reset();
+        get_info_client_.reset();
+        read_promise_.reset();
         read_client_.reset();
 
-        auto maybe_client = presentation_.makeClient<ReadService>(remote_node_id);
-        if (const auto* const failure = cetl::get_if<Presentation::MakeFailure>(&maybe_client))
+        file_stats_.file_size        = 0;
+        file_stats_.file_progress    = 0;
+        file_stats_.file_error.value = uavcan::file::Error_1_0::OK;
+
+        get_info_client_ = makeClient<Svc::GetInfo>("GetInfo", remote_node_id);
+        read_client_     = makeClient<Svc::Read>("Read", remote_node_id);
+        if (!get_info_client_ || !read_client_)
         {
-            (void) failure;
+            file_stats_.file_error.value = uavcan::file::Error_1_0::UNKNOWN_ERROR;
             return false;
         }
-        read_client_.emplace(cetl::get<ReadClient>(std::move(maybe_client)));
 
-        current_request_.offset    = 0;
-        current_request_.path.path = {file_path.begin(), file_path.end(), &presentation_.memory()};
+        read_request_.offset    = 0;
+        read_request_.path.path = {file_path.begin(), file_path.end(), &presentation_.memory()};
 
-        return initiateNextRequest();
+        std::cout << "Getting file info (path='" << file_path << "')...\n";
+        Svc::GetInfo::Request gi_request{&presentation_.memory()};
+        gi_request.path.path = {file_path.begin(), file_path.end(), &presentation_.memory()};
+        return makeRequest<Svc::GetInfo>("GetInfo",
+                                         get_info_client_,
+                                         get_info_promise_,
+                                         gi_request,
+                                         [this](const auto& arg) {
+                                             //
+                                             handleGetInfoPromiseResult(arg.result);
+                                         });
     }
 
 private:
-    using Presentation = libcyphal::presentation::Presentation;
+    using NodeId                 = libcyphal::transport::NodeId;
+    using Presentation           = libcyphal::presentation::Presentation;
+    using UnstructuredData       = uavcan::primitive::Unstructured_1_0;
+    using ResponsePromiseFailure = libcyphal::presentation::ResponsePromiseFailure;
+
+    template <typename T>
+    struct SvcSpec : T
+    {
+        using Client  = libcyphal::presentation::ServiceClient<T>;
+        using Promise = libcyphal::presentation::ResponsePromise<typename T::Response>;
+        using Failure = typename Client::Failure;
+    };
+    struct Svc
+    {
+        using Read    = SvcSpec<uavcan::file::Read_1_1>;
+        using GetInfo = SvcSpec<uavcan::file::GetInfo_0_2>;
+
+    };  // Svc
+
+    struct FileStats
+    {
+        uavcan::file::Error_1_0 file_error;
+        libcyphal::TimePoint    start_time;
+        std::size_t             file_size{0};
+        std::size_t             file_progress{0};
 
-    using ReadService     = uavcan::file::Read_1_1;
-    using ReadClient      = libcyphal::presentation::ServiceClient<ReadService>;
-    using ResponsePromise = libcyphal::presentation::ResponsePromise<ReadService::Response>;
-    using ResponseData    = ReadService::Response::_traits_::TypeOf::data;
+    };  // FileStats
 
     FileDownloader(Presentation& presentation, libcyphal::ITimeProvider& time_provider)
         : presentation_{presentation}
         , time_provider_{time_provider}
     {
     }
 
-    bool initiateNextRequest()
+    template <typename Service>
+    auto makeClient(const cetl::string_view role, const NodeId server_node_id)
+        -> cetl::optional<typename Service::Client>
+    {
+        auto maybe_client = presentation_.makeClient<Service>(server_node_id);
+        if (const auto* const failure = cetl::get_if<Presentation::MakeFailure>(&maybe_client))
+        {
+            (void) failure;
+            std::cerr << "Can't make '" << role << "' client.\n";
+            return cetl::nullopt;
+        }
+        return cetl::get<typename Service::Client>(std::move(maybe_client));
+    }
+
+    template <typename Service, typename Handler>
+    bool makeRequest(  //
+        const cetl::string_view                    role,
+        cetl::optional<typename Service::Client>&  client,
+        cetl::optional<typename Service::Promise>& promise,
+        const typename Service::Request&           request,
+        Handler&&                                  handler,
+        const libcyphal::Duration                  timeout = std::chrono::seconds{1})
     {
-        response_promise_.reset();
+        promise.reset();
 
-        constexpr auto timeout = std::chrono::seconds{1};
-        auto maybe_promise = read_client_->request(time_provider_.now() + timeout, current_request_);
-        if (const auto* const failure = cetl::get_if<ReadClient::Failure>(&maybe_promise))
+        auto maybe_promise = client->request(time_provider_.now() + timeout, request);
+        if (const auto* const failure = cetl::get_if<typename Service::Failure>(&maybe_promise))
         {
             (void) failure;
-            read_client_.reset();
+            file_stats_.file_error.value = uavcan::file::Error_1_0::UNKNOWN_ERROR;
+            std::cerr << "Can't make '" << role << "' request.\n";
+            complete();
             return false;
         }
-        response_promise_.emplace(cetl::get<ResponsePromise>(std::move(maybe_promise)));
-        response_promise_->setCallback([this](const auto& args) {
+
+        promise.emplace(cetl::get<typename Service::Promise>(std::move(maybe_promise)));
+        promise->setCallback(std::forward<Handler>(handler));
+        return true;
+    }
+
+    void handleGetInfoPromiseResult(const Svc::GetInfo::Promise::Result& result)
+    {
+        if (const auto* const failure = cetl::get_if<ResponsePromiseFailure>(&result))
+        {
+            (void) failure;
+            file_stats_.file_error.value = uavcan::file::Error_1_0::UNKNOWN_ERROR;
+            std::cerr << "GetInfo request failed.\n";
+            complete();
+            return;
+        }
+        const auto success = cetl::get<Svc::GetInfo::Promise::Success>(result);
+
+        get_info_promise_.reset();
+        get_info_client_.reset();
+
+        const auto& response = success.response;
+        if (response._error.value == uavcan::file::Error_1_0::OK)
+        {
+            file_stats_.file_size = response.size;
+            std::cout << "Downloading (size=" << file_stats_.file_size << ") ...\n";
+            if (file_stats_.file_size > 0)
+            {
+                file_stats_.start_time = time_provider_.now();
+
+                printProgress();
+                initiateNextReadRequest();
+                return;
+            }
+
+            file_stats_.file_error.value = uavcan::file::Error_1_0::OK;
+        }
+        else
+        {
+            file_stats_.file_error = response._error;
+            std::cerr << "Can't get file info (err=" << response._error.value << ").\n";
+        }
+
+        complete();
+    }
+
+    bool initiateNextReadRequest()
+    {
+        return makeRequest<Svc::Read>("Read", read_client_, read_promise_, read_request_, [this](const auto& arg) {
             //
-            handlePromiseResult(std::move(args.result));
+            handleReadPromiseResult(arg.result);
         });
+    }
 
-        return true;
+    void handleReadPromiseResult(Svc::Read::Promise::Result result)
+    {
+        if (const auto* const failure = cetl::get_if<ResponsePromiseFailure>(&result))
+        {
+            (void) failure;
+            file_stats_.file_error.value = uavcan::file::Error_1_0::UNKNOWN_ERROR;
+            std::cerr << "Read request failed.\n";
+            complete();
+            return;
+        }
+        const auto success = cetl::get<Svc::Read::Promise::Success>(std::move(result));
+
+        const auto& response = success.response;
+        if (response._error.value == uavcan::file::Error_1_0::OK)
+        {
+            const auto data_size = response.data.value.size();
+            read_request_.offset += response.data.value.size();
+
+            printProgress();
+
+            // Are we done?
+            if (data_size == UnstructuredData::_traits_::ArrayCapacity::value)
+            {
+                initiateNextReadRequest();
+                return;
+            }
+        }
+        else
+        {
+            file_stats_.file_error = response._error;
+            std::cerr << "Can't read file (err=" << response._error.value << ").\n";
+        }
+        complete();
     }
 
-    void handlePromiseResult(ResponsePromise::Result result)
+    void printProgress()
     {
-        if (const auto* const success = cetl::get_if<ResponsePromise::Success>(&result))
+        CETL_DEBUG_ASSERT(file_stats_.file_size > 0, "");
+        CETL_DEBUG_ASSERT(read_request_.offset <= file_stats_.file_size, "");
+
+        const auto progress = (read_request_.offset * 100U) / file_stats_.file_size;
+        CETL_DEBUG_ASSERT(progress <= 100U, "");
+
+        // Print progress only if its integer % has changed (or in the beginning).
+        if ((progress != file_stats_.file_progress) || (read_request_.offset == 0))
         {
-            const auto& response = success->response;
-            if (response._error.value == uavcan::file::Error_1_0::OK)
+            file_stats_.file_progress = progress;
+            const auto duration       = time_provider_.now() - file_stats_.start_time;
+            if (const auto duration_us = std::chrono::duration_cast<std::chrono::microseconds>(duration).count())
+            {
+                const auto speed_kb_per_sec = (read_request_.offset * 1000000U) / (duration_us * 1024U);
+                std::cout << "\r  progress " << progress << "% (speed=" << speed_kb_per_sec << "KB/s)            "
+                          << std::flush;
+            }
+            else
             {
-                const auto data_size = response.data.value.size();
-                current_request_.offset += response.data.value.size();
-
-                // Are we done?
-                if (data_size == ResponseData::_traits_::ArrayCapacity::value)
-                {
-                    initiateNextRequest();
-                    return;
-                }
+                std::cout << "\r  progress " << progress << "%" << std::flush;
             }
         }
-        std::cout << "Download complete\n";
-        response_promise_.reset();
+    }
+
+    void complete()
+    {
+        std::cout << "\nDownload completed (err=" << file_stats_.file_error.value << ").\n" << std::flush;
+
+        get_info_promise_.reset();
+        get_info_client_.reset();
+        read_promise_.reset();
         read_client_.reset();
     }
 
     // MARK: Data members:
 
-    Presentation&                   presentation_;
-    libcyphal::ITimeProvider&       time_provider_;
-    cetl::optional<ReadClient>      read_client_;
-    cetl::optional<ResponsePromise> response_promise_;
-    ReadService::Request            current_request_{&presentation_.memory()};
+    Presentation&                         presentation_;
+    libcyphal::ITimeProvider&             time_provider_;
+    cetl::optional<Svc::GetInfo::Client>  get_info_client_;
+    cetl::optional<Svc::GetInfo::Promise> get_info_promise_;
+    cetl::optional<Svc::Read::Client>     read_client_;
+    cetl::optional<Svc::Read::Promise>    read_promise_;
+    Svc::Read::Request                    read_request_{&presentation_.memory()};
+    FileStats                             file_stats_;
 
 };  // FileDownloader
 

libcyphal_demo/src/main.cpp

@@ -133,10 +133,12 @@ enum class ExitCode : std::uint8_t
 
 void PrintUniqueIdTo(const std::array<std::uint8_t, 16>& unique_id, std::ostream& os)
 {
+    const auto original_flags = os.flags();
     for (const auto byte : unique_id)
     {
         os << std::hex << std::setw(2) << std::setfill('0') << static_cast<std::uint32_t>(byte);
     }
+    os.flags(original_flags);
 }
 
 libcyphal::Expected<bool, ExitCode> run_application(const char* const root_path)