Ktomk\Pipelines\Runner\Docker\Binary\Repository

Complexity

Total Complexity

9

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	asPackageArray()	0	8	2
A	resolve()	0	9	1
A	containerProvisionDockerClientBinary()	0	5	1
A	getLocalBinary()	0	3	1
A	inject()	0	5	1
A	injectPackage()	0	4	1

<?php

/* this file is part of pipelines */

namespace Ktomk\Pipelines\Runner\Docker\Binary;

use Ktomk\Pipelines\Cli\Exec;
use Ktomk\Pipelines\Lib;
use Ktomk\Pipelines\Runner\Directories;

/**
 * Docker Binary Repository
 *
 * Docker provides a static binary which is useful to have in containers when
 * in the container itself docker should be available (e.g. services: - docker).
 *
 * It "comes" out of this binary repository. In the background there is a
 * BinaryUnPackager taking care of network interaction and file verification
 * as it is technically possible to have different kind of static docker
 * binaries also from different packages.
 *
 * Also there is a YAML package file reader which can read package information
 * out of such files.
 *
 * @package Ktomk\Pipelines\Runner\Docker
 */
class Repository implements PackageInterface
{
    /**
     * @var Exec
     */
    private $exec;

    /**
     * @var null|array package definition data
     */
    private $package;

    /**
     * @var null|UnPackager
     */
    private $unPackager;

    /**
     * Repository constructor.
     *
     * @param Exec $exec
     * @param Directories $directories (UnPackager dependency)
     * @param array $package [optional]
     * @param UnPackager $unPackager [optional]
     */
    public function __construct(Exec $exec, Directories $directories, array $package = null, UnPackager $unPackager = null)
    {
        $this->exec = $exec;
        $this->package = $package;
        if (null === $unPackager) {
            $unPackager = UnPackager::fromDirectories($this->exec, $directories);
        }
        $this->unPackager = $unPackager;
    }

    /**
     * provision docker client into a running container
     *
     * install a binary as /usr/bin/docker and make it executable.
     * show the version.
     *
     * @param string $containerId
     * @param string $path to static docker client binary
     */
    public function containerProvisionDockerClientBinary($containerId, $path)
    {
        $this->exec->pass(
            sprintf('2>&1 < %s docker', lib::quoteArg($path)),
            array('exec', '-i', $containerId, '/bin/sh', '-c', 'mkdir -p /usr/bin && cat - > /usr/bin/docker; chmod +x /usr/bin/docker; docker --version')
        );
    }

    /**
     * Resolve a binary package name in this repository
     *
     * @param string $packageName
     * @return Repository
     */
    public function resolve($packageName)
    {
        $packageDir = __DIR__ . '/../../../../lib/package';
        $reader = new PackageYamlFileReader(
            sprintf('%s/%s.yml', $packageDir, $packageName)
        );
        $this->package = $reader->asPackageArray();

        return $this;
    }

    /**
     * @param string $containerId
     */
    public function inject($containerId)
    {
        $package = $this->asPackageArray();
        $localBinary = $this->getLocalBinary($package);
        $this->containerProvisionDockerClientBinary($containerId, $localBinary);
    }

    /**
     * Inject binary docker client package by name into container
     *
     * @param string $name
     * @param string $containerId
     */
    public function injectPackage($name, $containerId)
    {
        $this->resolve($name);
        $this->inject($containerId);
    }

    /**
     * Get binary path from local store.
     *
     * @param array $package
     * @return string
     */
    public function getLocalBinary(array $package)
    {
        return $this->unPackager->getLocalBinary($package);

The method getLocalBinary() does not exist on null.

    }

    /**
     * @inheritDoc
     */
    public function asPackageArray()
    {
        $package = $this->package;
        if (null === $package) {
            $package = $this->resolve('docker-19.03.1-linux-static-x86_64')->package;
        }

        return $package;
    }
}