SMWIssue4785

Modified files for https://github.com/SemanticMediaWiki/SemanticMediaWiki/issues/4785

SetupCheck.php

  1<?php
  2
  3namespace SMW;
  4
  5use SMW\Utils\TemplateEngine;
  6use SMW\Utils\Logo;
  7use SMW\Localizer\LocalMessageProvider;
  8use SMW\Exception\FileNotReadableException;
  9use SMW\Exception\JSONFileParseException;
 10use RuntimeException;
 11
 12/**
 13 * @private
 14 *
 15 * @license GNU GPL v2+
 16 * @since 3.1
 17 *
 18 * @author mwjames
 19 */
 20class SetupCheck {
 21
 22	/**
 23	 * Semantic MediaWiki was loaded or accessed but not correctly enabled.
 24	 */
 25	const ERROR_EXTENSION_LOAD = 'ERROR_EXTENSION_LOAD';
 26
 27	/**
 28	 * Semantic MediaWiki was loaded or accessed but not correctly enabled.
 29	 */
 30	const ERROR_EXTENSION_INVALID_ACCESS = 'ERROR_EXTENSION_INVALID_ACCESS';
 31
 32	/**
 33	 * A user tried to use `wfLoadExtension( 'SemanticMediaWiki' )` and
 34	 * `enableSemantics` at the same causing the ExtensionRegistry to throw an
 35	 * "Uncaught Exception: It was attempted to load SemanticMediaWiki twice ..."
 36	 */
 37	const ERROR_EXTENSION_REGISTRY = 'ERROR_EXTENSION_REGISTRY';
 38
 39	/**
 40	 * A dependency (extension, MediaWiki) causes an error
 41	 */
 42	const ERROR_EXTENSION_DEPENDENCY = 'ERROR_EXTENSION_DEPENDENCY';
 43
 44	/**
 45	 * Multiple dependencies (extension, MediaWiki) caused an error
 46	 */
 47	const ERROR_EXTENSION_DEPENDENCY_MULTIPLE = 'ERROR_EXTENSION_DEPENDENCY_MULTIPLE';
 48
 49	/**
 50	 * Extension doesn't match MediaWiki or the PHP requirement.
 51	 */
 52	const ERROR_EXTENSION_INCOMPATIBLE = 'ERROR_EXTENSION_INCOMPATIBLE';
 53
 54	/**
 55	 * Extension doesn't match the DB requirement for Semantic MediaWiki.
 56	 */
 57	const ERROR_DB_REQUIREMENT_INCOMPATIBLE = 'ERROR_DB_REQUIREMENT_INCOMPATIBLE';
 58
 59	/**
 60	 * The upgrade key has change causing the schema to be invalid
 61	 */
 62	const ERROR_SCHEMA_INVALID_KEY = 'ERROR_SCHEMA_INVALID_KEY';
 63
 64	/**
 65	 * A selected default profile could not be loaded or is unknown.
 66	 */
 67	const ERROR_CONFIG_PROFILE_UNKNOWN = 'ERROR_CONFIG_PROFILE_UNKNOWN';
 68
 69	/**
 70	 * The system is currently in a maintenance window
 71	 */
 72	const MAINTENANCE_MODE = 'MAINTENANCE_MODE';
 73
 74	/**
 75	 * @var []
 76	 */
 77	private $options = [];
 78
 79	/**
 80	 * @var SetupFile
 81	 */
 82	private $setupFile;
 83
 84	/**
 85	 * @var TemplateEngine
 86	 */
 87	private $templateEngine;
 88
 89	/**
 90	 * @var LocalMessageProvider
 91	 */
 92	private $localMessageProvider;
 93
 94	/**
 95	 * @var []
 96	 */
 97	private $definitions = [];
 98
 99	/**
100	 * @var string
101	 */
102	private $languageCode = 'en';
103
104	/**
105	 * @var string
106	 */
107	private $fallbackLanguageCode = 'en';
108
109	/**
110	 * @var boolean
111	 */
112	private $sentHeader = true;
113
114	/**
115	 * @var string
116	 */
117	private $errorType = '';
118
119	/**
120	 * @var string
121	 */
122	private $errorMessage = '';
123
124	/**
125	 * @var string
126	 */
127	private $traceString = '';
128
129	/**
130	 * @since 3.1
131	 *
132	 * @param array $vars
133	 * @param SetupFile|null $setupFile
134	 */
135	public function __construct( array $options, SetupFile $setupFile = null ) {
136		$this->options = $options;
137		$this->setupFile = $setupFile;
138		$this->templateEngine = new TemplateEngine();
139		$this->localMessageProvider = new LocalMessageProvider( '/local/setupcheck.i18n.json' );
140
141		if ( $this->setupFile === null ) {
142			$this->setupFile = new SetupFile();
143		}
144	}
145
146	/**
147	 * @since 3.2
148	 *
149	 * @param string $file
150	 *
151	 * @return array
152	 * @throws RuntimeException
153	 */
154	public static function readFromFile( string $file ) : array {
155
156		if ( !is_readable( $file ) ) {
157			throw new FileNotReadableException( $file );
158		}
159
160		$contents = json_decode(
161			file_get_contents( $file ),
162			true
163		);
164
165		if ( json_last_error() === JSON_ERROR_NONE ) {
166			return $contents;
167		}
168
169		throw new JSONFileParseException( $file );
170	}
171
172	/**
173	 * @since 3.1
174	 *
175	 * @param SetupFile|null $setupFile
176	 *
177	 * @return SetupCheck
178	 */
179	public static function newFromDefaults( SetupFile $setupFile = null ) {
180
181		if ( !defined( 'SMW_VERSION' ) ) {
182			$version = self::readFromFile( $GLOBALS['smwgIP'] . 'extension.json' )['version'];
183		} else {
184			$version = SMW_VERSION;
185		}
186
187		$setupCheck = new SetupCheck(
188			[
189				'SMW_VERSION'    => $version,
190				'MW_VERSION'     => $GLOBALS['wgVersion'], // MW_VERSION may not yet be defined!!
191				'wgLanguageCode' => $GLOBALS['wgLanguageCode'],
192				'smwgUpgradeKey' => $GLOBALS['smwgUpgradeKey']
193			],
194			$setupFile
195		);
196
197		return $setupCheck;
198	}
199
200	/**
201	 * @since 3.2
202	 */
203	public function disableHeader() {
204		$this->sentHeader = false;
205	}
206
207	/**
208	 * @since 3.1
209	 *
210	 * @return boolean
211	 */
212	public function isCli() {
213		return PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg';
214	}
215
216	/**
217	 * @since 3.1
218	 *
219	 * @param string $traceString
220	 */
221	public function setTraceString( $traceString ) {
222		$this->traceString = $traceString;
223	}
224
225	/**
226	 * @since 3.2
227	 *
228	 * @param string $errorMessage
229	 */
230	public function setErrorMessage( string $errorMessage ) {
231		$this->errorMessage = $errorMessage;
232	}
233
234	/**
235	 * @since 3.2
236	 *
237	 * @param string $errorType
238	 */
239	public function setErrorType( string $errorType ) {
240		$this->errorType = $errorType;
241	}
242
243	/**
244	 * @since 3.2
245	 *
246	 * @return boolean
247	 */
248	public function isError( string $error ) : bool {
249		return $this->errorType === $error;
250	}
251
252	/**
253	 * @since 3.1
254	 *
255	 * @return boolean
256	 */
257	public function hasError() {
258
259		$this->errorType = '';
260
261		// When it is not a test run or run from the command line we expect that
262		// the extension is registered using `enableSemantics`
263		if ( !defined( 'SMW_EXTENSION_LOADED' ) && !$this->isCli() ) {
264			$this->errorType = self::ERROR_EXTENSION_LOAD;
265		} elseif ( $this->setupFile->inMaintenanceMode() ) {
266			$this->errorType = self::MAINTENANCE_MODE;
267		} elseif ( !$this->isCli() && !$this->setupFile->hasDatabaseMinRequirement() ) {
268			$this->errorType = self::ERROR_DB_REQUIREMENT_INCOMPATIBLE;
269		} elseif ( $this->setupFile->isGoodSchema() === false ) {
270			$this->errorType = self::ERROR_SCHEMA_INVALID_KEY;
271		}
272
273		return $this->errorType !== '';
274	}
275
276	/**
277	 * @note Adding a new error type requires to:
278	 *
279	 * - Define a constant to clearly identify the type of error
280	 * - Extend the `setupcheck.json` to add a definition for the new type and
281	 *   specify which information should be displayed
282	 * - In case the existing HTML elements aren't sufficient, create a new
283	 *   zxy.ms file and define the HTML code
284	 *
285	 * The `TemplateEngine` will replace arguments defined in the HTML hereby
286	 * absolving this class from any direct HTML manipulation.
287	 *
288	 * @since 3.1
289	 *
290	 * @param boolean $isCli
291	 *
292	 * @return string
293	 */
294	public function getError( $isCli = false ) {
295
296		$error = [
297			'title' => '',
298			'content' => ''
299		];
300
301		$this->languageCode = $_GET['uselang'] ?? $this->options['wgLanguageCode'] ?? 'en';
302
303		// Output forms for different error types are registered with a JSON file.
304		$this->definitions = $this->readFromFile(
305			$GLOBALS['smwgDir'] . '/data/template/setupcheck/setupcheck.json'
306		);
307
308		// Error messages are specified in a special i18n JSON file to avoid relying
309		// on the MW message system especially when SMW isn't fully registered
310		// and we are unable to access any `smw-...` message keys from the standard
311		// i18n files.
312		$this->localMessageProvider->setLanguageCode(
313			$this->languageCode
314		);
315
316		$this->localMessageProvider->loadMessages();
317
318		// HTML specific formatting is contained in the following files where
319		// a defined group of targets correspond to types used in the JSON
320		$this->templateEngine->bulkLoad(
321			[
322				'/setupcheck/setupcheck.ms' => 'setupcheck-html',
323				'/setupcheck/setupcheck.progress.ms' => 'setupcheck-progress',
324
325				// Target specific elements
326				'/setupcheck/setupcheck.section.ms'   => 'section',
327				'/setupcheck/setupcheck.version.ms'   => 'version',
328				'/setupcheck/setupcheck.paragraph.ms' => 'paragraph',
329				'/setupcheck/setupcheck.errorbox.ms'  => 'errorbox',
330				'/setupcheck/setupcheck.db.requirement.ms' => 'db-requirement',
331			]
332		);
333
334		if ( !isset( $this->definitions['error_types'][$this->errorType] ) ) {
335			throw new RuntimeException( "The `{$this->errorType}` type is not defined in the `setupcheck.json`!" );
336		}
337
338		$error = $this->createErrorContent( $this->errorType );
339
340		if ( $isCli === false ) {
341			$content = $this->buildHTML( $error );
342			$this->header( 'Content-Type: text/html; charset=UTF-8' );
343			$this->header( 'Content-Length: ' . strlen( $content ) );
344			$this->header( 'Cache-control: none' );
345			$this->header( 'Pragma: no-cache' );
346		} else {
347			$content = $error['title'] . "\n\n" . $error['content'];
348			$content = str_replace(
349				[ '<!-- ROW -->', '</h3>', '</h4>', '</p>', '&nbsp;' ],
350				[ "\n", "\n\n", "\n\n", "\n\n", ' ' ],
351				$content
352			);
353			$content = "\n" . wordwrap( strip_tags( trim( $content ) ), 73 );
354		}
355
356		return $content;
357	}
358
359	/**
360	 * @since 3.1
361	 *
362	 * @param boolean $isCli
363	 */
364	public function showErrorAndAbort( $isCli = false ) {
365
366		echo $this->getError( $isCli );
367
368		if ( ob_get_level() ) {
369			ob_flush();
370			flush();
371			ob_end_clean();
372		}
373
374		die();
375	}
376
377	private function header( $text ) {
378		if ( $this->sentHeader ) {
379			header( $text );
380		}
381  }
382
383  private function schemaError() {
384 	  // get trace
385		// https://stackoverflow.com/a/7039409/1497139
386		//
387		$e = new \Exception;
388		$content ='<pre>'.$e->getTraceAsString().'</pre>';
389		$content .='PHP_SAPI: '.PHP_SAPI."<br>";
390		$isCli=$this->isCli();
391		$schemaState=SetupFile::getSchemaState($isCli);
392		$content.='Schema state: '.$schemaState."<br>";
393		$upgradeKeyBase=SetupFile::makeKey($GLOBALS);
394    $content.='upgrade key base: '.$upgradeKeyBase;
395    return $content;
396  }
397
398	private function createErrorContent( $type ) {
399
400		$indicator_title = 'Error';
401		$template = $this->definitions['error_types'][$type];
402    $content = '';
403
404    if ($type==self::ERROR_SCHEMA_INVALID_KEY) {
405      $content.=$this->schemaError($this->isCli());
406    }
407
408		/**
409		 * Actual output form
410		 */
411		foreach ( $template['output_form'] as $value ) {
412			$content .= $this->createContent( $value, $type );
413		}
414
415		/**
416		 * Special handling for the progress output
417		 */
418		if ( isset( $template['progress'] ) ) {
419			foreach ( $template['progress'] as $value ) {
420				$text = $this->createCopy( $value['text'] );
421
422				if ( isset( $value['progress_keys'] ) ) {
423					$content .= $this->createProgressIndicator( $value );
424				}
425
426				$args = [
427					'text' => $text,
428					'template' => $value['type']
429				];
430
431				$this->templateEngine->compile(
432					$value['type'],
433					$args
434				);
435
436				$content .= $this->templateEngine->publish( $value['type'] );
437			}
438		}
439
440		/**
441		 * Special handling for the stack trace output
442		 */
443		if ( isset( $template['stack_trace'] ) && $this->traceString !== '' ) {
444			foreach ( $template['stack_trace'] as $value ) {
445				$content .= $this->createContent( $value, $type );
446			}
447		}
448
449		if ( isset( $template['indicator_title'] ) ) {
450			$indicator_title = $this->createCopy( $template['indicator_title'] );
451		}
452
453		$error = [
454			'title' => 'Semantic MediaWiki',
455			'indicator_title' => $indicator_title,
456			'content' => $content,
457			'borderColor' => $template['indicator_color']
458		];
459
460		return $error;
461	}
462
463	private function createContent( $value, $type ) {
464
465		if ( $value['text'] === 'ERROR_TEXT' ) {
466			$text = str_replace( "\n", '<br>', $this->errorMessage );
467		} elseif ( $value['text'] === 'ERROR_TEXT_MULTIPLE' ) {
468			$errors = explode( "\n", $this->errorMessage );
469			$text = '<ul><li>' . implode( '</li><li>', array_filter( $errors ) ) . '</li></ul>';
470		} elseif ( $value['text'] === 'TRACE_STRING' ) {
471			$text = $this->traceString;
472		} else {
473			$text = $this->createCopy( $value['text'] );
474		}
475
476		$args = [
477			'text' => $text,
478			'template' => $value['type']
479		];
480
481		if ( $value['type'] === 'version' ) {
482			$args['version-title'] = $text;
483			$args['smw-title'] = 'Semantic MediaWiki';
484			$args['smw-version'] = $this->options['SMW_VERSION'] ?? 'n/a';
485			$args['smw-upgradekey'] = $this->options['smwgUpgradeKey'] ?? 'n/a';
486			$args['mw-title'] = 'MediaWiki';
487			$args['mw-version'] = $this->options['MW_VERSION'] ?? 'n/a';
488			$args['code-title'] = $this->createCopy( 'smw-setupcheck-code' );
489			$args['code-type'] = $type;
490		}
491
492		if ( $value['type'] === 'db-requirement' ) {
493			$requirements = $this->setupFile->get( SetupFile::DB_REQUIREMENTS );
494			$args['version-title'] = $text;
495			$args['db-title'] = $this->createCopy( 'smw-setupcheck-db-title' );
496			$args['db-type'] = $requirements['type'] ?? 'N/A';
497			$args['db-current-title'] = $this->createCopy( 'smw-setupcheck-db-current-title' );
498			$args['db-minimum-title'] = $this->createCopy( 'smw-setupcheck-db-minimum-title' );
499			$args['db-current-version'] = $requirements['latest_version'] ?? 'N/A';
500			$args['db-minimum-version'] = $requirements['minimum_version'] ?? 'N/A';
501		}
502
503		// The type is expected to match a defined target and in an event
504		// that those don't match an exception will be raised.
505		$this->templateEngine->compile(
506			$value['type'],
507			$args
508		);
509
510		return $this->templateEngine->publish( $value['type'] );
511	}
512
513	private function createProgressIndicator( $value ) {
514
515		$maintenanceMode = (array)$this->setupFile->getMaintenanceMode();
516		$content = '';
517
518		foreach ( $maintenanceMode as $key => $v ) {
519
520			$args = [
521				'label' => $key,
522				'value' => $v
523			];
524
525			if ( isset( $value['progress_keys'][$key] ) ) {
526				$args['label'] = $this->createCopy( $value['progress_keys'][$key] );
527			}
528
529			$this->templateEngine->compile(
530				'setupcheck-progress',
531				$args
532			);
533
534			$content .= $this->templateEngine->publish( 'setupcheck-progress' );
535		}
536
537		return $content;
538	}
539
540	private function createCopy( $value, $default = 'n/a' ) {
541
542		if ( is_string( $value ) && $this->localMessageProvider->has( $value ) ) {
543			return $this->localMessageProvider->msg( $value );
544		}
545
546		return $default;
547	}
548
549	private function buildHTML( array $error ) {
550
551		$args = [
552			'logo' => Logo::get( 'small' ),
553			'title' => $error['title'] ?? '',
554			'indicator' => $error['indicator_title'] ?? '',
555			'content' => $error['content'] ?? '',
556			'borderColor' => $error['borderColor'] ?? '#fff',
557			'refresh' => $error['refresh'] ?? '30',
558		];
559
560		$this->templateEngine->compile(
561			'setupcheck-html',
562			$args
563		);
564
565		$html = $this->templateEngine->publish( 'setupcheck-html' );
566
567		// Minify CSS rules, we keep them readable in the template to allow for
568		// better adaption
569		// @see http://manas.tungare.name/software/css-compression-in-php/
570		$html = preg_replace_callback( "/<style\\b[^>]*>(.*?)<\\/style>/s", function( $matches ) {
571				// Remove space after colons
572				$style = str_replace( ': ', ':', $matches[0] );
573
574				// Remove whitespace
575				return str_replace( [ "\r\n", "\r", "\n", "\t", '  ', '    ', '    '], '', $style );
576			},
577			$html
578		);
579
580		return $html;
581	}
582
583}

SetupFile.php

  1<?php
  2
  3namespace SMW;
  4
  5use SMW\Exception\FileNotWritableException;
  6use SMW\Utils\File;
  7use SMW\SQLStore\Installer;
  8
  9/**
 10 * @private
 11 *
 12 * @license GNU GPL v2+
 13 * @since 3.1
 14 *
 15 * @author mwjames
 16 */
 17class SetupFile {
 18
 19	/**
 20	 * Describes the maintenance mode
 21	 */
 22	const MAINTENANCE_MODE = 'maintenance_mode';
 23
 24	/**
 25	 * Describes the upgrade key
 26	 */
 27	const UPGRADE_KEY = 'upgrade_key';
 28
 29	/**
 30	 * Describes the database requirements
 31	 */
 32	const DB_REQUIREMENTS = 'db_requirements';
 33
 34	/**
 35	 * Describes the entity collection setting
 36	 */
 37	const ENTITY_COLLATION = 'entity_collation';
 38
 39	/**
 40	 * Key that describes the date of the last table optimization run.
 41	 */
 42	const LAST_OPTIMIZATION_RUN = 'last_optimization_run';
 43
 44	/**
 45	 * Describes the file name
 46	 */
 47	const FILE_NAME = '.smw.json';
 48
 49	/**
 50	 * Describes incomplete tasks
 51	 */
 52	const INCOMPLETE_TASKS = 'incomplete_tasks';
 53
 54	/**
 55	 * Versions
 56	 */
 57	const LATEST_VERSION = 'latest_version';
 58	const PREVIOUS_VERSION = 'previous_version';
 59
 60	/**
 61	 * @var File
 62	 */
 63	private $file;
 64
 65	/**
 66	 * @since 3.1
 67	 *
 68	 * @param File|null $file
 69	 */
 70	public function __construct( File $file = null ) {
 71		$this->file = $file;
 72
 73		if ( $this->file === null ) {
 74			$this->file = new File();
 75		}
 76	}
 77
 78	/**
 79	 * @since 3.1
 80	 *
 81	 * @param array $vars
 82	 */
 83	public function loadSchema( &$vars = [] ) {
 84
 85		if ( $vars === [] ) {
 86			$vars = $GLOBALS;
 87		}
 88
 89		if ( isset( $vars['smw.json'] ) ) {
 90			return;
 91		}
 92
 93		// @see #3506
 94		$file = File::dir( $vars['smwgConfigFileDir'] . '/' . self::FILE_NAME );
 95
 96		// Doesn't exist? The `Setup::init` will take care of it by trying to create
 97		// a new file and if it fails or unable to do so wail raise an exception
 98		// as we expect to have access to it.
 99		if ( is_readable( $file ) ) {
100			$vars['smw.json'] = json_decode( file_get_contents( $file ), true );
101		}
102	}
103
104	/**
105	 * @since 3.1
106	 *
107	 * @param boolean $isCli
108	 *
109	 * @return boolean
110	 */
111	public static function isGoodSchema( $isCli = false ) {
112		// get the schema State as a  human readable description
113		$schemaState=SetupFile::getSchemaState($isCli);
114		// check that it starts with "ok:" and not "error:"
115		$result=SetupFile::strStartsWith($schemaState,"ok:");
116		return $result;
117	}
118
119	/**
120	 * @since 3.1.7
121	 *
122	 * see https://stackoverflow.com/a/6513929/1497139
123	 *
124	 * @param string $haystack
125	 * @param string $needle
126	 *
127	 * return boolean
128	 */
129	public static function strStartsWith($haystack, $needle) {
130           return (strpos($haystack, $needle) === 0);
131  }
132
133	/**
134	 * @since 3.1.7
135	 *
136	 * @param boolean $isCli
137	 *
138	 * @return string 
139	 */
140	public static function getSchemaState( $isCli = false ) {
141          
142		if ( $isCli && defined( 'MW_PHPUNIT_TEST' ) ) {
143			return "ok: CLI with PHP Unit Test active";
144		}
145
146		if ( $isCli === false && ( PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg' ) ) {
147			return "ok: isCli is true and PHP_SAPI cli/phpdbg=".PHP_SAPI;
148		}
149
150		// #3563, Use the specific wiki-id as identifier for the instance in use
151		$id = Site::id();
152
153    if ( !isset( $GLOBALS['smw.json'][$id]['upgrade_key'] ) ) {
154      global $smwgConfigFileDir;
155			return "error: smw.json for ".$id." upgrade key missing - you might want to check \$smwgConfigFileDir:".$smwgConfigFileDir;
156		}
157
158		$upgradeKey = self::makeUpgradeKey( $GLOBALS );
159		$expected   =$GLOBALS['smw.json'][$id]['upgrade_key'];
160		if ( $upgradeKey === $expected ) 
161			$schemaState= "ok: found upgradeKey.".$upgradeKey;
162		else
163			$schemaState= "error: expected upgradeKey ".$expected." for ".$id." but found ".$upgradeKey;
164
165		if (
166			isset( $GLOBALS['smw.json'][$id][self::MAINTENANCE_MODE] ) &&
167			$GLOBALS['smw.json'][$id][self::MAINTENANCE_MODE] !== false ) {
168			$schemaState= "error: upgradeKey ".$upgradeKey." is ok but maintainance is active";
169		}
170
171		return $schemaState;
172	}
173
174	/**
175	 * @since 3.1
176	 *
177	 * @param array $vars
178	 *
179	 * @return string
180	 */
181	public static function makeUpgradeKey( $vars ) {
182		return sha1( self::makeKey( $vars ) );
183	}
184
185	/**
186	 * @since 3.1
187	 *
188	 * @param array $vars
189	 *
190	 * @return boolean
191	 */
192	public function inMaintenanceMode( $vars = [] ) {
193
194		if ( !defined( 'MW_PHPUNIT_TEST' ) && ( PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg' ) ) {
195			return false;
196		}
197
198		if ( $vars === [] ) {
199			$vars = $GLOBALS;
200		}
201
202		$id = Site::id();
203
204		if ( !isset( $vars['smw.json'][$id][self::MAINTENANCE_MODE] ) ) {
205			return false;
206		}
207
208		return $vars['smw.json'][$id][self::MAINTENANCE_MODE] !== false;
209	}
210
211	/**
212	 * @since 3.1
213	 *
214	 * @param array $vars
215	 *
216	 * @return []
217	 */
218	public function getMaintenanceMode( $vars = [] ) {
219
220		if ( $vars === [] ) {
221			$vars = $GLOBALS;
222		}
223
224		$id = Site::id();
225
226		if ( !isset( $vars['smw.json'][$id][self::MAINTENANCE_MODE] ) ) {
227			return [];
228		}
229
230		return $vars['smw.json'][$id][self::MAINTENANCE_MODE];
231	}
232
233	/**
234	 * Tracking the latest and previous version, which allows us to decide whether
235	 * current activties relate to an install (new) or upgrade.
236	 *
237	 * @since 3.2
238	 *
239	 * @param int $version
240	 */
241	public function setLatestVersion( $version ) {
242
243		$latest = $this->get( SetupFile::LATEST_VERSION );
244		$previous = $this->get( SetupFile::PREVIOUS_VERSION );
245
246		if ( $latest === null && $previous === null ) {
247			$this->set(
248				[
249					SetupFile::LATEST_VERSION => $version
250				]
251			);
252		} elseif ( $latest !== $version ) {
253			$this->set(
254				[
255					SetupFile::LATEST_VERSION => $version,
256					SetupFile::PREVIOUS_VERSION => $latest
257				]
258			);
259		}
260	}
261
262	/**
263	 * @since 3.2
264	 *
265	 * @param string $key
266	 * @param array $args
267	 */
268	public function addIncompleteTask( string $key, array $args = [] ) {
269
270		$incomplete_tasks = $this->get( self::INCOMPLETE_TASKS );
271
272		if ( $incomplete_tasks === null ) {
273			$incomplete_tasks = [];
274		}
275
276		$incomplete_tasks[$key] = $args === [] ? true : $args;
277
278		$this->set( [ self::INCOMPLETE_TASKS => $incomplete_tasks ] );
279	}
280
281	/**
282	 * @since 3.2
283	 *
284	 * @param string $key
285	 */
286	public function removeIncompleteTask( string $key ) {
287
288		$incomplete_tasks = $this->get( self::INCOMPLETE_TASKS );
289
290		if ( $incomplete_tasks === null ) {
291			$incomplete_tasks = [];
292		}
293
294		unset( $incomplete_tasks[$key] );
295
296		$this->set( [ self::INCOMPLETE_TASKS => $incomplete_tasks ] );
297	}
298
299	/**
300	 * @since 3.2
301	 *
302	 * @param array $vars
303	 *
304	 * @return boolean
305	 */
306	public function hasDatabaseMinRequirement( array $vars = [] ) : bool {
307
308		if ( $vars === [] ) {
309			$vars = $GLOBALS;
310		}
311
312		$id = Site::id();
313
314		// No record means, no issues!
315		if ( !isset( $vars['smw.json'][$id][self::DB_REQUIREMENTS] ) ) {
316			return true;
317		}
318
319		$requirements = $vars['smw.json'][$id][self::DB_REQUIREMENTS];
320
321		return version_compare( $requirements['latest_version'], $requirements['minimum_version'], 'ge' );
322	}
323
324	/**
325	 * @since 3.1
326	 *
327	 * @param array $vars
328	 *
329	 * @return []
330	 */
331	public function findIncompleteTasks( $vars = [] ) {
332
333		if ( $vars === [] ) {
334			$vars = $GLOBALS;
335		}
336
337		$id = Site::id();
338		$tasks = [];
339
340		// Key field => [ value that constitutes the `INCOMPLETE` state, error msg ]
341		$checks = [
342			\SMW\SQLStore\Installer::POPULATE_HASH_FIELD_COMPLETE => [ false, 'smw-install-incomplete-populate-hash-field' ],
343			\SMW\Elastic\ElasticStore::REBUILD_INDEX_RUN_COMPLETE => [ false, 'smw-install-incomplete-elasticstore-indexrebuild' ]
344		];
345
346		foreach ( $checks as $key => $value ) {
347
348			if ( !isset( $vars['smw.json'][$id][$key] ) ) {
349				continue;
350			}
351
352			if ( $vars['smw.json'][$id][$key] === $value[0] ) {
353				$tasks[] = $value[1];
354			}
355		}
356
357		if ( isset( $vars['smw.json'][$id][self::INCOMPLETE_TASKS] ) ) {
358			foreach ( $vars['smw.json'][$id][self::INCOMPLETE_TASKS] as $key => $args ) {
359				if ( $args === true ) {
360					$tasks[] = $key;
361				} else {
362					$tasks[] = [ $key, $args ];
363				}
364			}
365		}
366
367		return $tasks;
368	}
369
370	/**
371	 * @since 3.1
372	 *
373	 * @param mixed $maintenanceMode
374	 */
375	public function setMaintenanceMode( $maintenanceMode, $vars = [] ) {
376
377		if ( $vars === [] ) {
378			$vars = $GLOBALS;
379		}
380
381		$this->write(
382			[
383				self::UPGRADE_KEY => self::makeUpgradeKey( $vars ),
384				self::MAINTENANCE_MODE => $maintenanceMode
385			],
386			$vars
387		);
388	}
389
390	/**
391	 * @since 3.1
392	 *
393	 * @param array $vars
394	 */
395	public function finalize( $vars = [] ) {
396
397		if ( $vars === [] ) {
398			$vars = $GLOBALS;
399		}
400
401		// #3563, Use the specific wiki-id as identifier for the instance in use
402		$key = self::makeUpgradeKey( $vars );
403		$id = Site::id();
404
405		if (
406			isset( $vars['smw.json'][$id][self::UPGRADE_KEY] ) &&
407			$key === $vars['smw.json'][$id][self::UPGRADE_KEY] &&
408			$vars['smw.json'][$id][self::MAINTENANCE_MODE] === false ) {
409			return false;
410		}
411
412		$this->write(
413			[
414				self::UPGRADE_KEY => $key,
415				self::MAINTENANCE_MODE => false
416			],
417			$vars
418		);
419	}
420
421	/**
422	 * @since 3.1
423	 *
424	 * @param array $vars
425	 */
426	public function reset( $vars = [] ) {
427
428		if ( $vars === [] ) {
429			$vars = $GLOBALS;
430		}
431
432		$id = Site::id();
433		$args = [];
434
435		if ( !isset( $vars['smw.json'][$id] ) ) {
436			return;
437		}
438
439		$vars['smw.json'][$id] = [];
440
441		$this->write( [], $vars );
442	}
443
444	/**
445	 * @since 3.1
446	 *
447	 * @param array $args
448	 */
449	public function set( array $args, $vars = [] ) {
450
451		if ( $vars === [] ) {
452			$vars = $GLOBALS;
453		}
454
455		$this->write( $args, $vars );
456	}
457
458	/**
459	 * @since 3.1
460	 *
461	 * @param array $args
462	 */
463	public function get( $key, $vars = [] ) {
464
465		if ( $vars === [] ) {
466			$vars = $GLOBALS;
467		}
468
469		$id = Site::id();
470
471		if ( isset( $vars['smw.json'][$id][$key] ) ) {
472			return $vars['smw.json'][$id][$key];
473		}
474
475		return null;
476	}
477
478	/**
479	 * @since 3.1
480	 *
481	 * @param string $key
482	 */
483	public function remove( $key, $vars = [] ) {
484
485		if ( $vars === [] ) {
486			$vars = $GLOBALS;
487		}
488
489		$this->write( [ $key => null ], $vars );
490	}
491
492	/**
493	 * @since 3.1
494	 *
495	 * @param array $vars
496	 * @param array $args
497	 */
498	public function write( array $args, array $vars ) {
499
500		$configFile = File::dir( $vars['smwgConfigFileDir'] . '/' . self::FILE_NAME );
501		$id = Site::id();
502
503		if ( !isset( $vars['smw.json'] ) ) {
504			$vars['smw.json'] = [];
505		}
506
507		foreach ( $args as $key => $value ) {
508			// NULL means that the key key is removed
509			if ( $value === null ) {
510				unset( $vars['smw.json'][$id][$key] );
511			} else {
512				$vars['smw.json'][$id][$key] = $value;
513			}
514		}
515
516		// Log the base elements used for computing the key
517		$vars['smw.json'][$id]['upgrade_key_base'] = self::makeKey(
518			$vars
519		);
520
521		// Remove legacy
522		if ( isset( $vars['smw.json']['upgradeKey'] ) ) {
523			unset( $vars['smw.json']['upgradeKey'] );
524		}
525		if ( isset( $vars['smw.json'][$id]['in.maintenance_mode'] ) ) {
526			unset( $vars['smw.json'][$id]['in.maintenance_mode'] );
527		}
528
529		try {
530			$this->file->write(
531				$configFile,
532				json_encode( $vars['smw.json'], JSON_PRETTY_PRINT )
533			);
534		} catch( FileNotWritableException $e ) {
535			// Users may not have `wgShowExceptionDetails` enabled and would
536			// therefore not see the exception error message hence we fail hard
537			// and die
538			die(
539				"\n\nERROR: " . $e->getMessage() . "\n" .
540				"\n       The \"smwgConfigFileDir\" setting should point to a" .
541				"\n       directory that is persistent and writable!\n"
542			);
543		}
544	}
545
546	/**
547	 * Listed keys will have a "global" impact of how data are stored, formatted,
548	 * or represented in Semantic MediaWiki. In most cases it will require an action
549	 * from an adminstrator when one of those keys are altered.
550	 */
551	public static function makeKey( $vars ) {
552
553		// Only recognize those properties that require a fixed table
554		$pageSpecialProperties = array_intersect(
555			// Special properties enabled?
556			$vars['smwgPageSpecialProperties'],
557
558			// Any custom fixed properties require their own table?
559			TypesRegistry::getFixedProperties( 'custom_fixed' )
560		);
561
562		$pageSpecialProperties = array_unique( $pageSpecialProperties );
563
564		// Sort to ensure the key contains the same order
565		sort( $vars['smwgFixedProperties'] );
566		sort( $pageSpecialProperties );
567
568		// The following settings influence the "shape" of the tables required
569		// therefore use the content to compute a key that reflects any
570		// changes to them
571		$components = [
572			$vars['smwgUpgradeKey'],
573			$vars['smwgDefaultStore'],
574			$vars['smwgFixedProperties'],
575			$vars['smwgEnabledFulltextSearch'],
576			$pageSpecialProperties
577		];
578
579		// Only add the key when it is different from the default setting
580		if ( $vars['smwgEntityCollation'] !== 'identity' ) {
581			$components += [ 'smwgEntityCollation' => $vars['smwgEntityCollation'] ];
582		}
583
584		if ( $vars['smwgFieldTypeFeatures'] !== false ) {
585			$components += [ 'smwgFieldTypeFeatures' => $vars['smwgFieldTypeFeatures'] ];
586		}
587
588		// Recognize when the version requirements change and force
589		// an update to be able to check the requirements
590		$components += Setup::MINIMUM_DB_VERSION;
591
592		return json_encode( $components );
593	}
594
595}