Pull in SDK renaming change

Author: archigup

.clang-format

@@ -29,9 +29,9 @@ PenaltyReturnTypeOnItsOwnLine: 240
 WhitespaceSensitiveMacros:
   - EMBED_FILE
 ForEachMacros:
-  - GGL_LIST_FOREACH
-  - GGL_MAP_FOREACH
-  - GGL_BUF_LIST_FOREACH
+  - GG_LIST_FOREACH
+  - GG_MAP_FOREACH
+  - GG_BUF_LIST_FOREACH
 Macros:
   - NODISCARD=[[nodiscard]]
   - GGL_EXPORT=[[gnu::visibility(protected)]]

CMakeLists.txt

@@ -268,8 +268,8 @@ check_c_source_compiles(
 # Add components
 #
 
-add_subdirectory(${ggl_sdk_SOURCE_DIR} ggl-sdk)
-target_include_directories(ggl-sdk INTERFACE ${ggl_sdk_SOURCE_DIR}/priv_include)
+add_subdirectory(${gg_sdk_SOURCE_DIR} gg-sdk)
+target_include_directories(gg-sdk INTERFACE ${gg_sdk_SOURCE_DIR}/priv_include)
 
 # Common setup for a GGL module
 function(ggl_init_module name)
@@ -296,7 +296,7 @@ function(ggl_init_module name)
   # src/dummy.c
   if(NOT SRCS_LEN EQUAL 0)
     add_library(${name} STATIC ${SRCS})
-    target_compile_definitions(${name} PRIVATE "GGL_MODULE=(\"${name}\")")
+    target_compile_definitions(${name} PRIVATE "GG_MODULE=(\"${name}\")")
     target_include_directories(${name} PUBLIC ${COMP_ARG_INCDIRS})
     target_link_libraries(${name} PRIVATE ${COMP_ARG_LIBS})
   endif()
@@ -325,7 +325,7 @@ function(ggl_init_module name)
     get_filename_component(bin_name ${bin} NAME_WLE)
     add_executable(${bin_name}-bin ${bin})
     target_compile_definitions(${bin_name}-bin
-                               PRIVATE "GGL_MODULE=(\"${name}\")")
+                               PRIVATE "GG_MODULE=(\"${name}\")")
     if(NOT SRCS_LEN EQUAL 0)
       target_link_libraries(${bin_name}-bin PRIVATE ${name})
     endif()

fc_deps.json

@@ -9,9 +9,9 @@
     "rev": "f0409ced6c2c9430f0e972019b7e8f20bbf58f4e",
     "hash": "sha256-6is4ymM/Ct9JntgpFHF4Vlv5+GUwy0HZvEiEV+ALJkw="
   },
-  "ggl_sdk": {
+  "gg_sdk": {
     "url": "https://github.com/aws-greengrass/aws-greengrass-sdk-lite.git",
-    "rev": "febee8463690b30580a8fdfddcceebb66596195d",
-    "hash": "sha256-yObuWnBN+VTcIpyo9ihVf2/7uXb/cA/QilC8TrwSFVo="
+    "rev": "08be374523066becf92dce52c84d3cb9bf3825a5",
+    "hash": "sha256-mpbcK18nRJYLo/tRgecQUT0bnEL+KCtKCQgKOYAaojY="
   }
 }

modules/aws-iot-call/CMakeLists.txt

@@ -2,4 +2,4 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-ggl_init_module(aws-iot-call LIBS ggl-sdk core-bus core-bus-aws-iot-mqtt)
+ggl_init_module(aws-iot-call LIBS gg-sdk core-bus core-bus-aws-iot-mqtt)

modules/aws-iot-call/include/ggl/aws_iot_call.h

@@ -7,22 +7,22 @@
 
 //! Helper for calling AWS IoT Core APIs
 
-#include <ggl/arena.h>
-#include <ggl/buffer.h>
-#include <ggl/error.h>
-#include <ggl/object.h>
+#include <gg/arena.h>
+#include <gg/buffer.h>
+#include <gg/error.h>
+#include <gg/object.h>
 #include <stdbool.h>
 
 /// Make a call to an AWS IoT MQTT API.
 /// Sends request on topic and waits for response on topic/(accepted|rejected).
 /// Responses will be filtered according to clientToken.
-GglError ggl_aws_iot_call(
-    GglBuffer socket_name,
-    GglBuffer topic,
-    GglObject payload,
+GgError ggl_aws_iot_call(
+    GgBuffer socket_name,
+    GgBuffer topic,
+    GgObject payload,
     bool virtual,
-    GglArena *alloc,
-    GglObject *result
+    GgArena *alloc,
+    GgObject *result
 );
 
 #endif

modules/aws-iot-call/src/aws_iot_call.c

@@ -5,18 +5,18 @@
 #include "ggl/aws_iot_call.h"
 #include <assert.h>
 #include <errno.h>
-#include <ggl/arena.h>
-#include <ggl/buffer.h>
-#include <ggl/cleanup.h>
+#include <gg/arena.h>
+#include <gg/buffer.h>
+#include <gg/cleanup.h>
+#include <gg/error.h>
+#include <gg/json_decode.h>
+#include <gg/json_encode.h>
+#include <gg/log.h>
+#include <gg/map.h>
+#include <gg/object.h>
+#include <gg/vector.h>
 #include <ggl/core_bus/aws_iot_mqtt.h>
 #include <ggl/core_bus/client.h> // IWYU pragma: keep (cleanup)
-#include <ggl/error.h>
-#include <ggl/json_decode.h>
-#include <ggl/json_encode.h>
-#include <ggl/log.h>
-#include <ggl/map.h>
-#include <ggl/object.h>
-#include <ggl/vector.h>
 #include <pthread.h>
 #include <sys/types.h>
 #include <time.h>
@@ -35,44 +35,44 @@ typedef struct {
     pthread_mutex_t *mtx;
     pthread_cond_t *cond;
     bool ready;
-    GglBuffer *client_token;
-    GglArena *alloc;
-    GglObject *result;
-    GglError ret;
+    GgBuffer *client_token;
+    GgArena *alloc;
+    GgObject *result;
+    GgError ret;
 } CallbackCtx;
 
 static void cleanup_pthread_cond(pthread_cond_t **cond) {
     pthread_cond_destroy(*cond);
 }
 
-static GglError get_client_token(GglObject payload, GglBuffer **client_token) {
+static GgError get_client_token(GgObject payload, GgBuffer **client_token) {
     assert(client_token != NULL);
     assert(*client_token != NULL);
 
-    if (ggl_obj_type(payload) != GGL_TYPE_MAP) {
+    if (gg_obj_type(payload) != GG_TYPE_MAP) {
         *client_token = NULL;
-        return GGL_ERR_OK;
+        return GG_ERR_OK;
     }
-    GglMap payload_map = ggl_obj_into_map(payload);
+    GgMap payload_map = gg_obj_into_map(payload);
 
-    GglObject *found;
-    if (!ggl_map_get(payload_map, GGL_STR("clientToken"), &found)) {
+    GgObject *found;
+    if (!gg_map_get(payload_map, GG_STR("clientToken"), &found)) {
         *client_token = NULL;
-        return GGL_ERR_OK;
+        return GG_ERR_OK;
     }
-    if (ggl_obj_type(*found) != GGL_TYPE_BUF) {
-        GGL_LOGE("Invalid clientToken type.");
-        return GGL_ERR_INVALID;
+    if (gg_obj_type(*found) != GG_TYPE_BUF) {
+        GG_LOGE("Invalid clientToken type.");
+        return GG_ERR_INVALID;
     }
-    **client_token = ggl_obj_into_buf(*found);
-    return GGL_ERR_OK;
+    **client_token = gg_obj_into_buf(*found);
+    return GG_ERR_OK;
 }
 
-static bool match_client_token(GglObject payload, GglBuffer *client_token) {
-    GglBuffer *payload_client_token = &(GglBuffer) { 0 };
+static bool match_client_token(GgObject payload, GgBuffer *client_token) {
+    GgBuffer *payload_client_token = &(GgBuffer) { 0 };
 
-    GglError ret = get_client_token(payload, &payload_client_token);
-    if (ret != GGL_ERR_OK) {
+    GgError ret = get_client_token(payload, &payload_client_token);
+    if (ret != GG_ERR_OK) {
         return false;
     }
 
@@ -84,93 +84,92 @@ static bool match_client_token(GglObject payload, GglBuffer *client_token) {
         return false;
     }
 
-    return ggl_buffer_eq(*client_token, *payload_client_token);
+    return gg_buffer_eq(*client_token, *payload_client_token);
 }
 
-static GglError subscription_callback(
-    void *ctx, uint32_t handle, GglObject data
+static GgError subscription_callback(
+    void *ctx, uint32_t handle, GgObject data
 ) {
     (void) handle;
     CallbackCtx *call_ctx = ctx;
 
-    GglBuffer topic;
-    GglBuffer payload = { 0 };
-    GglError ret
-        = ggl_aws_iot_mqtt_subscribe_parse_resp(data, &topic, &payload);
-    if (ret != GGL_ERR_OK) {
+    GgBuffer topic;
+    GgBuffer payload = { 0 };
+    GgError ret = ggl_aws_iot_mqtt_subscribe_parse_resp(data, &topic, &payload);
+    if (ret != GG_ERR_OK) {
         return ret;
     }
 
     bool decoded = true;
-    ret = ggl_json_decode_destructive(
+    ret = gg_json_decode_destructive(
         payload, call_ctx->alloc, call_ctx->result
     );
-    if (ret != GGL_ERR_OK) {
-        GGL_LOGE("Failed to decode response payload.");
-        *(call_ctx->result) = GGL_OBJ_NULL;
+    if (ret != GG_ERR_OK) {
+        GG_LOGE("Failed to decode response payload.");
+        *(call_ctx->result) = GG_OBJ_NULL;
         decoded = false;
     }
 
     if (!match_client_token(*call_ctx->result, call_ctx->client_token)) {
         // Skip this message
-        return GGL_ERR_OK;
+        return GG_ERR_OK;
     }
 
-    if (ggl_buffer_has_suffix(topic, GGL_STR("/accepted"))) {
+    if (gg_buffer_has_suffix(topic, GG_STR("/accepted"))) {
         if (!decoded) {
-            return GGL_ERR_INVALID;
+            return GG_ERR_INVALID;
         }
-        call_ctx->ret = GGL_ERR_OK;
-    } else if (ggl_buffer_has_suffix(topic, GGL_STR("/rejected"))) {
-        GGL_LOGE(
+        call_ctx->ret = GG_ERR_OK;
+    } else if (gg_buffer_has_suffix(topic, GG_STR("/rejected"))) {
+        GG_LOGE(
             "Received rejected response: %.*s", (int) payload.len, payload.data
         );
-        call_ctx->ret = GGL_ERR_REMOTE;
+        call_ctx->ret = GG_ERR_REMOTE;
     } else {
-        return GGL_ERR_INVALID;
+        return GG_ERR_INVALID;
     }
 
     // Err to close subscription
-    return GGL_ERR_EXPECTED;
+    return GG_ERR_EXPECTED;
 }
 
 static void subscription_close_callback(void *ctx, uint32_t handle) {
     (void) handle;
     CallbackCtx *call_ctx = ctx;
 
-    GGL_MTX_SCOPE_GUARD(call_ctx->mtx);
+    GG_MTX_SCOPE_GUARD(call_ctx->mtx);
     call_ctx->ready = true;
     pthread_cond_signal(call_ctx->cond);
 }
 
-GglError ggl_aws_iot_call(
-    GglBuffer socket_name,
-    GglBuffer topic,
-    GglObject payload,
+GgError ggl_aws_iot_call(
+    GgBuffer socket_name,
+    GgBuffer topic,
+    GgObject payload,
     bool virtual,
-    GglArena *alloc,
-    GglObject *result
+    GgArena *alloc,
+    GgObject *result
 ) {
     static pthread_mutex_t mem_mtx = PTHREAD_MUTEX_INITIALIZER;
-    GGL_MTX_SCOPE_GUARD(&mem_mtx);
+    GG_MTX_SCOPE_GUARD(&mem_mtx);
 
     // TODO: Share memory for topic filter and encode
     static uint8_t topic_filter_mem[AWS_IOT_MAX_TOPIC_SIZE];
     static uint8_t json_encode_mem[GGL_MAX_IOT_CORE_API_PAYLOAD_LEN];
 
-    GglByteVec topic_filter = GGL_BYTE_VEC(topic_filter_mem);
+    GgByteVec topic_filter = GG_BYTE_VEC(topic_filter_mem);
 
-    GglError ret = ggl_byte_vec_append(&topic_filter, topic);
-    ggl_byte_vec_chain_append(&ret, &topic_filter, GGL_STR("/+"));
-    if (ret != GGL_ERR_OK) {
-        GGL_LOGE("Failed to construct response topic filter.");
+    GgError ret = gg_byte_vec_append(&topic_filter, topic);
+    gg_byte_vec_chain_append(&ret, &topic_filter, GG_STR("/+"));
+    if (ret != GG_ERR_OK) {
+        GG_LOGE("Failed to construct response topic filter.");
         return ret;
     }
 
-    GglByteVec payload_vec = GGL_BYTE_VEC(json_encode_mem);
-    ret = ggl_json_encode(payload, ggl_byte_vec_writer(&payload_vec));
-    if (ret != GGL_ERR_OK) {
-        GGL_LOGE("Failed to encode JSON payload.");
+    GgByteVec payload_vec = GG_BYTE_VEC(json_encode_mem);
+    ret = gg_json_encode(payload, gg_byte_vec_writer(&payload_vec));
+    if (ret != GG_ERR_OK) {
+        GG_LOGE("Failed to encode JSON payload.");
         return ret;
     }
 
@@ -180,45 +179,45 @@ GglError ggl_aws_iot_call(
     pthread_cond_t notify_cond;
     pthread_cond_init(&notify_cond, &notify_condattr);
     pthread_condattr_destroy(&notify_condattr);
-    GGL_CLEANUP(cleanup_pthread_cond, &notify_cond);
+    GG_CLEANUP(cleanup_pthread_cond, &notify_cond);
     pthread_mutex_t notify_mtx = PTHREAD_MUTEX_INITIALIZER;
 
     CallbackCtx ctx = {
         .mtx = &notify_mtx,
         .cond = &notify_cond,
         .ready = false,
-        .client_token = &(GglBuffer) { 0 },
+        .client_token = &(GgBuffer) { 0 },
         .alloc = alloc,
         .result = result,
-        .ret = GGL_ERR_FAILURE,
+        .ret = GG_ERR_FAILURE,
     };
 
     ret = get_client_token(payload, &ctx.client_token);
-    if (ret != GGL_ERR_OK) {
+    if (ret != GG_ERR_OK) {
         return ret;
     }
 
     uint32_t sub_handle = 0;
     ret = ggl_aws_iot_mqtt_subscribe(
         socket_name,
-        GGL_BUF_LIST(topic_filter.buf),
+        GG_BUF_LIST(topic_filter.buf),
         1,
         virtual,
         subscription_callback,
         subscription_close_callback,
         &ctx,
         &sub_handle
     );
-    if (ret != GGL_ERR_OK) {
-        GGL_LOGE("Response topic subscription failed.");
+    if (ret != GG_ERR_OK) {
+        GG_LOGE("Response topic subscription failed.");
         return ret;
     }
 
     ret = ggl_aws_iot_mqtt_publish(
         socket_name, topic, payload_vec.buf, 1, true
     );
-    if (ret != GGL_ERR_OK) {
-        GGL_LOGE("Response topic subscription failed.");
+    if (ret != GG_ERR_OK) {
+        GG_LOGE("Response topic subscription failed.");
         ggl_client_sub_close(sub_handle);
         return ret;
     }
@@ -232,14 +231,14 @@ GglError ggl_aws_iot_call(
     {
         // Must be unlocked before closing subscription
         // (else subscription response may be blocked, and close would deadlock)
-        GGL_MTX_SCOPE_GUARD(&notify_mtx);
+        GG_MTX_SCOPE_GUARD(&notify_mtx);
 
         while (!ctx.ready) {
             int cond_ret
                 = pthread_cond_timedwait(&notify_cond, &notify_mtx, &timeout);
             if ((cond_ret != 0) && (cond_ret != EINTR)) {
                 assert(cond_ret == ETIMEDOUT);
-                GGL_LOGW("Timed out waiting for a response.");
+                GG_LOGW("Timed out waiting for a response.");
                 timed_out = true;
                 break;
             }

modules/core-bus-aws-iot-mqtt/CMakeLists.txt

@@ -2,4 +2,4 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-ggl_init_module(core-bus-aws-iot-mqtt LIBS ggl-sdk core-bus)
+ggl_init_module(core-bus-aws-iot-mqtt LIBS gg-sdk core-bus)