Runtime::getConfigOption() - Code Metrics - Inspection of "Merge pull request #450 from andres-montanez/disco..." - andres-montanez/Magallanes - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b7ade4...e7afcb )

by Andrés

created 2021-02-20 20:22 UTC

Runtime::getConfigOption() A

↳ Parent: Runtime

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

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

<?php
/*
 * This file is part of the Magallanes package.
 *
 * (c) Andrés Montañez <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Mage\Runtime;

use Mage\Deploy\Strategy\ReleasesStrategy;
use Mage\Deploy\Strategy\RsyncStrategy;
use Mage\Deploy\Strategy\StrategyInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;
use Symfony\Component\Process\Process;
use Mage\Runtime\Exception\RuntimeException;

/**
 * Runtime is a container of all run in time configuration, stages of progress, hosts being deployed, etc.
 *
 * @author Andrés Montañez <[email protected]>
 */
class Runtime
{
    const PRE_DEPLOY = 'pre-deploy';
    const ON_DEPLOY = 'on-deploy';
    const POST_DEPLOY = 'post-deploy';
    const ON_RELEASE = 'on-release';
    const POST_RELEASE = 'post-release';

    /**
     * @var array Magallanes configuration
     */
    protected $configuration = [];

    /**
     * @var string|null Environment being deployed
     */
    protected $environment;

    /**
     * @var string Stage of Deployment
     */
    protected $stage;

    /**
     * @var string|null The host being deployed to
     */
    protected $workingHost = null;

    /**
     * @var string|null The Release ID
     */
    protected $releaseId = null;

    /**
     * @var array Hold a bag of variables for sharing information between tasks, if needed
     */
    protected $vars = [];

    /**
     * @var LoggerInterface|null The logger instance
     */
    protected $logger;

    /**
     * @var bool Indicates if a Rollback operation is in progress
     */
    protected $rollback = false;

    public function isWindows()
    {
        return stripos(PHP_OS, 'WIN') === 0;
    }

    /**
     * Generate the Release ID
     *
     * @return Runtime
     */
    public function generateReleaseId()
    {
        $this->setReleaseId(date('YmdHis'));
        return $this;
    }

    /**
     * Sets the Release ID
     *
     * @param string $releaseId Release ID
     * @return Runtime
     */
    public function setReleaseId($releaseId)
    {
        $this->releaseId = $releaseId;
        return $this;
    }

    /**
     * Retrieve the current Release ID
     *
     * @return null|string Release ID
     */
    public function getReleaseId()
    {
        return $this->releaseId;
    }

    /**
     * Sets the Runtime in Rollback mode On or Off
     *
     * @param bool $inRollback
     * @return Runtime
     */
    public function setRollback($inRollback)
    {
        $this->rollback = $inRollback;
        return $this;
    }

    /**
     * Indicates if Runtime is in rollback
     *
     * @return bool
     */
    public function inRollback()
    {
        return $this->rollback;
    }

    /**
     * Sets a value in the Vars bag
     *
     * @param string $key Variable name
     * @param string $value Variable value
     * @return Runtime
     */
    public function setVar($key, $value)
    {
        $this->vars[$key] = $value;
        return $this;
    }

    /**
     * Retrieve a value from the Vars bag
     *
     * @param string $key Variable name
     * @param mixed $default Variable default value, returned if not found
     * @return string
     */
    public function getVar($key, $default = null)
    {
        if (array_key_exists($key, $this->vars)) {
            return $this->vars[$key];
        }

        return $default;
    }

    /**
     * Sets the Logger instance
     *
     * @param LoggerInterface $logger Logger instance
     * @return Runtime
     */
    public function setLogger(LoggerInterface $logger = null)
    {
        $this->logger = $logger;
        return $this;
    }

    /**
     * Sets the Magallanes Configuration to the Runtime
     *
     * @param array $configuration Configuration
     * @return Runtime
     */
    public function setConfiguration($configuration)
    {
        $this->configuration = $configuration;
        return $this;
    }

    /**
     * Retrieve the Configuration
     *
     * @return array
     */
    public function getConfiguration()
    {
        return $this->configuration;
    }

    /**
     * Retrieves the Configuration Option for a specific section in the configuration
     *
     * @param string $key Section name
     * @param mixed $default Default value
     * @return mixed
     */
    public function getConfigOption($key, $default = null)
    {
        if (array_key_exists($key, $this->configuration)) {
            return $this->configuration[$key];
        }

        return $default;
    }

    /**
     * Returns the Configuration Option for a specific section the current Environment
     *
     * @param string $key Section/Parameter name
     * @param mixed $default Default value
     * @return mixed
     */
    public function getEnvOption($key, $default = null)
    {
        if (!array_key_exists('environments', $this->configuration) || !is_array($this->configuration['environments'])) {
            return $default;
        }

        if (!array_key_exists($this->environment, $this->configuration['environments'])) {
            return $default;
        }

        if (array_key_exists($key, $this->configuration['environments'][$this->environment])) {

            return $this->configuration['environments'][$this->environment][$key];
        }

        return $default;
    }

    /**
     * Shortcut to get the the configuration option for a specific environment and merge it with
     * the global one (environment specific overrides the global one if present).
     *
     * @param       $key
     * @param array $defaultEnv
     *
     * @return array
     */
    public function getMergedOption($key, $defaultEnv = [])
    {
        $userGlobalOptions = $this->getConfigOption($key, $defaultEnv);
        $userEnvOptions = $this->getEnvOption($key, $defaultEnv);

        return array_merge(
            (is_array($userGlobalOptions) ? $userGlobalOptions : []),
            (is_array($userEnvOptions) ? $userEnvOptions : [])
        );
    }

    /**
     * Overwrites an Environment Configuration Option
     *
     * @param string $key
     * @param mixed $value
     * @return Runtime
     */
    public function setEnvOption($key, $value)
    {
        if (array_key_exists('environments', $this->configuration) && is_array($this->configuration['environments'])) {
            if (array_key_exists($this->environment, $this->configuration['environments'])) {

                $this->configuration['environments'][$this->environment][$key] = $value;
            }
        }

        return $this;
    }

    /**
     * Sets the working Environment
     *
     * @param string $environment Environment name
     * @return Runtime
     * @throws RuntimeException
     */
    public function setEnvironment($environment)
    {
        if (array_key_exists('environments', $this->configuration) && array_key_exists($environment, $this->configuration['environments'])) {
            $this->environment = $environment;
            return $this;
        }

        throw new RuntimeException(sprintf('The environment "%s" does not exists.', $environment), 100);
    }

    /**
     * Returns the current working Environment
     *
     * @return null|string
     */
    public function getEnvironment()
    {
        return $this->environment;
    }

    /**
     * Sets the working stage
     *
     * @param string $stage Stage code
     * @return Runtime
     */
    public function setStage($stage)
    {
        $this->stage = $stage;
        return $this;
    }

    /**
     * Retrieve the current working Stage
     *
     * @return string
     */
    public function getStage()
    {
        return $this->stage;
    }

    /**
     * Retrieve the defined Tasks for the current Environment and Stage
     *
     * @return array
     */
    public function getTasks()
    {
        if (!array_key_exists('environments', $this->configuration) || !is_array($this->configuration['environments'])) {
            return [];
        }

        if (!array_key_exists($this->environment, $this->configuration['environments'])) {
            return [];
        }

        if (array_key_exists($this->stage, $this->configuration['environments'][$this->environment])) {
            if (is_array($this->configuration['environments'][$this->environment][$this->stage])) {
                return $this->configuration['environments'][$this->environment][$this->stage];
            }
        }

        return [];
    }

    /**
     * Sets the working Host
     *
     * @param string $host Host name
     * @return Runtime
     */
    public function setWorkingHost($host)
    {
        $this->workingHost = $host;
        return $this;
    }

    /**
     * Retrieve the working Host
     *
     * @return null|string
     */
    public function getWorkingHost()
    {
        return $this->workingHost;
    }

    /**
     * Logs a Message into the Logger
     *
     * @param string $message Log message
     * @param string $level Log Level
     */
    public function log($message, $level = LogLevel::DEBUG)
    {
        if ($this->logger instanceof LoggerInterface) {
            $this->logger->log($level, $message);
        }
    }

    /**
     * Executes a command, it will be run Locally or Remotely based on the working Stage
     *
     * @param string $cmd Command to execute
     * @param int $timeout Seconds to wait
     * @return Process
     */
    public function runCommand($cmd, $timeout = 120)
    {
        switch ($this->getStage()) {
            case self::ON_DEPLOY:
            case self::ON_RELEASE:
            case self::POST_RELEASE:
                return $this->runRemoteCommand($cmd, true, $timeout);
            default:
                return $this->runLocalCommand($cmd, $timeout);
        }
    }

    /**
     * Execute a command locally
     *
     * @param string $cmd Command to execute
     * @param int $timeout Seconds to wait
     * @return Process
     */
    public function runLocalCommand($cmd, $timeout = 120)
    {
        $this->log($cmd, LogLevel::INFO);

        $process = Process::fromShellCommandline($cmd);
        $process->setTimeout($timeout);
        $process->run();

        $this->log($process->getOutput(), LogLevel::DEBUG);
        if (!$process->isSuccessful()) {
            $this->log($process->getErrorOutput(), LogLevel::ERROR);
        }

        return $process;
    }

    /**
     * Executes a command remotely, if jail is true, it will run inside the Host Path and the Release (if available)
     *
     * @param string $cmd Command to execute
     * @param bool $jail Jail the command
     * @param int $timeout Seconds to wait
     * @return Process
     */
    public function runRemoteCommand($cmd, $jail, $timeout = 120)
    {
        $user = $this->getEnvOption('user', $this->getCurrentUser());
        $sudo = $this->getEnvOption('sudo', false);
        $host = $this->getHostName();
        $sshConfig = $this->getSSHConfig();

        $cmdDelegate = $cmd;
        if ($sudo === true) {
            $cmdDelegate = sprintf('sudo %s', $cmd);
        }

        $hostPath = rtrim($this->getEnvOption('host_path'), '/');
        if ($jail && $this->getReleaseId() !== null) {
            $cmdDelegate = sprintf('cd %s/releases/%s && %s', $hostPath, $this->getReleaseId(), $cmdDelegate);
        } elseif ($jail) {
            $cmdDelegate = sprintf('cd %s && %s', $hostPath, $cmdDelegate);
        }

        $cmdRemote = str_replace('"', '\"', $cmdDelegate);
        $cmdLocal = sprintf('ssh -p %d %s %s@%s "%s"', $sshConfig['port'], $sshConfig['flags'], $user, $host, $cmdRemote);

        return $this->runLocalCommand($cmdLocal, $timeout);
    }

    /**
     * Get the SSH configuration based on the environment
     *
     * @return array
     */
    public function getSSHConfig()
    {
        $sshConfig = $this->getEnvOption('ssh', ['port' => 22, 'flags' => '-q -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no']);

        if ($this->getHostPort() !== null) {
            $sshConfig['port'] = $this->getHostPort();
        }

        if (!array_key_exists('port', $sshConfig)) {
            $sshConfig['port'] = '22';
        }

        if (!array_key_exists('flags', $sshConfig)) {
            $sshConfig['flags'] = '-q -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no';
        }

        if (!array_key_exists('timeout', $sshConfig)) {
            $sshConfig['timeout'] = 300;
        }

        return $sshConfig;
    }

    /**
     * Get the current Host Port or default ssh port
     *
     * @return integer
     */
    public function getHostPort()
    {
        $info = explode(':', $this->getWorkingHost());
        return isset($info[1]) ? $info[1] : null;
    }

    /**
     * Get the current Host Name
     *
     * @return string
     */
    public function getHostName()
    {
        if (strpos($this->getWorkingHost(), ':') === false) {
            return $this->getWorkingHost();
        }

        $info = explode(':', $this->getWorkingHost());
        return $info[0];
    }

    /**
     * Gets a Temporal File name
     *
     * @return string
     */
    public function getTempFile()
    {
        return tempnam(sys_get_temp_dir(), 'mage');
    }

    /**
     * Get the current user
     *
     * @return string
     */
    public function getCurrentUser()
    {
        $userData = posix_getpwuid(posix_geteuid());
        return $userData['name'];
    }

    /**
     * Shortcut for getting Branch information
     *
     * @return boolean|string
     */
    public function getBranch()
    {
        return $this->getEnvOption('branch', false);
    }

    /**
     * Guesses the Deploy Strategy to use
     *
     * @return StrategyInterface
     */
    public function guessStrategy()
    {
        $strategy = new RsyncStrategy();

        if ($this->getEnvOption('releases', false)) {
            $strategy = new ReleasesStrategy();
        }

        $strategy->setRuntime($this);
        return $strategy;
    }
}


1			<?php
2			/*
3			* This file is part of the Magallanes package.
4			*
5			* (c) Andrés Montañez <[email protected]>
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace Mage\Runtime;
12
13			use Mage\Deploy\Strategy\ReleasesStrategy;
14			use Mage\Deploy\Strategy\RsyncStrategy;
15			use Mage\Deploy\Strategy\StrategyInterface;
16			use Psr\Log\LoggerInterface;
17			use Psr\Log\LogLevel;
18			use Symfony\Component\Process\Process;
19			use Mage\Runtime\Exception\RuntimeException;
20
21			/**
22			* Runtime is a container of all run in time configuration, stages of progress, hosts being deployed, etc.
23			*
24			* @author Andrés Montañez <[email protected]>
25			*/
26			class Runtime
27			{
28			const PRE_DEPLOY = 'pre-deploy';
29			const ON_DEPLOY = 'on-deploy';
30			const POST_DEPLOY = 'post-deploy';
31			const ON_RELEASE = 'on-release';
32			const POST_RELEASE = 'post-release';
33
34			/**
35			* @var array Magallanes configuration
36			*/
37			protected $configuration = [];
38
39			/**
40			* @var string\|null Environment being deployed
41			*/
42			protected $environment;
43
44			/**
45			* @var string Stage of Deployment
46			*/
47			protected $stage;
48
49			/**
50			* @var string\|null The host being deployed to
51			*/
52			protected $workingHost = null;
53
54			/**
55			* @var string\|null The Release ID
56			*/
57			protected $releaseId = null;
58
59			/**
60			* @var array Hold a bag of variables for sharing information between tasks, if needed
61			*/
62			protected $vars = [];
63
64			/**
65			* @var LoggerInterface\|null The logger instance
66			*/
67			protected $logger;
68
69			/**
70			* @var bool Indicates if a Rollback operation is in progress
71			*/
72			protected $rollback = false;
73
74	12		public function isWindows()
75			{
76	12		return stripos(PHP_OS, 'WIN') === 0;
77			}
78
79			/**
80			* Generate the Release ID
81			*
82			* @return Runtime
83			*/
84	1		public function generateReleaseId()
85			{
86	1		$this->setReleaseId(date('YmdHis'));
87	1		return $this;
88			}
89
90			/**
91			* Sets the Release ID
92			*
93			* @param string $releaseId Release ID
94			* @return Runtime
95			*/
96	16		public function setReleaseId($releaseId)
97			{
98	16		$this->releaseId = $releaseId;
99	16		return $this;
100			}
101
102			/**
103			* Retrieve the current Release ID
104			*
105			* @return null\|string Release ID
106			*/
107	44		public function getReleaseId()
108			{
109	44		return $this->releaseId;
110			}
111
112			/**
113			* Sets the Runtime in Rollback mode On or Off
114			*
115			* @param bool $inRollback
116			* @return Runtime
117			*/
118	1		public function setRollback($inRollback)
119			{
120	1		$this->rollback = $inRollback;
121	1		return $this;
122			}
123
124			/**
125			* Indicates if Runtime is in rollback
126			*
127			* @return bool
128			*/
129	35		public function inRollback()
130			{
131	35		return $this->rollback;
132			}
133
134			/**
135			* Sets a value in the Vars bag
136			*
137			* @param string $key Variable name
138			* @param string $value Variable value
139			* @return Runtime
140			*/
141	26		public function setVar($key, $value)
142			{
143	26		$this->vars[$key] = $value;
144	26		return $this;
145			}
146
147			/**
148			* Retrieve a value from the Vars bag
149			*
150			* @param string $key Variable name
151			* @param mixed $default Variable default value, returned if not found
152			* @return string
153			*/
154	28		public function getVar($key, $default = null)
155			{
156	28		if (array_key_exists($key, $this->vars)) {
157	26		return $this->vars[$key];
158			}
159
160	28		return $default;
161			}
162
163			/**
164			* Sets the Logger instance
165			*
166			* @param LoggerInterface $logger Logger instance
167			* @return Runtime
168			*/
169	52		public function setLogger(LoggerInterface $logger = null)
170			{
171	52		$this->logger = $logger;
172	52		return $this;
173			}
174
175			/**
176			* Sets the Magallanes Configuration to the Runtime
177			*
178			* @param array $configuration Configuration
179			* @return Runtime
180			*/
181	87		public function setConfiguration($configuration)
182			{
183	87		$this->configuration = $configuration;
184	87		return $this;
185			}
186
187			/**
188			* Retrieve the Configuration
189			*
190			* @return array
191			*/
192	1		public function getConfiguration()
193			{
194	1		return $this->configuration;
195			}
196
197			/**
198			* Retrieves the Configuration Option for a specific section in the configuration
199			*
200			* @param string $key Section name
201			* @param mixed $default Default value
202			* @return mixed
203			*/
204	56		public function getConfigOption($key, $default = null)
205			{
206	56		if (array_key_exists($key, $this->configuration)) {
207	45		return $this->configuration[$key];
208			}
209
210	47		return $default;
211			}
212
213			/**
214			* Returns the Configuration Option for a specific section the current Environment
215			*
216			* @param string $key Section/Parameter name
217			* @param mixed $default Default value
218			* @return mixed
219			*/
220	59		public function getEnvOption($key, $default = null)
221			{
222	59		if (!array_key_exists('environments', $this->configuration) \|\| !is_array($this->configuration['environments'])) {
223	2		return $default;
224			}
225
226	57		if (!array_key_exists($this->environment, $this->configuration['environments'])) {
227	1		return $default;
228			}
229
230	56	View Code Duplication	if (array_key_exists($key, $this->configuration['environments'][$this->environment])) {
			0 ignored issues – show Duplication introduced 2017-01-24 18:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
231	43		return $this->configuration['environments'][$this->environment][$key];
232			}
233
234	54		return $default;
235			}
236
237			/**
238			* Shortcut to get the the configuration option for a specific environment and merge it with
239			* the global one (environment specific overrides the global one if present).
240			*
241			* @param $key
242			* @param array $defaultEnv
243			*
244			* @return array
245			*/
246	37		public function getMergedOption($key, $defaultEnv = [])
247			{
248	37		$userGlobalOptions = $this->getConfigOption($key, $defaultEnv);
249	37		$userEnvOptions = $this->getEnvOption($key, $defaultEnv);
250
251	37		return array_merge(
252	37		(is_array($userGlobalOptions) ? $userGlobalOptions : []),
253	37		(is_array($userEnvOptions) ? $userEnvOptions : [])
254			);
255			}
256
257			/**
258			* Overwrites an Environment Configuration Option
259			*
260			* @param string $key
261			* @param mixed $value
262			* @return Runtime
263			*/
264	1		public function setEnvOption($key, $value)
265			{
266	1		if (array_key_exists('environments', $this->configuration) && is_array($this->configuration['environments'])) {
267	1	View Code Duplication	if (array_key_exists($this->environment, $this->configuration['environments'])) {
			0 ignored issues – show Duplication introduced 2017-01-24 18:42 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
268	1		$this->configuration['environments'][$this->environment][$key] = $value;
269			}
270			}
271
272	1		return $this;
273			}
274
275			/**
276			* Sets the working Environment
277			*
278			* @param string $environment Environment name
279			* @return Runtime
280			* @throws RuntimeException
281			*/
282	85		public function setEnvironment($environment)
283			{
284	85		if (array_key_exists('environments', $this->configuration) && array_key_exists($environment, $this->configuration['environments'])) {
285	82		$this->environment = $environment;
286	82		return $this;
287			}
288
289	3		throw new RuntimeException(sprintf('The environment "%s" does not exists.', $environment), 100);
290			}
291
292			/**
293			* Returns the current working Environment
294			*
295			* @return null\|string
296			*/
297	62		public function getEnvironment()
298			{
299	62		return $this->environment;
300			}
301
302			/**
303			* Sets the working stage
304			*
305			* @param string $stage Stage code
306			* @return Runtime
307			*/
308	38		public function setStage($stage)
309			{
310	38		$this->stage = $stage;
311	38		return $this;
312			}
313
314			/**
315			* Retrieve the current working Stage
316			*
317			* @return string
318			*/
319	62		public function getStage()
320			{
321	62		return $this->stage;
322			}
323
324			/**
325			* Retrieve the defined Tasks for the current Environment and Stage
326			*
327			* @return array
328			*/
329	38		public function getTasks()
330			{
331	38		if (!array_key_exists('environments', $this->configuration) \|\| !is_array($this->configuration['environments'])) {
332	1		return [];
333			}
334
335	37		if (!array_key_exists($this->environment, $this->configuration['environments'])) {
336	1		return [];
337			}
338
339	36		if (array_key_exists($this->stage, $this->configuration['environments'][$this->environment])) {
340	35		if (is_array($this->configuration['environments'][$this->environment][$this->stage])) {
341	35		return $this->configuration['environments'][$this->environment][$this->stage];
342			}
343			}
344
345	26		return [];
346			}
347
348			/**
349			* Sets the working Host
350			*
351			* @param string $host Host name
352			* @return Runtime
353			*/
354	37		public function setWorkingHost($host)
355			{
356	37		$this->workingHost = $host;
357	37		return $this;
358			}
359
360			/**
361			* Retrieve the working Host
362			*
363			* @return null\|string
364			*/
365	66		public function getWorkingHost()
366			{
367	66		return $this->workingHost;
368			}
369
370			/**
371			* Logs a Message into the Logger
372			*
373			* @param string $message Log message
374			* @param string $level Log Level
375			*/
376	43		public function log($message, $level = LogLevel::DEBUG)
377			{
378	43		if ($this->logger instanceof LoggerInterface) {
379	41		$this->logger->log($level, $message);
380			}
381	43		}
382
383			/**
384			* Executes a command, it will be run Locally or Remotely based on the working Stage
385			*
386			* @param string $cmd Command to execute
387			* @param int $timeout Seconds to wait
388			* @return Process
389			*/
390	50		public function runCommand($cmd, $timeout = 120)
391			{
392	50		switch ($this->getStage()) {
393	50		case self::ON_DEPLOY:
394	48		case self::ON_RELEASE:
395	48		case self::POST_RELEASE:
396	16		return $this->runRemoteCommand($cmd, true, $timeout);
397			default:
398	48		return $this->runLocalCommand($cmd, $timeout);
399			}
400			}
401
402			/**
403			* Execute a command locally
404			*
405			* @param string $cmd Command to execute
406			* @param int $timeout Seconds to wait
407			* @return Process
408			*/
409	1		public function runLocalCommand($cmd, $timeout = 120)
410			{
411	1		$this->log($cmd, LogLevel::INFO);
412
413	1		$process = Process::fromShellCommandline($cmd);
414	1		$process->setTimeout($timeout);
415	1		$process->run();
416
417	1		$this->log($process->getOutput(), LogLevel::DEBUG);
418	1		if (!$process->isSuccessful()) {
419	1		$this->log($process->getErrorOutput(), LogLevel::ERROR);
420			}
421
422	1		return $process;
423			}
424
425			/**
426			* Executes a command remotely, if jail is true, it will run inside the Host Path and the Release (if available)
427			*
428			* @param string $cmd Command to execute
429			* @param bool $jail Jail the command
430			* @param int $timeout Seconds to wait
431			* @return Process
432			*/
433	26		public function runRemoteCommand($cmd, $jail, $timeout = 120)
434			{
435	26		$user = $this->getEnvOption('user', $this->getCurrentUser());
436	26		$sudo = $this->getEnvOption('sudo', false);
437	26		$host = $this->getHostName();
438	26		$sshConfig = $this->getSSHConfig();
439
440	26		$cmdDelegate = $cmd;
441	26		if ($sudo === true) {
442	1		$cmdDelegate = sprintf('sudo %s', $cmd);
443			}
444
445	26		$hostPath = rtrim($this->getEnvOption('host_path'), '/');
446	26		if ($jail && $this->getReleaseId() !== null) {
447	8		$cmdDelegate = sprintf('cd %s/releases/%s && %s', $hostPath, $this->getReleaseId(), $cmdDelegate);
448	26		} elseif ($jail) {
449	8		$cmdDelegate = sprintf('cd %s && %s', $hostPath, $cmdDelegate);
450			}
451
452	26		$cmdRemote = str_replace('"', '\"', $cmdDelegate);
453	26		$cmdLocal = sprintf('ssh -p %d %s %s@%s "%s"', $sshConfig['port'], $sshConfig['flags'], $user, $host, $cmdRemote);
454
455	26		return $this->runLocalCommand($cmdLocal, $timeout);
456			}
457
458			/**
459			* Get the SSH configuration based on the environment
460			*
461			* @return array
462			*/
463	39		public function getSSHConfig()
464			{
465	39		$sshConfig = $this->getEnvOption('ssh', ['port' => 22, 'flags' => '-q -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no']);
466
467	39		if ($this->getHostPort() !== null) {
468	3		$sshConfig['port'] = $this->getHostPort();
469			}
470
471	39		if (!array_key_exists('port', $sshConfig)) {
472	1		$sshConfig['port'] = '22';
473			}
474
475	39		if (!array_key_exists('flags', $sshConfig)) {
476	2		$sshConfig['flags'] = '-q -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no';
477			}
478
479	39		if (!array_key_exists('timeout', $sshConfig)) {
480	38		$sshConfig['timeout'] = 300;
481			}
482
483	39		return $sshConfig;
484			}
485
486			/**
487			* Get the current Host Port or default ssh port
488			*
489			* @return integer
490			*/
491	39		public function getHostPort()
492			{
493	39		$info = explode(':', $this->getWorkingHost());
494	39		return isset($info[1]) ? $info[1] : null;
495			}
496
497			/**
498			* Get the current Host Name
499			*
500			* @return string
501			*/
502	62		public function getHostName()
503			{
504	62		if (strpos($this->getWorkingHost(), ':') === false) {
505	62		return $this->getWorkingHost();
506			}
507
508	2		$info = explode(':', $this->getWorkingHost());
509	2		return $info[0];
510			}
511
512			/**
513			* Gets a Temporal File name
514			*
515			* @return string
516			*/
517	1		public function getTempFile()
518			{
519	1		return tempnam(sys_get_temp_dir(), 'mage');
520			}
521
522			/**
523			* Get the current user
524			*
525			* @return string
526			*/
527	36		public function getCurrentUser()
528			{
529	36		$userData = posix_getpwuid(posix_geteuid());
530	36		return $userData['name'];
531			}
532
533			/**
534			* Shortcut for getting Branch information
535			*
536			* @return boolean\|string
537			*/
538	36		public function getBranch()
539			{
540	36		return $this->getEnvOption('branch', false);
541			}
542
543			/**
544			* Guesses the Deploy Strategy to use
545			*
546			* @return StrategyInterface
547			*/
548	41		public function guessStrategy()
549			{
550	41		$strategy = new RsyncStrategy();
551
552	41		if ($this->getEnvOption('releases', false)) {
553	15		$strategy = new ReleasesStrategy();
554			}
555
556	41		$strategy->setRuntime($this);
557	41		return $strategy;
558			}
559			}
560

andres-montanez / Magallanes

Push — master ( b7ade4...e7afcb )

Runtime::getConfigOption() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like