Using annotation always resulting in writing to cache

[paventuri]

Given an annotation:

/**
 * @Annotation
 * @Target("METHOD")
 */
class MyAnnotation extends Annotation
{
    /**
     * @var string
     */
    public $name = null;

    /**
     * @var string
     */
    public $tag = null;
}

Given an aspect:

/**
     *
     * @param MethodInvocation $invocation
     *
     * @Around("@execution(MyAnnotation)")
     */
    public function aroundInvocation(MethodInvocation $invocation)
    {

        /** @var MyAnnotation $annotation */
        $annotation = $invocation->getMethod()->getAnnotation(MyAnnotation::class);
        $name = $annotation->name;
    }

The problem is that a call to $invocation->getMethod()->getAnnotation(MyAnnotation::class); results in a call to FileCacheReader::getAnnotations. Which will get the className like so: $class = $method->getDeclaringClass();

The declaring class in this case is always Class__AopProxied which is not cached. By the way, I'm using Features::PREBUILT_CACHE as I have a read-only file systems.

Error:
The directory "/var/www/html/docroot/bootstrap/cache/aspect/_annotations" is not writable. Both, the webserver and the console user need access. You can manage access rights for multiple users with "chmod +a". If your system does not support this, check out the acl package.

Is there any workaround for this issue? Thanks

[TheCelavi]

As far as I know, pre-built cache means that cache is built first in writable environment and after that deploy in non-writable cache environment (with pre-built cache on).

…

On Aug 27, 2017, at 7:09 PM, Paulo Venturi ***@***.***> wrote: Given an annotation: /** * @annotation * @target("METHOD") */ class MyAnnotation extends Annotation { /** * @var string */ public $name = null; /** * @var string */ public $tag = null; } Given an aspect: /** * * @param MethodInvocation $invocation * * @***@***.***(MyAnnotation)") */ public function aroundInvocation(MethodInvocation $invocation) { /** @var MyAnnotation $annotation */ $annotation = $invocation->getMethod()->getAnnotation(MyAnnotation::class); $name = $annotation->name; } The problem is that a call to $invocation->getMethod()->getAnnotation(MyAnnotation::class); results in a call to FileCacheReader::getAnnotations. Which will get the className like so: $class = $method->getDeclaringClass(); The declaring class in this case is always Class__AopProxied which is not cached. By the way, I'm using Features::PREBUILT_CACHE as I have a read-only file systems. Error: The directory "/var/www/html/docroot/bootstrap/cache/aspect/_annotations" is not writable. Both, the webserver and the console user need access. You can manage access rights for multiple users with "chmod +a". If your system does not support this, check out the acl package. Is there any workaround for this issue? Thanks — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub, or mute the thread.

[lisachenko]

Hi! Issue here in doctrine/annotations library, which always checks for write access. Upgrading this dependency should solve this issue.

[TheCelavi]

@lisachenko Beside that, he said:

The declaring class in this case is always Class__AopProxied which is not cached.

Did I understood wrong? When PREBUILT_CACHE is on, that means that you have already warmed up cache in writable environment and you are deploying to non-writable environment? So, even with upgrade of doctrine/annotations, he should warmup cache prior to deploy and deploy it with cache as well, right?

[paventuri]

@TheCelavi - I do warm up the cache before, but $class = $method->getDeclaringClass(); returns the proxied class and not the original class. The proxied class is not cached as part of the warm up process.

[lisachenko]

So, even with upgrade of doctrine/annotations, he should warmup cache prior to deploy and deploy it with cache as well, right?

Yes, you are right, all cache should be already prepared by cache warmer and packed into read-only FS or archive.

[lisachenko]

@paventuri it's ok for $method->getDeclaringClass() to return proxy class, because it's how framework works. You class is replaced with generated proxy in runtime. You can use get_class($invocation->getThis()); for dynamic methods.

[TheCelavi]

@lisachenko in regards to:

Hi! Issue here in doctrine/annotations library, which always checks for write access. Upgrading this dependency should solve this issue.

In change log of doctrine/annotations there is no info about this bug. Do you know which version is problematic one? With next PR, you could add better version constraint, instead of "doctrine/annotations": "~1.0"...

[paventuri]

@lisachenko - not sure if I followed You can use get_class($invocation->getThis()); for dynamic methods. since $method->getDeclaringClass() is called inside Doctrine\Common\Annotations::FileCacheReader->getMethodAnnotations

[paventuri]

Is there a way to overwrite the aspect.annotation.reader ?

[TheCelavi]

@paventuri Go weaves in runtime using proxies. Code of your class, as well as annotations (let say class X) ar in class X_AopProxied, while weaved class is class X that extends X_AopProxied.

So, after weaving, annotation is indeed in X_AopProxied class. Check cache directory of aspects, you will get clearer picture.

[TheCelavi]

@paventuri You can configure containerClass for your AspectKernel class and provide your own implementation. Go\Core\GoAspectContainer is default implementation, line no 91 is line of your interest.

[paventuri]

@TheCelavi - I think we are talking about 2 different things here. I'm talking about Doctrine\Common\Annotations::FileCacheReader, which has its own caching, which is different from the AopCache.

If you look the implementation of Doctrine\Common\Annotations::FileCacheReader->getMethodAnnotations you will see that it gets the X_AopProxied class and tries to find it in its own cache.

public function getMethodAnnotations(\ReflectionMethod $method)
    {
        $class = $method->getDeclaringClass();
        if ( ! isset($this->classNameHashes[$class->name])) {
            $this->classNameHashes[$class->name] = sha1($class->name);
        }
        $key = $this->classNameHashes[$class->name].'#'.$method->getName();

        if (isset($this->loadedAnnotations[$key])) {
            return $this->loadedAnnotations[$key];
        }

        $path = $this->dir.'/'.strtr($key, '\\', '-').'.cache.php';
        if (!is_file($path)) {
            $annot = $this->reader->getMethodAnnotations($method);
            $this->saveCacheFile($path, $annot);
            return $this->loadedAnnotations[$key] = $annot;
        }

        if ($this->debug
            && (false !== $filename = $class->getFilename())
            && filemtime($path) < filemtime($filename)) {
            @unlink($path);

            $annot = $this->reader->getMethodAnnotations($method);
            $this->saveCacheFile($path, $annot);
            return $this->loadedAnnotations[$key] = $annot;
        }

        return $this->loadedAnnotations[$key] = include $path;
    }

This is the way FileCacheReader works.

[TheCelavi]

I think I got it, when AOP cache is created (warmed up), annotations are moved from original classes to proxy classes, while annotation cache is not recreated and therefore, annotation cache misses its reads because new class names are being used for same annotations.

Is that right @paventuri ?