io.dropwizard.auth.AuthValueFactoryProvider Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of dropwizard-auth Show documentation
There is a newer version: 1.3.7
package io.dropwizard.auth;

import org.glassfish.hk2.api.InjectionResolver;
import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.hk2.api.TypeLiteral;
import org.glassfish.hk2.utilities.binding.AbstractBinder;
import org.glassfish.jersey.server.internal.inject.AbstractContainerRequestValueFactory;
import org.glassfish.jersey.server.internal.inject.AbstractValueFactoryProvider;
import org.glassfish.jersey.server.internal.inject.MultivaluedParameterExtractorProvider;
import org.glassfish.jersey.server.internal.inject.ParamInjectionResolver;
import org.glassfish.jersey.server.model.Parameter;
import org.glassfish.jersey.server.spi.internal.ValueFactoryProvider;

import javax.inject.Inject;
import javax.inject.Singleton;
import java.security.Principal;

/**
 * Value factory provider supporting {@link Principal} injection
 * by the {@link Auth} annotation.
 *
 * @param  the type of the principal
 */
@Singleton
public class AuthValueFactoryProvider extends AbstractValueFactoryProvider {

    /**
     * Class of the provided {@link Principal}
     */
    private final Class principalClass;

    /**
     * {@link Principal} value factory provider injection constructor.
     *
     * @param mpep                   multivalued parameter extractor provider
     * @param injector               injector instance
     * @param principalClassProvider provider of the principal class
     */
    @Inject
    public AuthValueFactoryProvider(MultivaluedParameterExtractorProvider mpep,
                                    ServiceLocator injector, PrincipalClassProvider principalClassProvider) {
        super(mpep, injector, Parameter.Source.UNKNOWN);
        this.principalClass = principalClassProvider.clazz;
    }

    /**
     * Return a factory for the provided parameter. We only expect objects of
     * the type {@link T} being annotated with {@link Auth} annotation.
     *
     * @param parameter parameter that was annotated for being injected
     * @return the factory if annotated parameter matched type
     */
    @Override
    public AbstractContainerRequestValueFactory createValueFactory(Parameter parameter) {
        if (!parameter.isAnnotationPresent(Auth.class) || !principalClass.equals(parameter.getRawType())) {
            return null;
        } else {
            return new PrincipalContainerRequestValueFactory();
        }
    }

    @Singleton
    static class AuthInjectionResolver extends ParamInjectionResolver {

        /**
         * Create new {@link Auth} annotation injection resolver.
         */
        AuthInjectionResolver() {
            super(AuthValueFactoryProvider.class);
        }
    }

    @Singleton
    static class PrincipalClassProvider {

        private final Class clazz;

        PrincipalClassProvider(Class clazz) {
            this.clazz = clazz;
        }
    }

    /**
     * Injection binder for {@link AuthValueFactoryProvider} and {@link AuthInjectionResolver}.
     *
     * @param  the type of the principal
     */
    public static class Binder extends AbstractBinder {

        private final Class principalClass;

        public Binder(Class principalClass) {
            this.principalClass = principalClass;
        }

        @Override
        protected void configure() {
            bind(new PrincipalClassProvider<>(principalClass)).to(PrincipalClassProvider.class);
            bind(AuthValueFactoryProvider.class).to(ValueFactoryProvider.class).in(Singleton.class);
            bind(AuthInjectionResolver.class).to(new TypeLiteral>() {
            }).in(Singleton.class);
        }
    }
}