Env::setFirstPipelineVariable() - Code Metrics - Inspection of "poc mkdocs: no directory urls" - ktomk/pipelines - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 88d9d6...ec4c8d )

by Tom

created 2020-09-13 23:34 UTC

Env::setFirstPipelineVariable() A

↳ Parent: Env

Complexity

Conditions	4
Paths	2

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	4

Importance

Changes	1
Bugs	0	Features	0

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

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines\Runner;

use Ktomk\Pipelines\Cli\Args\Args;
use Ktomk\Pipelines\Cli\Args\Collector;
use Ktomk\Pipelines\Lib;
use Ktomk\Pipelines\LibFsPath;
use Ktomk\Pipelines\Runner\Docker\ArgsBuilder;

/**
 * Pipeline environment collaborator
 */
class Env
{
    /**
     * @var array pipelines (bitbucket) environment variables
     */
    private $vars = array();

    /**
     * collected arguments
     *
     * @var array
     */
    private $collected = array();

    /**
     * environment variables to inherit from
     *
     * @var array
     */
    private $inherit = array();

    /**
     * @var EnvResolver
     */
    private $resolver;

    /**
     * create with no default initialization
     *
     * @param null|array $inherit
     *
     * @return Env
     */
    public static function create(array $inherit = null)
    {
        $env = new self();
        $env->initInherit((array)$inherit);

        return $env;
    }

    /**
     * @param null|array $inherit
     *
     * @return Env
     */
    public static function createEx(array $inherit = null)
    {
        $env = new self();
        $env->initDefaultVars((array)$inherit);

        return $env;
    }

    /**
     * Initialize default environment used in a Bitbucket Pipeline
     *
     * As the runner mimics some values, defaults are available
     *
     * @param array $inherit Environment variables to inherit from
     *
     * @return void
     */
    public function initDefaultVars(array $inherit)
    {
        $this->initInherit($inherit);

        $inheritable = array(
            'BITBUCKET_BOOKMARK' => null,
            'BITBUCKET_BRANCH' => null,
            'BITBUCKET_BUILD_NUMBER' => '0',
            'BITBUCKET_COMMIT' => '0000000000000000000000000000000000000000',
            'BITBUCKET_REPO_OWNER' => '' . Lib::r($inherit['USER'], 'nobody'),
            'BITBUCKET_REPO_SLUG' => 'local-has-no-slug',
            'BITBUCKET_STEP_RUN_NUMBER' => '1',
            'BITBUCKET_TAG' => null,
            'CI' => 'true',
            'PIPELINES_CONTAINER_NAME' => null,
            'PIPELINES_IDS' => null,
            'PIPELINES_PARENT_CONTAINER_NAME' => null,
            'PIPELINES_PIP_CONTAINER_NAME' => null,
            'PIPELINES_PROJECT_PATH' => null,
        );

        $invariant = array(
            'PIPELINES_ID' => null,
        );

        $var = $invariant + array_intersect_key(array_filter($inherit, 'is_string'), $inheritable) + $inheritable;
        ksort($var);

        $this->vars = $var;
    }

    /**
     * Map reference to environment variable setting
     *
     * Only add the BITBUCKET_BOOKMARK/_BRANCH/_TAG variable
     * if not yet set.
     *
     * @param Reference $ref
     *
     * @return void
     */
    public function addReference(Reference $ref)
    {
        if (null === $type = $ref->getType()) {
            return;
        }

        $map = array(
            'bookmark' => 'BITBUCKET_BOOKMARK',
            'branch' => 'BITBUCKET_BRANCH',
            'tag' => 'BITBUCKET_TAG',
            'pr' => 'BITBUCKET_BRANCH',
        );

        if (!isset($map[$type])) {
            throw new \UnexpectedValueException(sprintf('Unknown reference type: "%s"', $type));
        }

        if ($this->addPrReference($ref)) {
            return;
        }

        $this->addVar($map[$type], $ref->getName());
    }

    /**
     * add a variable if not yet set (real add new)
     *
     * @param string $name
     * @param string $value
     *
     * @return void
     */
    public function addVar($name, $value)
    {
        if (!isset($this->vars[$name])) {
            $this->vars[$name] = $value;
        }
    }

    /**
     * @param Reference $reference
     *
     * @return bool
     */
    public function addPrReference(Reference $reference)
    {
        if ('pr' !== $reference->getType()) {
            return false;
        }

        $var = array_combine(
            array('BITBUCKET_BRANCH', 'BITBUCKET_PR_DESTINATION_BRANCH'),
            explode(':', $reference->getName(), 2) + array(null, null)
        );

        foreach ($var as $name => $value) {
            isset($value) && $this->addVar($name, $value);
        }

        return true;
    }

    /**
     * @param string $name of container
     *
     * @return void
     */
    public function setContainerName($name)
    {
        if (isset($this->vars['PIPELINES_CONTAINER_NAME'])) {
            $this->vars['PIPELINES_PARENT_CONTAINER_NAME']
                = $this->vars['PIPELINES_CONTAINER_NAME'];
        }

        $this->vars['PIPELINES_CONTAINER_NAME'] = $name;
        $this->setFirstPipelineVariable('PIPELINES_PIP_CONTAINER_NAME', $name);
    }

    /**
     * set the pipelines environment's running pipeline id
     *
     * @param string $id of pipeline, e.g. "default" or "branch/feature/*"
     *
     * @return bool whether was used before (endless pipelines in pipelines loop)
     */
    public function setPipelinesId($id)
    {
        $list = (string)$this->getValue('PIPELINES_IDS');
        $hashes = preg_split('~\s+~', $list, -1, PREG_SPLIT_NO_EMPTY);
        $hashes = array_map('strtolower', /** @scrutinizer ignore-type */ $hashes);

        $idHash = md5($id);
        $hasId = in_array($idHash, $hashes, true);
        $hashes[] = $idHash;

        $this->vars['PIPELINES_ID'] = $id;
        $this->vars['PIPELINES_IDS'] = implode(' ', $hashes);

        return $hasId;
    }

    /**
     * $BITBUCKET_STEP_RUN_NUMBER can be inherited from environment and after
     * the first step did run is being reset to 1
     *
     * allows to test it for steps `BITBUCKET_STEP_RUN_NUMBER=2 pipelines --step 1-`
     *
     * @return void
     */
    public function resetStepRunNumber()
    {
        $this->vars['BITBUCKET_STEP_RUN_NUMBER'] = '1';
    }

    /**
     * set PIPELINES_PROJECT_PATH
     *
     * can never be overwritten, must be set by pipelines itself for the
     * initial pipeline. will be taken over into each sub-pipeline.
     *
     * @param string $path absolute path to the project directory (deploy source path)
     *
     * @return void
     */
    public function setPipelinesProjectPath($path)
    {
        if (!LibFsPath::isAbsolute($path)) {
            throw new \InvalidArgumentException(sprintf('not an absolute path: "%s"', $path));
        }

        $this->setFirstPipelineVariable('PIPELINES_PROJECT_PATH', $path);
    }

    /**
     * @param string $option "-e" typically for Docker binary
     *
     * @return array of options (from $option) and values, ['-e', 'val1', '-e', 'val2', ...]
     */
    public function getArgs($option)
    {
        return Lib::merge(
            $this->collected,
            ArgsBuilder::optMap($option, $this->vars, true)
        );
    }

    /**
     * get a variables' value from the inherited
     * environment or null if not set
     *
     * @param string $name
     *
     * @return null|string
     */
    public function getInheritValue($name)
    {
        return isset($this->inherit[$name])
            ? $this->inherit[$name]
            : null;
    }

    /**
     * get a variables value or null if not set
     *
     * @param string $name
     *
     * @return null|string
     */
    public function getValue($name)
    {
        return isset($this->vars[$name])
            ? $this->vars[$name]
            : null;
    }

    /**
     * collect option arguments
     *
     * those options to be passed to docker client, normally -e,
     * --env and --env-file.
     *
     * @param Args $args
     * @param string|string[] $option
     *
     * @throws \InvalidArgumentException
     * @throws \Ktomk\Pipelines\Cli\ArgsException
     *
     * @return void
     */
    public function collect(Args $args, $option)
    {
        $collector = new Collector($args);
        $collector->collect($option);
        $this->collected = array_merge($this->collected, $collector->getArgs());

        $this->getResolver()->addArguments($collector);
    }

    /**
     * @param array $paths
     *
     * @throws \InvalidArgumentException
     *
     * @return void
     */
    public function collectFiles(array $paths)
    {
        $resolver = $this->getResolver();
        foreach ($paths as $path) {
            if ($resolver->addFileIfExists($path)) {
                $this->collected[] = '--env-file';
                $this->collected[] = $path;
            }
        }
    }

    /**
     * @return EnvResolver
     */
    public function getResolver()
    {
        if (null === $this->resolver) {
            $this->resolver = new EnvResolver($this->inherit);
        }

        return $this->resolver;
    }

    /**
     * get all variables collected so far
     *
     * @return array
     */
    public function getVariables()
    {
        return (array)$this->getResolver()->getVariables();
    }

    /**
     * @param array $inherit
     *
     * @return void
     */
    private function initInherit(array $inherit)
    {
        $this->inherit = array_filter($inherit, 'is_string');
    }

    /**
     * set an environment variable only if not yet set and in the first
     * pipeline.
     *
     * @param string $name
     * @param string $value
     *
     * @return void
     */
    private function setFirstPipelineVariable($name, $value)
    {
        if (isset($this->vars[$name])
            || !isset($this->vars['PIPELINES_ID'], $this->vars['PIPELINES_IDS'])
            || $this->vars['PIPELINES_IDS'] !== md5($this->vars['PIPELINES_ID'])
        ) {
            return;
        }

        $this->vars[$name] = $value;
    }
}


1		<?php
2
3		/* this file is part of pipelines */
4
5		namespace Ktomk\Pipelines\Runner;
6
7		use Ktomk\Pipelines\Cli\Args\Args;
8		use Ktomk\Pipelines\Cli\Args\Collector;
9		use Ktomk\Pipelines\Lib;
10		use Ktomk\Pipelines\LibFsPath;
11		use Ktomk\Pipelines\Runner\Docker\ArgsBuilder;
12
13		/**
14		* Pipeline environment collaborator
15		*/
16		class Env
17		{
18		/**
19		* @var array pipelines (bitbucket) environment variables
20		*/
21		private $vars = array();
22
23		/**
24		* collected arguments
25		*
26		* @var array
27		*/
28		private $collected = array();
29
30		/**
31		* environment variables to inherit from
32		*
33		* @var array
34		*/
35		private $inherit = array();
36
37		/**
38		* @var EnvResolver
39		*/
40		private $resolver;
41
42		/**
43		* create with no default initialization
44		*
45		* @param null\|array $inherit
46		*
47		* @return Env
48		*/
49	3	public static function create(array $inherit = null)
50		{
51	3	$env = new self();
52	3	$env->initInherit((array)$inherit);
53
54	3	return $env;
55		}
56
57		/**
58		* @param null\|array $inherit
59		*
60		* @return Env
61		*/
62	18	public static function createEx(array $inherit = null)
63		{
64	18	$env = new self();
65	18	$env->initDefaultVars((array)$inherit);
66
67	18	return $env;
68		}
69
70		/**
71		* Initialize default environment used in a Bitbucket Pipeline
72		*
73		* As the runner mimics some values, defaults are available
74		*
75		* @param array $inherit Environment variables to inherit from
76		*
77		* @return void
78		*/
79	23	public function initDefaultVars(array $inherit)
80		{
81	23	$this->initInherit($inherit);
82
83		$inheritable = array(
84	23	'BITBUCKET_BOOKMARK' => null,
85		'BITBUCKET_BRANCH' => null,
86	23	'BITBUCKET_BUILD_NUMBER' => '0',
87	23	'BITBUCKET_COMMIT' => '0000000000000000000000000000000000000000',
88	23	'BITBUCKET_REPO_OWNER' => '' . Lib::r($inherit['USER'], 'nobody'),
89	23	'BITBUCKET_REPO_SLUG' => 'local-has-no-slug',
90	23	'BITBUCKET_STEP_RUN_NUMBER' => '1',
91		'BITBUCKET_TAG' => null,
92	23	'CI' => 'true',
93		'PIPELINES_CONTAINER_NAME' => null,
94		'PIPELINES_IDS' => null,
95		'PIPELINES_PARENT_CONTAINER_NAME' => null,
96		'PIPELINES_PIP_CONTAINER_NAME' => null,
97		'PIPELINES_PROJECT_PATH' => null,
98		);
99
100		$invariant = array(
101	23	'PIPELINES_ID' => null,
102		);
103
104	23	$var = $invariant + array_intersect_key(array_filter($inherit, 'is_string'), $inheritable) + $inheritable;
105	23	ksort($var);
106
107	23	$this->vars = $var;
108	23	}
109
110		/**
111		* Map reference to environment variable setting
112		*
113		* Only add the BITBUCKET_BOOKMARK/_BRANCH/_TAG variable
114		* if not yet set.
115		*
116		* @param Reference $ref
117		*
118		* @return void
119		*/
120	4	public function addReference(Reference $ref)
121		{
122	4	if (null === $type = $ref->getType()) {
123	2	return;
124		}
125
126		$map = array(
127	4	'bookmark' => 'BITBUCKET_BOOKMARK',
128		'branch' => 'BITBUCKET_BRANCH',
129		'tag' => 'BITBUCKET_TAG',
130		'pr' => 'BITBUCKET_BRANCH',
131		);
132
133	4	if (!isset($map[$type])) {
134	1	throw new \UnexpectedValueException(sprintf('Unknown reference type: "%s"', $type));
135		}
136
137	3	if ($this->addPrReference($ref)) {
138	1	return;
139		}
140
141	2	$this->addVar($map[$type], $ref->getName());
142	2	}
143
144		/**
145		* add a variable if not yet set (real add new)
146		*
147		* @param string $name
148		* @param string $value
149		*
150		* @return void
151		*/
152	3	public function addVar($name, $value)
153		{
154	3	if (!isset($this->vars[$name])) {
155	2	$this->vars[$name] = $value;
156		}
157	3	}
158
159		/**
160		* @param Reference $reference
161		*
162		* @return bool
163		*/
164	3	public function addPrReference(Reference $reference)
165		{
166	3	if ('pr' !== $reference->getType()) {
167	2	return false;
168		}
169
170	1	$var = array_combine(
171	1	array('BITBUCKET_BRANCH', 'BITBUCKET_PR_DESTINATION_BRANCH'),
172	1	explode(':', $reference->getName(), 2) + array(null, null)
173		);
174
175	1	foreach ($var as $name => $value) {
176	1	isset($value) && $this->addVar($name, $value);
177		}
178
179	1	return true;
180		}
181
182		/**
183		* @param string $name of container
184		*
185		* @return void
186		*/
187	2	public function setContainerName($name)
188		{
189	2	if (isset($this->vars['PIPELINES_CONTAINER_NAME'])) {
190	2	$this->vars['PIPELINES_PARENT_CONTAINER_NAME']
191	2	= $this->vars['PIPELINES_CONTAINER_NAME'];
192		}
193
194	2	$this->vars['PIPELINES_CONTAINER_NAME'] = $name;
195	2	$this->setFirstPipelineVariable('PIPELINES_PIP_CONTAINER_NAME', $name);
196	2	}
197
198		/**
199		* set the pipelines environment's running pipeline id
200		*
201		* @param string $id of pipeline, e.g. "default" or "branch/feature/*"
202		*
203		* @return bool whether was used before (endless pipelines in pipelines loop)
204		*/
205	2	public function setPipelinesId($id)
206		{
207	2	$list = (string)$this->getValue('PIPELINES_IDS');
208	2	$hashes = preg_split('~\s+~', $list, -1, PREG_SPLIT_NO_EMPTY);
209	2	$hashes = array_map('strtolower', /** @scrutinizer ignore-type */ $hashes);
210
211	2	$idHash = md5($id);
212	2	$hasId = in_array($idHash, $hashes, true);
213	2	$hashes[] = $idHash;
214
215	2	$this->vars['PIPELINES_ID'] = $id;
216	2	$this->vars['PIPELINES_IDS'] = implode(' ', $hashes);
217
218	2	return $hasId;
219		}
220
221		/**
222		* $BITBUCKET_STEP_RUN_NUMBER can be inherited from environment and after
223		* the first step did run is being reset to 1
224		*
225		* allows to test it for steps `BITBUCKET_STEP_RUN_NUMBER=2 pipelines --step 1-`
226		*
227		* @return void
228		*/
229	1	public function resetStepRunNumber()
230		{
231	1	$this->vars['BITBUCKET_STEP_RUN_NUMBER'] = '1';
232	1	}
233
234		/**
235		* set PIPELINES_PROJECT_PATH
236		*
237		* can never be overwritten, must be set by pipelines itself for the
238		* initial pipeline. will be taken over into each sub-pipeline.
239		*
240		* @param string $path absolute path to the project directory (deploy source path)
241		*
242		* @return void
243		*/
244	2	public function setPipelinesProjectPath($path)
245		{
246	2	if (!LibFsPath::isAbsolute($path)) {
247	1	throw new \InvalidArgumentException(sprintf('not an absolute path: "%s"', $path));
248		}
249
250	1	$this->setFirstPipelineVariable('PIPELINES_PROJECT_PATH', $path);
251	1	}
252
253		/**
254		* @param string $option "-e" typically for Docker binary
255		*
256		* @return array of options (from $option) and values, ['-e', 'val1', '-e', 'val2', ...]
257		*/
258	13	public function getArgs($option)
259		{
260	13	return Lib::merge(
261	13	$this->collected,
262	13	ArgsBuilder::optMap($option, $this->vars, true)
263		);
264		}
265
266		/**
267		* get a variables' value from the inherited
268		* environment or null if not set
269		*
270		* @param string $name
271		*
272		* @return null\|string
273		*/
274	1	public function getInheritValue($name)
275		{
276	1	return isset($this->inherit[$name])
277	1	? $this->inherit[$name]
278	1	: null;
279		}
280
281		/**
282		* get a variables value or null if not set
283		*
284		* @param string $name
285		*
286		* @return null\|string
287		*/
288	8	public function getValue($name)
289		{
290	8	return isset($this->vars[$name])
291	7	? $this->vars[$name]
292	8	: null;
293		}
294
295		/**
296		* collect option arguments
297		*
298		* those options to be passed to docker client, normally -e,
299		* --env and --env-file.
300		*
301		* @param Args $args
302		* @param string\|string[] $option
303		*
304		* @throws \InvalidArgumentException
305		* @throws \Ktomk\Pipelines\Cli\ArgsException
306		*
307		* @return void
308		*/
309	2	public function collect(Args $args, $option)
310		{
311	2	$collector = new Collector($args);
312	2	$collector->collect($option);
313	2	$this->collected = array_merge($this->collected, $collector->getArgs());
314
315	2	$this->getResolver()->addArguments($collector);
316	2	}
317
318		/**
319		* @param array $paths
320		*
321		* @throws \InvalidArgumentException
322		*
323		* @return void
324		*/
325	2	public function collectFiles(array $paths)
326		{
327	2	$resolver = $this->getResolver();
328	2	foreach ($paths as $path) {
329	2	if ($resolver->addFileIfExists($path)) {
330	2	$this->collected[] = '--env-file';
331	2	$this->collected[] = $path;
332		}
333		}
334	2	}
335
336		/**
337		* @return EnvResolver
338		*/
339	6	public function getResolver()
340		{
341	6	if (null === $this->resolver) {
342	6	$this->resolver = new EnvResolver($this->inherit);
343		}
344
345	6	return $this->resolver;
346		}
347
348		/**
349		* get all variables collected so far
350		*
351		* @return array
352		*/
353	2	public function getVariables()
354		{
355	2	return (array)$this->getResolver()->getVariables();
356		}
357
358		/**
359		* @param array $inherit
360		*
361		* @return void
362		*/
363	24	private function initInherit(array $inherit)
364		{
365	24	$this->inherit = array_filter($inherit, 'is_string');
366	24	}
367
368		/**
369		* set an environment variable only if not yet set and in the first
370		* pipeline.
371		*
372		* @param string $name
373		* @param string $value
374		*
375		* @return void
376		*/
377	3	private function setFirstPipelineVariable($name, $value)
378		{
379	3	if (isset($this->vars[$name])
380	3	\|\| !isset($this->vars['PIPELINES_ID'], $this->vars['PIPELINES_IDS'])
381	3	\|\| $this->vars['PIPELINES_IDS'] !== md5($this->vars['PIPELINES_ID'])
382		) {
383	3	return;
384		}
385
386	1	$this->vars[$name] = $value;
387	1	}
388		}
389

ktomk / pipelines

Push — master ( 88d9d6...ec4c8d )

Env::setFirstPipelineVariable() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like