midcom_db_attachment

Complexity

Total Complexity

56

Size/Duplication

Total Lines	475
Duplicated Lines	12.21 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	get_parent_guid_uncached()	0	4	1
A	read()	0	7	1
B	close()	0	24	4
A	safe_filename()	0	23	3
A	get_cache_path()	0	17	3
B	get_url()	0	35	6
C	file_to_cache()	0	58	9
A	_create_attachment_location()	0	23	3
A	_on_creating()	0	11	2
A	update_cache()	0	15	4
A	_on_updated()	0	4	1
A	_on_deleted()	0	12	3
A	get_parent_guid_uncached_static()	12	12	2
B	open()	6	38	5
A	stat()	6	20	3
A	copy_from_memory()	14	14	2
A	copy_from_handle()	14	14	2
A	copy_from_file()	6	13	2

<?php
/**
 * @package midcom.db
 * @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
 */

/**
 * MidCOM level replacement for the Midgard Attachment record with framework support.
 *
 * @package midcom.db
 */
class midcom_db_attachment extends midcom_core_dbaobject

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{
    public $__midcom_class_name__ = __CLASS__;
    public $__mgdschema_class_name__ = 'midgard_attachment';

    public $_use_activitystream = false;
    public $_use_rcs = false;

    /**
     * Internal tracking state variable, holds the file handle of any open
     * attachment.
     *
     * @var resource
     */
    private $_open_handle = null;

    /**
     * Internal tracking state variable, true if the attachment has a handle opened in write mode
     */
    private $_open_write_mode = false;

    public function get_parent_guid_uncached()
    {
        return $this->parentguid;
    }

    /**
     * Returns the Parent of the Attachment, which is identified by the table/id combination
     * in the attachment record. The table in question is used to identify the object to
     * use. If multiple objects are registered for a given table, the first matching class
     * returned by the dbfactory is used (which is usually rather arbitrary).
     *
     * @return string Parent GUID.
     */
    public static function get_parent_guid_uncached_static($guid, $classname = __CLASS__)

This method seems to be duplicated in your project.

    {
        $mc = new midgard_collector('midgard_attachment', 'guid', $guid);
        $mc->set_key_property('parentguid');
        $mc->execute();
        $link_values = $mc->list_keys();
        if (empty($link_values))
        {
            return null;
        }
        return key($link_values);
    }

    /**
     * Opens the attachment for file IO.
     *
     * Returns a filehandle that can be used with the usual PHP file functions if successful,
     * the handle has to be closed with the close() method when you no longer need it, don't
     * let it fall over the end of the script.
     *
     * <b>Important Note:</b> It is important to use the close() member function of
     * this class to close the file handle, not just fclose(). Otherwise, the upgrade
     * notification switches will fail.
     *
     * @param string $mode The mode which should be used to open the attachment, same as
     *     the mode parameter of the PHP fopen call. This defaults to write access (see
     *     mgd_open_attachmentl for details).
     * @return resource A file handle to the attachment if successful, false on failure.
     */
    public function open($mode = 'default')
    {
        if (! $this->id)

This code seems to be duplicated across your project.

        {
            debug_add('Cannot open a non-persistent attachment.', MIDCOM_LOG_WARN);
            debug_print_r('Object state:', $this);
            return false;
        }

        if ($this->_open_handle !== null)
        {
            debug_add("Warning, the Attachment {$this->id} already had an open file handle, we close it implicitly.", MIDCOM_LOG_WARN);
            fclose($this->_open_handle);
            $this->_open_handle = null;
        }

        $blob = new midgard_blob($this->__object);
        if ($mode == 'default')
        {
            $this->_open_write_mode = true;
            $handle = $blob->get_handler();
        }
        else
        {
            /* WARNING, read mode not supported by midgard_blob! */
            $this->_open_write_mode = ($mode{0} != 'r');
            $handle = fopen($blob->get_path(), $mode);
        }

        if (!$handle)
        {
            debug_add("Failed to open attachment with mode {$mode}, last Midgard error was: " . midcom_connection::get_error_string(), MIDCOM_LOG_WARN);
        }

        $this->_open_handle = $handle;

        return $handle;
    }

    /**
     * Read the file and return its contents
     *
     * @return string
     */
    public function read()
    {
        $attachment = new midgard_attachment($this->guid);
        $blob = new midgard_blob($attachment);

        return $blob->read_content();
    }

    /**
     * Close the open write handle obtained by the open() call again.
     * It is required to call this function instead of a simple fclose to ensure proper
     * upgrade notifications.
     */
    public function close()
    {
        if ($this->_open_handle === null)
        {
            debug_add("Tried to close non-open attachment {$this->id}", MIDCOM_LOG_WARN);
            return;
        }

        fclose ($this->_open_handle);
        $this->_open_handle = null;

        if ($this->_open_write_mode)
        {
            // We need to update the attachment now, this cannot be done in the Midgard Core
            // at this time.
            if (! $this->update())
            {
                debug_add("Failed to update attachment {$this->id}", MIDCOM_LOG_WARN);
                return;
            }

            $this->file_to_cache();
        }
    }

    /**
     * Rewrite a filename to URL safe form
     *
     * @param string $filename file name to rewrite
     * @param boolean $force_single_extension force file to single extension (defaults to true)
     * @return string rewritten filename
     * @todo add possibility to use the file utility to determine extension if missing.
     */
    public static function safe_filename($filename, $force_single_extension = true)
    {
        $filename = basename(trim($filename));
        if ($force_single_extension)
        {
            $regex = '/^(.*)(\..*?)$/';
        }
        else
        {
            $regex = '/^(.*?)(\..*)$/';
        }
        if (preg_match($regex, $filename, $ext_matches))
        {
            $name = $ext_matches[1];
            $ext = $ext_matches[2];
        }
        else
        {
            $name = $filename;
            $ext = '';
        }
        return midcom::get()->serviceloader->load('midcom_core_service_urlgenerator')->from_string($name) . $ext;
    }

    /**
     * Get the path to the document in the static cache
     *
     * @return string
     */
    public function get_cache_path()
    {
        if (!midcom::get()->config->get('attachment_cache_enabled'))
        {
            return null;
        }

        // Copy the file to the static directory
        $cacheroot = midcom::get()->config->get('attachment_cache_root');
        $subdir = substr($this->guid, 0, 1);
        if (!file_exists("{$cacheroot}/{$subdir}"))
        {
            mkdir("{$cacheroot}/{$subdir}", 0777, true);
        }

        return "{$cacheroot}/{$subdir}/{$this->guid}_{$this->name}";
    }

    public static function get_url($attachment, $name = null)
    {
        if (is_string($attachment))
        {
            $guid = $attachment;
            if (null === $name)
            {
                $mc = self::new_collector('guid', $guid);
                $names = $mc->get_values('name');
                $name = array_pop($names);
            }
        }
        else if (midcom::get()->dbfactory->is_a($attachment, 'midgard_attachment'))
        {
            $guid = $attachment->guid;
            $name = $attachment->name;
        }
        else
        {
            throw new midcom_error('Invalid attachment identifier');
        }

        if (midcom::get()->config->get('attachment_cache_enabled'))
        {
            $subdir = substr($guid, 0, 1);

            if (file_exists(midcom::get()->config->get('attachment_cache_root') . '/' . $subdir . '/' . $guid . '_' . $name))
            {
                return midcom::get()->config->get('attachment_cache_url') . '/' . $subdir . '/' . $guid . '_' . urlencode($name);
            }
        }

        // Use regular MidCOM attachment server
        return midcom_connection::get_url('self') . 'midcom-serveattachmentguid-' . $guid . '/' . urlencode($name);
    }

    function file_to_cache()

It is generally recommended to explicitly declare the visibility for methods.

    {
        // Check if the attachment can be read anonymously
        if (!midcom::get()->config->get('attachment_cache_enabled'))
        {
            return;
        }

        if (!$this->can_do('midgard:read', 'EVERYONE'))
        {
            debug_add("Attachment {$this->name} ({$this->guid}) is not publicly readable, not caching.");
            return;
        }

        $filename = $this->get_cache_path();

        if (!$filename)
        {
            debug_add("Failed to generate cache path for attachment {$this->name} ({$this->guid}), not caching.");
            return;
        }

        if (   file_exists($filename)
            && is_link($filename))
        {
            debug_add("Attachment {$this->name} ({$this->guid}) is already in cache as {$filename}, skipping.");
            return;
        }

        // Then symlink the file
        $blob = new midgard_blob($this->__object);

        if (@symlink($blob->get_path(), $filename))
        {
            debug_add("Symlinked attachment {$this->name} ({$this->guid}) as {$filename}.");
            return;
        }

        // Symlink failed, actually copy the data
        $fh = $this->open('r');
        if (!$fh)
        {
            debug_add("Failed to cache attachment {$this->name} ({$this->guid}), opening failed.");
            return;
        }

        $data = '';
        while (!feof($fh))
        {
            $data .= fgets($fh);
        }
        fclose($fh);
        $this->_open_handle = null;

        file_put_contents($filename, $data);

        debug_add("Symlinking attachment {$this->name} ({$this->guid}) as {$filename} failed, data copied instead.");
    }

    /**
     * Simple wrapper for stat() on the blob object.
     *
     * @return mixed Either a stat array as for stat() or false on failure.
     */
    public function stat()
    {
        if (!$this->id)

This code seems to be duplicated across your project.

        {
            debug_add('Cannot open a non-persistent attachment.', MIDCOM_LOG_WARN);
            debug_print_r('Object state:', $this);
            return false;
        }

        $blob = new midgard_blob($this->__object);

        $path = $blob->get_path();
        if (!file_exists($path))
        {
            debug_add("File {$path} that blob {$this->guid} points to cannot be found", MIDCOM_LOG_WARN);
            return false;
        }

        return stat($path);
    }

    /**
     * Internal helper, computes an MD5 string which is used as an attachment location.
     * It should be random enough, even if the algorithm used does not match the one
     * Midgard uses. If the location already exists, it will iterate until an unused
     * location is found.
     *
     * @return string An unused attachment location.
     */
    private function _create_attachment_location()
    {
        $max_tries = 500;

        for ($i = 0; $i < $max_tries; $i++)
        {
            $name = strtolower(md5(uniqid('', true)));
            $location = strtoupper(substr($name, 0, 1) . '/' . substr($name, 1, 1) . '/') . $name;

            // Check uniqueness
            $qb = midcom_db_attachment::new_query_builder();
            $qb->add_constraint('location', '=', $location);
            $result = $qb->count_unchecked();

            if ($result == 0)
            {
                debug_add("Created this location: {$location}");
                return $location;
            }
            debug_add("Location {$location} is in use, retrying");
        }
        throw new midcom_error('could not create attachment location');
    }

    /**
     * Simple creation event handler which fills out the location field if it
     * is still empty with a location generated by _create_attachment_location().
     *
     * @return boolean True if creation may commence.
     */
    public function _on_creating()
    {
        if (empty($this->mimetype))
        {
            $this->mimetype = 'application/octet-stream';
        }

        $this->location = $this->_create_attachment_location();

        return true;
    }

    function update_cache()

It is generally recommended to explicitly declare the visibility for methods.

    {
        // Check if the attachment can be read anonymously
        if (   midcom::get()->config->get('attachment_cache_enabled')
            && !$this->can_do('midgard:read', 'EVERYONE'))
        {
            // Not public file, ensure it is removed
            $subdir = substr($this->guid, 0, 1);
            $filename = midcom::get()->config->get('attachment_cache_root') . "/{$subdir}/{$this->guid}_{$this->name}";
            if (file_exists($filename))
            {
                @unlink($filename);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

            }
        }
    }

    /**
     * Updated callback, triggers watches on the parent(!) object.
     */
    public function _on_updated()
    {
        $this->update_cache();
    }

    /**
     * Deleted callback, triggers watches on the parent(!) object.
     */
    public function _on_deleted()
    {
        if (midcom::get()->config->get('attachment_cache_enabled'))
        {
            // Remove attachment cache
            $filename = $this->get_cache_path();
            if (file_exists($filename))
            {
                @unlink($filename);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

            }
        }
    }

    /**
     * Updates the contents of the attachments with the contents given.
     *
     * @param mixed $source File contents.
     * @return boolean Indicating success.
     */
    public function copy_from_memory($source)

This method seems to be duplicated in your project.

    {
        $dest = $this->open();
        if (! $dest)
        {
            debug_add('Could not open attachment for writing, last Midgard error was: ' . midcom_connection::get_error_string(), MIDCOM_LOG_WARN);
            return false;
        }

        fwrite($dest, $source);

        $this->close();
        return true;
    }

    /**
     * Updates the contents of the attachments with the contents of the resource identified
     * by the filehandle passed.
     *
     * @param resource $source The handle to read from.
     * @return boolean Indicating success.
     */
    public function copy_from_handle($source)

This method seems to be duplicated in your project.

    {
        $dest = $this->open();
        if (! $dest)
        {
            debug_add('Could not open attachment for writing, last Midgard error was: ' . midcom_connection::get_error_string(), MIDCOM_LOG_WARN);
            return false;
        }

        stream_copy_to_stream($source, $dest);

        $this->close();
        return true;
    }

    /**
     * Updates the contents of the attachments with the contents of the file specified.
     * This is a wrapper for copy_from_handle.
     *
     * @param string $filename The file to read.
     * @return boolean Indicating success.
     */
    public function copy_from_file($filename)
    {
        $source = @fopen ($filename, 'r');
        if (! $source)

This code seems to be duplicated across your project.

        {
            debug_add('Could not open file for reading.' . midcom_connection::get_error_string(), MIDCOM_LOG_WARN);
            midcom::get()->debug->log_php_error(MIDCOM_LOG_WARN);
            return false;
        }
        $result = $this->copy_from_handle($source);
        fclose($source);
        return $result;
    }
}