How can I use git in daemonized python code?

Question

My project I am writing is a daemon, which i can run undaemonized for debugging purposes.

I am trying to use simple git functionality in Python. Here is my git Class.

import os
import subprocess


class Git():

    def __init__(self, server_log, config, repo_path):

        self.log = server_log
        self.config = config

        self.repo_path = repo_path
        self.repo_name = os.path.basename(repo_path.strip("/"))

        self.base_command = "/usr/bin/git "


    def push(self):

        command = self.base_command + "push"
        output, return_code = self.run_command(command)
        self.print_output("push", output, return_code)


    def pull(self):

        command = self.base_command + "pull"
        output, return_code = self.run_command(command)
        self.print_output("pull", output, return_code)


    def commit(self, message):

        command = self.base_command + "commit -a -m \"" + message +  "\""
        output, return_code = self.run_command(command)
        self.print_output("commit", output, return_code)


    def print_output(self, command_type, output, return_code):

        self.log.info("Git " + command_type + ": " + self.repo_name + " Returncode: " + str(return_code))
        self.log.info("\n" + output)


    def run_command(self, command):

        self.log.info("Command: " + command)
        process = subprocess.Popen(command, shell = True, cwd = self.repo_path, stdout = subprocess.PIPE, stderr = subprocess.PIPE, universal_newlines = True)
        (stdout_data, stderr_data) = process.communicate()
        return_code = process.returncode

        output = stdout_data.strip()
        if stderr_data:
            if output:
                output += "\n"
            output += stderr_data.strip()

        return (output, return_code)

This code works as intended in non daemonized context. But if you combine it with python-daemon it falls apart.

This is how i daemonize, which worked no problem so far.

with daemon.DaemonContext(pidfile = daemon.pidfile.PIDLockFile(self.config["pid_file"])):
            self.run_server()

The run_server method was asked for, so i include it here:

def run_server(self):

        setproctitle.setproctitle("server")

        # Logging
        log = Logger(self.config["logfile"], "Server", self.config["loglevel"], self.config["log_size"], self.config["kept_rotations"])
        # For quit_handler
        self.log = log

        # Register Signal Handler
        signal.signal(signal.SIGINT,  self.quit_handler)
        signal.signal(signal.SIGQUIT, self.quit_handler)

        log.print("Server Version " + version.get_version() + " started.")

        scan_queue = multiprocessing.Queue()

        # Create and start Scan Manager
        scan_manager = ScanManager(log, self.config, scan_queue)
        scan_manager_proc = multiprocessing.Process(target=scan_manager.run_manager, name="scan_manager")
        scan_manager_proc.daemon = False
        scan_manager_proc.start()

        # Create and start REST Interfaces
        rest_api = RestApi(log, self.config, scan_queue)
        rest_api_proc = multiprocessing.Process(target=rest_api.run_api, name="rest_api")
        rest_api_proc.daemon = False
        rest_api_proc.start()

        # Create and start NginxProxy
        nginx = NginxProxy(log, self.config)
        nginx_proc = multiprocessing.Process(target=nginx.start, name="nginx")
        nginx_proc.daemon = False
        nginx_proc.start()

        # Wait for signal.
        signal.pause()

        # Quit processes
        scan_manager_proc.terminate()
        rest_api_proc.terminate()
        nginx_proc.terminate()
        log.print("Stopped")

This is the result non daemonized:

04.12.2020 11:54:38 INFO: Command: /usr/bin/git pull
04.12.2020 11:54:38 INFO: Git pull: repo Returncode: 0
04.12.2020 11:54:38 INFO:
Already up-to-date.
04.12.2020 11:54:38 INFO: Command: /usr/bin/git commit -a -m "SetNodeStatus 04.12.2020 11:54 UTC on ['server']"
04.12.2020 11:54:38 INFO: Git commit: repo Returncode: 0
04.12.2020 11:54:38 INFO:
[master df88920] SetNodeStatus 04.12.2020 11:54 UTC on ['server']
 1 file changed, 1 insertion(+), 1 deletion(-)
04.12.2020 11:54:38 INFO: Command: /usr/bin/git push
04.12.2020 11:54:39 INFO: Git push: repo Returncode: 0
04.12.2020 11:54:39 INFO:
To git@gitserver:repo.git
   428a77e..df88920  master -> master

And here it is daemonized:

04.12.2020 11:54:50 INFO: Command: /usr/bin/git pull
04.12.2020 11:54:51 INFO: Git pull: repo Returncode: 1
04.12.2020 11:54:51 INFO:
fatal: The remote end hung up unexpectedly
04.12.2020 11:54:51 INFO: Command: /usr/bin/git commit -a -m "SetNodeStatus 04.12.2020 11:54 UTC off ['server']"
04.12.2020 11:54:51 INFO: Git commit: repo Returncode: 128
04.12.2020 11:54:51 INFO:
error: unable to create temporary file: file already exists
fatal: Error writing version object.
04.12.2020 11:54:51 INFO: Command: /usr/bin/git push
04.12.2020 11:54:51 INFO: Git push: repo Returncode: -13
04.12.2020 11:54:51 INFO:
fatal: The remote end hung up unexpectedly

I also implemented this using GitPython with the same effect.

Why is that and how can I make this work?

Solution:

in subprocess.Popenstdin defaults to None. Defining stdin as a pipe fixed the problem.

process = subprocess.Popen(command, shell = True, cwd = self.repo_path, stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = subprocess.PIPE, universal_newlines = True)