Plugins.php

Go to the documentation of this file.

<?php
namespace Elgg\Database;

use Elgg\Cache\Pool;
use Elgg\Profilable;
use Exception;
use Elgg\Cache\PluginSettingsCache;

class Plugins {
    use Profilable;

    private $boot_plugins = [];

    private $provides_cache;

    private $active_guids = array();

    private $active_guids_known = false;

    private $plugins_by_id;

    private $settings_cache;

    public function __construct(Pool $pool, PluginSettingsCache $cache) {
        $this->plugins_by_id = $pool;
        $this->settings_cache = $cache;
    }

    public function setBootPlugins(array $plugins) {
        $this->boot_plugins = $plugins;
        foreach ($plugins as $plugin) {
            $this->plugins_by_id->put($plugin->getID(), $plugin);
        }
    }

    function getDirsInDir($dir = null) {
        if (!$dir) {
            $dir = elgg_get_plugins_path();
        }
    
        $plugin_dirs = array();
        $handle = opendir($dir);
    
        if ($handle) {
            while ($plugin_dir = readdir($handle)) {
                // must be directory and not begin with a .
                if (substr($plugin_dir, 0, 1) !== '.' && is_dir($dir . $plugin_dir)) {
                    $plugin_dirs[] = $plugin_dir;
                }
            }
        }
    
        sort($plugin_dirs);
    
        return $plugin_dirs;
    }
    
    function generateEntities() {
    
        $mod_dir = elgg_get_plugins_path();
        $db_prefix = elgg_get_config('dbprefix');
    
        // ignore access in case this is called with no admin logged in - needed for creating plugins perhaps?
        $old_ia = elgg_set_ignore_access(true);
    
        // show hidden entities so that we can enable them if appropriate
        $old_access = access_get_show_hidden_status();
        access_show_hidden_entities(true);
    
        $options = array(
            'type' => 'object',
            'subtype' => 'plugin',
            'selects' => array('plugin_oe.*'),
            'joins' => array("JOIN {$db_prefix}objects_entity plugin_oe on plugin_oe.guid = e.guid"),
            'limit' => ELGG_ENTITIES_NO_VALUE,
        );
        $known_plugins = elgg_get_entities_from_relationship($options);
        /* @var \ElggPlugin[] $known_plugins */
    
        if (!$known_plugins) {
            $known_plugins = array();
        }
    
        // map paths to indexes
        $id_map = array();
        foreach ($known_plugins as $i => $plugin) {
            // if the ID is wrong, delete the plugin because we can never load it.
            $id = $plugin->getID();
            if (!$id) {
                $plugin->delete();
                unset($known_plugins[$i]);
                continue;
            }
            $id_map[$plugin->getID()] = $i;
        }
    
        $physical_plugins = $this->getDirsInDir($mod_dir);
    
        if (!$physical_plugins) {
            return false;
        }
    
        // check real plugins against known ones
        foreach ($physical_plugins as $plugin_id) {
            // is this already in the db?
            if (array_key_exists($plugin_id, $id_map)) {
                $index = $id_map[$plugin_id];
                $plugin = $known_plugins[$index];
                // was this plugin deleted and its entity disabled?
                if (!$plugin->isEnabled()) {
                    $plugin->enable();
                    $plugin->deactivate();
                    $plugin->setPriority('last');
                }
    
                // remove from the list of plugins to disable
                unset($known_plugins[$index]);
            } else {
                // create new plugin
                // priority is forced to last in save() if not set.
                $plugin = new \ElggPlugin($mod_dir . $plugin_id);
                $plugin->save();
            }
        }
    
        // everything remaining in $known_plugins needs to be disabled
        // because they are entities, but their dirs were removed.
        // don't delete the entities because they hold settings.
        foreach ($known_plugins as $plugin) {
            if ($plugin->isActive()) {
                $plugin->deactivate();
            }
            // remove the priority.
            $name = $this->namespacePrivateSetting('internal', 'priority');
            remove_private_setting($plugin->guid, $name);
            if ($plugin->isEnabled()) {
                $plugin->disable();
            }
        }
    
        access_show_hidden_entities($old_access);
        elgg_set_ignore_access($old_ia);

        $this->reindexPriorities();

    
        return true;
    }
    
    function cache(\ElggPlugin $plugin) {
        $this->plugins_by_id->put($plugin->getID(), $plugin);
    }
    
    function get($plugin_id) {
        return $this->plugins_by_id->get($plugin_id, function () use ($plugin_id) {
            $plugin_id = sanitize_string($plugin_id);
            $db_prefix = get_config('dbprefix');

            $options = array(
                'type' => 'object',
                'subtype' => 'plugin',
                'joins' => array("JOIN {$db_prefix}objects_entity oe on oe.guid = e.guid"),
                'selects' => array("oe.title", "oe.description"),
                'wheres' => array("oe.title = '$plugin_id'"),
                'limit' => 1,
                'distinct' => false,
            );

            $plugins = elgg_get_entities($options);

            if ($plugins) {
                return $plugins[0];
            }

            return null;
        });
    }
    
    function exists($id) {
        return (bool)$this->get($id);
    }
    
    function getMaxPriority() {
        $db_prefix = get_config('dbprefix');
        $priority = $this->namespacePrivateSetting('internal', 'priority');
        $plugin_subtype = get_subtype_id('object', 'plugin');
    
        $q = "SELECT MAX(CAST(ps.value AS unsigned)) as max
            FROM {$db_prefix}entities e, {$db_prefix}private_settings ps
            WHERE ps.name = '$priority'
            AND ps.entity_guid = e.guid
            AND e.type = 'object' and e.subtype = $plugin_subtype";
    
        $data = get_data($q);
        if ($data) {
            $max = $data[0]->max;
        } else {
            $max = 1;
        }
    
        // can't have a priority of 0.
        return ($max) ? $max : 1;
    }
    
    function isActive($plugin_id, $site_guid = null) {
        $current_site_guid = elgg_get_site_entity()->guid;

        if ($this->active_guids_known
                && ($site_guid === null || $site_guid == $current_site_guid)) {
            return isset($this->active_guids[$plugin_id]);
        }

        if ($site_guid) {
            $site = get_entity($site_guid);
        } else {
            $site = elgg_get_site_entity();
        }
    
        if (!($site instanceof \ElggSite)) {
            return false;
        }
    
        $plugin = $this->get($plugin_id);
    
        if (!$plugin) {
            return false;
        }
    
        return $plugin->isActive($site->guid);
    }
    
    function load() {
        if ($this->timer) {
            $this->timer->begin([__METHOD__]);
        }

        $plugins_path = elgg_get_plugins_path();
        $start_flags = ELGG_PLUGIN_INCLUDE_START |
                        ELGG_PLUGIN_REGISTER_VIEWS |
                        ELGG_PLUGIN_REGISTER_LANGUAGES |
                        ELGG_PLUGIN_REGISTER_CLASSES;
    
        if (!$plugins_path) {
            return false;
        }
    
        // temporary disable all plugins if there is a file called 'disabled' in the plugin dir
        if (file_exists("$plugins_path/disabled")) {
            if (elgg_is_admin_logged_in() && elgg_in_context('admin')) {
                system_message(_elgg_services()->translator->translate('plugins:disabled'));
            }
            return false;
        }
    
        if (elgg_get_config('system_cache_loaded')) {
            $start_flags = $start_flags & ~ELGG_PLUGIN_REGISTER_VIEWS;
        }
    
        if (!empty($GLOBALS['_ELGG']->i18n_loaded_from_cache)) {
            $start_flags = $start_flags & ~ELGG_PLUGIN_REGISTER_LANGUAGES;
        }
    
        $plugins = $this->boot_plugins;
        if (!$plugins) {
            $this->active_guids_known = true;
            return true;
        }

        $return = true;
        foreach ($plugins as $plugin) {
            $id = $plugin->getID();
            try {
                $plugin->start($start_flags);
                $this->active_guids[$id] = $plugin->guid;
            } catch (Exception $e) {
                $disable_plugins = elgg_get_config('auto_disable_plugins');
                if ($disable_plugins === null) {
                    $disable_plugins = true;
                }
                if ($disable_plugins) {
                    $plugin->deactivate();
                
                    $msg = _elgg_services()->translator->translate('PluginException:CannotStart',
                                    array($id, $plugin->guid, $e->getMessage()));
                    elgg_add_admin_notice("cannot_start $id", $msg);
                    $return = false;
                }
            }
        }

        $this->active_guids_known = true;

        if ($this->timer) {
            $this->timer->end([__METHOD__]);
        }
        return $return;
    }
    
    function find($status = 'active', $site_guid = null) {
        $db_prefix = elgg_get_config('dbprefix');
        $priority = $this->namespacePrivateSetting('internal', 'priority');
    
        if (!$site_guid) {
            $site_guid = elgg_get_site_entity()->guid;
        }
    
        // grab plugins
        $options = array(
            'type' => 'object',
            'subtype' => 'plugin',
            'limit' => ELGG_ENTITIES_NO_VALUE,
            'selects' => array('plugin_oe.*', 'ps.value'),
            'joins' => array(
                "JOIN {$db_prefix}private_settings ps on ps.entity_guid = e.guid",
                "JOIN {$db_prefix}objects_entity plugin_oe on plugin_oe.guid = e.guid"
                ),
            'wheres' => array("ps.name = '$priority'"),
            // ORDER BY CAST(ps.value) is super slow. We usort() below.
            'order_by' => false,
            'distinct' => false,
        );
    
        switch ($status) {
            case 'active':
                $options['relationship'] = 'active_plugin';
                $options['relationship_guid'] = $site_guid;
                $options['inverse_relationship'] = true;
                break;
    
            case 'inactive':
                $options['wheres'][] = "NOT EXISTS (
                        SELECT 1 FROM {$db_prefix}entity_relationships active_er
                        WHERE active_er.guid_one = e.guid
                            AND active_er.relationship = 'active_plugin'
                            AND active_er.guid_two = $site_guid)";
                break;
    
            case 'all':
            default:
                break;
        }
    
        $old_ia = elgg_set_ignore_access(true);
        $plugins = elgg_get_entities_from_relationship($options);
        elgg_set_ignore_access($old_ia);

        usort($plugins, function (\ElggPlugin $a, \ElggPlugin $b) {
            $a_value = $a->getVolatileData('select:value');
            $b_value = $b->getVolatileData('select:value');

            if ($b_value !== $a_value) {
                return $a_value - $b_value;
            } else {
                return $a->guid - $b->guid;
            }
        });
    
        return $plugins;
    }
    
    function setPriorities(array $order) {
        $name = $this->namespacePrivateSetting('internal', 'priority');
    
        $plugins = $this->find('any');
        if (!$plugins) {
            return false;
        }
    
        $return = true;
    
        // reindex to get standard counting. no need to increment by 10.
        // though we do start with 1
        $order = array_values($order);
    
        $missing_plugins = array();
        /* @var \ElggPlugin[] $missing_plugins */
    
        foreach ($plugins as $plugin) {
            $plugin_id = $plugin->getID();
    
            if (!in_array($plugin_id, $order)) {
                $missing_plugins[] = $plugin;
                continue;
            }
    
            $priority = array_search($plugin_id, $order) + 1;
    
            if (!$plugin->setPrivateSetting($name, $priority)) {
                $return = false;
                break;
            }
        }
    
        // set the missing plugins' priorities
        if ($return && $missing_plugins) {
            if (!isset($priority)) {
                $priority = 0;
            }
            foreach ($missing_plugins as $plugin) {
                $priority++;
                if (!$plugin->setPrivateSetting($name, $priority)) {
                    $return = false;
                    break;
                }
            }
        }
    
        return $return;
    }
    
    function reindexPriorities() {
        return $this->setPriorities([]);
    }
    
    function namespacePrivateSetting($type, $name, $id = null) {
        switch ($type) {
            // commented out because it breaks $plugin->$name access to variables
            //case 'setting':
            //  $name = ELGG_PLUGIN_SETTING_PREFIX . $name;
            //  break;
    
            case 'user_setting':
                if (!$id) {
                    elgg_deprecated_notice("You must pass the plugin id to _elgg_namespace_plugin_private_setting() for user settings", 1.9);
                    $id = elgg_get_calling_plugin_id();
                }
                $name = ELGG_PLUGIN_USER_SETTING_PREFIX . "$id:$name";
                break;
    
            case 'internal':
                $name = ELGG_PLUGIN_INTERNAL_PREFIX . $name;
                break;
        }
    
        return $name;
    }
    
    
    function getProvides($type = null, $name = null) {
        if ($this->provides_cache === null) {
            $active_plugins = $this->find('active');
        
            $provides = array();
    
            foreach ($active_plugins as $plugin) {
                $plugin_provides = array();
                $manifest = $plugin->getManifest();
                if ($manifest instanceof \ElggPluginManifest) {
                    $plugin_provides = $plugin->getManifest()->getProvides();
                }
                if ($plugin_provides) {
                    foreach ($plugin_provides as $provided) {
                        $provides[$provided['type']][$provided['name']] = array(
                            'version' => $provided['version'],
                            'provided_by' => $plugin->getID()
                        );
                    }
                }
            }
            
            $this->provides_cache = $provides;
        }
        
        if ($type && $name) {
            if (isset($this->provides_cache[$type][$name])) {
                return $this->provides_cache[$type][$name];
            } else {
                return false;
            }
        } elseif ($type) {
            if (isset($this->provides_cache[$type])) {
                return $this->provides_cache[$type];
            } else {
                return false;
            }
        }
    
        return $this->provides_cache;
    }
    
    function invalidateProvidesCache() {
        $this->provides_cache = null;
        return true;
    }

    public function invalidateIsActiveCache() {
        $this->active_guids = array();
        $this->active_guids_known = false;
    }
    
    function checkProvides($type, $name, $version = null, $comparison = 'ge') {
        $provided = $this->getProvides($type, $name);
        if (!$provided) {
            return array(
                'status' => false,
                'value' => ''
            );
        }
    
        if ($version) {
            $status = version_compare($provided['version'], $version, $comparison);
        } else {
            $status = true;
        }
    
        return array(
            'status' => $status,
            'value' => $provided['version']
        );
    }
    
    function getDependencyStrings($dep) {
        $translator = _elgg_services()->translator;
        $dep_system = elgg_extract('type', $dep);
        $info = elgg_extract('dep', $dep);
        $type = elgg_extract('type', $info);
    
        if (!$dep_system || !$info || !$type) {
            return false;
        }
    
        // rewrite some of these to be more readable
        $comparison = elgg_extract('comparison', $info);
        switch($comparison) {
            case 'lt':
                $comparison = '<';
                break;
            case 'gt':
                $comparison = '>';
                break;
            case 'ge':
                $comparison = '>=';
                break;
            case 'le':
                $comparison = '<=';
                break;
            default:
                //keep $comparison value intact
                break;
        }
    
        /*
        'requires'  'plugin oauth_lib'  <1.3    1.3     'downgrade'
        'requires'  'php setting bob'   >3      3       'change it'
        'conflicts' 'php setting'       >3      4       'change it'
        'conflicted''plugin profile'    any     1.8     'disable profile'
        'provides'  'plugin oauth_lib'  1.3     --      --
        'priority'  'before blog'       --      after   'move it'
        */
        $strings = array();
        $strings['type'] = $translator->translate('ElggPlugin:Dependencies:' . ucwords($dep_system));
    
        switch ($type) {
            case 'elgg_release':
                // 'Elgg Version'
                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:Elgg');
                $strings['expected_value'] = "$comparison {$info['version']}";
                $strings['local_value'] = $dep['value'];
                $strings['comment'] = '';
                break;
    
            case 'php_version':
                // 'PHP version'
                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:PhpVersion');
                $strings['expected_value'] = "$comparison {$info['version']}";
                $strings['local_value'] = $dep['value'];
                $strings['comment'] = '';
                break;
            
            case 'php_extension':
                // PHP Extension %s [version]
                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:PhpExtension', array($info['name']));
                if ($info['version']) {
                    $strings['expected_value'] = "$comparison {$info['version']}";
                    $strings['local_value'] = $dep['value'];
                } else {
                    $strings['expected_value'] = '';
                    $strings['local_value'] = '';
                }
                $strings['comment'] = '';
                break;
    
            case 'php_ini':
                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:PhpIni', array($info['name']));
                $strings['expected_value'] = "$comparison {$info['value']}";
                $strings['local_value'] = $dep['value'];
                $strings['comment'] = '';
                break;
    
            case 'plugin':
                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:Plugin', array($info['name']));
                $expected = $info['version'] ? "$comparison {$info['version']}" : $translator->translate('any');
                $strings['expected_value'] = $expected;
                $strings['local_value'] = $dep['value'] ? $dep['value'] : '--';
                $strings['comment'] = '';
                break;
    
            case 'priority':
                $expected_priority = ucwords($info['priority']);
                $real_priority = ucwords($dep['value']);
                $strings['name'] = $translator->translate('ElggPlugin:Dependencies:Priority');
                $strings['expected_value'] = $translator->translate("ElggPlugin:Dependencies:Priority:$expected_priority", array($info['plugin']));
                $strings['local_value'] = $translator->translate("ElggPlugin:Dependencies:Priority:$real_priority", array($info['plugin']));
                $strings['comment'] = '';
                break;
        }
    
        if ($dep['type'] == 'suggests') {
            if ($dep['status']) {
                $strings['comment'] = $translator->translate('ok');
            } else {
                $strings['comment'] = $translator->translate('ElggPlugin:Dependencies:Suggests:Unsatisfied');
            }
        } else {
            if ($dep['status']) {
                $strings['comment'] = $translator->translate('ok');
            } else {
                $strings['comment'] = $translator->translate('error');
            }
        }
    
        return $strings;
    }
    
    function getAllUserSettings($user_guid = 0, $plugin_id = null, $return_obj = false) {
        if ($plugin_id) {
            $plugin = $this->get($plugin_id);
        } else {
            elgg_deprecated_notice('elgg_get_all_plugin_user_settings() requires plugin_id to be set', 1.9);
            $plugin = elgg_get_calling_plugin_entity();
        }
    
        if (!$plugin instanceof \ElggPlugin) {
            return false;
        }
    
        $settings = $plugin->getAllUserSettings((int)$user_guid);
    
        if ($settings && $return_obj) {
            $return = new \stdClass;
    
            foreach ($settings as $k => $v) {
                $return->$k = $v;
            }
    
            return $return;
        } else {
            return $settings;
        }
    }
    
    function setUserSetting($name, $value, $user_guid = 0, $plugin_id = null) {
        if ($plugin_id) {
            $plugin = $this->get($plugin_id);
        } else {
            elgg_deprecated_notice('elgg_set_plugin_user_setting() requires plugin_id to be set', 1.9);
            $plugin = elgg_get_calling_plugin_entity();
        }
    
        if (!$plugin) {
            return false;
        }
    
        return $plugin->setUserSetting($name, $value, (int)$user_guid);
    }
    
    function unsetUserSetting($name, $user_guid = 0, $plugin_id = null) {
        if ($plugin_id) {
            $plugin = $this->get($plugin_id);
        } else {
            elgg_deprecated_notice('elgg_unset_plugin_user_setting() requires plugin_id to be set', 1.9);
            $plugin = elgg_get_calling_plugin_entity();
        }
    
        if (!$plugin) {
            return false;
        }
    
        return $plugin->unsetUserSetting($name, (int)$user_guid);
    }
    
    function getUserSetting($name, $user_guid = 0, $plugin_id = null, $default = null) {
        if ($plugin_id) {
            $plugin = $this->get($plugin_id);
        } else {
            elgg_deprecated_notice('elgg_get_plugin_user_setting() requires plugin_id to be set', 1.9);
            $plugin = elgg_get_calling_plugin_entity();
        }
    
        if (!$plugin) {
            return false;
        }
    
        return $plugin->getUserSetting($name, (int)$user_guid, $default);
    }
    
    function setSetting($name, $value, $plugin_id = null) {
        if ($plugin_id) {
            $plugin = $this->get($plugin_id);
        } else {
            elgg_deprecated_notice('elgg_set_plugin_setting() requires plugin_id to be set', 1.9);
            $plugin = elgg_get_calling_plugin_entity();
        }
    
        if (!$plugin) {
            return false;
        }
    
        return $plugin->setSetting($name, $value);
    }
    
    function getSetting($name, $plugin_id = null, $default = null) {
        if ($plugin_id) {
            $plugin = $this->get($plugin_id);
        } else {
            elgg_deprecated_notice('elgg_get_plugin_setting() requires plugin_id to be set', 1.9);
            $plugin = elgg_get_calling_plugin_entity();
        }
    
        if (!$plugin) {
            return false;
        }
    
        return $plugin->getSetting($name, $default);
    }
    
    function unsetSetting($name, $plugin_id = null) {
        if ($plugin_id) {
            $plugin = $this->get($plugin_id);
        } else {
            elgg_deprecated_notice('elgg_unset_plugin_setting() requires plugin_id to be set', 1.9);
            $plugin = elgg_get_calling_plugin_entity();
        }
    
        if (!$plugin) {
            return false;
        }
    
        return $plugin->unsetSetting($name);
    }
    
    function unsetAllSettings($plugin_id = null) {
        if ($plugin_id) {
            $plugin = $this->get($plugin_id);
        } else {
            elgg_deprecated_notice('elgg_unset_all_plugin_settings() requires plugin_id to be set', 1.9);
            $plugin = elgg_get_calling_plugin_entity();
        }
    
        if (!$plugin) {
            return false;
        }
    
        return $plugin->unsetAllSettings();
    }
    
    function getEntitiesFromUserSettings(array $options = array()) {
        if (!isset($options['plugin_id'])) {
            elgg_deprecated_notice("'plugin_id' is now required for elgg_get_entities_from_plugin_user_settings()", 1.9);
            $options['plugin_id'] = elgg_get_calling_plugin_id();
        }
    
        $singulars = array('plugin_user_setting_name', 'plugin_user_setting_value',
            'plugin_user_setting_name_value_pair');
    
        $options = _elgg_normalize_plural_options_array($options, $singulars);
    
        // rewrite plugin_user_setting_name_* to the right PS ones.
        $map = array(
            'plugin_user_setting_names' => 'private_setting_names',
            'plugin_user_setting_values' => 'private_setting_values',
            'plugin_user_setting_name_value_pairs' => 'private_setting_name_value_pairs',
            'plugin_user_setting_name_value_pairs_operator' => 'private_setting_name_value_pairs_operator',
        );
    
        foreach ($map as $plugin => $private) {
            if (!isset($options[$plugin])) {
                continue;
            }
    
            if (isset($options[$private])) {
                if (!is_array($options[$private])) {
                    $options[$private] = array($options[$private]);
                }
    
                $options[$private] = array_merge($options[$private], $options[$plugin]);
            } else {
                $options[$private] = $options[$plugin];
            }
        }
    
        $prefix = $this->namespacePrivateSetting('user_setting', '', $options['plugin_id']);
        $options['private_setting_name_prefix'] = $prefix;
    
        return elgg_get_entities_from_private_settings($options);
    }
}