Manager::start() - Code Metrics - peridot-php/webdriver-manager - Measure and Improve Code Quality continuously with Scrutinizer

Manager::start() A
last analyzed 2018-06-29 02:55 UTC

↳ Parent: Manager

Complexity

Conditions	3
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	18
rs	9.6666
cc	3
nc	4
nop	3

<?php
namespace Peridot\WebDriverManager;

use Peridot\WebDriverManager\Binary\BinaryInterface;
use Peridot\WebDriverManager\Binary\BinaryResolver;
use Peridot\WebDriverManager\Binary\BinaryResolverInterface;
use Peridot\WebDriverManager\Binary\ChromeDriver;
use Peridot\WebDriverManager\Binary\DriverInterface;
use Peridot\WebDriverManager\Binary\IEDriver;
use Peridot\WebDriverManager\Binary\SeleniumStandalone;
use Peridot\WebDriverManager\Event\EventEmitterInterface;
use Peridot\WebDriverManager\Event\EventEmitterTrait;
use Peridot\WebDriverManager\Process\SeleniumProcessInterface;
use Peridot\WebDriverManager\Process\SeleniumProcess;
use RuntimeException;

/**
 * The Manager provides an api for controlling Selenium Server. It can be used
 * to keep binaries and drivers up to date, as well as start Selenium Server.
 *
 * @package Peridot\WebDriverManager
 */
class Manager implements EventEmitterInterface
{
    use EventEmitterTrait;

    /**
     * @var array
     */
    protected $binaries;

    /**
     * @var BinaryResolverInterface
     */
    protected $resolver;

    /**
     * @var SeleniumProcessInterface
     */
    protected $process;

    /**
     * @var string
     */
    protected $installPath = '';

    /**
     * @param BinaryResolverInterface $resolver
     * @param SeleniumProcessInterface $process
     */
    public function __construct(BinaryResolverInterface $resolver = null, SeleniumProcessInterface $process = null) {
        $this->resolver = $resolver;
        $this->process = $process;
        $this->binaries = [];

        $resolver = $this->getBinaryResolver();
        $this->addBinary(new SeleniumStandalone($resolver));
        $this->addBinary(new ChromeDriver($resolver));
        $this->addBinary(new IEDriver($resolver));
        $this->setBinaryResolver($resolver);
    }

    /**
     * Add a binary to the collection of managed binaries.
     *
     * @param BinaryInterface $binary
     */
    public function addBinary(BinaryInterface $binary)
    {
        $this->binaries[$binary->getName()] = $binary;
    }

    /**
     * Remove a binary from the collection of managed binaries.
     *
     * @param string $binaryName
     */
    public function removeBinary($binaryName)
    {
        if (isset($this->binaries[$binaryName])) {
            unset($this->binaries[$binaryName]);
        }
    }

    /**
     * Return the BinaryResolver used to resolve binary files.
     *
     * @return BinaryResolver|BinaryResolverInterface
     */
    public function getBinaryResolver()
    {
        if ($this->resolver === null) {
            $this->resolver = new BinaryResolver();
        }

        return $this->resolver;
    }

    /**
     * Set the BinaryResolver used to resolve binary files.
     *
     * @param BinaryResolverInterface $resolver
     */
    public function setBinaryResolver(BinaryResolverInterface $resolver)
    {
        $this->resolver = $resolver;
        $this->inherit(['progress', 'request.start', 'complete'], $resolver);
    }

    /**
     * Return the SeleniumProcessInterface that will execute the
     * selenium server command.
     *
     * @return SeleniumProcess|SeleniumProcessInterface
     */
    public function getSeleniumProcess()
    {
        if ($this->process === null) {
            $this->process = new SeleniumProcess();
        }

        return $this->process;
    }

    /**
     * Return all managed binaries.
     *
     * @param callable $predicate
     * @return array
     */
    public function getBinaries(callable $predicate = null)
    {
        $binaries = $this->binaries;
        if ($predicate !== null) {
            return array_filter($binaries, $predicate);
        }
        return $binaries;
    }

    /**
     * Return all binaries that are considered drivers.
     *
     * @return array
     */
    public function getDrivers()
    {
        return $this->getBinaries(function ($binary) {
            return $binary instanceof DriverInterface;
        });
    }

    /**
     * Pending binaries are binaries that are supported but have not been installed.
     *
     * @return array
     */
    public function getPendingBinaries()
    {
        return $this->getBinaries(function (BinaryInterface $binary) {
            $exists = $binary->exists($this->getInstallPath());
            $supported = $binary->isSupported();
            return $supported && !$exists;
        });
    }

    /**
     * Fetch and save binaries.
     *
     * @return bool
     */
    public function update($binaryName = '')
    {
        if ($binaryName) {
            $this->updateSingle($binaryName);
            return;
        }

        foreach ($this->binaries as $binary) {
            $binary->fetchAndSave($this->getInstallPath());
        }
    }

    /**
     * Update a single binary.
     *
     * @param $binaryName
     * @return void
     */
    public function updateSingle($binaryName)
    {
        if (! array_key_exists($binaryName, $this->binaries)) {
            throw new RuntimeException("Binary named $binaryName does not exist");
        }

        $binary = $this->binaries[$binaryName];
        $binary->fetchAndSave($this->getInstallPath());
    }

    /**
     * Start the Selenium server.
     *
     * @param bool $background
     * @param int $port
     * @param array $args
     * @return SeleniumProcessInterface
     */
    public function start($background = false, $port = 4444, array $args = [])
    {
        $selenium = $this->binaries['selenium'];
        $this->assertStartConditions($selenium);

        $process = $this->getSeleniumProcess();
        $this->registerBinaries($process, $selenium);

        if ($port != 4444) {
            $process->addArg('-port', $port);
        }

        if (!empty($args)) {
            $process->addArgs($args);
        }

        return $process->start($background);
    }

    /**
     * Start Selenium in the foreground.
     *
     * @param int $port
     * @return SeleniumProcessInterface
     */
    public function startInForeground($port = 4444, array $args = [])
    {
        return $this->start(false, $port, $args);
    }

    /**
     * Start Selenium in a background process.
     *
     * @param int $port
     * @return SeleniumProcessInterface
     */
    public function startInBackground($port = 4444, array $args = [])
    {
        return $this->start(true, $port, $args);
    }

    /**
     * Remove all binaries from the install path.
     *
     * @return void
     */
    public function clean()
    {
        $files = glob($this->getInstallPath() . '/*');
        foreach ($files as $file) {
            unlink($file);
        }
    }

    /**
     * Get the installation path of binaries.
     *
     * @return string
     */
    public function getInstallPath()
    {
        if ($this->installPath === '') {
            $this->installPath = realpath(__DIR__ . '/../binaries');
        }

        return $this->installPath;
    }

    /**
     * Set the installation path for binaries.
     *
     * @param string $path
     */
    public function setInstallPath($path)
    {
        $this->installPath = $path;
    }

    /**
     * Assert that the selenium server can start.
     *
     * @param SeleniumStandalone $selenium
     * @throws \RuntimeException
     * @return void
     */
    protected function assertStartConditions(SeleniumStandalone $selenium)
    {
        if (!$selenium->exists($this->getInstallPath())) {
            throw new RuntimeException("Selenium Standalone binary not installed");
        }

        if (!$this->getSeleniumProcess()->isAvailable()) {
            throw new RuntimeException('java is not available');
        }
    }

    /**
     * Register selenium binary and drivers with the process.
     *
     * @param SeleniumProcessInterface $process
     * @param SeleniumStandalone $selenium
     * @return void
     */
    protected function registerBinaries(SeleniumProcessInterface $process, SeleniumStandalone $selenium)
    {
        $drivers = $this->getDrivers();
        foreach ($drivers as $driver) {
            $process->addBinary($driver, $this->getInstallPath());
        }
        $process->addBinary($selenium, $this->getInstallPath());
    }
}


1			<?php
2			namespace Peridot\WebDriverManager;
3
4			use Peridot\WebDriverManager\Binary\BinaryInterface;
5			use Peridot\WebDriverManager\Binary\BinaryResolver;
6			use Peridot\WebDriverManager\Binary\BinaryResolverInterface;
7			use Peridot\WebDriverManager\Binary\ChromeDriver;
8			use Peridot\WebDriverManager\Binary\DriverInterface;
9			use Peridot\WebDriverManager\Binary\IEDriver;
10			use Peridot\WebDriverManager\Binary\SeleniumStandalone;
11			use Peridot\WebDriverManager\Event\EventEmitterInterface;
12			use Peridot\WebDriverManager\Event\EventEmitterTrait;
13			use Peridot\WebDriverManager\Process\SeleniumProcessInterface;
14			use Peridot\WebDriverManager\Process\SeleniumProcess;
15			use RuntimeException;
16
17			/**
18			* The Manager provides an api for controlling Selenium Server. It can be used
19			* to keep binaries and drivers up to date, as well as start Selenium Server.
20			*
21			* @package Peridot\WebDriverManager
22			*/
23			class Manager implements EventEmitterInterface
24			{
25			use EventEmitterTrait;
26
27			/**
28			* @var array
29			*/
30			protected $binaries;
31
32			/**
33			* @var BinaryResolverInterface
34			*/
35			protected $resolver;
36
37			/**
38			* @var SeleniumProcessInterface
39			*/
40			protected $process;
41
42			/**
43			* @var string
44			*/
45			protected $installPath = '';
46
47			/**
48			* @param BinaryResolverInterface $resolver
49			* @param SeleniumProcessInterface $process
50			*/
51			public function __construct(BinaryResolverInterface $resolver = null, SeleniumProcessInterface $process = null) {
52			$this->resolver = $resolver;
53			$this->process = $process;
54			$this->binaries = [];
55
56			$resolver = $this->getBinaryResolver();
57			$this->addBinary(new SeleniumStandalone($resolver));
58			$this->addBinary(new ChromeDriver($resolver));
59			$this->addBinary(new IEDriver($resolver));
60			$this->setBinaryResolver($resolver);
61			}
62
63			/**
64			* Add a binary to the collection of managed binaries.
65			*
66			* @param BinaryInterface $binary
67			*/
68			public function addBinary(BinaryInterface $binary)
69			{
70			$this->binaries[$binary->getName()] = $binary;
71			}
72
73			/**
74			* Remove a binary from the collection of managed binaries.
75			*
76			* @param string $binaryName
77			*/
78			public function removeBinary($binaryName)
79			{
80			if (isset($this->binaries[$binaryName])) {
81			unset($this->binaries[$binaryName]);
82			}
83			}
84
85			/**
86			* Return the BinaryResolver used to resolve binary files.
87			*
88			* @return BinaryResolver\|BinaryResolverInterface
89			*/
90			public function getBinaryResolver()
91			{
92			if ($this->resolver === null) {
93			$this->resolver = new BinaryResolver();
94			}
95
96			return $this->resolver;
97			}
98
99			/**
100			* Set the BinaryResolver used to resolve binary files.
101			*
102			* @param BinaryResolverInterface $resolver
103			*/
104			public function setBinaryResolver(BinaryResolverInterface $resolver)
105			{
106			$this->resolver = $resolver;
107			$this->inherit(['progress', 'request.start', 'complete'], $resolver);
108			}
109
110			/**
111			* Return the SeleniumProcessInterface that will execute the
112			* selenium server command.
113			*
114			* @return SeleniumProcess\|SeleniumProcessInterface
115			*/
116			public function getSeleniumProcess()
117			{
118			if ($this->process === null) {
119			$this->process = new SeleniumProcess();
120			}
121
122			return $this->process;
123			}
124
125			/**
126			* Return all managed binaries.
127			*
128			* @param callable $predicate
129			* @return array
130			*/
131			public function getBinaries(callable $predicate = null)
132			{
133			$binaries = $this->binaries;
134			if ($predicate !== null) {
135			return array_filter($binaries, $predicate);
136			}
137			return $binaries;
138			}
139
140			/**
141			* Return all binaries that are considered drivers.
142			*
143			* @return array
144			*/
145			public function getDrivers()
146			{
147			return $this->getBinaries(function ($binary) {
148			return $binary instanceof DriverInterface;
149			});
150			}
151
152			/**
153			* Pending binaries are binaries that are supported but have not been installed.
154			*
155			* @return array
156			*/
157			public function getPendingBinaries()
158			{
159			return $this->getBinaries(function (BinaryInterface $binary) {
160			$exists = $binary->exists($this->getInstallPath());
161			$supported = $binary->isSupported();
162			return $supported && !$exists;
163			});
164			}
165
166			/**
167			* Fetch and save binaries.
168			*
169			* @return bool
170			*/
171			public function update($binaryName = '')
172			{
173			if ($binaryName) {
174			$this->updateSingle($binaryName);
175			return;
176			}
177
178			foreach ($this->binaries as $binary) {
179			$binary->fetchAndSave($this->getInstallPath());
180			}
181			}
182
183			/**
184			* Update a single binary.
185			*
186			* @param $binaryName
187			* @return void
188			*/
189			public function updateSingle($binaryName)
190			{
191			if (! array_key_exists($binaryName, $this->binaries)) {
192			throw new RuntimeException("Binary named $binaryName does not exist");
193			}
194
195			$binary = $this->binaries[$binaryName];
196			$binary->fetchAndSave($this->getInstallPath());
197			}
198
199			/**
200			* Start the Selenium server.
201			*
202			* @param bool $background
203			* @param int $port
204			* @param array $args
205			* @return SeleniumProcessInterface
206			*/
207			public function start($background = false, $port = 4444, array $args = [])
208			{
209			$selenium = $this->binaries['selenium'];
210			$this->assertStartConditions($selenium);
211
212			$process = $this->getSeleniumProcess();
213			$this->registerBinaries($process, $selenium);
214
215			if ($port != 4444) {
216			$process->addArg('-port', $port);
217			}
218
219			if (!empty($args)) {
220			$process->addArgs($args);
221			}
222
223			return $process->start($background);
224			}
225
226			/**
227			* Start Selenium in the foreground.
228			*
229			* @param int $port
230			* @return SeleniumProcessInterface
231			*/
232			public function startInForeground($port = 4444, array $args = [])
233			{
234			return $this->start(false, $port, $args);
235			}
236
237			/**
238			* Start Selenium in a background process.
239			*
240			* @param int $port
241			* @return SeleniumProcessInterface
242			*/
243			public function startInBackground($port = 4444, array $args = [])
244			{
245			return $this->start(true, $port, $args);
246			}
247
248			/**
249			* Remove all binaries from the install path.
250			*
251			* @return void
252			*/
253			public function clean()
254			{
255			$files = glob($this->getInstallPath() . '/*');
256			foreach ($files as $file) {
257			unlink($file);
258			}
259			}
260
261			/**
262			* Get the installation path of binaries.
263			*
264			* @return string
265			*/
266			public function getInstallPath()
267			{
268			if ($this->installPath === '') {
269			$this->installPath = realpath(__DIR__ . '/../binaries');
270			}
271
272			return $this->installPath;
273			}
274
275			/**
276			* Set the installation path for binaries.
277			*
278			* @param string $path
279			*/
280			public function setInstallPath($path)
281			{
282			$this->installPath = $path;
283			}
284
285			/**
286			* Assert that the selenium server can start.
287			*
288			* @param SeleniumStandalone $selenium
289			* @throws \RuntimeException
290			* @return void
291			*/
292			protected function assertStartConditions(SeleniumStandalone $selenium)
293			{
294			if (!$selenium->exists($this->getInstallPath())) {
295			throw new RuntimeException("Selenium Standalone binary not installed");
296			}
297
298			if (!$this->getSeleniumProcess()->isAvailable()) {
299			throw new RuntimeException('java is not available');
300			}
301			}
302
303			/**
304			* Register selenium binary and drivers with the process.
305			*
306			* @param SeleniumProcessInterface $process
307			* @param SeleniumStandalone $selenium
308			* @return void
309			*/
310			protected function registerBinaries(SeleniumProcessInterface $process, SeleniumStandalone $selenium)
311			{
312			$drivers = $this->getDrivers();
313			foreach ($drivers as $driver) {
314			$process->addBinary($driver, $this->getInstallPath());
315			}
316			$process->addBinary($selenium, $this->getInstallPath());
317			}
318			}
319

peridot-php / webdriver-manager

Manager::start() A last analyzed 2018-06-29 02:55 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Manager::start() A
last analyzed 2018-06-29 02:55 UTC