Containers::execKillAndRemove() - Code Metrics - Inspection of "prepare 0.0.42 release" - ktomk/pipelines - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d8d9f2...800fb3 )

by Tom

created 2020-06-24 22:53 UTC

Containers::execKillAndRemove() A

↳ Parent: Containers

Complexity

Conditions	3
Paths	4

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	3
eloc	4
c	1
b	0
f	1
nc	4
nop	4
dl	0
loc	8
ccs	5
cts	5
cp	1
crap	3
rs	10

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines\Runner;

use Ktomk\Pipelines\Cli\Docker;
use Ktomk\Pipelines\Cli\Exec;
use Ktomk\Pipelines\Cli\Streams;
use Ktomk\Pipelines\File\Definitions\Service;
use Ktomk\Pipelines\File\Pipeline\Step;
use Ktomk\Pipelines\Lib;
use Ktomk\Pipelines\Runner\Containers\NameBuilder;
use Ktomk\Pipelines\Runner\Containers\StepContainer;
use Ktomk\Pipelines\Runner\Docker\ImageLogin;

/**
 * Class Containers
 *
 * Containers as per the runner
 *
 * An extraction of more generic container functionality from the
 * StepContainer that is more specific and did host them since
 * introducing services
 *
 * @package Ktomk\Pipelines\Runner
 */
class Containers
{
    /**
     * @var Runner
     */
    private $runner;

    /**
     * kill and remove static implementation
     *
     * @param Exec $exec
     * @param string|string[] $idOrIds container id(s) or name(s)
     * @param bool $kill
     * @param bool $remove
     *
     * @return void
     */
    public static function execKillAndRemove(Exec $exec, $idOrIds, $kill, $remove)
    {
        if ($kill) {
            Docker::create($exec)->getProcessManager()->kill($idOrIds);
        }

        if ($remove) {
            Docker::create($exec)->getProcessManager()->remove($idOrIds);
        }
    }

    /**
     * @param Exec $exec
     * @param array $args
     *
     * @return array array(int $status, string $out, string $err, string|null $id)
     */
    public static function execRun(Exec $exec, array $args)
    {
        $status = $exec->capture('docker', Lib::merge('run', $args), $out, $err);

        $id = null;
        if (0 === $status) {
            $id = rtrim($out) ?: null;
        }

        return array($status, $out, $err, $id);
    }

    /**
     * @param Exec $exec
     * @param Service $service
     * @param callable $resolver
     * @param string $prefix
     * @param string $project
     *
     * @return array(int $status, array $network)
     */
    public static function execRunServiceContainer(Exec $exec, Service $service, $resolver, $prefix, $project)
    {
        $execRunServiceRunner = self::execRunServiceContainerImpl($exec, $service, $resolver, $prefix, $project);

        return $execRunServiceRunner(false, '--detach');
    }

    /**
     * @param Exec $exec
     * @param Service $service
     * @param callable $resolver
     * @param string $prefix
     * @param string $project
     *
     * @return array
     */
    public static function execRunServiceContainerAttached(Exec $exec, Service $service, $resolver, $prefix, $project)
    {
        $execRunServiceRunner = self::execRunServiceContainerImpl($exec, $service, $resolver, $prefix, $project);

        return $execRunServiceRunner(true, '--rm');
    }

    /**
     * @param Exec $exec
     * @param Service $service
     * @param callable $resolver
     * @param string $prefix
     * @param string $project
     *
     * @return \Closure
     */
    public static function execRunServiceContainerImpl(Exec $exec, Service $service, $resolver, $prefix, $project)
    {
        /**
         * @param bool $pass (or capture)
         * @param string $additionalArg
         *
         * @return array
         */
        return function ($pass, $additionalArg) use ($exec, $service, $resolver, $prefix, $project) {
            $network = array('--network', 'host');
            $image = $service->getImage();
            ImageLogin::loginImage($exec, $resolver, null, $image);

            $containerName = NameBuilder::serviceContainerName($prefix, $service->getName(), $project);

            $variables = $resolver($service->getVariables());

            $args = array(
                $network, '--name',
                $containerName,
                $additionalArg,
                Env::createArgVarDefinitions('-e', $variables),
                $image->getName(),
            );

            $status = $pass
                ? $exec->pass('docker', Lib::merge('run', $args))
                : $exec->capture('docker', Lib::merge('run', $args), $out, $err);

            return array($status, $network);
        };
    }

    /**
     * @param Exec $exec
     * @param Streams $streams
     * @param string|string[] $idOrIds
     * @param int $status
     * @param Flags $flags
     * @param string $message
     * @param string $id
     *
     * @return void
     *
     * @see StepRunner::shutdownStepContainer
     */
    public static function execShutdownContainer(Exec $exec, Streams $streams, $idOrIds, $status, Flags $flags, $message)
    {
        # keep container on error
        if (0 !== $status && $flags->keepOnError()) {
            $streams->err(sprintf("error, %s\n", $message));

            return;
        }

        # keep or kill/remove container
        self::execKillAndRemove($exec, $idOrIds, $flags->killContainer(), $flags->removeContainer());

        if ($flags->keep()) {
            $streams->out(sprintf("%s\n", $message));
        }
    }

    /**
     * StepContainers constructor.
     *
     * @param Runner $runner
     */
    public function __construct(Runner $runner)
    {
        $this->runner = $runner;
    }

    /**
     * @param Step $step
     *
     * @return StepContainer
     */
    public function createStepContainer(Step $step)
    {
        $prefix = $this->runner->getPrefix();
        $projectName = $this->runner->getProject();

        $name = NameBuilder::stepContainerNameByStep($step, $prefix, $projectName);

        return new StepContainer($name, $step, $this->runner);
    }
}


1		<?php
2
3		/* this file is part of pipelines */
4
5		namespace Ktomk\Pipelines\Runner;
6
7		use Ktomk\Pipelines\Cli\Docker;
8		use Ktomk\Pipelines\Cli\Exec;
9		use Ktomk\Pipelines\Cli\Streams;
10		use Ktomk\Pipelines\File\Definitions\Service;
11		use Ktomk\Pipelines\File\Pipeline\Step;
12		use Ktomk\Pipelines\Lib;
13		use Ktomk\Pipelines\Runner\Containers\NameBuilder;
14		use Ktomk\Pipelines\Runner\Containers\StepContainer;
15		use Ktomk\Pipelines\Runner\Docker\ImageLogin;
16
17		/**
18		* Class Containers
19		*
20		* Containers as per the runner
21		*
22		* An extraction of more generic container functionality from the
23		* StepContainer that is more specific and did host them since
24		* introducing services
25		*
26		* @package Ktomk\Pipelines\Runner
27		*/
28		class Containers
29		{
30		/**
31		* @var Runner
32		*/
33		private $runner;
34
35		/**
36		* kill and remove static implementation
37		*
38		* @param Exec $exec
39		* @param string\|string[] $idOrIds container id(s) or name(s)
40		* @param bool $kill
41		* @param bool $remove
42		*
43		* @return void
44		*/
45	2	public static function execKillAndRemove(Exec $exec, $idOrIds, $kill, $remove)
46		{
47	2	if ($kill) {
48	2	Docker::create($exec)->getProcessManager()->kill($idOrIds);
49		}
50
51	2	if ($remove) {
52	2	Docker::create($exec)->getProcessManager()->remove($idOrIds);
53		}
54	2	}
55
56		/**
57		* @param Exec $exec
58		* @param array $args
59		*
60		* @return array array(int $status, string $out, string $err, string\|null $id)
61		*/
62	1	public static function execRun(Exec $exec, array $args)
63		{
64	1	$status = $exec->capture('docker', Lib::merge('run', $args), $out, $err);
65
66	1	$id = null;
67	1	if (0 === $status) {
68	1	$id = rtrim($out) ?: null;
69		}
70
71	1	return array($status, $out, $err, $id);
72		}
73
74		/**
75		* @param Exec $exec
76		* @param Service $service
77		* @param callable $resolver
78		* @param string $prefix
79		* @param string $project
80		*
81		* @return array(int $status, array $network)
82		*/
83	1	public static function execRunServiceContainer(Exec $exec, Service $service, $resolver, $prefix, $project)
84		{
85	1	$execRunServiceRunner = self::execRunServiceContainerImpl($exec, $service, $resolver, $prefix, $project);
86
87	1	return $execRunServiceRunner(false, '--detach');
88		}
89
90		/**
91		* @param Exec $exec
92		* @param Service $service
93		* @param callable $resolver
94		* @param string $prefix
95		* @param string $project
96		*
97		* @return array
98		*/
99	1	public static function execRunServiceContainerAttached(Exec $exec, Service $service, $resolver, $prefix, $project)
100		{
101	1	$execRunServiceRunner = self::execRunServiceContainerImpl($exec, $service, $resolver, $prefix, $project);
102
103	1	return $execRunServiceRunner(true, '--rm');
104		}
105
106		/**
107		* @param Exec $exec
108		* @param Service $service
109		* @param callable $resolver
110		* @param string $prefix
111		* @param string $project
112		*
113		* @return \Closure
114		*/
115		public static function execRunServiceContainerImpl(Exec $exec, Service $service, $resolver, $prefix, $project)
116		{
117		/**
118		* @param bool $pass (or capture)
119		* @param string $additionalArg
120		*
121		* @return array
122		*/
123	3	return function ($pass, $additionalArg) use ($exec, $service, $resolver, $prefix, $project) {
124	3	$network = array('--network', 'host');
125	3	$image = $service->getImage();
126	3	ImageLogin::loginImage($exec, $resolver, null, $image);
127
128	3	$containerName = NameBuilder::serviceContainerName($prefix, $service->getName(), $project);
129
130	3	$variables = $resolver($service->getVariables());
131
132		$args = array(
133	3	$network, '--name',
134	3	$containerName,
135	3	$additionalArg,
136	3	Env::createArgVarDefinitions('-e', $variables),
137	3	$image->getName(),
138		);
139
140	3	$status = $pass
141	2	? $exec->pass('docker', Lib::merge('run', $args))
142	3	: $exec->capture('docker', Lib::merge('run', $args), $out, $err);
143
144	3	return array($status, $network);
145	3	};
146		}
147
148		/**
149		* @param Exec $exec
150		* @param Streams $streams
151		* @param string\|string[] $idOrIds
152		* @param int $status
153		* @param Flags $flags
154		* @param string $message
155		* @param string $id
156		*
157		* @return void
158		*
159		* @see StepRunner::shutdownStepContainer
160		*/
161	1	public static function execShutdownContainer(Exec $exec, Streams $streams, $idOrIds, $status, Flags $flags, $message)
162		{
163		# keep container on error
164	1	if (0 !== $status && $flags->keepOnError()) {
165	1	$streams->err(sprintf("error, %s\n", $message));
166
167	1	return;
168		}
169
170		# keep or kill/remove container
171	1	self::execKillAndRemove($exec, $idOrIds, $flags->killContainer(), $flags->removeContainer());
172
173	1	if ($flags->keep()) {
174	1	$streams->out(sprintf("%s\n", $message));
175		}
176	1	}
177
178		/**
179		* StepContainers constructor.
180		*
181		* @param Runner $runner
182		*/
183	2	public function __construct(Runner $runner)
184		{
185	2	$this->runner = $runner;
186	2	}
187
188		/**
189		* @param Step $step
190		*
191		* @return StepContainer
192		*/
193	1	public function createStepContainer(Step $step)
194		{
195	1	$prefix = $this->runner->getPrefix();
196	1	$projectName = $this->runner->getProject();
197
198	1	$name = NameBuilder::stepContainerNameByStep($step, $prefix, $projectName);
199
200	1	return new StepContainer($name, $step, $this->runner);
201		}
202		}
203

ktomk / pipelines

Push — master ( d8d9f2...800fb3 )

Containers::execKillAndRemove() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like