1: | <?php declare(strict_types=1); |
2: | |
3: | |
4: | |
5: | |
6: | |
7: | |
8: | |
9: | |
10: | |
11: | |
12: | |
13: | |
14: | use Module\Support\Webapps\App\Loader; |
15: | use Module\Support\Webapps\App\Type\Wordpress\DefineReplace; |
16: | use Module\Support\Webapps\App\Type\Wordpress\Wpcli; |
17: | use Module\Support\Webapps\ComposerWrapper; |
18: | use Module\Support\Webapps\DatabaseGenerator; |
19: | use Module\Support\Webapps\Git; |
20: | use Module\Support\Webapps\Messages; |
21: | use Module\Support\Webapps\MetaManager; |
22: | use Opcenter\Versioning; |
23: | |
24: | |
25: | |
26: | |
27: | |
28: | |
29: | |
30: | |
31: | class Wordpress_Module extends \Module\Support\Webapps |
32: | { |
33: | const APP_NAME = 'WordPress'; |
34: | const ASSET_SKIPLIST = '.wp-update-skip'; |
35: | |
36: | const VERSION_CHECK_URL = 'https://api.wordpress.org/core/version-check/1.7/'; |
37: | const PLUGIN_VERSION_CHECK_URL = 'https://api.wordpress.org/plugins/info/1.0/%plugin%.json'; |
38: | const THEME_VERSION_CHECK_URL = 'https://api.wordpress.org/themes/info/1.2/?action=theme_information&request[slug]=%theme%&request[fields][versions]=1'; |
39: | const DEFAULT_VERSION_LOCK = 'none'; |
40: | |
41: | protected $aclList = array( |
42: | 'min' => array( |
43: | 'wp-content', |
44: | '.htaccess', |
45: | 'wp-config.php' |
46: | ), |
47: | 'max' => array( |
48: | 'wp-content/uploads', |
49: | 'wp-content/cache', |
50: | 'wp-content/wflogs', |
51: | 'wp-content/updraft' |
52: | ) |
53: | ); |
54: | |
55: | |
56: | |
57: | |
58: | protected $controlFiles = [ |
59: | '/wp-admin/includes/file.php' |
60: | ]; |
61: | |
62: | |
63: | |
64: | |
65: | const NON_UPDATEABLE_TYPES = [ |
66: | 'dropin', |
67: | 'must-use' |
68: | ]; |
69: | |
70: | |
71: | |
72: | |
73: | |
74: | |
75: | |
76: | |
77: | |
78: | public function install(string $hostname, string $path = '', array $opts = array()): bool |
79: | { |
80: | if (!$this->mysql_enabled()) { |
81: | return error(Messages::ERR_INSTALL_MISSING_PREREQ, |
82: | ['what' => 'MySQL', 'app' => static::APP_NAME]); |
83: | } |
84: | |
85: | if (!$this->parseInstallOptions($opts, $hostname, $path)) { |
86: | return false; |
87: | } |
88: | |
89: | $docroot = $this->getDocumentRoot($hostname, $path); |
90: | |
91: | $ret = $this->execCommand( |
92: | $docroot, |
93: | 'core %(mode)s --version=%(version)s', |
94: | [ |
95: | 'mode' => 'download', |
96: | 'version' => $opts['version'], |
97: | 'user' => $opts['user'] |
98: | ] |
99: | ); |
100: | |
101: | if (!$ret['success']) { |
102: | return error( |
103: | Messages::ERR_APP_DOWNLOAD_FAILED, |
104: | [ |
105: | 'app' => static::APP_NAME, |
106: | 'version' => $opts['version'], |
107: | 'msg' => coalesce($ret['stdout'], $ret['stderr']) |
108: | ] |
109: | ); |
110: | } |
111: | |
112: | $dbCred = DatabaseGenerator::mysql($this->getAuthContext(), $hostname); |
113: | if (!$dbCred->create()) { |
114: | return false; |
115: | } |
116: | |
117: | if (!$this->generateNewConfiguration($hostname, $docroot, $dbCred)) { |
118: | info(Messages::MSG_CHECKPOINT_REMOVING_TEMP_FILES); |
119: | if (!array_get($opts, 'hold')) { |
120: | $this->file_delete($docroot, true); |
121: | $dbCred->rollback(); |
122: | } |
123: | return false; |
124: | } |
125: | |
126: | if (!isset($opts['title'])) { |
127: | $opts['title'] = 'A Random Blog for a Random Reason'; |
128: | } |
129: | |
130: | if (!isset($opts['password'])) { |
131: | $opts['password'] = \Opcenter\Auth\Password::generate(); |
132: | info(Messages::MSG_CHECKPOINT_GENERATED_PASSWORD, ['password' => $opts['password']]); |
133: | } |
134: | |
135: | info(Messages::MSG_CHECKPOINT_SET_USERNAME, ['user' => $this->username]); |
136: | |
137: | $fqdn = $this->web_normalize_hostname($hostname); |
138: | $opts['url'] = rtrim($fqdn . '/' . $path, '/'); |
139: | $args = array( |
140: | 'email' => $opts['email'], |
141: | 'mode' => 'install', |
142: | 'url' => $opts['url'], |
143: | 'title' => $opts['title'], |
144: | 'user' => $opts['user'], |
145: | 'password' => $opts['password'], |
146: | 'proto' => !empty($opts['ssl']) ? 'https://' : 'http://', |
147: | 'mysqli81' => 'function_exists("mysqli_report") && mysqli_report(0);' |
148: | ); |
149: | $ret = $this->execCommand($docroot, 'core %(mode)s --admin_email=%(email)s --skip-email ' . |
150: | '--url=%(proto)s%(url)s --title=%(title)s --admin_user=%(user)s --exec=%(mysqli81)s ' . |
151: | '--admin_password=%(password)s', $args); |
152: | if (!$ret['success']) { |
153: | if (!array_get($opts, 'hold')) { |
154: | $dbCred->rollback(); |
155: | } |
156: | return error(Messages::ERR_DATABASE_CREATION_FAILED, coalesce($ret['stderr'], $ret['stdout'])); |
157: | } |
158: | |
159: | |
160: | |
161: | |
162: | if (!file_exists($this->domain_fs_path() . "/${docroot}/.htaccess")) { |
163: | $this->file_touch("${docroot}/.htaccess"); |
164: | } |
165: | |
166: | $wpcli = Wpcli::instantiateContexted($this->getAuthContext()); |
167: | $wpcli->setConfiguration(['apache_modules' => ['mod_rewrite']]); |
168: | |
169: | $ret = $this->execCommand($docroot, "rewrite structure --hard '/%%postname%%/'"); |
170: | if (!$ret['success']) { |
171: | |
172: | return error('failed to set rewrite structure, error: %s', coalesce($ret['stderr'], $ret['stdout'])); |
173: | } |
174: | |
175: | if (!empty($opts['cache'])) { |
176: | if ($this->install_plugin($hostname, $path, 'w3-total-cache')) { |
177: | $wpcli->exec($docroot, 'w3-total-cache option set pgcache.enabled true --type=boolean'); |
178: | $wpcli->exec($docroot, 'w3-total-cache fix_environment'); |
179: | $httxt = preg_replace( |
180: | '/^\s*AddType\s+.*$[\r\n]?/mi', |
181: | '', |
182: | $this->file_get_file_contents($docroot . '/.htaccess') |
183: | ); |
184: | $this->file_put_file_contents($docroot . '/.htaccess', $httxt); |
185: | } else { |
186: | warn("Failed to install caching plugin - performance will be suboptimal"); |
187: | } |
188: | } |
189: | if (!$this->file_exists($docroot . '/wp-content/cache')) { |
190: | $this->file_create_directory($docroot . '/wp-content/cache'); |
191: | } |
192: | |
193: | $this->notifyInstalled($hostname, $path, $opts); |
194: | |
195: | return info(Messages::MSG_CHECKPOINT_APP_INSTALLED, ['app' => static::APP_NAME, 'email' => $opts['email']]); |
196: | } |
197: | |
198: | protected function execCommand(?string $path, string $cmd, array $args = [], array $env = []) |
199: | { |
200: | return Wpcli::instantiateContexted($this->getAuthContextFromDocroot($path ?? \Web_Module::MAIN_DOC_ROOT))->exec($path, $cmd, $args, $env); |
201: | } |
202: | |
203: | protected function generateNewConfiguration(string $domain, string $docroot, DatabaseGenerator $dbcredentials, array $ftpcredentials = array()): bool |
204: | { |
205: | |
206: | if (!isset($ftpcredentials['user'])) { |
207: | $ftpcredentials['user'] = $this->username . '@' . $this->domain; |
208: | } |
209: | if (!isset($ftpcredentials['host'])) { |
210: | $ftpcredentials['host'] = 'localhost'; |
211: | } |
212: | if (!isset($ftpcredentials['password'])) { |
213: | $ftpcredentials['password'] = ''; |
214: | } |
215: | $svc = \Opcenter\SiteConfiguration::shallow($this->getAuthContext()); |
216: | $xtraPHP = (string)(new \Opcenter\Provisioning\ConfigurationWriter('@webapp(wordpress)::templates.wp-config-extra', $svc))->compile([ |
217: | 'svc' => $svc, |
218: | 'afi' => $this->getApnscpFunctionInterceptor(), |
219: | 'db' => $dbcredentials, |
220: | 'ftp' => [ |
221: | 'username' => $ftpcredentials['user'], |
222: | 'hostname' => 'localhost', |
223: | 'password' => $ftpcredentials['password'] |
224: | ], |
225: | 'hostname' => $domain, |
226: | 'docroot' => $docroot |
227: | ]); |
228: | |
229: | $xtraphp = '<<EOF ' . "\n" . $xtraPHP . "\n" . 'EOF'; |
230: | $args = array( |
231: | 'mode' => 'config', |
232: | 'db' => $dbcredentials->database, |
233: | 'password' => $dbcredentials->password, |
234: | 'user' => $dbcredentials->username |
235: | ); |
236: | |
237: | $ret = $this->execCommand($docroot, |
238: | 'core %(mode)s --dbname=%(db)s --dbpass=%(password)s --dbuser=%(user)s --dbhost=localhost --extra-php ' . $xtraphp, |
239: | $args); |
240: | if (!$ret['success']) { |
241: | return error('failed to generate configuration, error: %s', coalesce($ret['stderr'], $ret['stdout'])); |
242: | } |
243: | |
244: | return true; |
245: | } |
246: | |
247: | |
248: | |
249: | |
250: | |
251: | |
252: | |
253: | |
254: | public function get_version(string $hostname, string $path = ''): ?string |
255: | { |
256: | if (!$this->valid($hostname, $path)) { |
257: | return null; |
258: | } |
259: | $docroot = $this->getAppRoot($hostname, $path); |
260: | $ret = $this->execCommand($docroot, 'core version'); |
261: | if (!$ret['success']) { |
262: | return null; |
263: | } |
264: | |
265: | return trim($ret['stdout']); |
266: | |
267: | } |
268: | |
269: | |
270: | |
271: | |
272: | |
273: | |
274: | |
275: | |
276: | public function valid(string $hostname, string $path = ''): bool |
277: | { |
278: | if ($hostname[0] === '/') { |
279: | $docroot = $hostname; |
280: | } else { |
281: | $docroot = $this->getAppRoot($hostname, $path); |
282: | if (!$docroot) { |
283: | return false; |
284: | } |
285: | } |
286: | |
287: | return $this->file_exists($docroot . '/wp-config.php') || $this->file_exists($docroot . '/wp-config-sample.php'); |
288: | } |
289: | |
290: | |
291: | |
292: | |
293: | |
294: | |
295: | |
296: | |
297: | |
298: | |
299: | public function fortify(string $hostname, string $path = '', string $mode = 'max', $args = []): bool |
300: | { |
301: | if (!parent::fortify($hostname, $path, $mode, $args)) { |
302: | return false; |
303: | } |
304: | |
305: | $docroot = $this->getAppRoot($hostname, $path); |
306: | if ($mode === 'min') { |
307: | |
308: | $this->shareOwnershipSystemCheck($docroot); |
309: | } else { |
310: | |
311: | $this->assertOwnershipSystemCheck($docroot); |
312: | } |
313: | |
314: | $this->setFsMethod($docroot, $mode); |
315: | |
316: | return true; |
317: | } |
318: | |
319: | |
320: | |
321: | |
322: | |
323: | |
324: | |
325: | |
326: | protected function setFsMethod(string $approot, $mode): bool |
327: | { |
328: | $method = \in_array($mode, [false, 'learn', 'write', null ], true) ? 'direct' : false; |
329: | return $this->updateConfiguration($approot, ['FS_METHOD' => $method]); |
330: | } |
331: | |
332: | |
333: | |
334: | |
335: | |
336: | |
337: | |
338: | |
339: | protected function updateConfiguration(string $approot, array $pairs): bool |
340: | { |
341: | $file = $approot . '/wp-config.php'; |
342: | try { |
343: | $instance = DefineReplace::instantiateContexted($this->getAuthContext(), [$file]); |
344: | foreach ($pairs as $k => $v) { |
345: | $instance->set($k, $v); |
346: | } |
347: | return $instance->save(); |
348: | } catch (\PhpParser\Error $e) { |
349: | return warn("Failed parsing %(file)s - cannot update %(directive)s", |
350: | ['file' => $file, 'directive' => 'FS_METHOD']); |
351: | } catch (\ArgumentError $e) { |
352: | return warn("Failed parsing %(file)s - does not exist"); |
353: | } |
354: | |
355: | return false; |
356: | } |
357: | |
358: | |
359: | |
360: | |
361: | |
362: | |
363: | |
364: | protected function shareOwnershipSystemCheck(string $docroot): int |
365: | { |
366: | $changed = 0; |
367: | $options = $this->getOptions($docroot); |
368: | if (!array_get($options, 'fortify', 'min')) { |
369: | return $changed; |
370: | } |
371: | $user = array_get($options, 'user', $this->getDocrootUser($docroot)); |
372: | $webuser = $this->web_get_user($docroot); |
373: | foreach ($this->controlFiles as $file) { |
374: | $path = $docroot . $file; |
375: | if (!file_exists($this->domain_fs_path() . $path)) { |
376: | continue; |
377: | } |
378: | $this->file_chown($path, $webuser); |
379: | $this->file_set_acls($path, $user, 6); |
380: | $changed++; |
381: | } |
382: | |
383: | return $changed; |
384: | } |
385: | |
386: | |
387: | |
388: | |
389: | |
390: | |
391: | |
392: | protected function assertOwnershipSystemCheck(string $docroot): int |
393: | { |
394: | $changed = 0; |
395: | $options = $this->getOptions($docroot); |
396: | $user = array_get($options, 'user', $this->getDocrootUser($docroot)); |
397: | foreach ($this->controlFiles as $file) { |
398: | $path = $docroot . $file; |
399: | if (!file_exists($this->domain_fs_path() . $path)) { |
400: | continue; |
401: | } |
402: | $this->file_chown($path, $user); |
403: | $changed++; |
404: | } |
405: | |
406: | return $changed; |
407: | } |
408: | |
409: | |
410: | |
411: | |
412: | |
413: | |
414: | |
415: | |
416: | |
417: | public function plugin_status(string $hostname, string $path = '', string $plugin = null) |
418: | { |
419: | $docroot = $this->getAppRoot($hostname, $path); |
420: | if (!$docroot) { |
421: | return error('invalid WP location'); |
422: | } |
423: | |
424: | $matches = $this->assetListWrapper($docroot, 'plugin', [ |
425: | 'name', |
426: | 'status', |
427: | 'version', |
428: | 'update_version' |
429: | ]); |
430: | |
431: | if (!$matches) { |
432: | return false; |
433: | } |
434: | |
435: | $pluginmeta = []; |
436: | |
437: | foreach ($matches as $match) { |
438: | if (\in_array($match['status'], self::NON_UPDATEABLE_TYPES , true)) { |
439: | continue; |
440: | } |
441: | $name = $match['name']; |
442: | $version = $match['version']; |
443: | |
444: | if (empty($version)) { |
445: | warn([':msg_wordpress_asset_versionless', "Theme or plugin `%(name)s' is versionless"], |
446: | ['name' => $name]); |
447: | } |
448: | |
449: | if (!$versions = $this->pluginVersions($name)) { |
450: | |
451: | if (empty($match['update_version'])) { |
452: | $match['update_version'] = $match['version']; |
453: | } |
454: | |
455: | $versions = array_filter([$version, $match['update_version']]); |
456: | } |
457: | $pluginmeta[$name] = [ |
458: | 'version' => $version, |
459: | 'next' => Versioning::nextVersion($versions, (string)$version), |
460: | 'max' => (string)($this->pluginInfo($name)['version'] ?? end($versions)), |
461: | 'active' => $match['status'] !== 'inactive' |
462: | ]; |
463: | |
464: | $pluginmeta[$name]['current'] = version_compare((string)array_get($pluginmeta, "${name}.max", |
465: | '99999999.999'), (string)$version, '<=') ?: |
466: | (bool)Versioning::current($versions, $version); |
467: | } |
468: | |
469: | return $plugin ? $pluginmeta[$plugin] ?? error("unknown plugin `%s'", $plugin) : $pluginmeta; |
470: | } |
471: | |
472: | protected function assetListWrapper(string $approot, string $type, array $fields): ?array { |
473: | $ret = $this->execCommand($approot, |
474: | $type . ' list --format=json --fields=%s', [implode(',', $fields)]); |
475: | |
476: | |
477: | $line = strtok($ret['stdout'], "\n"); |
478: | do { |
479: | if ($line[0] === '[') { |
480: | break; |
481: | } |
482: | } while (false !== ($line = strtok("\n"))); |
483: | if (!$ret['success']) { |
484: | error('failed to get %s status: %s', $type, coalesce($ret['stderr'], $ret['stdout'])); |
485: | return null; |
486: | } |
487: | |
488: | if (null === ($matches = json_decode(str_replace(':""', ':null', $ret['stdout']), true))) { |
489: | dlog('Failed decode results: %s', var_export($ret, true)); |
490: | return nerror('Failed to decode %s output', $type); |
491: | } |
492: | |
493: | return $matches; |
494: | } |
495: | |
496: | protected function pluginVersions(string $plugin): ?array |
497: | { |
498: | $info = $this->pluginInfo($plugin); |
499: | if (!$info || empty($info['versions'])) { |
500: | return null; |
501: | } |
502: | array_forget($info, 'versions.trunk'); |
503: | |
504: | return array_keys($info['versions']); |
505: | } |
506: | |
507: | |
508: | |
509: | |
510: | |
511: | |
512: | |
513: | protected function pluginInfo(string $plugin): array |
514: | { |
515: | $cache = \Cache_Super_Global::spawn(); |
516: | $key = 'wp.pinfo-' . $plugin; |
517: | if (false !== ($data = $cache->get($key))) { |
518: | return $data; |
519: | } |
520: | $url = str_replace('%plugin%', $plugin, static::PLUGIN_VERSION_CHECK_URL); |
521: | $info = []; |
522: | $contents = silence(static function() use($url) { |
523: | return file_get_contents($url); |
524: | }); |
525: | if (false !== $contents) { |
526: | $info = (array)json_decode($contents, true); |
527: | if (isset($info['versions'])) { |
528: | uksort($info['versions'], 'version_compare'); |
529: | } |
530: | } else { |
531: | info("Plugin `%s' detected as commercial. Using transient data.", $plugin); |
532: | } |
533: | $cache->set($key, $info, 86400); |
534: | |
535: | return $info; |
536: | } |
537: | |
538: | |
539: | |
540: | |
541: | |
542: | |
543: | |
544: | |
545: | |
546: | |
547: | public function install_plugin( |
548: | string $hostname, |
549: | string $path, |
550: | string $plugin, |
551: | string $version = '' |
552: | ): bool { |
553: | $docroot = $this->getAppRoot($hostname, $path); |
554: | if (!$docroot) { |
555: | return error('invalid WP location'); |
556: | } |
557: | |
558: | $args = array( |
559: | 'plugin' => $plugin |
560: | ); |
561: | $cmd = 'plugin install %(plugin)s --activate'; |
562: | if ($version) { |
563: | $cmd .= ' --version=%(version)s'; |
564: | $args['version'] = $version; |
565: | } |
566: | |
567: | $ret = $this->execCommand( |
568: | $docroot, |
569: | $cmd, |
570: | $args, |
571: | [ |
572: | 'REQUEST_URI' => '/' . rtrim($path) |
573: | ] |
574: | ); |
575: | if (!$ret['success']) { |
576: | return error("failed to install plugin `%s': %s", $plugin, coalesce($ret['stderr'], $ret['stdout'])); |
577: | } |
578: | info("installed plugin `%s'", $plugin); |
579: | |
580: | return true; |
581: | } |
582: | |
583: | |
584: | |
585: | |
586: | |
587: | |
588: | |
589: | |
590: | |
591: | |
592: | public function uninstall_plugin(string $hostname, string $path, string $plugin, bool $force = false): bool |
593: | { |
594: | $docroot = $this->getAppRoot($hostname, $path); |
595: | if (!$docroot) { |
596: | return error('invalid WP location'); |
597: | } |
598: | |
599: | $args = array( |
600: | 'plugin' => $plugin |
601: | ); |
602: | $cmd = 'plugin uninstall %(plugin)s'; |
603: | if ($force) { |
604: | $cmd .= ' --deactivate'; |
605: | } |
606: | $ret = $this->execCommand($docroot, $cmd, $args); |
607: | |
608: | if (!$ret['stdout'] || !strncmp($ret['stdout'], 'Warning:', strlen('Warning:'))) { |
609: | return error("failed to uninstall plugin `%s': %s", $plugin, coalesce($ret['stderr'], $ret['stdout'])); |
610: | } |
611: | info("uninstalled plugin `%s'", $plugin); |
612: | |
613: | return true; |
614: | } |
615: | |
616: | |
617: | |
618: | |
619: | |
620: | |
621: | |
622: | |
623: | |
624: | public function disable_plugin(string $hostname, string $path, string $plugin): bool |
625: | { |
626: | $docroot = $this->getAppRoot($hostname, $path); |
627: | if (!$docroot) { |
628: | return error('invalid WP location'); |
629: | } |
630: | |
631: | return $this->assetManagerWrapper($docroot, 'plugin', 'deactivate', $plugin); |
632: | } |
633: | |
634: | |
635: | |
636: | |
637: | |
638: | |
639: | |
640: | |
641: | |
642: | public function enable_plugin(string $hostname, string $path, string $plugin): bool |
643: | { |
644: | $docroot = $this->getAppRoot($hostname, $path); |
645: | if (!$docroot) { |
646: | return error('invalid WP location'); |
647: | } |
648: | |
649: | return $this->assetManagerWrapper($docroot, 'plugin', 'activate', $plugin); |
650: | } |
651: | |
652: | |
653: | |
654: | |
655: | |
656: | |
657: | |
658: | |
659: | |
660: | public function disable_theme(string $hostname, string $path, string $plugin): bool |
661: | { |
662: | $docroot = $this->getAppRoot($hostname, $path); |
663: | if (!$docroot) { |
664: | return error('invalid WP location'); |
665: | } |
666: | |
667: | return $this->assetManagerWrapper($docroot, 'theme', 'disable', $plugin); |
668: | } |
669: | |
670: | |
671: | |
672: | |
673: | |
674: | |
675: | |
676: | |
677: | |
678: | public function enable_theme(string $hostname, string $path, string $plugin): bool |
679: | { |
680: | $docroot = $this->getAppRoot($hostname, $path); |
681: | if (!$docroot) { |
682: | return error('invalid WP location'); |
683: | } |
684: | |
685: | return $this->assetManagerWrapper($docroot, 'theme', 'activate', $plugin); |
686: | } |
687: | |
688: | private function assetManagerWrapper(string $docroot, string $type, string $mode, string $asset): bool |
689: | { |
690: | $ret = $this->execCommand($docroot, '%s %s %s', [$type, $mode, $asset]); |
691: | |
692: | return $ret['success'] ?: error("Failed to %(mode)s `%(asset)s': %(err)s", [ |
693: | 'mode' => $mode, 'asset' => $asset, 'err' => coalesce($ret['stderr'], $ret['stdout']) |
694: | ]); |
695: | } |
696: | |
697: | |
698: | |
699: | |
700: | |
701: | |
702: | |
703: | |
704: | |
705: | |
706: | |
707: | public function uninstall_theme(string $hostname, string $path, string $theme, bool $force = false): bool |
708: | { |
709: | $docroot = $this->getAppRoot($hostname, $path); |
710: | if (!$docroot) { |
711: | return error('invalid WP location'); |
712: | } |
713: | |
714: | $args = array( |
715: | 'theme' => $theme |
716: | ); |
717: | if ($force) { |
718: | warn('Force parameter unused - deactivate theme first through WP panel if necessary'); |
719: | } |
720: | $cmd = 'theme uninstall %(theme)s'; |
721: | $ret = $this->execCommand($docroot, $cmd, $args); |
722: | |
723: | if (!$ret['stdout'] || !strncmp($ret['stdout'], 'Warning:', strlen('Warning:'))) { |
724: | return error("failed to uninstall plugin `%s': %s", $theme, coalesce($ret['stderr'], $ret['stdout'])); |
725: | } |
726: | info("uninstalled theme `%s'", $theme); |
727: | |
728: | return true; |
729: | } |
730: | |
731: | |
732: | |
733: | |
734: | |
735: | |
736: | |
737: | |
738: | public function disable_all_plugins(string $hostname, string $path = ''): bool |
739: | { |
740: | $docroot = $this->getAppRoot($hostname, $path); |
741: | if (!$docroot) { |
742: | return error('failed to determine path'); |
743: | } |
744: | |
745: | $ret = $this->execCommand($docroot, 'plugin deactivate --all --skip-plugins'); |
746: | if (!$ret['success']) { |
747: | return error('failed to deactivate all plugins: %s', coalesce($ret['stderr'], $ret['stdout'])); |
748: | } |
749: | |
750: | return info('plugin deactivation successful: %s', $ret['stdout']); |
751: | } |
752: | |
753: | |
754: | |
755: | |
756: | |
757: | |
758: | |
759: | |
760: | |
761: | public function uninstall(string $hostname, string $path = '', string $delete = 'all'): bool |
762: | { |
763: | return parent::uninstall($hostname, $path, $delete); |
764: | } |
765: | |
766: | |
767: | |
768: | |
769: | |
770: | |
771: | |
772: | |
773: | public function db_config(string $hostname, string $path = '') |
774: | { |
775: | $docroot = $this->getAppRoot($hostname, $path); |
776: | if (!$docroot) { |
777: | return error('failed to determine WP'); |
778: | } |
779: | $code = 'ob_start(); register_shutdown_function(static function() { global $table_prefix; file_put_contents("php://fd/3", serialize(array("user" => DB_USER, "password" => DB_PASSWORD, "db" => DB_NAME, "host" => DB_HOST, "prefix" => $table_prefix))); ob_get_level() && ob_clean(); die(); }); include("./wp-config.php"); die();'; |
780: | $ret = \Module\Support\Webapps\PhpWrapper::instantiateContexted($this->getAuthContextFromDocroot($docroot))->exec( |
781: | $docroot, '-r %(code)s 3>&1-', ['code' => $code], |
782: | ); |
783: | |
784: | if (empty($ret['stdout']) && !$ret['success']) { |
785: | return error("failed to obtain WP configuration for `%s': %s", $docroot, $ret['stderr']); |
786: | } |
787: | |
788: | return \Util_PHP::unserialize(trim($ret['stdout'])); |
789: | } |
790: | |
791: | |
792: | |
793: | |
794: | |
795: | |
796: | |
797: | |
798: | |
799: | |
800: | |
801: | |
802: | |
803: | |
804: | public function change_admin(string $hostname, string $path, array $fields): bool |
805: | { |
806: | $docroot = $this->getAppRoot($hostname, $path); |
807: | if (!$docroot) { |
808: | return warn('failed to change administrator information'); |
809: | } |
810: | $admin = $this->get_admin($hostname, $path); |
811: | |
812: | if (!$admin) { |
813: | return error('cannot determine admin of WP install'); |
814: | } |
815: | |
816: | if (isset($fields['user_login'])) { |
817: | return error('user login field cannot be changed in WP'); |
818: | } |
819: | |
820: | $args = array( |
821: | 'user' => $admin |
822: | ); |
823: | $cmd = 'user update %(user)s'; |
824: | foreach ($fields as $k => $v) { |
825: | $cmd .= ' --' . $k . '=%(' . $k . ')s'; |
826: | $args[$k] = $v; |
827: | } |
828: | |
829: | $ret = $this->execCommand($docroot, $cmd, $args); |
830: | if (!$ret['success']) { |
831: | return error("failed to update admin `%s', error: %s", |
832: | $admin, |
833: | coalesce($ret['stderr'], $ret['stdout']) |
834: | ); |
835: | } |
836: | |
837: | return $ret['success']; |
838: | } |
839: | |
840: | |
841: | |
842: | |
843: | |
844: | |
845: | |
846: | |
847: | public function get_admin(string $hostname, string $path = ''): ?string |
848: | { |
849: | $docroot = $this->getAppRoot($hostname, $path); |
850: | $ret = $this->execCommand($docroot, 'user list --role=administrator --field=user_login'); |
851: | if (!$ret['success'] || !$ret['stdout']) { |
852: | warn('failed to enumerate WP administrative users'); |
853: | |
854: | return null; |
855: | } |
856: | |
857: | return strtok($ret['stdout'], "\r\n"); |
858: | } |
859: | |
860: | |
861: | |
862: | |
863: | |
864: | |
865: | |
866: | |
867: | |
868: | public function update_all(string $hostname, string $path = '', string $version = null): bool |
869: | { |
870: | $docroot = $this->getAppRoot($hostname, $path); |
871: | if (is_dir($this->domain_fs_path($docroot . '/wp-content/upgrade'))) { |
872: | |
873: | |
874: | $ctx = null; |
875: | $stat = $this->file_stat($docroot); |
876: | if (!$stat || !$this->file_set_acls($docroot . '/wp-content/upgrade', [ |
877: | [$stat['owner'] => 'rwx'], |
878: | [$stat['owner'] => 'drwx'] |
879: | ], File_Module::ACL_MODE_RECURSIVE)) { |
880: | warn('Failed to apply ACLs for %s/wp-content/upgrade. WP update may fail', $docroot); |
881: | } |
882: | } |
883: | $ret = ($this->update_themes($hostname, $path) && $this->update_plugins($hostname, $path) && |
884: | $this->update($hostname, $path, $version)) || error('failed to update all components'); |
885: | |
886: | $this->setInfo($this->getDocumentRoot($hostname, $path), [ |
887: | 'version' => $this->get_version($hostname, $path), |
888: | 'failed' => !$ret |
889: | ]); |
890: | |
891: | return $ret; |
892: | } |
893: | |
894: | |
895: | |
896: | |
897: | |
898: | |
899: | |
900: | |
901: | |
902: | |
903: | private function getNextVersionFromAsset(string $name, array $assetInfo, string $lock, string $type): ?string |
904: | { |
905: | if (!isset($assetInfo['version'])) { |
906: | error("Unable to query version for %s `%s', ignoring. Asset info: %s", |
907: | ucwords($type), |
908: | $name, |
909: | var_export($assetInfo, true) |
910: | ); |
911: | |
912: | return null; |
913: | } |
914: | |
915: | $version = $assetInfo['version']; |
916: | $versions = $this->{$type . 'Versions'}($name) ?? [$assetInfo['version'], $assetInfo['max']]; |
917: | $next = $this->windThroughVersions($version, $lock, $versions); |
918: | if ($next === null && end($versions) !== $version) { |
919: | info("%s `%s' already at maximal version `%s' for lock spec `%s'. " . |
920: | 'Newer versions available. Manually upgrade or disable version lock to ' . |
921: | 'update this component.', |
922: | ucwords($type), $name, $version, $lock |
923: | ); |
924: | } |
925: | |
926: | return $next; |
927: | } |
928: | |
929: | |
930: | |
931: | |
932: | |
933: | |
934: | |
935: | |
936: | |
937: | private function windThroughVersions(string $cur, ?string $lock, array $versions): ?string |
938: | { |
939: | $maximal = $tmp = $cur; |
940: | do { |
941: | $tmp = $maximal; |
942: | $maximal = Versioning::nextSemanticVersion( |
943: | $tmp, |
944: | $versions, |
945: | $lock |
946: | ); |
947: | } while ($maximal && $tmp !== $maximal); |
948: | |
949: | if ($maximal === $cur) { |
950: | return null; |
951: | } |
952: | |
953: | return $maximal; |
954: | } |
955: | |
956: | |
957: | |
958: | |
959: | |
960: | |
961: | |
962: | |
963: | |
964: | public function update_themes(string $hostname, string $path = '', array $themes = array()): bool |
965: | { |
966: | $docroot = $this->getAppRoot($hostname, $path); |
967: | if (!$docroot) { |
968: | return error('update failed'); |
969: | } |
970: | $flags = []; |
971: | $lock = $this->getVersionLock($docroot); |
972: | $skiplist = $this->getSkiplist($docroot, 'theme'); |
973: | |
974: | if (!$skiplist && !$themes && !$lock) { |
975: | $ret = $this->execCommand($docroot, 'theme update --all ' . implode(' ', $flags)); |
976: | if (!$ret['success']) { |
977: | return error("theme update failed: `%s'", coalesce($ret['stderr'], $ret['stdout'])); |
978: | } |
979: | |
980: | return $ret['success']; |
981: | } |
982: | |
983: | $status = 1; |
984: | if (false === ($allthemeinfo = $this->theme_status($hostname, $path))) { |
985: | return false; |
986: | } |
987: | $themes = $themes ?: array_keys($allthemeinfo); |
988: | foreach ($themes as $theme) { |
989: | $version = null; |
990: | $name = $theme['name'] ?? $theme; |
991: | $themeInfo = $allthemeinfo[$name]; |
992: | if ((isset($skiplist[$name]) || $themeInfo['current']) && !array_get((array)$theme, 'force')) { |
993: | continue; |
994: | } |
995: | |
996: | if (isset($theme['version'])) { |
997: | $version = $theme['version']; |
998: | } else if ($lock && !($version = $this->getNextVersionFromAsset($name, $themeInfo, $lock, 'theme'))) { |
999: | |
1000: | continue; |
1001: | } |
1002: | |
1003: | $cmd = 'theme update %(name)s'; |
1004: | $args = [ |
1005: | 'name' => $name |
1006: | ]; |
1007: | |
1008: | |
1009: | |
1010: | |
1011: | |
1012: | |
1013: | $cmdTmp = $cmd; |
1014: | if ($version) { |
1015: | $cmd .= ' --version=%(version)s'; |
1016: | $args['version'] = $version; |
1017: | } |
1018: | |
1019: | $cmd .= ' ' . implode(' ', $flags); |
1020: | $ret = $this->execCommand($docroot, $cmd, $args); |
1021: | |
1022: | if (!$ret['success'] && $version) { |
1023: | warn( |
1024: | "Update failed for %s, falling back to versionless update: %s", |
1025: | $name, |
1026: | coalesce($ret['stderr'], $ret['stdout']) |
1027: | ); |
1028: | $cmdTmp .= ' ' . implode(' ', $flags); |
1029: | $ret = $this->execCommand($docroot, $cmdTmp, $args); |
1030: | } |
1031: | |
1032: | if (!$ret['success']) { |
1033: | error("failed to update theme `%s': %s", $name, coalesce($ret['stderr'], $ret['stdout'])); |
1034: | } |
1035: | $status &= $ret['success']; |
1036: | } |
1037: | |
1038: | return (bool)$status; |
1039: | } |
1040: | |
1041: | |
1042: | |
1043: | |
1044: | |
1045: | |
1046: | |
1047: | |
1048: | protected function getSkiplist(string $docroot, ?string $type) |
1049: | { |
1050: | if ($type !== null && $type !== 'plugin' && $type !== 'theme') { |
1051: | error("Unrecognized skiplist type `%s'", $type); |
1052: | |
1053: | return []; |
1054: | } |
1055: | $skiplist = $this->skiplistContents($docroot); |
1056: | |
1057: | return array_flip(array_filter(array_map(static function ($line) use ($type) { |
1058: | if (false !== ($pos = strpos($line, ':'))) { |
1059: | if (!$type || strpos($line, $type . ':') === 0) { |
1060: | return substr($line, $pos + 1); |
1061: | } |
1062: | |
1063: | return; |
1064: | } |
1065: | |
1066: | return $line; |
1067: | }, $skiplist))); |
1068: | } |
1069: | |
1070: | private function skiplistContents(string $approot): array |
1071: | { |
1072: | $skipfile = $this->domain_fs_path($approot . '/' . self::ASSET_SKIPLIST); |
1073: | if (!file_exists($skipfile)) { |
1074: | return []; |
1075: | } |
1076: | |
1077: | return (array)file($skipfile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES); |
1078: | } |
1079: | |
1080: | |
1081: | |
1082: | |
1083: | |
1084: | |
1085: | |
1086: | |
1087: | |
1088: | public function update_plugins(string $hostname, string $path = '', array $plugins = array()): bool |
1089: | { |
1090: | $docroot = $this->getAppRoot($hostname, $path); |
1091: | if (!$docroot) { |
1092: | return error('update failed'); |
1093: | } |
1094: | $flags = []; |
1095: | $lock = $this->getVersionLock($docroot); |
1096: | $skiplist = $this->getSkiplist($docroot, 'plugin'); |
1097: | |
1098: | if (!$plugins && !$skiplist && !$lock) { |
1099: | $ret = $this->execCommand($docroot, 'plugin update --all ' . implode(' ', $flags)); |
1100: | if (!$ret['success']) { |
1101: | return error("plugin update failed: `%s'", coalesce($ret['stderr'], $ret['stdout'])); |
1102: | } |
1103: | |
1104: | return $ret['success']; |
1105: | } |
1106: | |
1107: | $status = 1; |
1108: | if (false === ($allplugininfo = $this->plugin_status($hostname, $path))) { |
1109: | return false; |
1110: | } |
1111: | $plugins = $plugins ?: array_keys($allplugininfo); |
1112: | foreach ($plugins as $plugin) { |
1113: | |
1114: | $version = null; |
1115: | $name = $plugin['name'] ?? $plugin; |
1116: | $pluginInfo = $allplugininfo[$name]; |
1117: | if ((isset($skiplist[$name]) || $pluginInfo['current']) && !array_get((array)$plugin, 'force')) { |
1118: | continue; |
1119: | } |
1120: | |
1121: | if (isset($plugin['version'])) { |
1122: | $version = $plugin['version']; |
1123: | } else if ($lock && !($version = $this->getNextVersionFromAsset($name, $pluginInfo, $lock, 'plugin'))) { |
1124: | |
1125: | continue; |
1126: | } |
1127: | |
1128: | $cmd = 'plugin update %(name)s'; |
1129: | $args = [ |
1130: | 'name' => $name |
1131: | ]; |
1132: | |
1133: | |
1134: | |
1135: | |
1136: | |
1137: | |
1138: | |
1139: | $cmdTmp = $cmd; |
1140: | if ($version) { |
1141: | $cmd .= ' --version=%(version)s'; |
1142: | $args['version'] = $version; |
1143: | } |
1144: | $cmd .= ' ' . implode(' ', $flags); |
1145: | $ret = $this->execCommand($docroot, $cmd, $args); |
1146: | |
1147: | if (!$ret['success'] && $version) { |
1148: | warn( |
1149: | "Update failed for %s, falling back to versionless update: %s", |
1150: | $name, |
1151: | coalesce($ret['stderr'], $ret['stdout']) |
1152: | ); |
1153: | $cmdTmp .= ' ' . implode(' ', $flags); |
1154: | $ret = $this->execCommand($docroot, $cmdTmp, $args); |
1155: | } |
1156: | |
1157: | if (!$ret['success']) { |
1158: | error("failed to update plugin `%s': %s", $name, coalesce($ret['stderr'], $ret['stdout'])); |
1159: | } |
1160: | $status &= $ret['success']; |
1161: | } |
1162: | |
1163: | return (bool)$status; |
1164: | } |
1165: | |
1166: | |
1167: | |
1168: | |
1169: | |
1170: | |
1171: | |
1172: | |
1173: | |
1174: | public function update(string $hostname, string $path = '', string $version = null): bool |
1175: | { |
1176: | $docroot = $this->getAppRoot($hostname, $path); |
1177: | if (!$docroot) { |
1178: | return error('update failed'); |
1179: | } |
1180: | $this->assertOwnershipSystemCheck($docroot); |
1181: | |
1182: | $cmd = 'core update'; |
1183: | $args = []; |
1184: | |
1185: | if ($version) { |
1186: | if (!is_scalar($version) || strcspn($version, '.0123456789')) { |
1187: | return error('invalid version number, %s', $version); |
1188: | } |
1189: | $cmd .= ' --version=%(version)s'; |
1190: | $args['version'] = $version; |
1191: | |
1192: | $ret = $this->execCommand($docroot, 'option get WPLANG'); |
1193: | if (trim($ret['stdout']) === 'en') { |
1194: | |
1195: | |
1196: | warn('Bugged WPLANG setting. Changing en to en_US'); |
1197: | $this->execCommand($docroot, 'site switch-language en_US'); |
1198: | } |
1199: | } |
1200: | |
1201: | $oldversion = $this->get_version($hostname, $path); |
1202: | $ret = $this->execCommand($docroot, $cmd, $args); |
1203: | |
1204: | if (!$ret['success']) { |
1205: | $output = coalesce($ret['stderr'], $ret['stdout']); |
1206: | if (str_starts_with($output, 'Error: Download failed.')) { |
1207: | return warn('Failed to fetch update - retry update later: %s', $output); |
1208: | } |
1209: | |
1210: | return error("update failed: `%s'", coalesce($ret['stderr'], $ret['stdout'])); |
1211: | } |
1212: | |
1213: | |
1214: | if ($oldversion === $this->get_version($hostname, $path) && |
1215: | !$this->is_current($oldversion, Versioning::asMajor($oldversion))) { |
1216: | return error('Failed to update WordPress - old version is same as new version - %s! ' . |
1217: | 'Diagnostics: (stderr) %s (stdout) %s', $oldversion, $ret['stderr'], $ret['stdout']); |
1218: | } |
1219: | |
1220: | info('updating WP database if necessary'); |
1221: | $ret = $this->execCommand($docroot, 'core update-db'); |
1222: | $this->shareOwnershipSystemCheck($docroot); |
1223: | |
1224: | if (!$ret['success']) { |
1225: | return warn('failed to update WP database - ' . |
1226: | 'login to WP admin panel to manually perform operation'); |
1227: | } |
1228: | |
1229: | return $ret['success']; |
1230: | } |
1231: | |
1232: | |
1233: | |
1234: | |
1235: | |
1236: | |
1237: | |
1238: | |
1239: | |
1240: | |
1241: | |
1242: | |
1243: | |
1244: | |
1245: | |
1246: | |
1247: | |
1248: | |
1249: | |
1250: | public function theme_status(string $hostname, string $path = '', string $theme = null) |
1251: | { |
1252: | $docroot = $this->getAppRoot($hostname, $path); |
1253: | if (!$docroot) { |
1254: | return error('invalid WP location'); |
1255: | } |
1256: | |
1257: | $matches = $this->assetListWrapper($docroot, 'theme', [ |
1258: | 'name', |
1259: | 'status', |
1260: | 'version', |
1261: | 'update_version' |
1262: | ]); |
1263: | |
1264: | if (!$matches) { |
1265: | return false; |
1266: | } |
1267: | |
1268: | $themes = []; |
1269: | foreach ($matches as $match) { |
1270: | if (\in_array($match['status'], self::NON_UPDATEABLE_TYPES, true)) { |
1271: | continue; |
1272: | } |
1273: | $name = $match['name']; |
1274: | $version = $match['version']; |
1275: | if (empty($version)) { |
1276: | warn([':msg_wordpress_asset_versionless', "Theme or plugin `%(name)s' is versionless"], ['name' => $name]); |
1277: | } |
1278: | if (!$versions = $this->themeVersions($name)) { |
1279: | |
1280: | if (empty($match['update_version'])) { |
1281: | $match['update_version'] = $match['version']; |
1282: | } |
1283: | |
1284: | $versions = array_filter([$version, $match['update_version']]); |
1285: | } |
1286: | |
1287: | $themes[$name] = [ |
1288: | 'version' => $version, |
1289: | 'next' => Versioning::nextVersion($versions, (string)$version), |
1290: | 'max' => (string)($this->themeInfo($name)['version'] ?? end($versions)) |
1291: | ]; |
1292: | |
1293: | $themes[$name]['current'] = version_compare((string)array_get($themes, "${name}.max", |
1294: | '99999999.999'), (string)$version, '<=') ?: |
1295: | (bool)Versioning::current($versions, $version); |
1296: | } |
1297: | |
1298: | return $theme ? $themes[$theme] ?? error("unknown theme `%s'", $theme) : $themes; |
1299: | } |
1300: | |
1301: | |
1302: | |
1303: | |
1304: | |
1305: | |
1306: | |
1307: | protected function themeVersions($theme): ?array |
1308: | { |
1309: | $info = $this->themeInfo($theme); |
1310: | if (!$info || empty($info['versions'])) { |
1311: | return null; |
1312: | } |
1313: | array_forget($info, 'versions.trunk'); |
1314: | |
1315: | return array_keys($info['versions']); |
1316: | } |
1317: | |
1318: | |
1319: | |
1320: | |
1321: | |
1322: | |
1323: | |
1324: | protected function themeInfo(string $theme): ?array |
1325: | { |
1326: | $cache = \Cache_Super_Global::spawn(); |
1327: | $key = 'wp.tinfo-' . $theme; |
1328: | if (false !== ($data = $cache->get($key))) { |
1329: | return $data; |
1330: | } |
1331: | $url = str_replace('%theme%', $theme, static::THEME_VERSION_CHECK_URL); |
1332: | $info = []; |
1333: | $contents = silence(static function () use ($url) { |
1334: | return file_get_contents($url); |
1335: | }); |
1336: | if (false !== $contents) { |
1337: | $info = (array)json_decode($contents, true); |
1338: | if (isset($info['versions'])) { |
1339: | uksort($info['versions'], 'version_compare'); |
1340: | } |
1341: | } else { |
1342: | info("Theme `%s' detected as commercial. Using transient data.", $theme); |
1343: | } |
1344: | $cache->set($key, $info, 86400); |
1345: | |
1346: | return $info; |
1347: | } |
1348: | |
1349: | public function install_theme(string $hostname, string $path, string $theme, string $version = null): bool |
1350: | { |
1351: | $docroot = $this->getAppRoot($hostname, $path); |
1352: | if (!$docroot) { |
1353: | return error('invalid WP location'); |
1354: | } |
1355: | |
1356: | $args = array( |
1357: | 'theme' => $theme |
1358: | ); |
1359: | $cmd = 'theme install %(theme)s --activate'; |
1360: | if ($version) { |
1361: | $cmd .= ' --version=%(version)s'; |
1362: | $args['version'] = $version; |
1363: | } |
1364: | $ret = $this->execCommand($docroot, $cmd, $args); |
1365: | if (!$ret['success']) { |
1366: | return error("failed to install theme `%s': %s", $theme, coalesce($ret['stderr'], $ret['stdout'])); |
1367: | } |
1368: | info("installed theme `%s'", $theme); |
1369: | |
1370: | return true; |
1371: | } |
1372: | |
1373: | |
1374: | |
1375: | |
1376: | |
1377: | |
1378: | |
1379: | |
1380: | |
1381: | public function unfortify(string $hostname, string $path = ''): bool |
1382: | { |
1383: | return parent::unfortify($hostname, $path) && $this->setFsMethod($this->getAppRoot($hostname, $path), false); |
1384: | } |
1385: | |
1386: | |
1387: | |
1388: | |
1389: | |
1390: | |
1391: | |
1392: | public function _housekeeping() |
1393: | { |
1394: | if (file_exists(Wpcli::BIN) && filemtime(Wpcli::BIN) < filemtime(__FILE__)) { |
1395: | unlink(Wpcli::BIN); |
1396: | } |
1397: | |
1398: | if (!file_exists(Wpcli::BIN)) { |
1399: | $url = Wpcli::DOWNLOAD_URL; |
1400: | $tmp = tempnam(storage_path('tmp'), 'wp-cli') . '.phar'; |
1401: | $res = Util_HTTP::download($url, $tmp); |
1402: | if (!$res) { |
1403: | file_exists($tmp) && unlink($tmp); |
1404: | |
1405: | return error('failed to install wp-cli module'); |
1406: | } |
1407: | try { |
1408: | (new \Phar($tmp))->getSignature(); |
1409: | rename($tmp, Wpcli::BIN) && chmod(Wpcli::BIN, 0755); |
1410: | info('downloaded wp-cli'); |
1411: | } catch (\UnexpectedValueException $e) { |
1412: | return error('WP-CLI signature failed, ignoring update'); |
1413: | } finally { |
1414: | if (file_exists($tmp)) { |
1415: | unlink($tmp); |
1416: | } |
1417: | } |
1418: | |
1419: | $local = $this->service_template_path('siteinfo') . Wpcli::BIN; |
1420: | if (!file_exists($local) && !copy(Wpcli::BIN, $local)) { |
1421: | return false; |
1422: | } |
1423: | chmod($local, 0755); |
1424: | |
1425: | } |
1426: | |
1427: | if (is_dir($this->service_template_path('siteinfo'))) { |
1428: | $link = $this->service_template_path('siteinfo') . '/usr/bin/wp-cli'; |
1429: | $local = $this->service_template_path('siteinfo') . Wpcli::BIN; |
1430: | if (!is_link($link) || realpath($link) !== realpath($local)) { |
1431: | is_link($link) && unlink($link); |
1432: | $referent = $this->file_convert_absolute_relative($link, $local); |
1433: | |
1434: | return symlink($referent, $link); |
1435: | } |
1436: | } |
1437: | |
1438: | return true; |
1439: | } |
1440: | |
1441: | |
1442: | |
1443: | |
1444: | |
1445: | |
1446: | public function get_versions(): array |
1447: | { |
1448: | $versions = $this->_getVersions(); |
1449: | |
1450: | return array_reverse(array_column($versions, 'version')); |
1451: | } |
1452: | |
1453: | protected function mapFilesFromList(array $files, string $docroot): array |
1454: | { |
1455: | if (file_exists($this->domain_fs_path($docroot . '/wp-content'))) { |
1456: | return parent::mapFilesFromList($files, $docroot); |
1457: | } |
1458: | $path = $tmp = $docroot; |
1459: | |
1460: | $ret = \Module\Support\Webapps\PhpWrapper::instantiateContexted($this->getAuthContextFromDocroot($docroot))->exec( |
1461: | $docroot, '-r %(code)s', [ |
1462: | 'code' => 'set_error_handler(function() { echo defined("WP_CONTENT_DIR") ? constant("WP_CONTENT_DIR") : dirname(__FILE__); die(); }); include("./wp-config.php"); trigger_error("");define("ABS_PATH", "/dev/null");' |
1463: | ] |
1464: | ); |
1465: | |
1466: | if ($ret['success']) { |
1467: | $tmp = $ret['stdout']; |
1468: | if (0 === strpos($tmp, $this->domain_fs_path() . '/')) { |
1469: | $tmp = $this->file_unmake_path($tmp); |
1470: | } |
1471: | } |
1472: | |
1473: | if ($path !== $tmp) { |
1474: | $relpath = $this->file_convert_absolute_relative($docroot . '/wp-content/', $tmp); |
1475: | foreach ($files as $k => $f) { |
1476: | if (0 !== strncmp($f, 'wp-content/', 11)) { |
1477: | continue; |
1478: | } |
1479: | $f = $relpath . substr($f, strlen('wp-content')); |
1480: | $files[$k] = $f; |
1481: | } |
1482: | } |
1483: | |
1484: | return parent::mapFilesFromList($files, $docroot); |
1485: | } |
1486: | |
1487: | |
1488: | |
1489: | |
1490: | |
1491: | |
1492: | protected function _getLastestVersion() |
1493: | { |
1494: | $versions = $this->_getVersions(); |
1495: | if (!$versions) { |
1496: | return null; |
1497: | } |
1498: | |
1499: | return $versions[0]['version']; |
1500: | } |
1501: | |
1502: | |
1503: | |
1504: | |
1505: | |
1506: | |
1507: | protected function _getVersions() |
1508: | { |
1509: | $key = 'wp.versions'; |
1510: | $cache = Cache_Super_Global::spawn(); |
1511: | if (false !== ($ver = $cache->get($key))) { |
1512: | return $ver; |
1513: | } |
1514: | $url = self::VERSION_CHECK_URL; |
1515: | $contents = file_get_contents($url); |
1516: | if (!$contents) { |
1517: | return array(); |
1518: | } |
1519: | $versions = json_decode($contents, true); |
1520: | $versions = $versions['offers']; |
1521: | if (isset($versions[1]['version'], $versions[0]['version']) |
1522: | && $versions[0]['version'] === $versions[1]['version']) { |
1523: | |
1524: | array_shift($versions); |
1525: | } |
1526: | $cache->set($key, $versions, 43200); |
1527: | |
1528: | return $versions; |
1529: | } |
1530: | |
1531: | |
1532: | |
1533: | |
1534: | |
1535: | |
1536: | |
1537: | |
1538: | |
1539: | public function asset_summary(string $hostname, string $path = ''): array |
1540: | { |
1541: | if (!$approot = $this->getAppRoot($hostname, $path)) { |
1542: | return []; |
1543: | } |
1544: | |
1545: | $plugin = $this->assetListWrapper($approot, 'plugin', ['name', 'status', 'version', 'description', 'update_version']); |
1546: | $theme = $this->assetListWrapper($approot, 'theme', ['name', 'status', 'version', 'description', 'update_version']); |
1547: | $skippedtheme = $this->getSkiplist($approot, 'theme'); |
1548: | $skippedplugin = $this->getSkiplist($approot, 'plugin'); |
1549: | $merged = []; |
1550: | foreach (['plugin', 'theme'] as $type) { |
1551: | $skipped = ${'skipped' . $type}; |
1552: | $assets = (array)${$type}; |
1553: | usort($assets, static function ($a1, $a2) { |
1554: | return strnatcmp($a1['name'], $a2['name']); |
1555: | }); |
1556: | foreach ($assets as &$asset) { |
1557: | if (\in_array($asset['status'], self::NON_UPDATEABLE_TYPES, true)) { |
1558: | continue; |
1559: | } |
1560: | $name = $asset['name']; |
1561: | $asset['skipped'] = isset($skipped[$name]); |
1562: | $asset['active'] = $asset['status'] !== 'inactive'; |
1563: | $asset['type'] = $type; |
1564: | $merged[] = $asset; |
1565: | } |
1566: | unset($asset); |
1567: | } |
1568: | return $merged; |
1569: | } |
1570: | |
1571: | |
1572: | |
1573: | |
1574: | |
1575: | |
1576: | |
1577: | |
1578: | |
1579: | |
1580: | public function skip_asset(string $hostname, string $path, string $name, ?string $type): bool |
1581: | { |
1582: | if (!$approot = $this->getAppRoot($hostname, $path)) { |
1583: | return error("App root for `%s'/`%s' does not exist", $hostname, $path); |
1584: | } |
1585: | |
1586: | $contents = implode("\n", $this->skiplistContents($approot)); |
1587: | $contents .= "\n" . $type . ($type ? ':' : '') . $name; |
1588: | |
1589: | return $this->file_put_file_contents("${approot}/" . self::ASSET_SKIPLIST, ltrim($contents)); |
1590: | } |
1591: | |
1592: | |
1593: | |
1594: | |
1595: | |
1596: | |
1597: | |
1598: | |
1599: | |
1600: | |
1601: | public function unskip_asset(string $hostname, string $path, string $name, ?string $type): bool |
1602: | { |
1603: | if (!$approot = $this->getAppRoot($hostname, $path)) { |
1604: | return error("App root for `%s'/`%s' does not exist", $hostname, $path); |
1605: | } |
1606: | |
1607: | $assets = $this->getSkiplist($approot, $type); |
1608: | |
1609: | if (!isset($assets[$name])) { |
1610: | return warn("%(type)s `%(asset)s' not present in skiplist", ['type' => $type, 'asset' => $name]); |
1611: | } |
1612: | |
1613: | $skiplist = array_flip($this->skiplistContents($approot)); |
1614: | unset($skiplist["${type}:${name}"],$skiplist[$name]); |
1615: | return $this->file_put_file_contents("${approot}/" . self::ASSET_SKIPLIST, implode("\n", array_keys($skiplist))); |
1616: | } |
1617: | |
1618: | |
1619: | public function asset_skipped(string $hostname, string $path, string $name, ?string $type): bool |
1620: | { |
1621: | if (!$approot = $this->getAppRoot($hostname, $path)) { |
1622: | return error("App root for `%s'/`%s' does not exist", $hostname, $path); |
1623: | } |
1624: | |
1625: | $assets = $this->getSkiplist($approot, $type); |
1626: | return isset($assets[$name]); |
1627: | } |
1628: | |
1629: | |
1630: | |
1631: | |
1632: | |
1633: | |
1634: | |
1635: | |
1636: | |
1637: | |
1638: | |
1639: | public function duplicate(string $shostname, string $spath, string $dhostname, string $dpath, array $opts = []): bool |
1640: | { |
1641: | if (!$this->valid($shostname, $spath)) { |
1642: | return error("%(hostname)s/%(path)s does not contain a valid %(app)s install", |
1643: | ['hostname' => $shostname, 'path' => $spath, 'app' => static::APP_NAME] |
1644: | ); |
1645: | } |
1646: | |
1647: | return (bool)serial(function () use ($spath, $dpath, $dhostname, $shostname, $opts) { |
1648: | $sapproot = $this->getAppRoot($shostname, $spath); |
1649: | $dapproot = $this->getAppRoot($dhostname, $dpath); |
1650: | |
1651: | |
1652: | if ($sapproot === $dapproot || 0 === strpos("${dapproot}/", "${sapproot}/")) { |
1653: | return error("Source `%(source)s' and target `%(target)s' are the same or nested", |
1654: | ['source' => $sapproot, 'target' => $dapproot]); |
1655: | } |
1656: | |
1657: | if (!empty($opts['clean']) && is_dir($this->domain_fs_path($dapproot))) { |
1658: | if ($this->webapp_valid($dhostname, $dpath)) { |
1659: | $this->webapp_uninstall($dhostname, $dpath); |
1660: | } else { |
1661: | $this->file_delete($dapproot, true); |
1662: | } |
1663: | } |
1664: | |
1665: | $this->checkDocroot($dapproot); |
1666: | |
1667: | |
1668: | $this->file_copy("${sapproot}/", $dapproot, true); |
1669: | $db = DatabaseGenerator::mysql($this->getAuthContext(), $dhostname); |
1670: | $db->create(); |
1671: | $db->autoRollback = true; |
1672: | $oldDbConfig = $this->db_config($shostname, $spath); |
1673: | $this->mysql_clone($oldDbConfig['db'], $db->database); |
1674: | $sapp = Loader::fromDocroot('wordpress', $sapproot, $this->getAuthContext()); |
1675: | $dapp = Loader::fromDocroot('wordpress', $dapproot, $this->getAuthContext()); |
1676: | |
1677: | $vals = array_diff_key( |
1678: | $this->get_reconfigurable($shostname, $spath, $sapp->getReconfigurables()), |
1679: | array_flip($dapp::TRANSIENT_RECONFIGURABLES) |
1680: | ); |
1681: | info("Reconfiguring %s", implode(", ", array_key_map(static function ($k, $v) { |
1682: | if (is_bool($v)) { |
1683: | $v = $v ? "true" : "false"; |
1684: | } |
1685: | return "$k => $v"; |
1686: | }, $vals))); |
1687: | $dapp->reconfigure($vals); |
1688: | $this->updateConfiguration($dapproot, [ |
1689: | 'DB_NAME' => $db->database, |
1690: | 'DB_USER' => $db->username, |
1691: | 'DB_PASSWORD' => $db->password, |
1692: | 'DB_HOST' => $db->hostname, |
1693: | ]); |
1694: | $db->autoRollback = false; |
1695: | $cli = Wpcli::instantiateContexted($this->getAuthContext()); |
1696: | $cli->exec($dapproot, 'config shuffle-salts'); |
1697: | $dapp->reconfigure(['migrate' => $dhostname . '/' . $dpath]); |
1698: | |
1699: | if ($dapp->hasGit()) { |
1700: | $git = Git::instantiateContexted( |
1701: | $this->getAuthContext(), [ |
1702: | $dapp->getAppRoot(), |
1703: | MetaManager::factory($this->getAuthContext())->get($dapp->getDocumentRoot()) |
1704: | ] |
1705: | ); |
1706: | $git->remove(); |
1707: | $git->createRepository(); |
1708: | } |
1709: | |
1710: | return null !== $this->webapp_discover($dhostname, $dpath); |
1711: | }); |
1712: | } |
1713: | |
1714: | |
1715: | |
1716: | |
1717: | |
1718: | |
1719: | |
1720: | public function install_package(string $package): bool |
1721: | { |
1722: | $cli = ComposerWrapper::instantiateContexted($this->getAuthContext()); |
1723: | if (!$this->file_exists('~/.wp-cli/packages')) { |
1724: | $this->file_create_directory('~/.wp-cli/packages', 493, true); |
1725: | $cli->exec('~/.wp-cli/packages', 'init -n --name=local/wp-cli-packages -sdev --repository=https://wp-cli.org/package-index/'); |
1726: | } |
1727: | $ret = $cli->exec('~/.wp-cli/packages', 'require %s', [$package]); |
1728: | |
1729: | |
1730: | return $ret['success'] ?: |
1731: | error("Failed to install %s: %s", $package, coalesce($ret['stderr'], $ret['stdout'])); |
1732: | } |
1733: | |
1734: | |
1735: | |
1736: | |
1737: | |
1738: | |
1739: | |
1740: | public function package_installed(string $package): bool |
1741: | { |
1742: | $cli = Wpcli::instantiateContexted($this->getAuthContext()); |
1743: | $ret = $cli->exec(null, 'package path %s', [$package]); |
1744: | return $ret['success']; |
1745: | } |
1746: | |
1747: | |
1748: | |
1749: | |
1750: | |
1751: | |
1752: | |
1753: | public function uninstall_package(string $package): bool |
1754: | { |
1755: | $cli = ComposerWrapper::instantiateContexted($this->getAuthContext()); |
1756: | $ret = $cli->exec('~/.wp-cli/packages', 'remove %s', [$package]); |
1757: | return $ret['success'] ?: |
1758: | error("Failed to uninstall %s: %s", $package, coalesce($ret['stderr'], $ret['stdout'])); |
1759: | } |
1760: | |
1761: | |
1762: | |
1763: | |
1764: | |
1765: | |
1766: | |
1767: | |
1768: | |
1769: | |
1770: | |
1771: | |
1772: | |
1773: | |
1774: | |
1775: | |
1776: | |
1777: | |
1778: | |
1779: | |
1780: | |
1781: | public function cli(string $command, $args = [], string $hostname = null, string $path = ''): array |
1782: | { |
1783: | if (!$hostname) { |
1784: | $apps = (new \Module\Support\Webapps\Finder($this->getAuthContext()))->getApplicationsByType($this->getModule()); |
1785: | } else { |
1786: | $docroot = $this->getDocumentRoot($hostname, $path); |
1787: | $apps = [$docroot => ['path' => $path, 'hostname' => $hostname]]; |
1788: | } |
1789: | |
1790: | $wpcli = Wpcli::instantiateContexted($this->getAuthContext()); |
1791: | $processed = []; |
1792: | foreach ($apps as $info) { |
1793: | if (!$this->valid($info['hostname'], $info['path'] ?? '')) { |
1794: | debug("%(host)/%(path)s is not valid %(type)s, skipping", [ |
1795: | 'host' => $info['hostname'], |
1796: | 'path' => $info['path'] ?? '', |
1797: | 'type' => $this->getModule() |
1798: | ]); |
1799: | } |
1800: | $appRoot = $this->getAppRoot($info['hostname'], $info['path']); |
1801: | $ret = $wpcli->exec($appRoot, $command, (array)$args); |
1802: | |
1803: | $processed[$appRoot] = array_only($info, ['hostname', 'path']) + $ret; |
1804: | } |
1805: | |
1806: | return $hostname ? array_pop($processed) : $processed; |
1807: | } |
1808: | } |