plugins: exec: exit fluent-bit after oneshot and propagate exit code

CMakeLists.txt

@@ -89,6 +89,7 @@ include(ExternalProject)
 include(cmake/FindJournald.cmake)
 include(cmake/FindMonkey.cmake)
 include(cmake/macros.cmake)
+include(cmake/platform_feature_checks.cmake)
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake/sanitizers-cmake/cmake" ${CMAKE_MODULE_PATH})
 find_package(Sanitizers)
 

cmake/platform_feature_checks.cmake

@@ -0,0 +1,8 @@
+# Feature tests for various platform and compiler capabilities,
+# system headers, etc.
+
+include(CheckIncludeFile)
+CHECK_INCLUDE_FILE("sys/wait.h" FLB_HAVE_SYS_WAIT_H)
+if (FLB_HAVE_SYS_WAIT_H)
+    FLB_DEFINITION(FLB_HAVE_SYS_WAIT_H)
+endif()

plugins/in_exec/in_exec.c

@@ -29,6 +29,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include "in_exec_win32_compat.h"
 
 #include "in_exec.h"
 
@@ -37,6 +38,8 @@ static int in_exec_collect(struct flb_input_instance *ins,
                            struct flb_config *config, void *in_context)
 {
     int ret = -1;
+    int cmdret;
+    int flb_exit_code;
     uint64_t val;
     size_t str_len = 0;
     FILE *cmdp = NULL;
@@ -56,7 +59,7 @@ static int in_exec_collect(struct flb_input_instance *ins,
         }
     }
 
-    cmdp = popen(ctx->cmd, "r");
+    cmdp = flb_popen(ctx->cmd, "r");
     if (cmdp == NULL) {
         flb_plg_debug(ctx->ins, "command %s failed", ctx->cmd);
         goto collect_end;
@@ -165,7 +168,73 @@ static int in_exec_collect(struct flb_input_instance *ins,
 
  collect_end:
     if(cmdp != NULL){
-        pclose(cmdp);
+        /*
+         * If we're propagating the child exit code to the fluent-bit exit code
+         * in one-shot mode, popen() will have invoked our child command via
+         * its own shell, so unless the shell itself exited on a signal the
+         * translation is already done for us.
+         * For references on exit code handling in wrappers see
+         * https://www.gnu.org/software/bash/manual/html_node/Exit-Status.html
+         * and
+         * https://skarnet.org/software/execline/exitcodes.html
+         */
+        cmdret = flb_pclose(cmdp);
+        if (cmdret == -1) {
+            flb_errno();
+            flb_plg_debug(ctx->ins,
+                    "unexpected error while waiting for exit of command %s ",
+                    ctx->cmd);
+            /*
+             * The exit code of the shell run by popen() could not be
+             * determined; exit with 128, which is not a code that could be
+             * returned through a shell by a real child command.
+             */
+            flb_exit_code = 128;
+        } else if (FLB_WIFEXITED(cmdret)) {
+            flb_plg_debug(ctx->ins, "command %s exited with code %d",
+                    ctx->cmd, FLB_WEXITSTATUS(cmdret));
+            /*
+             * Propagate shell exit code, which may encode a normal or signal
+             * exit for the real child process, directly to the caller. This
+             * could be greater than 127 if the shell encoded a signal exit
+             * status from the child process into its own return code.
+             */
+            flb_exit_code = FLB_WEXITSTATUS(cmdret);
+        } else if (FLB_WIFSIGNALED(cmdret)) {
+            flb_plg_debug(ctx->ins, "command %s exited with signal %d",
+                    ctx->cmd, FLB_WTERMSIG(cmdret));
+            /*
+             * Follow the shell convention of returning 128+signo for signal
+             * exits. The consumer of fluent-bit's exit code will be unable to
+             * differentiate between the shell exiting on a signal and the
+             * process called by the shell exiting on a signal.
+             */
+            flb_exit_code = 128 + FLB_WTERMSIG(cmdret);
+        } else {
+            flb_plg_debug(ctx->ins, "command %s exited with unknown status",
+                    ctx->cmd);
+            flb_exit_code = 128;
+        }
+
+        /*
+         * In one-shot mode, exit fluent-bit once the child process terminates.
+         */
+        if (ctx->exit_after_oneshot == FLB_TRUE) {
+            /*
+             * propagate the child process exit code as the fluent-bit exit
+             * code so fluent-bit with the exec plugin can be used as a
+             * command wrapper.
+             */
+            if (ctx->propagate_exit_code == FLB_TRUE) {
+                config->exit_status_code = flb_exit_code;
+            }
+            flb_plg_info(ctx->ins,
+                    "one-shot command exited, terminating fluent-bit");
+            flb_engine_exit(config);
+        } else {
+            flb_plg_debug(ctx->ins,
+                    "one-shot command exited but exit_after_oneshot not set");
+        }
     }
 
     return ret;
@@ -212,6 +281,23 @@ static int in_exec_config_read(struct flb_exec *ctx,
         ctx->interval_nsec = atoi(DEFAULT_INTERVAL_NSEC);
     }
 
+    /*
+     * propagate_exit_code is not being forced to imply exit_after_oneshot in
+     * case somebody in future wishes to make the exec plugin exit on nonzero
+     * exit codes for normal repeating commands.
+     */
+    if (ctx->propagate_exit_code && !ctx->exit_after_oneshot) {
+        flb_plg_error(in,
+                "propagate_exit_code=True option makes no sense without "
+                "exit_after_oneshot=True");
+        return -1;
+    }
+
+    if (ctx->exit_after_oneshot && !ctx->oneshot) {
+        flb_plg_debug(in, "exit_after_oneshot implies oneshot mode, enabling");
+        ctx->oneshot = FLB_TRUE;
+    }
+
     if (ctx->oneshot) {
         ctx->interval_sec = -1;
         ctx->interval_nsec = -1;
@@ -378,6 +464,17 @@ static struct flb_config_map config_map[] = {
       0, FLB_TRUE, offsetof(struct flb_exec, oneshot),
       "execute the command only once"
     },
+    {
+      FLB_CONFIG_MAP_BOOL, "exit_after_oneshot", "false",
+      0, FLB_TRUE, offsetof(struct flb_exec, exit_after_oneshot),
+      "exit fluent-bit after the command terminates in one-shot mode"
+    },
+    {
+      FLB_CONFIG_MAP_BOOL, "propagate_exit_code", "false",
+      0, FLB_TRUE, offsetof(struct flb_exec, propagate_exit_code),
+      "propagate oneshot exit command fluent-bit exit code using "
+      "shell exit code translation conventions"
+    },
     /* EOF */
     {0}
 };

plugins/in_exec/in_exec.h

@@ -45,6 +45,8 @@ struct flb_exec {
     int interval_sec;
     int interval_nsec;
     struct flb_log_event_encoder log_encoder;
+    int exit_after_oneshot;
+    int propagate_exit_code;
 };
 
 #endif /* FLB_IN_EXEC_H */

plugins/in_exec/in_exec_win32_compat.h

@@ -0,0 +1,94 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*  Fluent Bit
+ *  ==========
+ *  Copyright (C) 2015-2022 The Fluent Bit Authors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+#ifndef FLB_IN_EXEC_WIN32_COMPAT_H
+#define FLB_IN_EXEC_WIN32_COMPAT_H
+
+#include <stdio.h>
+#include <fluent-bit/flb_info.h>
+
+/*
+ * Work around lack of sys/wait.h and POSIX exit status macros from waitpid()
+ * in win32's _popen() and _pclose() implementation, since fluent-bit uses
+ * these in the in_exec plugin.
+ *
+ * On POSIX-like OSes this'll just use the standard macros with a name alias.
+ *
+ * On windows, where the concept of a signal exit does not exist, it defines
+ * dummy macros to indicate that the process exited normally and extract the
+ * exit code.
+ *
+ * These macros are for use with flb_pclose() only. Do not use them with
+ * other APIs that may differ in return value semantics.
+ */
+#ifdef FLB_HAVE_SYS_WAIT_H
+#include <sys/wait.h>
+#define FLB_WIFEXITED(status) WIFEXITED((status))
+#define FLB_WEXITSTATUS(status) WEXITSTATUS((status))
+#define FLB_WIFSIGNALED(status) WIFSIGNALED((status))
+#define FLB_WTERMSIG(status) WTERMSIG((status))
+#else
+#define FLB_WIFEXITED(status) (1)
+#define FLB_WEXITSTATUS(status) ((status) & 0x00ff)
+#define FLB_WIFSIGNALED(status) (0)
+#define FLB_WTERMSIG(status) (-1)
+#endif
+
+/*
+ * Because Windows has to do everything differently, call _popen() and
+ * _pclose() instead of the POSIX popen() and pclose() functions.
+ *
+ * flb_pclose() has different return value semantics on Windows vs non-windows
+ * targets because it propagates the pclose() or _pclose() return value
+ * directly. You MUST use the FLB_WIFEXITED(), FLB_WEXITSTATUS(),
+ * FLB_WIFSIGNALED() and FLB_WTERMSIG() macros to consume the return value,
+ * rather than the underlying POSIX macros or manual bit-shifts.
+ */
+#if !defined(FLB_SYSTEM_WINDOWS)
+static inline FILE* flb_popen(const char *command, const char *type) {
+    return popen(command, type);
+}
+static inline int flb_pclose(FILE *stream) {
+    return pclose(stream);
+}
+#define FLB_PCLOSE pclose
+#else
+static inline FILE* flb_popen(const char *command, const char *type) {
+    return _popen(command, type);
+}
+/*
+ * flb_pclose() has the same return value on Windows as win32 _pclose(), rather
+ * than posix pclose(). The process exit code is not bit-shifted to the high
+ * byte.
+ *
+ * The MSVC docs for _pclose() at
+ * https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/pclose?view=msvc-170
+ * are misleading; they say that "The format of the return value is the same as
+ * for _cwait, except the low-order and high-order bytes are swapped." But
+ * _cwait isn't documented as having any meaningful return on success, the
+ * process exit code is meant to be in  its "termstat" out parameter per
+ * https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/cwait?view=msvc-170
+ * The return code of _pclose() actually appears to be the process exit code
+ * without the bit-shift that waitpid() applies.
+ */
+static inline int flb_pclose(FILE *stream) {
+    return _pclose(stream);
+}
+#endif
+
+#endif /* FLB_IN_EXEC_WIN32_COMPAT_H */