Modules::calculateState() - Code Metrics - Inspection of "Reduce method complexity" - tvdijen/simplesamlphp-module-monitor - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( df2b0c...c88b01 )

by Tim

created 2018-01-03 17:29 UTC

Modules::calculateState() A

↳ Parent: Modules

Complexity

Conditions	4
Paths	3

Size

Total Lines	21
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	14
c	1
b	0
f	0
nc	3
nop	1
dl	0
loc	21
rs	9.0534

<?php

namespace SimpleSAML\Module\monitor\TestSuite;

use \SimpleSAML\Module\monitor\TestConfiguration as TestConfiguration;
use \SimpleSAML\Module\monitor\State as State;
use \SimpleSAML\Module\monitor\TestData as TestData;

final class Modules extends \SimpleSAML\Module\monitor\TestSuiteFactory
{
    /**
     * @var array
     */
    private $requiredApacheModules = array();

    /**
     * @var array
     */
    private $requiredPhpModules = array();

    /**
     * @var array
     */
    // Important!!  Modules-names are handled case-sensitive!!
    private $storeApacheDependencies = array();

    /**
     * @var array
     */
    private $storePhpDependencies = array(
        'memcache' => 'memcached|memcache',
        'phpsession' => 'session',
        'redis' => 'redis',
        'redissentinel' => 'redis',
        'riak:Store' => 'riak',
        'sql' => 'PDO'
    );

    /**
     * @var array
     */
    private $moduleApacheDependencies = array(
        'negotiateext' => 'mod_auth_kerb|mod_auth_gssapi'
    );

    /**
     * @var array
     */
    private $modulePhpDependencies = array(
        'authfacebook' => array('curl', 'json'),
        'authYubiKey' => 'curl',
// TODO: consent only requires pdo when database backend is used.. Should probably add this to required-list when processing metadata
//        'consent' => 'PDO',
        'consentAdmin' => 'PDO',
        'ldap' => 'ldap',
        'memcacheMonitor' => 'memcached|memcache',
        'negotiate' => 'krb5',
        'radius' => 'radius',
        'riak' => 'riak',
        'sqlauth' => 'PDO'
    );

    /**
     * @param TestConfiguration|null $configuration
     */
    public function __construct($configuration = null)
    {
        parent::__construct($configuration);
    }

    /**
     * @param TestData $testData

     *
     * @return void
     */
    protected function initialize($testData = null)
    {
        $this->setRequiredApacheModules();
        $this->setRequiredPhpModules();
        $this->setRequiredSspModules();
    }

    /**
     * @return void
     */
    private function addRequiredApacheModule($module)
    {
        if (!in_array($module, $this->requiredApacheModules)) {
            $this->requiredApacheModules[] = $module;
        }
    }

    /**
     * @return void
     */
    private function addRequiredPhpModule($module)
    {
        if (!in_array($module, $this->requiredPhpModules)) {
            $this->requiredPhpModules[] = $module;
        }
    }

    /**
     * @return void
     */
    private function setRequiredApacheModules()
    {
        // Apache Modules
        if (\SimpleSAML\Utils\HTTP::isHTTPS()) {
            $this->addRequiredApacheModule('mod_ssl');
        }
        if (function_exists('apache_get_modules')) {
            $this->addRequiredApacheModule('mod_php|mod_php5');
        }

        // Determine extra required modules
        $configuration = $this->getConfiguration();
        $globalConfig = $configuration->getGlobalConfig();
        $store = $globalConfig->getValue('store.type');
        if (array_key_exists($store, $this->storeApacheDependencies)) {
            $this->addRequiredApacheModule($this->storeApacheDependencies[$store]);
        }
    }

    /**
     * @return void
     */
    private function setRequiredPhpModules()
    {
        // PHP modules
        $composerFile = \SimpleSAML\Utils\System::resolvePath('composer.json');
        $composerData = file_get_contents($composerFile);
        $composer = json_decode($composerData, true);
        $composerRequired = $composer['require'];

        foreach ($composerRequired as $ext => $ver) {
            if (preg_match('/^ext-/', $ext)) {
                $this->addRequiredPhpModule(substr($ext, 4));
            }
        }

        // Determine extra required modules
        $configuration = $this->getConfiguration();
        $globalConfig = $configuration->getGlobalConfig();
        $store = $globalConfig->getValue('store.type');
        if (array_key_exists($store, $this->storePhpDependencies)) {
            $this->addRequiredPhpModule($this->storePhpDependencies[$store]);
        }
    }

    /**
     * @return void
     */
    private function setRequiredSspModules()
    {
        $modules = \SimpleSAML\Module::getModules();
        foreach ($modules as $module) {
            if (\SimpleSAML\Module::isModuleEnabled($module)) {
                if (array_key_exists($module, $this->moduleApacheDependencies)) {
                    $dependencies = \SimpleSAML\Utils\Arrays::Arrayize($this->moduleApacheDependencies[$module]);
                    foreach ($dependencies as $dependency) {
                        $this->addRequiredApacheModule($dependency);
                    }
                }
                if (array_key_exists($module, $this->modulePhpDependencies)) {
                    $dependencies = \SimpleSAML\Utils\Arrays::Arrayize($this->modulePhpDependencies[$module]);
                    foreach ($dependencies as $dependency) {
                        $this->addRequiredPhpModule($dependency);
                    }
                }
            }
        }
    }

    /**
     * @return array<string,array>
     */
    public function getAvailableModules()
    {
        $configuration = $this->getConfiguration();
        return array(
            'Apache' => $configuration->getAvailableApacheModules(),
            'Php' => $configuration->getAvailablePhpModules()
        );
    }

    /**
     * @return array<string,array>
     */
    private function getRequiredModules()
    {
        return array('Apache' => $this->requiredApacheModules, 'Php' => $this->requiredPhpModules);
    }

    /**
     * @return array<string,array>
     */
    private function getModuleDependencies()
    {
        return array('Apache' => $this->moduleApacheDependencies, 'Php' => $this->modulePhpDependencies);
    }

    /**
     * @return void
     */
    protected function invokeTestSuite()
    {
        $availableModules = $this->getAvailableModules();
        $requiredModules = $this->getRequiredModules();
        $moduleDependencies = $this->getModuleDependencies();
        $output = array();

        // Test for the availability of required modules
        foreach ($availableModules as $category => $available) {
            if (is_null($available)) {
                $output[$category][] = array(State::SKIPPED, $category, implode(', ', $requiredModules[$category]), 'Unable to verify installed modules');
            } else {
                $dependencies = array_key_exists($category, $moduleDependencies) ? $moduleDependencies[$category] : array();
                $required = array_key_exists($category, $requiredModules) ? $requiredModules[$category] : array();
                $available = array_key_exists($category, $availableModules) ? $availableModules[$category] : array();

                foreach ($required as $require) {
                    $testData = new TestData(
                        array(
                            'require' => $require,
                            'available' => $available
                        )
                    );
                    $this->testRequirement($testData, $category, $dependencies, $output);
                }
            }
        }

        $this->calculateState($output);
    }

    /**
     * @param array $output
     *
     * @return void
     */
    protected function calculateState($output)
    {
        $availableModules = $this->getAvailableModules();
        $tests = $this->getTests();

        foreach ($availableModules as $category => $available) {
            $categories = array_fill(0, count($tests), $category);
            if (!isSet($output[$category])) {
                $modules = array_map(
                  function($test, $category) {
                    return ($test->getCategory() === $category) ? $test->getModuleName() : false;
                  }, $tests, $categories
                );
                $modules = array_diff($modules, array(false));
                $output[$category][] = array(State::OK, $category, implode(', ', $modules), "All required modules are loaded");
            }
            $this->addMessages($output[$category], $category);
        }

        parent::calculateState();
    }

    /**
     * @param TestData $testData
     * @param string $category
     * @param array $dependencies
     * @param array $output
     *
     * @return void
     */
    private function testRequirement($testData, $category, $dependencies, &$output)
    {
        $require = $testData->getInput('require');
        $class = '\\SimpleSAML\\Module\\monitor\\TestCase\\Module\\' . $category;

        $test = new $class($this, $testData);
        $this->addTest($test);

        $state = $test->getState();
        if ($state !== State::OK) {
            $missing = array();
            while ($dependency = array_search($require, $dependencies)) {
                if (\SimpleSAML\Module::isModuleEnabled($dependency)) {
                    $missing[] = $dependency;
                }
                unset($dependencies[$dependency]);
            }
        }

        if (!empty($missing)) {
            $output[$category][] = array($state, $category, $test->getModuleName(), 'Module not loaded; dependency for ' . implode(', ', $missing));
        } else {
            $output[$category][] = array($state, $category, $test->getModuleName(), 'Module not loaded');
        }
    }
}


1			<?php
2
3			namespace SimpleSAML\Module\monitor\TestSuite;
4
5			use \SimpleSAML\Module\monitor\TestConfiguration as TestConfiguration;
6			use \SimpleSAML\Module\monitor\State as State;
7			use \SimpleSAML\Module\monitor\TestData as TestData;
8
9			final class Modules extends \SimpleSAML\Module\monitor\TestSuiteFactory
10			{
11			/**
12			* @var array
13			*/
14			private $requiredApacheModules = array();
15
16			/**
17			* @var array
18			*/
19			private $requiredPhpModules = array();
20
21			/**
22			* @var array
23			*/
24			// Important!! Modules-names are handled case-sensitive!!
25			private $storeApacheDependencies = array();
26
27			/**
28			* @var array
29			*/
30			private $storePhpDependencies = array(
31			'memcache' => 'memcached\|memcache',
32			'phpsession' => 'session',
33			'redis' => 'redis',
34			'redissentinel' => 'redis',
35			'riak:Store' => 'riak',
36			'sql' => 'PDO'
37			);
38
39			/**
40			* @var array
41			*/
42			private $moduleApacheDependencies = array(
43			'negotiateext' => 'mod_auth_kerb\|mod_auth_gssapi'
44			);
45
46			/**
47			* @var array
48			*/
49			private $modulePhpDependencies = array(
50			'authfacebook' => array('curl', 'json'),
51			'authYubiKey' => 'curl',
52			// TODO: consent only requires pdo when database backend is used.. Should probably add this to required-list when processing metadata
53			// 'consent' => 'PDO',
54			'consentAdmin' => 'PDO',
55			'ldap' => 'ldap',
56			'memcacheMonitor' => 'memcached\|memcache',
57			'negotiate' => 'krb5',
58			'radius' => 'radius',
59			'riak' => 'riak',
60			'sqlauth' => 'PDO'
61			);
62
63			/**
64			* @param TestConfiguration\|null $configuration
65			*/
66			public function __construct($configuration = null)
67			{
68			parent::__construct($configuration);
69			}
70
71			/**
72			* @param TestData $testData
			0 ignored issues – show Documentation introduced 2018-01-03 12:40 UTC by Report Bug Copy Issue Report Should the type for parameter `$testData` not be `TestData\|null`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
73			*
74			* @return void
75			*/
76			protected function initialize($testData = null)
77			{
78			$this->setRequiredApacheModules();
79			$this->setRequiredPhpModules();
80			$this->setRequiredSspModules();
81			}
82
83			/**
84			* @return void
85			*/
86			private function addRequiredApacheModule($module)
87			{
88			if (!in_array($module, $this->requiredApacheModules)) {
89			$this->requiredApacheModules[] = $module;
90			}
91			}
92
93			/**
94			* @return void
95			*/
96			private function addRequiredPhpModule($module)
97			{
98			if (!in_array($module, $this->requiredPhpModules)) {
99			$this->requiredPhpModules[] = $module;
100			}
101			}
102
103			/**
104			* @return void
105			*/
106			private function setRequiredApacheModules()
107			{
108			// Apache Modules
109			if (\SimpleSAML\Utils\HTTP::isHTTPS()) {
110			$this->addRequiredApacheModule('mod_ssl');
111			}
112			if (function_exists('apache_get_modules')) {
113			$this->addRequiredApacheModule('mod_php\|mod_php5');
114			}
115
116			// Determine extra required modules
117			$configuration = $this->getConfiguration();
118			$globalConfig = $configuration->getGlobalConfig();
119			$store = $globalConfig->getValue('store.type');
120			if (array_key_exists($store, $this->storeApacheDependencies)) {
121			$this->addRequiredApacheModule($this->storeApacheDependencies[$store]);
122			}
123			}
124
125			/**
126			* @return void
127			*/
128			private function setRequiredPhpModules()
129			{
130			// PHP modules
131			$composerFile = \SimpleSAML\Utils\System::resolvePath('composer.json');
132			$composerData = file_get_contents($composerFile);
133			$composer = json_decode($composerData, true);
134			$composerRequired = $composer['require'];
135
136			foreach ($composerRequired as $ext => $ver) {
137			if (preg_match('/^ext-/', $ext)) {
138			$this->addRequiredPhpModule(substr($ext, 4));
139			}
140			}
141
142			// Determine extra required modules
143			$configuration = $this->getConfiguration();
144			$globalConfig = $configuration->getGlobalConfig();
145			$store = $globalConfig->getValue('store.type');
146			if (array_key_exists($store, $this->storePhpDependencies)) {
147			$this->addRequiredPhpModule($this->storePhpDependencies[$store]);
148			}
149			}
150
151			/**
152			* @return void
153			*/
154			private function setRequiredSspModules()
155			{
156			$modules = \SimpleSAML\Module::getModules();
157			foreach ($modules as $module) {
158			if (\SimpleSAML\Module::isModuleEnabled($module)) {
159			if (array_key_exists($module, $this->moduleApacheDependencies)) {
160			$dependencies = \SimpleSAML\Utils\Arrays::Arrayize($this->moduleApacheDependencies[$module]);
161			foreach ($dependencies as $dependency) {
162			$this->addRequiredApacheModule($dependency);
163			}
164			}
165			if (array_key_exists($module, $this->modulePhpDependencies)) {
166			$dependencies = \SimpleSAML\Utils\Arrays::Arrayize($this->modulePhpDependencies[$module]);
167			foreach ($dependencies as $dependency) {
168			$this->addRequiredPhpModule($dependency);
169			}
170			}
171			}
172			}
173			}
174
175			/**
176			* @return array<string,array>
177			*/
178			public function getAvailableModules()
179			{
180			$configuration = $this->getConfiguration();
181			return array(
182			'Apache' => $configuration->getAvailableApacheModules(),
183			'Php' => $configuration->getAvailablePhpModules()
184			);
185			}
186
187			/**
188			* @return array<string,array>
189			*/
190			private function getRequiredModules()
191			{
192			return array('Apache' => $this->requiredApacheModules, 'Php' => $this->requiredPhpModules);
193			}
194
195			/**
196			* @return array<string,array>
197			*/
198			private function getModuleDependencies()
199			{
200			return array('Apache' => $this->moduleApacheDependencies, 'Php' => $this->modulePhpDependencies);
201			}
202
203			/**
204			* @return void
205			*/
206			protected function invokeTestSuite()
207			{
208			$availableModules = $this->getAvailableModules();
209			$requiredModules = $this->getRequiredModules();
210			$moduleDependencies = $this->getModuleDependencies();
211			$output = array();
212
213			// Test for the availability of required modules
214			foreach ($availableModules as $category => $available) {
215			if (is_null($available)) {
216			$output[$category][] = array(State::SKIPPED, $category, implode(', ', $requiredModules[$category]), 'Unable to verify installed modules');
217			} else {
218			$dependencies = array_key_exists($category, $moduleDependencies) ? $moduleDependencies[$category] : array();
219			$required = array_key_exists($category, $requiredModules) ? $requiredModules[$category] : array();
220			$available = array_key_exists($category, $availableModules) ? $availableModules[$category] : array();
221
222			foreach ($required as $require) {
223			$testData = new TestData(
224			array(
225			'require' => $require,
226			'available' => $available
227			)
228			);
229			$this->testRequirement($testData, $category, $dependencies, $output);
230			}
231			}
232			}
233
234			$this->calculateState($output);
235			}
236
237			/**
238			* @param array $output
239			*
240			* @return void
241			*/
242			protected function calculateState($output)
243			{
244			$availableModules = $this->getAvailableModules();
245			$tests = $this->getTests();
246
247			foreach ($availableModules as $category => $available) {
248			$categories = array_fill(0, count($tests), $category);
249			if (!isSet($output[$category])) {
250			$modules = array_map(
251			function($test, $category) {
252			return ($test->getCategory() === $category) ? $test->getModuleName() : false;
253			}, $tests, $categories
254			);
255			$modules = array_diff($modules, array(false));
256			$output[$category][] = array(State::OK, $category, implode(', ', $modules), "All required modules are loaded");
257			}
258			$this->addMessages($output[$category], $category);
259			}
260
261			parent::calculateState();
262			}
263
264			/**
265			* @param TestData $testData
266			* @param string $category
267			* @param array $dependencies
268			* @param array $output
269			*
270			* @return void
271			*/
272			private function testRequirement($testData, $category, $dependencies, &$output)
273			{
274			$require = $testData->getInput('require');
275			$class = '\\SimpleSAML\\Module\\monitor\\TestCase\\Module\\' . $category;
276
277			$test = new $class($this, $testData);
278			$this->addTest($test);
279
280			$state = $test->getState();
281			if ($state !== State::OK) {
282			$missing = array();
283			while ($dependency = array_search($require, $dependencies)) {
284			if (\SimpleSAML\Module::isModuleEnabled($dependency)) {
285			$missing[] = $dependency;
286			}
287			unset($dependencies[$dependency]);
288			}
289			}
290
291			if (!empty($missing)) {
292			$output[$category][] = array($state, $category, $test->getModuleName(), 'Module not loaded; dependency for ' . implode(', ', $missing));
293			} else {
294			$output[$category][] = array($state, $category, $test->getModuleName(), 'Module not loaded');
295			}
296			}
297			}
298

tvdijen / simplesamlphp-module-monitor

Push — master ( df2b0c...c88b01 )

Modules::calculateState() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like