@Override public List<ResourceFilter> create(AbstractMethod am) { // DenyAll on the method take precedence over RolesAllowed and PermitAll if (am.isAnnotationPresent(DenyAll.class)) return Collections.<ResourceFilter>singletonList(new Filter()); // RolesAllowed on the method takes precedence over PermitAll RolesAllowed ra = am.getAnnotation(RolesAllowed.class); if (ra != null) return Collections.<ResourceFilter>singletonList(new Filter(ra.value())); // PermitAll takes precedence over RolesAllowed on the class if (am.isAnnotationPresent(PermitAll.class)) return null; // RolesAllowed on the class takes precedence over PermitAll ra = am.getResource().getAnnotation(RolesAllowed.class); if (ra != null) return Collections.<ResourceFilter>singletonList(new Filter(ra.value())); // No need to check whether PermitAll is present. return null; } }
private boolean isAnonymousAllowed() { return (abstractMethod.getMethod() != null && abstractMethod.getMethod().getAnnotation(AnonymousAllowed.class) != null) || abstractMethod.getResource().getAnnotation(AnonymousAllowed.class) != null; }
public List<ResourceFilter> create(AbstractMethod am) { ResourceFilters rfs = am.getAnnotation(ResourceFilters.class); if (rfs == null) rfs = am.getResource().getAnnotation(ResourceFilters.class); if (rfs == null) return null; return getResourceFilters(rfs.value()); }
private static boolean annotationIsPresent(AbstractMethod method, Class<? extends Annotation> annotationType) { return method.isAnnotationPresent(annotationType) || method.getResource().isAnnotationPresent(annotationType) || packageHasAnnotation(annotationType, method.getResource().getResourceClass().getPackage()); }
@Override public List<ResourceFilter> create(AbstractMethod am) { if (am.isAnnotationPresent(CacheMaxAge.class)) { CacheMaxAge maxAge = am.getAnnotation(CacheMaxAge.class); return newCacheFilter("max-age: " + maxAge.unit().toSeconds(maxAge.time())); } else if (am.isAnnotationPresent(NoCache.class)) { return newCacheFilter("no-cache"); } else { return Collections.emptyList(); } } private List<ResourceFilter> newCacheFilter(String content) { return Collections .<ResourceFilter> singletonList(new CacheResponseFilter(content)); }
public List<ResourceFilter> create(final AbstractMethod method) { final boolean hasEnforceAnnotation = hasRequiresXsrfCheckAnnotation( method) || hasRequiresXsrfCheckAnnotation(method.getResource()); final boolean hasExcludeAnnotation = isXsrfProtectionExcludedAnnotationPresent(method.getAnnotations()); XsrfResourceFilter xsrfResourceFilter = null; if (inLegacyXsrfMode()) { if (hasEnforceAnnotation) { xsrfResourceFilter = new XsrfResourceFilter(); } else if (method.getAnnotations().length != 0) { xsrfResourceFilter = new OriginBasedXsrfResourceFilter(); method.isAnnotationPresent(GET.class) && hasEnforceAnnotation) || (!method.isAnnotationPresent(GET.class) && !hasExcludeAnnotation)) { xsrfResourceFilter = new XsrfResourceFilter();
am.getAnnotation(BodySizeLimit.class), am.getResource().getAnnotation(BodySizeLimit.class)); final Method realMethod = am.getMethod(); Class<?> resourceClass = am.getResource().getResourceClass(); Map<String, Long> foundValues = Maps.newLinkedHashMap(); do {
for (Annotation annotation : am.getAnnotations()) { logger.trace("AtmosphereFilter processing annotation: {}", annotation); if (am.getMethod() == null) { return null; if (SuspendResponse.class.isAssignableFrom(am.getMethod().getReturnType())) { list.addLast(new Filter(Action.SUSPEND_RESPONSE)); return list; if (am.isAnnotationPresent(Broadcast.class)) { int delay = am.getAnnotation(Broadcast.class).delay(); Class[] broadcastFilter = am.getAnnotation(Broadcast.class).filters(); if (am.getAnnotation(Broadcast.class).resumeOnBroadcast()) { f = new Filter(Action.RESUME_ON_BROADCAST, delay, 0, Suspend.SCOPE.APPLICATION, broadcastFilter, null, am.getAnnotation(Broadcast.class).writeEntity()); } else { f = new Filter(Action.BROADCAST, delay, 0, Suspend.SCOPE.APPLICATION, broadcastFilter, null, am.getAnnotation(Broadcast.class).writeEntity()); if (am.isAnnotationPresent(Cluster.class)) { broadcastFilter = am.getAnnotation(Cluster.class).value(); for (Class<ClusterBroadcastFilter> c : broadcastFilter) { try { ClusterBroadcastFilter cbf = c.newInstance(); cbf.setUri(am.getAnnotation(Cluster.class).name()); f.addCluster(cbf); } catch (Throwable t) {
public class OverrideInputTypeResourceFilterFactory implements ResourceFilterFactory { @Override public List<ResourceFilter> create(AbstractMethod am) { // documented to only be AbstractSubResourceLocator, AbstractResourceMethod, or AbstractSubResourceMethod if (am instanceof AbstractSubResourceLocator) { // not actually invoked per request, nothing to do log.debug("Ignoring AbstractSubResourceLocator {}", am); return null; } else if (am instanceof AbstractResourceMethod) { OverrideInputType annotation = am.getAnnotation(OverrideInputType.class); if (annotation == null) { annotation = am.getResource().getAnnotation(OverrideInputType.class); } if (annotation != null) { return Lists.<ResourceFilter>newArrayList( new OverrideInputTypeResourceFilter(annotation.value(), annotation.except())); } } else { log.warn("Got an unexpected instance of {}: {}", am.getClass().getName(), am); } return null; } }
@Override public List<ResourceFilter> create(final AbstractMethod am) { if (getAnnotation(RequiresDarkFeature.class, am) != null || getAnnotation(RequiresDarkFeature.class, am.getResource()) != null) { log.debug("RequiresDarkFeature annotation found - creating filter"); return Collections.<ResourceFilter>singletonList(new DarkFeatureResourceFilter(am, darkFeatureManager)); } log.debug("No RequiresDarkFeature annotation found - not creating filter"); return Collections.emptyList(); } }
@Override public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) { return getAnnotation(annotationType) != null; } }
/** * @param r * @param m * @param p * @return the enhanced {@link Param} * @see com.sun.jersey.server.wadl.WadlGenerator#createParam(com.sun.jersey.api.model.AbstractResource, com.sun.jersey.api.model.AbstractMethod, com.sun.jersey.api.model.Parameter) */ public Param createParam(AbstractResource r, AbstractMethod m, Parameter p) { final Param result = _delegate.createParam(r, m, p); if (result != null) { final ParamDocType paramDoc = resourceDoc.getParamDoc( r.getResourceClass(), (m == null ? null : m.getMethod()), p ); if(paramDoc != null && !isEmpty( paramDoc.getCommentText())) { final Doc doc = new Doc(); doc.getContent().add( paramDoc.getCommentText() ); result.getDoc().add( doc ); } } return result; }
public List<ResourceFilter> create(final AbstractMethod abstractMethod) { return abstractMethod.isAnnotationPresent(Secure.class) ? Collections.<ResourceFilter>singletonList(new IsSecureFilter()): null;
public List<ResourceFilter> create(final AbstractMethod method) { if (annotationIsPresent(method, CorsAllowed.class)) { String targetMethod = HttpMethod.GET; for (Annotation ann : method.getAnnotations()) { HttpMethod m = ann.annotationType().getAnnotation(HttpMethod.class); if (m != null) { targetMethod = m.value(); break; } } ResourceFilter resourceFilter = new CorsResourceFilter(tracker, targetMethod); return singletonList(resourceFilter); } else { return emptyList(); } }
@Override public List<ResourceFilter> create(AbstractMethod am) { if (am.getResource().getAnnotation(Unbuffered.class) != null || am.getAnnotation(Unbuffered.class) != null) { return ImmutableList.of(this); } return ImmutableList.of(); }
/** * Check if the {@link AdminRequired} annotation is present for this {@link AbstractMethod} * * @return {@code true} if the {@link AdminRequired} annotation is present on the method or resource */ private boolean isAdminRequired() { return ((abstractMethod != null) && (abstractMethod.isAnnotationPresent(AdminRequired.class) || abstractMethod.getResource().isAnnotationPresent(AdminRequired.class))); }
@Override public List<ResourceFilter> create(AbstractMethod abstractMethod) { List<ResourceFilter> resourceFilters = Lists.newArrayList(); if (abstractMethod.isAnnotationPresent(ThrottleConcurrentRequests.class)) { int maxRequests = abstractMethod.getAnnotation(ThrottleConcurrentRequests.class).maxRequests(); InstanceConcurrentRequestRegulatorSupplier regulatorSupplier = new InstanceConcurrentRequestRegulatorSupplier( new DefaultConcurrentRequestRegulator(SEMAPHORE_PROPERTY, maxRequests, _meter)); resourceFilters.add(new ConcurrentRequestsThrottlingFilter(regulatorSupplier)); } return resourceFilters; } }
@Override public ContainerRequest filter(final ContainerRequest request) { log.debug("Applying dark feature filter to request {} {}", request.getMethod(), request.getRequestUri()); if (accessIsAllowed(abstractMethod) && accessIsAllowed(abstractMethod.getResource())) { log.debug("Dark feature check OK"); return request; } log.debug("Dark feature check failed. Refusing access to the resource."); throw new NotFoundException(request.getRequestUri()); }
CacheControlHeader cch = am.getAnnotation(CacheControlHeader.class); if (cch == null) { return NO_CACHE_FILTER;
Invokable.from(abstractMethod.getMethod()).getParameters();