Solve issues on docker, improbe build warnings.

viferga · viferga · commit bcf26cb2b0b9 · 2025-04-24T17:07:03.000+02:00
diff --git a/.github/workflows/docker-hub.yml b/.github/workflows/docker-hub.yml
@@ -67,42 +67,32 @@ jobs:
         run: |
           ./docker-compose.sh platform
 
-      - name: Tag Platform Images
-        run: |
-          set -exuo pipefail
-          platform_tag=$(echo "${{ matrix.platform }}" | tr '/' '-')
-          echo "Platform Tag: ${platform_tag}"
-          for tag in "deps" "dev" "runtime" "cli"; do
-            docker tag metacall/${IMAGE_NAME}:${tag} \
-              metacall/${IMAGE_NAME}:${tag}-${platform_tag}
-            docker tag metacall/${IMAGE_NAME}:${tag} \
-              ${DOCKER_REGISTRY}/${DOCKER_USERNAME}/${IMAGE_NAME}:${tag}-${platform_tag}
-          done
-
       - name: Run Tests
         run: |
           set -exuo pipefail
-          platform_tag=$(echo "${{ matrix.platform }}" | tr '/' '-')
-          docker image inspect metacall/${IMAGE_NAME}:cli-${platform_tag} --format='{{.Os}}/{{.Architecture}}'
+          docker image inspect ${DOCKER_REGISTRY}/${DOCKER_USERNAME}/${IMAGE_NAME}:cli --format='{{.Os}}/{{.Architecture}}'
           cat <<EOF > Dockerfile.test
-          FROM metacall/${IMAGE_NAME}:cli-${platform_tag}
-          RUN echo "console.log('0123456789abcdef')" > script.js
-          RUN apt-get update && apt-get install file
+          FROM ${DOCKER_REGISTRY}/${DOCKER_USERNAME}/${IMAGE_NAME}:cli
+          RUN apt-get update && apt-get install -y file
           RUN file /usr/local/bin/metacallcli
-          RUN /usr/local/bin/metacallcli /usr/local/scripts/script.js
-          RUN /usr/local/bin/metacallcli script.js | tee output.txt
+          RUN echo "console.log('0123456789abcdef')" > script.js
+          RUN metacallcli script.js | tee output.txt
           RUN grep 0123456789abcdef output.txt
           EOF
 
           export DOCKER_BUILDKIT=1
           docker build --progress=plain --platform=${{ matrix.platform }} -f Dockerfile.test -t test-image .
 
-      - name: Push Platform Images
+      - name: Tag & Push Platform Images
         # Only run when master or when tagging a version
         if: (github.ref == 'refs/heads/master' || startsWith(github.ref, 'refs/tags/')) && github.event_name != 'pull_request'
         run: |
           platform_tag=$(echo "${{ matrix.platform }}" | tr '/' '-')
           for tag in "deps" "dev" "runtime" "cli"; do
+            docker tag \
+              ${DOCKER_REGISTRY}/${DOCKER_USERNAME}/${IMAGE_NAME}:${tag} \
+              ${DOCKER_REGISTRY}/${DOCKER_USERNAME}/${IMAGE_NAME}:${tag}-${platform_tag}
+
             echo "Pushing image for tag: ${tag} with platform: ${platform_tag}"
             docker push ${DOCKER_REGISTRY}/${DOCKER_USERNAME}/${IMAGE_NAME}:${tag}-${platform_tag}
           done
diff --git a/docker-compose.test.yml b/docker-compose.test.yml
@@ -25,10 +25,10 @@ services:
     build:
       args:
         METACALL_BUILD_TYPE: ${METACALL_BUILD_TYPE}
-        METACALL_INSTALL_OPTIONS: base python ruby netcore7 nodejs typescript file rpc wasm java c cobol go rust rapidjson swig pack backtrace sandbox ${METACALL_BUILD_COVERAGE} # clangformat v8rep51
+        METACALL_INSTALL_OPTIONS: base python ruby netcore8 nodejs typescript file rpc wasm java c cobol go rust rapidjson swig pack backtrace sandbox ${METACALL_BUILD_COVERAGE} # clangformat v8rep51
   dev:
     image: metacall/core:dev
     build:
       args:
         METACALL_BUILD_TYPE: ${METACALL_BUILD_TYPE}
-        METACALL_BUILD_OPTIONS: ${METACALL_BUILD_SANITIZER} python ruby netcore7 nodejs typescript file rpc wasm java c cobol go rust examples tests scripts ports install pack sandbox benchmarks ${METACALL_BUILD_COVERAGE} # v8
+        METACALL_BUILD_OPTIONS: ${METACALL_BUILD_SANITIZER} python ruby netcore8 nodejs typescript file rpc wasm java c cobol go rust examples tests scripts ports install pack sandbox benchmarks ${METACALL_BUILD_COVERAGE} # v8
diff --git a/source/loaders/node_loader/include/node_loader/node_loader_impl.h b/source/loaders/node_loader/include/node_loader/node_loader_impl.h
@@ -67,7 +67,7 @@ NODE_LOADER_NO_EXPORT void node_loader_impl_destroy_safe_impl(loader_impl_node n
 
 NODE_LOADER_NO_EXPORT void node_loader_impl_print_handles(loader_impl_node node_impl);
 
-NODE_LOADER_NO_EXPORT int64_t node_loader_impl_user_async_handles_count(loader_impl_node node_impl);
+NODE_LOADER_NO_EXPORT uint64_t node_loader_impl_user_async_handles_count(loader_impl_node node_impl);
 
 NODE_LOADER_NO_EXPORT napi_value node_loader_impl_register_bootstrap_startup(loader_impl_node node_impl, napi_env env);
 
diff --git a/source/loaders/node_loader/source/node_loader_impl.cpp b/source/loaders/node_loader/source/node_loader_impl.cpp
@@ -704,8 +704,8 @@ struct loader_impl_node_type
 	/* TODO: This implementation won't work for multi-isolate environments. We should test it. */
 	std::thread::id js_thread_id;
 
-	int64_t base_active_handles;
-	std::atomic_int64_t extra_active_handles;
+	uint64_t base_active_handles;
+	std::atomic_uint64_t extra_active_handles;
 	uv_prepare_t destroy_prepare;
 	uv_check_t destroy_check;
 	std::atomic_bool event_loop_empty;
@@ -874,7 +874,7 @@ static void node_loader_impl_thread_log(void *data);
 static void node_loader_impl_walk_async_handles_count(uv_handle_t *handle, void *arg);
 #endif
 
-static int64_t node_loader_impl_async_handles_count(loader_impl_node node_impl);
+static uint64_t node_loader_impl_async_handles_count(loader_impl_node node_impl);
 
 static void node_loader_impl_try_destroy(loader_impl_node node_impl);
 
@@ -4346,7 +4346,7 @@ static void node_loader_impl_destroy_cb(loader_impl_node node_impl)
 	node_loader_impl_print_handles(node_impl);
 #endif
 
-	if (node_impl->event_loop_empty.load() == false && node_loader_impl_user_async_handles_count(node_impl) <= 0)
+	if (node_impl->event_loop_empty.load() == false && node_loader_impl_user_async_handles_count(node_impl) == 0)
 	{
 		loader_impl_handle_safe_cast<uv_prepare_t> destroy_prepare_cast = { NULL };
 		loader_impl_handle_safe_cast<uv_check_t> destroy_check_cast = { NULL };
@@ -4399,7 +4399,7 @@ void node_loader_impl_destroy_safe(napi_env env, loader_impl_async_destroy_safe_
 	node_loader_impl_exception(env, status);
 
 	/* Check if there are async handles, destroy if the queue is empty, otherwise request the destroy */
-	if (node_loader_impl_user_async_handles_count(node_impl) <= 0 || node_impl->event_loop_empty.load() == true)
+	if (node_loader_impl_user_async_handles_count(node_impl) == 0 || node_impl->event_loop_empty.load() == true)
 	{
 		node_loader_impl_destroy_safe_impl(node_impl, env);
 		destroy_safe->has_finished = true;
@@ -4431,7 +4431,7 @@ static inline int uv__queue_empty(const struct node_loader_impl_uv__queue *q)
 #if (defined(__APPLE__) && defined(__MACH__)) || defined(__MACOSX__)
 void node_loader_impl_walk_async_handles_count(uv_handle_t *handle, void *arg)
 {
-	int64_t *async_count = static_cast<int64_t *>(arg);
+	uint64_t *async_count = static_cast<uint64_t *>(arg);
 
 	if (uv_is_active(handle) && !uv_is_closing(handle))
 	{
@@ -4447,11 +4447,11 @@ void node_loader_impl_walk_async_handles_count(uv_handle_t *handle, void *arg)
 }
 #endif
 
-int64_t node_loader_impl_async_closing_handles_count(loader_impl_node node_impl)
+uint64_t node_loader_impl_async_closing_handles_count(loader_impl_node node_impl)
 {
 #if defined(WIN32) || defined(_WIN32)
-	return (int64_t)(node_impl->thread_loop->pending_reqs_tail != NULL) +
-		   (int64_t)(node_impl->thread_loop->endgame_handles != NULL);
+	return (uint64_t)(node_impl->thread_loop->pending_reqs_tail != NULL) +
+		   (uint64_t)(node_impl->thread_loop->endgame_handles != NULL);
 #else
 	union
 	{
@@ -4461,49 +4461,66 @@ int64_t node_loader_impl_async_closing_handles_count(loader_impl_node node_impl)
 
 	uv__queue_cast.data = (void *)&node_impl->thread_loop->pending_queue;
 
-	return (int64_t)(!uv__queue_empty(uv__queue_cast.ptr)) +
-		   (int64_t)(node_impl->thread_loop->closing_handles != NULL);
+	return (uint64_t)(!uv__queue_empty(uv__queue_cast.ptr)) +
+		   (uint64_t)(node_impl->thread_loop->closing_handles != NULL);
 #endif
 }
 
-int64_t node_loader_impl_async_handles_count(loader_impl_node node_impl)
+uint64_t node_loader_impl_async_handles_count(loader_impl_node node_impl)
 {
 #if (defined(__APPLE__) && defined(__MACH__)) || defined(__MACOSX__)
-	int64_t active_handles = 0;
+	uint64_t active_handles = 0;
 	uv_walk(node_impl->thread_loop, node_loader_impl_walk_async_handles_count, (void *)&active_handles);
 
 	return active_handles +
-		   (int64_t)(node_impl->thread_loop->active_reqs.count > 0) +
+		   (uint64_t)(node_impl->thread_loop->active_reqs.count > 0) +
 		   node_loader_impl_async_closing_handles_count(node_impl);
 #else
-	int64_t active_handles = (int64_t)node_impl->thread_loop->active_handles +
-							 (int64_t)(node_impl->thread_loop->active_reqs.count > 0) +
-							 node_loader_impl_async_closing_handles_count(node_impl);
+	uint64_t active_handles = (uint64_t)node_impl->thread_loop->active_handles +
+							  (uint64_t)(node_impl->thread_loop->active_reqs.count > 0) +
+							  node_loader_impl_async_closing_handles_count(node_impl);
 	return active_handles;
 #endif
 }
 
-int64_t node_loader_impl_user_async_handles_count(loader_impl_node node_impl)
+uint64_t node_loader_impl_user_async_handles_count(loader_impl_node node_impl)
 {
-	int64_t active_handles = node_loader_impl_async_handles_count(node_impl);
-	int64_t extra_active_handles = node_impl->extra_active_handles.load();
+	uint64_t active_handles = node_loader_impl_async_handles_count(node_impl);
+	uint64_t extra_active_handles = node_impl->extra_active_handles.load();
+	uint64_t base_active_handles = node_impl->base_active_handles;
 
 	/* TODO: Uncomment for debugging handles */
 	/*
 #if (!defined(NDEBUG) || defined(DEBUG) || defined(_DEBUG) || defined(__DEBUG) || defined(__DEBUG__))
-	int64_t closing = node_loader_impl_async_closing_handles_count(node_impl);
+	uint64_t closing = node_loader_impl_async_closing_handles_count(node_impl);
 
 	printf("[active_handles] - [base_active_handles] - [extra_active_handles] + [active_reqs] + [closing]\n");
-	printf("       %" PRId64 "        -           %" PRId64 "          -            %" PRId64 "           +    %" PRId64 " [> 0]    +    %" PRId64 "\n",
-		(int64_t)node_impl->thread_loop->active_handles,
-		node_impl->base_active_handles,
+	printf("       %" PRIu64 "        -           %" PRIu64 "          -            %" PRIu64 "           +    %" PRIu64 " [> 0]    +    %" PRIu64 "\n",
+		(uint64_t)node_impl->thread_loop->active_handles,
+		base_active_handles,
 		extra_active_handles,
-		(int64_t)node_impl->thread_loop->active_reqs.count,
+		(uint64_t)node_impl->thread_loop->active_reqs.count,
 		closing);
 #endif
 */
 
-	return active_handles - node_impl->base_active_handles - extra_active_handles;
+	/* Check for overflow */
+	uint64_t total_base_handles = base_active_handles + extra_active_handles;
+
+	if (total_base_handles < base_active_handles)
+	{
+		/* Overflow occurred */
+		return UINT64_MAX;
+	}
+
+	/* Check for underflow */
+	if (active_handles < total_base_handles)
+	{
+		/* Underflow occurred */
+		return 0;
+	}
+
+	return active_handles - total_base_handles;
 }
 
 void node_loader_impl_print_handles(loader_impl_node node_impl)
@@ -4512,8 +4529,8 @@ void node_loader_impl_print_handles(loader_impl_node node_impl)
 
 	/* TODO: Uncomment for debugging handles */
 	/*
-	printf("Number of active handles: %" PRId64 "\n", node_loader_impl_async_handles_count(node_impl));
-	printf("Number of user active handles: %" PRId64 "\n", node_loader_impl_user_async_handles_count(node_impl));
+	printf("Number of active handles: %" PRIu64 "\n", node_loader_impl_async_handles_count(node_impl));
+	printf("Number of user active handles: %" PRIu64 "\n", node_loader_impl_user_async_handles_count(node_impl));
 	uv_print_active_handles(node_impl->thread_loop, stdout);
 	fflush(stdout);
 	*/
diff --git a/source/loaders/node_loader/source/node_loader_trampoline.cpp b/source/loaders/node_loader/source/node_loader_trampoline.cpp
@@ -397,12 +397,17 @@ napi_value node_loader_trampoline_active_handles(napi_env env, napi_callback_inf
 		return nullptr;
 	}
 
-	int64_t active_handles = node_loader_impl_user_async_handles_count(node_impl_cast.data);
+	uint64_t active_handles = node_loader_impl_user_async_handles_count(node_impl_cast.data);
 
 	/* Create the integer return value */
 	napi_value result;
 
-	status = napi_create_int64(env, active_handles, &result);
+	if (active_handles > (uint64_t)INT64_MAX)
+	{
+		active_handles = (uint64_t)INT64_MAX;
+	}
+
+	status = napi_create_int64(env, (int64_t)active_handles, &result);
 
 	node_loader_impl_exception(env, status);
 
diff --git a/source/loaders/py_loader/source/py_loader_dict.c b/source/loaders/py_loader/source/py_loader_dict.c
@@ -26,10 +26,32 @@
 #include <Python.h>
 
 #if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 13
+	/* Disable warnings from Python */
+	#if defined(__clang__)
+		#pragma clang diagnostic push
+		#pragma clang diagnostic ignored "-Wredundant-decls"
+		#pragma clang diagnostic ignored "-Wstrict-aliasing"
+		#pragma clang diagnostic ignored "-Wunused-parameter"
+		#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+	#elif defined(__GNUC__)
+		#pragma GCC diagnostic push
+		#pragma GCC diagnostic ignored "-Wredundant-decls"
+		#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+		#pragma GCC diagnostic ignored "-Wunused-parameter"
+		#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+	#endif
+
 	#ifndef Py_BUILD_CORE
 		#define Py_BUILD_CORE
 	#endif
 	#include <internal/pycore_dict.h>
+
+	/* Disable warnings from Python */
+	#if defined(__clang__)
+		#pragma clang diagnostic pop
+	#elif defined(__GNUC__)
+		#pragma GCC diagnostic pop
+	#endif
 #endif
 
 struct py_loader_impl_dict_obj
diff --git a/source/loaders/py_loader/source/py_loader_impl.c b/source/loaders/py_loader/source/py_loader_impl.c
@@ -44,8 +44,6 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-#include <Python.h>
-
 #define PY_LOADER_IMPL_FUNCTION_TYPE_INVOKE_FUNC "__py_loader_impl_function_type_invoke__"
 #define PY_LOADER_IMPL_FINALIZER_FUNC			 "__py_loader_impl_finalizer__"
 
diff --git a/source/loaders/py_loader/source/py_loader_threading.cpp b/source/loaders/py_loader/source/py_loader_threading.cpp
@@ -24,8 +24,6 @@
 
 #include <Python.h>
 
-#include <thread>
-
 struct py_thread_state
 {
 	uint64_t ref_count;
diff --git a/source/loaders/rb_loader/source/rb_loader_impl.c b/source/loaders/rb_loader/source/rb_loader_impl.c
@@ -42,6 +42,7 @@
 	#pragma GCC diagnostic push
 	#pragma GCC diagnostic ignored "-Wredundant-decls"
 	#pragma GCC diagnostic ignored "-Wpedantic"
+	#pragma GCC diagnostic ignored "-Wunused-parameter"
 #endif
 
 #include <ruby.h>
diff --git a/source/ports/py_port/helper.py b/source/ports/py_port/helper.py
@@ -112,7 +112,7 @@ def pre_install(components):
 def pre_install_prompt():
 
     answers = {'yes': True, 'y': True, 'no': False, 'n': False}
-    components = ['python', 'ruby', 'netcore7', 'v8', 'nodejs', 'ports']
+    components = ['python', 'ruby', 'netcore8', 'v8', 'nodejs', 'ports']
     args = []
 
     try:
diff --git a/source/reflect/source/reflect_class.c b/source/reflect/source/reflect_class.c
@@ -123,6 +123,7 @@ klass class_create(const char *name, enum accessor_type_id accessor, class_impl
 			log_write("metacall", LOG_LEVEL_ERROR, "Invalid class (%s) create callback <%p>", cls->name, cls->interface->create);
 
 			free(cls->name);
+			threading_atomic_ref_count_destroy(&cls->ref);
 			vector_destroy(cls->constructors);
 			map_destroy(cls->methods);
 			map_destroy(cls->static_methods);
diff --git a/source/reflect/source/reflect_exception.c b/source/reflect/source/reflect_exception.c
@@ -138,9 +138,15 @@ exception exception_create_const(const char *message, const char *label, int64_t
 	return ex;
 
 stacktrace_bad_alloc:
-	free(ex->label);
+	if (ex->label != NULL)
+	{
+		free(ex->label);
+	}
 label_bad_alloc:
-	free(ex->message);
+	if (ex->message != NULL)
+	{
+		free(ex->message);
+	}
 message_bad_alloc:
 	free(ex);
 exception_bad_alloc:
diff --git a/source/reflect/source/reflect_function.c b/source/reflect/source/reflect_function.c
@@ -66,9 +66,7 @@ function function_create(const char *name, size_t args_count, function_impl impl
 		{
 			log_write("metacall", LOG_LEVEL_ERROR, "Invalid function name allocation <%s>", name);
 
-			free(func);
-
-			return NULL;
+			goto name_error;
 		}
 
 		memcpy(func->name, name, func_name_size);
@@ -88,7 +86,7 @@ function function_create(const char *name, size_t args_count, function_impl impl
 	{
 		log_write("metacall", LOG_LEVEL_ERROR, "Invalid function signature allocation");
 
-		goto function_create_error;
+		goto signature_error;
 	}
 
 	threading_atomic_ref_count_initialize(&func->ref);
@@ -101,16 +99,22 @@ function function_create(const char *name, size_t args_count, function_impl impl
 		{
 			log_write("metacall", LOG_LEVEL_ERROR, "Invalid function (%s) create callback <%p>", func->name, func->interface->create);
 
-			goto function_create_error;
+			goto interface_create_error;
 		}
 	}
 
 	reflect_memory_tracker_allocation(function_stats);
 
 	return func;
 
-function_create_error:
-	free(func->name);
+interface_create_error:
+	signature_destroy(func->s);
+signature_error:
+	if (func->name != NULL)
+	{
+		free(func->name);
+	}
+name_error:
 	free(func);
 
 	return NULL;
diff --git a/source/reflect/source/reflect_object.c b/source/reflect/source/reflect_object.c
diff --git a/source/threading/include/threading/threading_atomic_ref_count.h b/source/threading/include/threading/threading_atomic_ref_count.h
diff --git a/tools/metacall-configure.sh b/tools/metacall-configure.sh
diff --git a/tools/metacall-environment.sh b/tools/metacall-environment.sh
diff --git a/tools/metacall-runtime.sh b/tools/metacall-runtime.sh
diff --git a/tools/metacall-sanitizer.sh b/tools/metacall-sanitizer.sh

Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,6 @@`
`24`	`24`
`25`	`25`	`#include <Python.h>`
`26`	`26`
`27`		`-#include <thread>`
`28`		`-`
`29`	`27`	`struct py_thread_state`
`30`	`28`	`{`
`31`	`29`	`uint64_t ref_count;`