midcom_services_cache_module_nap::put_node() - Code Metrics - Inspection of "Inject config instead of relying on global getter" - flack/openpsa - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( ae9760...35700c )

by Andreas
created 2020-06-13 11:24 UTC
midcom_services_cache_module_nap::put_node() A

↳ Parent: midcom_services_cache_module_nap
Complexity

Conditions	3
Paths	3
Size

Total Lines	14
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	9
CRAP Score	3.009
Importance

Changes
Metric	Value
cc	3
eloc	9
nc	3
nop	2
dl	0
loc	14
ccs	9
cts	10
cp	0.9
crap	3.009
rs	9.9666
c	0
b	0
f	0
<?php
/**
 * @package midcom.services
 * @author The Midgard Project, http://www.midgard-project.org
 * @copyright The Midgard Project, http://www.midgard-project.org
 * @license http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public License
 */

/**
 * This is the NAP caching module. It provides the basic management functionality
 * for the various backend databases which will be created based on the root topic of the
 * NAP trees.
 *
 * The actual handling of the various dbs is done with Doctrine Cache, this
 * class is responsible for the creation of backend instances and invalidation for NAP
 * cache objects. (Which implies that it is fully aware of the data structures
 * stored in the cache.)
 *
 * All entries are indexed by their Midgard Object GUID. The entries in the NAP cache
 * basically resemble the arrays within the NAP backend node/leaf cache
 *
 * NAP caches can be shared over multiple sites, as all site specific data (like
 * site prefixes) are evaluated during runtime.
 *
 * Most of the cache update work is done in midcom_helper_nav_backend,
 * so you should look there for details about the caching strategy.
 *
 * @see midcom_helper_nav_backend
 *
 * @package midcom.services
 */
class midcom_services_cache_module_nap extends midcom_services_cache_module
{
    /**
     * The cache backend instance to use.
     *
     * @var Doctrine\Common\Cache\CacheProvider
     */
    private $_cache;

    /**
     * Initialization event handler.
     *
     * It will load the cache backends for the current MidCOM topic.
     *
     * Initializes the backend configuration.
     */
    public function __construct(midcom_config $config)
    {
        parent::__construct();
        if ($driver = $config->get('cache_module_memcache_backend')) {
            $backend_config = $config->get('cache_module_memcache_backend_config');
            $backend_config['driver'] = $driver;
            $this->_cache = $this->_create_backend('module_nap', $backend_config);
            $this->_cache = $this->_create_backend('module_nap', /** @scrutinizer ignore-type */ $backend_config);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function invalidate($guid, $object = null)
    {
        $napobject = $this->get_guid($guid);

        if (!$napobject) {
            // The object itself is not in cache, but it still might have a parent that
            // needs invalidating (f.x. if it is newly-created or was moved from outside the tree)
            $napobject = $this->_load_from_guid($guid, $object);
            if (!$napobject) {
                // We couldn't load the object (because it's deleted f.x.) or it is not in NAP.
                // Either way, there is nothing more we can do here.
                return;
            }
        }

        if ($napobject[MIDCOM_NAV_TYPE] == 'leaf') {
            $cached_node_id = $napobject[MIDCOM_NAV_NODEID];
            // Get parent from DB and compare to catch moves
            if ($parent = $napobject[MIDCOM_NAV_OBJECT]->get_parent()) {
                $parent_entry = $this->get_guid($parent->guid);
                if (   $parent_entry
                    && $parent_entry[MIDCOM_NAV_ID] != $cached_node_id) {
                    $this->_cache->delete($this->_prefix . '-' . $parent_entry[MIDCOM_NAV_ID] . '-leaves');
                }
            }
            if (!empty($napobject[MIDCOM_NAV_GUID])) {
                $this->_cache->delete($this->_prefix . '-' . $napobject[MIDCOM_NAV_GUID]);
            }
        } else {
            $cached_node_id = $napobject[MIDCOM_NAV_ID];

            //Invalidate subnode cache for the (cached) parent
            $parent_id = $napobject[MIDCOM_NAV_NODEID];
            $parent_entry = $this->get_node($parent_id);

            if (   $parent_entry
                && array_key_exists(MIDCOM_NAV_SUBNODES, $parent_entry)) {
                unset($parent_entry[MIDCOM_NAV_SUBNODES]);
                $this->put_node($parent_id, $parent_entry);
            }

            //Cross-check parent value from object to detect topic moves
            if ($parent = $napobject[MIDCOM_NAV_OBJECT]->get_parent()) {
                $parent_entry_from_object = $this->get_guid($parent->guid);

                if (    !empty($parent_entry_from_object[MIDCOM_NAV_ID])
                     && !empty($parent_entry[MIDCOM_NAV_ID])
                     && $parent_entry_from_object[MIDCOM_NAV_ID] != $parent_entry[MIDCOM_NAV_ID]) {
                    unset($parent_entry_from_object[MIDCOM_NAV_SUBNODES]);
                    $this->put_node($parent_entry_from_object[MIDCOM_NAV_ID], $parent_entry_from_object);
                }
            }
        }

        $leaves_key = "{$cached_node_id}-leaves";

        $this->_cache->delete("{$this->_prefix}-{$cached_node_id}");
        $this->_cache->delete($this->_prefix . '-' . $napobject[MIDCOM_NAV_GUID]);
        $this->_cache->delete("{$this->_prefix}-{$leaves_key}");
    }

    private function _load_from_guid(string $guid, $object)
    {
        $napobject = false;
        try {
            if (!is_object($object)) {
                $object = midcom::get()->dbfactory->get_object_by_guid($guid);
            }
            $nav = new midcom_helper_nav;
            if ($object instanceof midcom_db_topic) {
                $napobject = $nav->get_node($object->id);
            } elseif (   ($node = $nav->find_closest_topic($object))
                      && $nodeobject = $nav->get_node($node->id)) {
                $napobject = $nav->get_leaf($nodeobject[MIDCOM_NAV_ID] . '-' . $object->id);
            }
        } catch (midcom_error $e) {
            $e->log();
        }
        return $napobject;
    }

    /**
     * Looks up a node in the cache and returns it. Not existent
     * keys are caught in this call as well, so you do not need
     * to call exists first.
     *
     * @param string $key The key to look up.
     * @return mixed The cached value on success, false on failure.
     */
    public function get_node($key)
    {
        if ($this->_cache === null) {
            return false;
        }
        $lang_id = midcom::get()->i18n->get_current_language();
        $result = $this->_cache->fetch("{$this->_prefix}-{$key}");
        if (   !is_array($result)
            || !isset($result[$lang_id])) {
            return false;
        }

        return $result[$lang_id];
    }

    /**
     * Looks up a node in the cache and returns it. Not existent
     * keys are caught in this call as well, so you do not need
     * to call exists first.
     *
     * @param string $key The key to look up.
     * @return mixed The cached value on success, false on failure.
     */
    public function get_leaves($key)
    {
        if ($this->_cache === null) {
            return false;
        }

        $lang_id = midcom::get()->i18n->get_current_language();
        $result = $this->_cache->fetch("{$this->_prefix}-{$key}");
        if (   !is_array($result)
            || !isset($result[$lang_id])) {
            return false;
        }

        return $result[$lang_id];
    }

    /**
     * Sets a given node key in the cache.
     *
     * @param string $key The key to look up.
     * @param mixed $data The data to store.
     */
    public function put_node($key, $data)
    {
        if ($this->_cache === null) {
            return;
        }

        $lang_id = midcom::get()->i18n->get_current_language();
        $result = $this->_cache->fetch("{$this->_prefix}-{$key}");
        if (!is_array($result)) {
            $result = [];
        }
        $result[$lang_id] = $data;
        $this->_cache->save("{$this->_prefix}-{$key}", $result);
        $this->_cache->save($this->_prefix . '-' . $data[MIDCOM_NAV_GUID], $result);
    }

    /**
     * Save a given array by GUID in the cache.
     *
     * @param string $guid The key to store.
     * @param mixed $data The data to store.
     */
    public function put_guid($guid, $data)
    {
        if ($this->_cache === null) {
            return;
        }

        $lang_id = midcom::get()->i18n->get_current_language();
        $result = $this->_cache->fetch("{$this->_prefix}-{$guid}");
        if (!is_array($result)) {
            $result = [];
        }
        $result[$lang_id] = $data;
        $this->_cache->save($this->_prefix . '-' . $guid, $result);
    }

    /**
     * Get a given array by GUID from the cache.
     *
     * @param string $guid The key to look up.
     */
    public function get_guid($guid)
    {
        if ($this->_cache === null) {
            return;
        }

        $lang_id = midcom::get()->i18n->get_current_language();
        $result = $this->_cache->fetch("{$this->_prefix}-{$guid}");
        if (   !is_array($result)
            || !isset($result[$lang_id])) {
            return false;
        }
        return $result[$lang_id];
    }

    /**
     * Sets a given leave key in the cache
     *
     * @param string $key The key to look up.
     * @param mixed $data The data to store.
     */
    public function put_leaves($key, $data)
    {
        if ($this->_cache === null) {
            return;
        }

        $lang_id = midcom::get()->i18n->get_current_language();
        $result = $this->_cache->fetch("{$this->_prefix}-{$key}");
        if (!is_array($result)) {
            $result = [];
        }
        $result[$lang_id] = $data;
        $this->_cache->save("{$this->_prefix}-{$key}", $result);
    }
}

flack / openpsa

Push — master ( ae9760...35700c )

midcom_services_cache_module_nap::put_node() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
