From 27d243a0c989a1b417200346a5f6be702a8dd9cc Mon Sep 17 00:00:00 2001 From: Lennart Becker Date: Wed, 7 May 2025 13:17:36 +0200 Subject: [PATCH] Fixed linter issues. Updated ci.yml to check linting. --- .github/workflows/ci.yml | 77 ++++++++++++++++++++++++++++++ .github/workflows/ci_conan_profile | 8 ++++ pubsub/src/main_pub.cpp | 42 ++++++++-------- pubsub/src/main_sub.cpp | 44 ++++++++--------- rpc/include/common.h | 5 +- rpc/src/main_rpc_client.cpp | 41 +++++++++------- rpc/src/main_rpc_server.cpp | 52 +++++++++++--------- 7 files changed, 185 insertions(+), 84 deletions(-) create mode 100644 .github/workflows/ci_conan_profile diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index b9d1e6b..e59f073 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -69,6 +69,83 @@ jobs: cd build/Release cmake --build . -- -j + - name: Upload compile commands + uses: actions/upload-artifact@v4 + with: + name: compile-commands + path: up-zenoh-example-cpp/build/Release/compile_commands.json + + + - name: Save conan cache to archive + shell: bash + run: | + conan cache save --file ./conan-cache.tgz '*' + + - name: Upload conan cache for linting + uses: actions/upload-artifact@v4 + with: + name: conan-cache + path: ./conan-cache.tgz + + lint: + name: Lint C++ sources + runs-on: ubuntu-22.04 + needs: build + permissions: + contents: write + pull-requests: read + steps: + - name: Fetch up-zenoh-example-cpp + uses: actions/checkout@v4 + with: + path: up-zenoh-example-cpp + + - name: Get build commands + uses: actions/download-artifact@v4 + with: + name: compile-commands + + - name: Install Conan + id: conan + uses: turtlebrowser/get-conan@main + with: + version: 2.3.2 + + - name: Install conan CI profile + shell: bash + run: | + conan profile detect + cp up-zenoh-example-cpp/.github/workflows/ci_conan_profile "$(conan profile path default)" + conan profile show + + - name: Get conan cache + uses: actions/download-artifact@v4 + with: + name: conan-cache + + - name: Restore conan cache from archive + shell: bash + run: | + conan cache restore conan-cache.tgz + + - name: Run linters on source + id: source-linter + uses: cpp-linter/cpp-linter-action@v2 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + repo-root: up-zenoh-example-cpp + style: 'file' # read .clang-format for configuration + tidy-checks: '' # Read .clang-tidy for configuration + database: compile_commands.json + version: 13 + + - name: Report lint failure + if: + steps.source-linter.outputs.checks-failed > 0 + run: | + exit 1 + # NOTE: In GitHub repository settings, the "Require status checks to pass # before merging" branch protection rule ensures that commits are only merged diff --git a/.github/workflows/ci_conan_profile b/.github/workflows/ci_conan_profile new file mode 100644 index 0000000..73fec78 --- /dev/null +++ b/.github/workflows/ci_conan_profile @@ -0,0 +1,8 @@ +[settings] +arch=x86_64 +build_type=Release +compiler=gcc +compiler.cppstd=gnu17 +compiler.libcxx=libstdc++11 +compiler.version=11 +os=Linux diff --git a/pubsub/src/main_pub.cpp b/pubsub/src/main_pub.cpp index 144475f..b4da755 100644 --- a/pubsub/src/main_pub.cpp +++ b/pubsub/src/main_pub.cpp @@ -18,36 +18,39 @@ #include #include #include +#include #include "common.h" -using namespace uprotocol::datamodel::builder; -using namespace uprotocol::communication; -using namespace uprotocol::v1; - +using Payload = uprotocol::datamodel::builder::Payload; +using Publisher = uprotocol::communication::Publisher; +using UPayloadFormat = uprotocol::v1::UPayloadFormat; +using UCode = uprotocol::v1::UCode; using ZenohUTransport = uprotocol::transport::ZenohUTransport; -bool gTerminate = false; +bool g_terminate = false; void signalHandler(int signal) { if (signal == SIGINT) { std::cout << "Ctrl+C received. Exiting..." << std::endl; - gTerminate = true; + g_terminate = true; } } int64_t getTime() { - auto currentTime = std::chrono::system_clock::now(); - auto duration = currentTime.time_since_epoch(); - int64_t timeMilli = + auto current_time = std::chrono::system_clock::now(); + auto duration = current_time.time_since_epoch(); + int64_t time_milli = std::chrono::duration_cast(duration).count(); - return timeMilli; + return time_milli; } int32_t getRandom() { - int32_t val = std::rand(); - return val; + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution distribution(0, INT32_MAX); + return distribution(gen); } uint8_t getCounter() { @@ -59,9 +62,8 @@ uint8_t getCounter() { /* The sample pub applications demonstrates how to send data using uTransport - * There are three topics that are published - random number, current time and a * counter */ -int main(int argc, char** argv) { - (void)argc; - (void)argv; +int main(int argc, char* argv[]) { + std::vector args(argv, argv + argc); if (argc < 2) { std::cout << "No Zenoh config has been provided" << std::endl; @@ -69,16 +71,16 @@ int main(int argc, char** argv) { return 1; } - signal(SIGINT, signalHandler); - signal(SIGPIPE, signalHandler); + (void)signal(SIGINT, signalHandler); + (void)signal(SIGPIPE, signalHandler); - UStatus status; + uprotocol::v1::UStatus status; auto source = getUUri(0); auto topic_time = getTimeUUri(); auto topic_random = getRandomUUri(); auto topic_counter = getCounterUUri(); - auto transport = std::make_shared(source, argv[1]); + auto transport = std::make_shared(source, args.at(1)); Publisher publish_time(transport, std::move(topic_time), UPayloadFormat::UPAYLOAD_FORMAT_TEXT); Publisher publish_random(transport, std::move(topic_random), @@ -86,7 +88,7 @@ int main(int argc, char** argv) { Publisher publish_counter(transport, std::move(topic_counter), UPayloadFormat::UPAYLOAD_FORMAT_TEXT); - while (!gTerminate) { + while (!g_terminate) { // send a string with a time value (ie "15665489") uint64_t time_val = getTime(); spdlog::info("sending time = {}", time_val); diff --git a/pubsub/src/main_sub.cpp b/pubsub/src/main_sub.cpp index b80ac84..6635af2 100644 --- a/pubsub/src/main_sub.cpp +++ b/pubsub/src/main_sub.cpp @@ -13,23 +13,25 @@ #include #include #include +#include #include #include #include "common.h" -using namespace uprotocol::communication; -using namespace uprotocol::v1; +using Subscriber = uprotocol::communication::Subscriber; +using UMessage = uprotocol::v1::UMessage; +using UPayloadFormat = uprotocol::v1::UPayloadFormat; using ZenohUTransport = uprotocol::transport::ZenohUTransport; -bool gTerminate = false; +bool g_terminate = false; void signalHandler(int signal) { if (signal == SIGINT) { std::cout << "Ctrl+C received. Exiting..." << std::endl; - gTerminate = true; + g_terminate = true; } } @@ -64,9 +66,8 @@ void onReceiveCounter(const uprotocol::v1::UMessage& message) { * - * There are three topics that are received - random number, current time and a * counter */ -int main(int argc, char** argv) { - (void)argc; - (void)argv; +int main(int argc, char* argv[]) { + std::vector args(argv, argv + argc); if (argc < 2) { std::cout << "No Zenoh config has been provided" << std::endl; @@ -74,24 +75,23 @@ int main(int argc, char** argv) { return 1; } - signal(SIGINT, signalHandler); - signal(SIGPIPE, signalHandler); + (void)signal(SIGINT, signalHandler); + (void)signal(SIGPIPE, signalHandler); - UStatus status; - UUri source = getUUri(0); - auto topic_time = getTimeUUri(); - auto topic_random = getRandomUUri(); - auto topic_counter = getCounterUUri(); - auto transport = std::make_shared(source, argv[1]); + uprotocol::v1::UStatus status; + uprotocol::v1::UUri source = getUUri(0); + const auto& topic_time = getTimeUUri(); + const auto& topic_random = getRandomUUri(); + const auto& topic_counter = getCounterUUri(); + auto transport = std::make_shared(source, args.at(1)); - auto resTime = - Subscriber::subscribe(transport, std::move(topic_time), onReceiveTime); - auto resRandom = Subscriber::subscribe(transport, std::move(topic_random), - onReceiveRandom); - auto resCounter = Subscriber::subscribe(transport, std::move(topic_counter), - onReceiveCounter); + auto res_time = Subscriber::subscribe(transport, topic_time, onReceiveTime); + auto res_random = + Subscriber::subscribe(transport, topic_random, onReceiveRandom); + auto res_counter = + Subscriber::subscribe(transport, topic_counter, onReceiveCounter); - while (!gTerminate) { + while (!g_terminate) { sleep(1); } diff --git a/rpc/include/common.h b/rpc/include/common.h index 039a3d2..34b0130 100644 --- a/rpc/include/common.h +++ b/rpc/include/common.h @@ -13,11 +13,12 @@ #define RPC_COMMON_H #include +constexpr uint32_t RPC_UE_ID = 0x10001; -uprotocol::v1::UUri getRpcUUri(const int resource_id) { +inline uprotocol::v1::UUri getRpcUUri(const int resource_id) { uprotocol::v1::UUri uuri; uuri.set_authority_name("test_rpc.app"); - uuri.set_ue_id(0x10001); + uuri.set_ue_id(RPC_UE_ID); uuri.set_ue_version_major(1); uuri.set_resource_id(resource_id); return uuri; diff --git a/rpc/src/main_rpc_client.cpp b/rpc/src/main_rpc_client.cpp index 8ff6ada..295f18c 100644 --- a/rpc/src/main_rpc_client.cpp +++ b/rpc/src/main_rpc_client.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include @@ -21,23 +22,28 @@ #include "common.h" -using namespace uprotocol::v1; -using namespace uprotocol::communication; -using namespace uprotocol::datamodel::builder; +constexpr uint32_t METHOD_RPC_RESOURCE_ID = 12; +constexpr std::chrono::milliseconds RPCCLIENT_TTL(500); + +using UMessage = uprotocol::v1::UMessage; +using UStatus = uprotocol::v1::UStatus; +using UPayloadFormat = uprotocol::v1::UPayloadFormat; +using RpcClient = uprotocol::communication::RpcClient; using ZenohUTransport = uprotocol::transport::ZenohUTransport; +using UUri = uprotocol::v1::UUri; -bool gTerminate = false; +bool g_terminate = false; void signalHandler(int signal) { if (signal == SIGINT) { std::cout << "Ctrl+C received. Exiting..." << std::endl; - gTerminate = true; + g_terminate = true; } } void OnReceive(RpcClient::MessageOrStatus expected) { if (!expected.has_value()) { - UStatus status = expected.error(); + const UStatus& status = expected.error(); spdlog::error("Expected value not found. -- Status: {}", status.DebugString()); return; @@ -62,16 +68,17 @@ void OnReceive(RpcClient::MessageOrStatus expected) { // sequence number, current time, and random value spdlog::debug("(Client) Received message: {}", message.DebugString()); - const uint64_t* pdata = (uint64_t*)message.payload().data(); + const size_t num_bytes = message.payload().size(); + std::vector pdata(num_bytes / sizeof(uint64_t)); + memcpy(pdata.data(), message.payload().data(), num_bytes); spdlog::info("Received payload: {} - {}, {}", pdata[0], pdata[1], pdata[2]); } /* The sample RPC client applications demonstrates how to send RPC requests and * wait for the response */ -int main(int argc, char** argv) { - (void)argc; - (void)argv; +int main(int argc, char* argv[]) { + std::vector args(argv, argv + argc); if (argc < 2) { std::cout << "No Zenoh config has been provided" << std::endl; @@ -79,17 +86,17 @@ int main(int argc, char** argv) { return 1; } - signal(SIGINT, signalHandler); + (void)signal(SIGINT, signalHandler); UUri source = getRpcUUri(0); - UUri method = getRpcUUri(12); - auto transport = std::make_shared(source, argv[1]); - auto client = - RpcClient(transport, std::move(method), UPriority::UPRIORITY_CS4, - std::chrono::milliseconds(500)); + UUri method = getRpcUUri(METHOD_RPC_RESOURCE_ID); + auto transport = std::make_shared(source, args.at(1)); + auto client = RpcClient(transport, std::move(method), + uprotocol::v1::UPriority::UPRIORITY_CS4, + std::chrono::milliseconds(RPCCLIENT_TTL)); RpcClient::InvokeHandle handle; - while (!gTerminate) { + while (!g_terminate) { handle = client.invokeMethod(OnReceive); sleep(1); } diff --git a/rpc/src/main_rpc_server.cpp b/rpc/src/main_rpc_server.cpp index ba485c8..43a95b7 100644 --- a/rpc/src/main_rpc_server.cpp +++ b/rpc/src/main_rpc_server.cpp @@ -16,29 +16,32 @@ #include #include -#include #include +#include #include "common.h" -using namespace uprotocol::v1; -using namespace uprotocol::communication; -using namespace uprotocol::datamodel::builder; +constexpr uint32_t METHOD_RPC_RESOURCE_ID = 12; + +using UMessage = uprotocol::v1::UMessage; +using UPayloadFormat = uprotocol::v1::UPayloadFormat; using ZenohUTransport = uprotocol::transport::ZenohUTransport; +using Payload = uprotocol::datamodel::builder::Payload; +using UUri = uprotocol::v1::UUri; -bool gTerminate = false; +bool g_terminate = false; void signalHandler(int signal) { if (signal == SIGINT) { std::cout << "Ctrl+C received. Exiting..." << std::endl; - gTerminate = true; + g_terminate = true; } } -std::optional OnReceive( - const UMessage& message) { +std::optional OnReceive(const UMessage& message) { // Validate message is an RPC request - if (message.attributes().type() != UMessageType::UMESSAGE_TYPE_REQUEST) { + if (message.attributes().type() != + uprotocol::v1::UMessageType::UMESSAGE_TYPE_REQUEST) { spdlog::error("Received message is not a request\n{}", message.DebugString()); return {}; @@ -53,12 +56,15 @@ std::optional OnReceive( // Received request with empty payload, generate response with // sequence number, current time, and random value - static uint64_t seqNum = 0; - uint64_t randVal = std::rand(); - uint64_t timeVal = std::chrono::duration_cast( - std::chrono::system_clock::now().time_since_epoch()) - .count(); - std::vector payload_data = {seqNum++, timeVal, randVal}; + static uint64_t seq_num = 0; + std::random_device rd; + std::mt19937_64 gen(rd()); + std::uniform_int_distribution distribution(0, UINT64_MAX); + uint64_t rand_val = distribution(gen); + uint64_t time_val = std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()) + .count(); + std::vector payload_data = {seq_num++, time_val, rand_val}; spdlog::debug("(Server) Received request:\n{}", message.DebugString()); @@ -73,9 +79,8 @@ std::optional OnReceive( /* The sample RPC server applications demonstrates how to receive RPC requests * and send a response back to the client - * The response in this example will be the current time */ -int main(int argc, char** argv) { - (void)argc; - (void)argv; +int main(int argc, char* argv[]) { + std::vector args(argv, argv + argc); if (argc < 2) { std::cout << "No Zenoh config has been provided" << std::endl; @@ -83,11 +88,12 @@ int main(int argc, char** argv) { return 1; } - signal(SIGINT, signalHandler); + (void)signal(SIGINT, signalHandler); UUri source = getRpcUUri(0); - UUri method = getRpcUUri(12); - auto transport = std::make_shared(source, argv[1]); - auto server = RpcServer::create(transport, method, OnReceive); + UUri method = getRpcUUri(METHOD_RPC_RESOURCE_ID); + auto transport = std::make_shared(source, args.at(1)); + auto server = uprotocol::communication::RpcServer::create(transport, method, + OnReceive); if (!server.has_value()) { spdlog::error("Failed to create RPC server: {}", @@ -95,7 +101,7 @@ int main(int argc, char** argv) { return 1; } - while (!gTerminate) { + while (!g_terminate) { sleep(1); }