ApacheSolrForTypo3\Tika\Process

Complexity

Total Complexity

22

Size/Duplication

Total Lines	207
Duplicated Lines	0 %

Test Coverage

Coverage

86.36%

Importance

Changes	10
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	setArguments()	0	3	1
A	isRunning()	0	17	3
A	getExecutable()	0	3	1
A	getPid()	0	3	1
A	__construct()	0	4	1
A	stop()	0	12	2
A	escapePsOutputCommand()	0	16	4
A	start()	0	4	1
A	setPid()	0	3	1
A	runCommand()	0	12	2
A	findPid()	0	20	4
A	getArguments()	0	3	1

<?php

declare(strict_types=1);

namespace ApacheSolrForTypo3\Tika;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

/**
 * Run, check, and stop external processes. Linux only.
 * @author Ingo Renner <ingo@typo3.org>
 */
class Process
{

    /**
     * Process ID
     *
     * @var int|null
     */
    protected ?int $pid = null;

    /**
     * Executable running the command
     *
     * @var string
     */
    protected string $executable;

    /**
     * Executable arguments
     *
     * @var string
     */
    protected string $arguments;

    /**
     * Constructor
     *
     * @param string $executable
     * @param string $arguments
     */
    public function __construct(string $executable, string $arguments = '')
    {
        $this->executable = $executable;
        $this->arguments = $arguments;
    }

    /**
     * Arguments getter
     *
     * @return string
     */
    public function getArguments(): string
    {
        return $this->arguments;
    }

    /**
     * Arguments setter
     *
     * @param string $arguments
     */
    public function setArguments(string $arguments): void
    {
        $this->arguments = $arguments;
    }

    /**
     * Gets the process executable
     *
     * @return string
     */
    public function getExecutable(): string
    {
        return $this->executable;
    }

    /**
     * Gets the process ID
     *
     * @return int|null process ID
     */
    public function getPid(): ?int
    {
        return $this->pid;
    }

    /**
     * Sets the process ID
     *
     * @param int $pid
     */
    public function setPid(int $pid): void
    {
        $this->pid = $pid;
    }

    /**
     * Tries to find the process' pid using ps
     *
     * @return int|null Null if the pid can't be found, otherwise the pid
     */
    public function findPid(): ?int
    {
        $processCommand = $this->executable;
        if (!empty($this->arguments)) {
            $processCommand .= ' ' . $this->arguments;
        }

        $ps = 'ps h --format pid,args -C ' . basename($this->executable);
        $output = [];
        exec($ps, $output);

        foreach ($output as $line) {
            [$pid, $command] = explode(' ', trim($line), 2);
            $command = $this->escapePsOutputCommand($command);
            if ($command == $processCommand) {
                return (int)$pid;
            }
        }

        return null;
    }

    /**
     * Escapes 'ps' command output to match what we expect to get as arguments
     * when executing a command.
     *
     * @param string $command
     * @return string
     */
    protected function escapePsOutputCommand(string $command): string
    {
        $command = explode(' ', $command);

        foreach ($command as $k => $v) {
            if ($k == 0) {
                // skip the executable
                continue;
            }

            if ($v[0] != '-') {
                $command[$k] = escapeshellarg($v);
            }
        }

        return implode(' ', $command);
    }

    /**
     * Starts the process.
     *
     * @return bool TRUE if the process could be started, FALSE otherwise
     */
    public function start(): bool
    {
        $this->runCommand();
        return $this->isRunning();
    }

    /**
     * Executes the command
     */
    protected function runCommand(): void
    {
        $command = 'nohup ' . $this->executable;
        if (!empty($this->arguments)) {
            $command .= ' ' . $this->arguments;
        }
        $command .= ' > /dev/null 2>&1 & echo $!';

        $output = [];
        exec($command, $output);

        $this->pid = (int)$output[0];
    }

    /**
     * Checks whether the process is running
     *
     * @return bool TRUE if the process is running, FALSE otherwise
     */
    public function isRunning(): bool
    {
        if (is_null($this->pid)) {
            return false;
        }

        $running = false;
        $output = [];

        $command = 'ps h -p ' . $this->pid;
        exec($command, $output);

        if (!empty($output)) {
            $running = true;
        }

        return $running;
    }

    /**
     * Stops the process
     *
     * @return bool
     */
    public function stop(): bool
    {
        $command = 'kill ' . $this->pid;
        exec($command);

        if ($this->isRunning() == false) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            $stopped = true;
        } else {
            $stopped = false;
        }

        return $stopped;
    }
}