@Test public void testRegister() throws Exception { logger.info("start Register test"); Client client = newClient(); Map<Class<?>, Integer> myContracts = new HashMap<Class<?>, Integer>(); myContracts.put(Feature.class, 1200); client.register(MyComponent.class, myContracts); Configuration configuration = client.getConfiguration(); Set<Class<?>> classes = configuration.getClasses(); for (Class<?> clazz : classes) { if (MyComponent.class.isAssignableFrom(clazz)) { Map<Class<?>, Integer> contracts = configuration.getContracts(clazz); int priority = contracts.get(Feature.class); assertTrue("Only standard: Feature, DynamicFeature, WriterInterceptor, " + "ReaderInterceptor, ContainerResponseFilter, " + "ContainerRequestFilter, " + "ClientResponseFilter, ClientRequestFilter, " + "ExceptionMapper, MessageBodyWriter, " + "MessageBodyReader,ParamConverterProvider or implemented: InjectorFactory, " + "StringParameterUnmarshaller, StringConverter, " + "ContextResolver, PostProcessInterceptor, " + "PreProcessInterceptor, ClientExecutionInterceptor, ClientExceptionMapper" + "can be registered as contracts. Registered priority", priority == 1200); } } }
/** * Register a Jersey JSON provider feature only if another JSON provider is not already registered, checking * {@link #JERSEY_JSON_PROVIDER_PROPERTY} property value. * @param context Feature context * @param feature Feature to register * @param featureName Feature name to register * @return <code>true</code> if feature was registered, <code>false</code> otherwise */ private static boolean registerJerseyJsonFeature(FeatureContext context, Class<? extends Feature> feature, String featureName) { final Configuration config = context.getConfiguration(); final String jsonFeature = CommonProperties.getValue(config.getProperties(), config.getRuntimeType(), JERSEY_JSON_PROVIDER_PROPERTY, featureName, String.class); if (!featureName.equalsIgnoreCase(jsonFeature)) { // Other JSON providers registered return false; } // Disable other JSON providers context.property( PropertiesHelper.getPropertyNameForRuntime(JERSEY_JSON_PROVIDER_PROPERTY, config.getRuntimeType()), featureName); // Register if (!config.isRegistered(feature)) { context.register(feature); } return true; }
public TestChain(TestServiceRunnerBase serviceRunner) { this.actions = ImmutableList.of(); this.serviceLocator = new ServiceLocatorHolder(); Feature lifecycleListener = new Feature() { @Inject public void setServiceLocator(ServiceLocator s) { serviceLocator.set(s); } @Override public boolean configure(FeatureContext context) { return false; } }; this.serviceRunner = serviceRunner .serviceConfig(serviceRunner.getServiceConfig() .registerInstance(lifecycleListener) ); }
public synchronized void addFeature(ApplicationKey application, Feature feature) { if (application == null || feature == null) { throw new RuntimeException( "Unable to add feature for " + application); } List<Feature> list; if (features.containsKey(application)) { list = features.get(application); } else { list = new ArrayList<>(); features.put(application, list); } list.add(feature); }
protected ClientConfig createConfig(Set<Feature> features) { ClientConfig config = new ClientConfig(); config.property(ClientProperties.FOLLOW_REDIRECTS, followRedirects); config.property(ClientProperties.READ_TIMEOUT, readTimeoutMs); config.property(ClientProperties.CONNECT_TIMEOUT, connectTimeoutMs); config.property(ClientProperties.ASYNC_THREADPOOL_SIZE, asyncThreadPoolSize); features.forEach(f -> config.register(f)); if (compression) { config.register(new EncodingFeature(GZipEncoder.class)); } configRequestLogging(config); return config; }
@Test public void testDefaultServiceReferencePropertiesAreAvailableInFeatures() { AtomicBoolean executed = new AtomicBoolean(); AtomicReference<Object> propertyvalue = new AtomicReference<>(); registerExtension( Feature.class, featureContext -> { executed.set(true); Map<String, Object> properties = (Map<String, Object>) featureContext.getConfiguration().getProperty( "osgi.jaxrs.application.serviceProperties"); propertyvalue.set(properties.get(JAX_RS_NAME)); return false; }, "Feature", JAX_RS_APPLICATION_SELECT, "("+ JAX_RS_NAME + "=" + JAX_RS_DEFAULT_APPLICATION + ")"); assertTrue(executed.get()); assertEquals(JAX_RS_DEFAULT_APPLICATION, propertyvalue.get()); }
@Test public void testErroredExtension() { registerApplication(new TestApplication()); ServiceRegistration<Feature> serviceRegistration = registerExtension( Feature.class, context -> { throw new RuntimeException(); }, "ErrorFeature", JAX_RS_APPLICATION_SELECT, "(" + JAX_RS_APPLICATION_BASE + "=/test-application)"); RuntimeDTO runtimeDTO = _runtime.getRuntimeDTO(); assertEquals(1, runtimeDTO.failedExtensionDTOs.length); assertEquals( serviceRegistration.getReference().getProperty("service.id"), runtimeDTO.failedExtensionDTOs[0].serviceId); assertEquals( DTOConstants.FAILURE_REASON_UNKNOWN, runtimeDTO.failedExtensionDTOs[0].failureReason); }
@Test public void testFeatureExtension() { WebTarget webTarget = createDefaultTarget().path("/test-application"); registerApplication(new TestApplication()); registerExtension( Feature.class, context -> { context.register(new TestFilter()); return true; }, "Feature", JAX_RS_APPLICATION_SELECT, "(" + JAX_RS_APPLICATION_BASE + "=/test-application)"); Response response = webTarget.request().get(); assertEquals("Hello application", response.readEntity(String.class)); assertEquals("true", response.getHeaders().getFirst("Filtered")); }
@Singleton @Provides private ResourceConfig createResourceConfig(Injector injector, Set<Feature> features, Set<DynamicFeature> dynamicFeatures, @JerseyResource Set<Object> resources, Set<Package> packages, @JerseyResource Map<String, Object> properties) { ResourceConfig config = new ResourceConfig(); packages.forEach(p -> config.packages(true, p.getName())); resources.forEach(r -> config.register(r)); features.forEach(f -> config.register(f)); dynamicFeatures.forEach(df -> config.register(df)); config.addProperties(properties); // TODO: make this pluggable? config.register(ResourceModelDebugger.class); // register Guice Injector as a service in Jersey HK2, and GuiceBridgeFeature as a GuiceBridgeFeature.register(config, injector); return config; }
private void checkAdminGuiceFeature(final Environment environment, final JerseyEnvironment jerseyEnvironment) { try { Feature feature = new Feature() { @Override public boolean configure(FeatureContext context) { for ( Object obj : environment.jersey().getResourceConfig().getSingletons() ) { if ( obj instanceof InternalFeatureRegistrations ) { ((InternalFeatureRegistrations)obj).apply(context); } } return true; } }; jerseyEnvironment.register(feature); } catch ( Exception ignore ) { // ignore - GuiceBundle not added } }
public static AccessToken configureOAuth1( String consumerKey, String consumerSecret, String token, String tokenSecret, ClientBuilder clientBuilder ) { ConsumerCredentials consumerCredentials = new ConsumerCredentials(consumerKey, consumerSecret); AccessToken accessToken = new AccessToken(token, tokenSecret); Feature feature = OAuth1ClientSupport.builder(consumerCredentials) .feature() .accessToken(accessToken) .build(); clientBuilder.register(feature); return accessToken; }
@Override public Application configure() { EntityResolver mockResolver = mock(EntityResolver.class); DataChannel mockChannel = mock(DataChannel.class); when(mockChannel.getEntityResolver()).thenReturn(mockResolver); ServerRuntime runtime = mock(ServerRuntime.class); when(runtime.getChannel()).thenReturn(mockChannel); Feature lrFeature = LinkRestBuilder.build(runtime); Feature testFeature = new Feature() { @Override public boolean configure(FeatureContext context) { context.register(ExceptionResource.class); return true; } }; return new ResourceConfig().register(testFeature).register(lrFeature); }
@Override public Application configure() { Feature lrFeature = new LinkRestBuilder().adapter(new LinkRestAdapter() { @Override public void contributeToRuntime(Binder binder) { binder.bind(SelectProcessorFactory.class).toProvider(PojoSelectProcessorFactoryProvider.class); binder.bind(PojoFetchStage.class).to(PojoFetchStage.class); binder.bind(PojoDB.class).toInstance(pojoDB); } @Override public void contributeToJaxRs(Collection<Feature> features) { // nothing to contribute... } }).build(); Feature unitFeature = context -> { doAddResources(context); return true; }; return new ResourceConfig().register(unitFeature).register(lrFeature); }
@Override public Application configure() { EntityResolver mockResolver = mock(EntityResolver.class); DataChannel mockChannel = mock(DataChannel.class); when(mockChannel.getEntityResolver()).thenReturn(mockResolver); ServerRuntime runtime = mock(ServerRuntime.class); when(runtime.getChannel()).thenReturn(mockChannel); Feature lrFeature = LinkRestBuilder.build(runtime); Feature feature = new Feature() { @Override public boolean configure(FeatureContext context) { context.register(SimpleResponseResource.class); return true; } }; return new ResourceConfig().register(feature).register(lrFeature); }
/** * Create a new UriTemplateApplication. * */ public UriTemplateApplication() { registerClasses(UriTemplateResource.class); registerClasses(SchemaResource.class); register(new Feature() { @Override public boolean configure(final FeatureContext context) { final String disableMoxy = CommonProperties.MOXY_JSON_FEATURE_DISABLE + '.' + context.getConfiguration().getRuntimeType().name().toLowerCase(); context.property(disableMoxy, true); context.register(JacksonJaxbJsonProvider.class, MessageBodyReader.class, MessageBodyWriter.class); return true; } }); }
@Test public void testConfiguration() throws Exception { logger.info("start REST Configuration test"); Client client = newClient(); Configuration configuration = client.getConfiguration(); Set<Class<?>> classes = configuration.getClasses(); for (Class<?> clazz : classes) { assertTrue("verify if the class is a rest component or provider", MessageBodyReader.class.isAssignableFrom(clazz) || MessageBodyWriter.class.isAssignableFrom(clazz) || clazz.isAnnotationPresent(Provider.class) || DynamicFeature.class.isAssignableFrom(clazz)); Map<Class<?>, Integer> contracts = configuration.getContracts(clazz); assertFalse("each class has different contracts", contracts.isEmpty()); for (Class<?> contract : contracts.keySet()) { int value = contracts.get(contract); assertTrue("verify if the contract is a rest component or provider", value == 5000 || value == 4000 || value == 3000 || value == 0); } } Set<Object> instances = configuration.getInstances(); assertTrue("by default there are not instances", instances.isEmpty()); Map<String, Object> properties = configuration.getProperties(); assertTrue("by default there are not properties", properties.isEmpty()); MyComponent myComponent = new MyComponent(); client.register(myComponent); instances = configuration.getInstances(); assertFalse("Added instance", instances.isEmpty()); for (Object instance : instances) { if (instance instanceof MyComponent) assertTrue("MyComponent is registered and active", configuration.isEnabled((Feature) instance)); } assertEquals("Added property through MyComponent", 1, properties.size()); boolean property = (Boolean) properties.get("configured_myComponent"); assertEquals("configured_myComponent ok!", true, property); assertEquals("type CLIENT by default", CLIENT, configuration.getRuntimeType()); }
@SuppressWarnings("unchecked") private void registerFeature(final Class<?> c) { if (!Feature.class.isAssignableFrom(c)) { return; } final Class<? extends Feature> featureClass = (Class<? extends Feature>) c; try { get(featureClass).configure(this); } catch (final Exception ex) { throw new MinijaxException(ex); } }
@Inject public DefaultResourceConfigProvider(Set<Feature> features, Set<Class<? extends Feature>> featureClasses, Injector injector) { this.features = features; this.featureClasses = featureClasses; this.injector = injector; }
@ProvidesIntoSet Feature exceptionMappersFeature() { return (context) -> { context.register(RuntimeExceptionMapper.class); context.register(WebApplicationExceptionMapper.class); return true; }; }
@Test public void configure() throws Exception { Feature feature = new BoundWebResourcesFeature(injector); feature.configure(featureContext); Mockito.verify(featureContext, Mockito.times(2)).register(Matchers.any(Object.class)); }
@ProvidesIntoSet Feature customFeature() { return (context) -> { context.register(xPoweredByFilter()); context.register(requestLoggerFilter()); return true; }; }
public HttpClientFactory createClientFactory(Injector injector, Set<Feature> features) { ClientConfig config = createConfig(features); // register Guice Injector as a service in Jersey HK2, and // GuiceBridgeFeature as a ClientGuiceBridgeFeature.register(config, injector); KeyStore trustStore = createTrustStore(); return new DefaultHttpClientFactory(config, trustStore, createAuthFilters(injector)); }
protected Multibinder<Feature> contributeFeatures() { if (features == null) { features = Multibinder.newSetBinder(binder, Feature.class, JerseyClientFeatures.class); } return features; }
@Provides @Singleton HttpClientFactory createClientFactory(ConfigurationFactory configurationFactory, Injector injector, @JerseyClientFeatures Set<Feature> features) { return configurationFactory.config(HttpClientFactoryFactory.class, configPrefix).createClientFactory(injector, features); }
@Test public void testFeatureProvider() { Feature feature = mock(Feature.class); LrFeatureProvider featureProvider = mock(LrFeatureProvider.class); when(featureProvider.feature(any(Injector.class))).thenReturn(feature); testFactory.app("-c", "classpath:LinkRestModuleExtenderIT.yml") .autoLoadModules() .module(b -> LinkRestModule.extend(b).addFeatureProvider(featureProvider)) .start(); verify(featureProvider).feature(any(Injector.class)); verify(feature).configure(any(FeatureContext.class)); }
@Test public void testServiceReferencePropertiesAreAvailableInFeatures() { AtomicBoolean executed = new AtomicBoolean(); AtomicReference<Object> propertyvalue = new AtomicReference<>(); registerExtension( Feature.class, featureContext -> { executed.set(true); Map<String, Object> properties = (Map<String, Object>) featureContext.getConfiguration().getProperty( "osgi.jaxrs.application.serviceProperties"); propertyvalue.set(properties.get("property")); return false; }, "Feature", JAX_RS_APPLICATION_SELECT, "(property=true)"); registerApplication( new Application() { @Override public Set<Object> getSingletons() { return Collections.singleton( new Object() { @GET public String hello() { return "hello"; } }); } }, JAX_RS_NAME, "test", "property", true); assertTrue(executed.get()); assertEquals(true, propertyvalue.get()); }
@Test public void testServiceReferencePropertiesAreAvailableInStaticFeatures() { AtomicBoolean executed = new AtomicBoolean(); AtomicReference<Object> propertyvalue = new AtomicReference<>(); registerApplication( new Application() { @Override public Set<Object> getSingletons() { return new HashSet<>(Arrays.asList( (Feature)featureContext -> { executed.set(true); Map<String, Object> properties = (Map<String, Object>) featureContext.getConfiguration().getProperty( "osgi.jaxrs.application.serviceProperties"); propertyvalue.set(properties.get("property")); return false; }, new Object() { @GET public String hello() { return "hello"; } } )); } }, JAX_RS_NAME, "test", "property", true); assertTrue(executed.get()); assertEquals(true, propertyvalue.get()); }
private Client createClient(ObjectMapper objectMapper) { final ClientConfig clientConfig = new ClientConfig(); clientConfig.property(ClientProperties.FOLLOW_REDIRECTS, true); clientConfig.property(ClientProperties.CONNECT_TIMEOUT, 3000); clientConfig.property(ClientProperties.READ_TIMEOUT, 3000); clientConfig.property(ClientProperties.FEATURE_AUTO_DISCOVERY_DISABLE, true); final JacksonJsonProvider jacksonJsonProvider = new JacksonJsonProvider(objectMapper); final Client client = ClientBuilder.newClient(clientConfig).register(jacksonJsonProvider).register(MultiPartFeature.class); final Feature feature = new LoggingFeature(JERSEY_LOGGER, Level.FINE, LoggingFeature.Verbosity.PAYLOAD_ANY, null); client.register(feature); return client; }
@Inject public DaggerApplication(Set<Feature> features, @Resources Set<Object> resources, @Providers Set<Object> providers) { this.singletons = ImmutableSet.builder() .addAll(features) .addAll(resources) .addAll(providers) .build(); }
/** * {@inheritDoc} */ @Override public void setup(final Application application) { final Set<ClassInfo> classInfoSet = Sets.newLinkedHashSet(); subscribeSystemEvent(ClassFoundEvent.class, event -> event.accept(info -> { if (info.containsAnnotations(Service.class)) { classInfoSet.add(info); return true; } return false; })); final Feature localResource = new Feature() { @Inject private ServiceLocator locator; @Override public boolean configure(FeatureContext context) { for (ClassInfo classInfo : classInfoSet) { ServiceLocatorUtilities.addClasses(locator, classInfo.toClass()); } classInfoSet.clear(); return true; } }; application.register(localResource); }
@Override public boolean configure(FeatureContext context) { if (!context.getConfiguration().isRegistered(ShiroDynamicFeature.class)) { if (!context.getConfiguration().isRegistered(Cache.Feature.class)) { context.register(Cache.Feature.class) .register(this); return false; } String conf = (String) context.getConfiguration().getProperty("security.shiro.conf"); Ini ini = new Ini(); InputStream in = IOUtils.getResourceAsStream(conf); if (in != null) { try { ini.load(in); } finally { IOUtils.closeQuietly(in); } } else { logger.warn("No Shiro configuration found."); } IniSecurityManagerFactory factory = new IniSecurityManagerFactory(ini, injectionManager); final SecurityManager securityManager = factory.getInstance(); SecurityUtils.setSecurityManager(securityManager); context.register(ShiroDynamicFeature.class) .register(ShiroExceptionMapper.class) .register(new ShiroBinder(securityManager)) .register(ShiroContainerFilter.class); return true; } return false; }
@Override public boolean configure(FeatureContext context) { // this gives everyone access to the LinkRest services context.property(LinkRestRuntime.LINK_REST_CONTAINER_PROPERTY, injector); @SuppressWarnings("unchecked") Map<String, Class> bodyWriters = injector.getInstance(Key.getMapOf(String.class, Class.class, LinkRestRuntime.BODY_WRITERS_MAP)); for (Class<?> type : bodyWriters.values()) { context.register(type); } context.register(ResponseStatusDynamicFeature.class); context.register(EntityUpdateReader.class); context.register(EntityUpdateCollectionReader.class); for (Class<?> c : extraComponents) { context.register(c); } for (Feature f : extraFeatures) { f.configure(context); } return true; }
@Test public void testMapException_Standard() { LinkRestBuilder builder = new LinkRestBuilder(); Feature f = builder.build(); FeatureContext context = mock(FeatureContext.class); f.configure(context); verify(context).register(ValidationExceptionMapper.class); }
@Test public void testMapException_Custom() { LinkRestBuilder builder = new LinkRestBuilder().mapException(TestValidationExceptionMapper.class); Feature f = builder.build(); FeatureContext context = mock(FeatureContext.class); f.configure(context); verify(context).register(TestValidationExceptionMapper.class); verify(context, never()).register(ValidationExceptionMapper.class); }
@Test public void testBuild_Adapter() { final Feature adapterFeature = mock(Feature.class); LinkRestAdapter adapter = mock(LinkRestAdapter.class); doAnswer((Answer<Object>) invocation -> { @SuppressWarnings("unchecked") Collection<Feature> c = (Collection<Feature>) invocation.getArguments()[0]; c.add(adapterFeature); return null; }).when(adapter).contributeToJaxRs(anyCollectionOf(Feature.class)); final IRequestParser mockParser = mock(IRequestParser.class); doAnswer((Answer<Object>) invocation -> { Binder b = (Binder) invocation.getArguments()[0]; b.bind(IRequestParser.class).toInstance(mockParser); return null; }).when(adapter).contributeToRuntime(any(Binder.class)); LinkRestRuntime runtime = new LinkRestBuilder().adapter(adapter).build(); assertSame(mockParser, runtime.service(IRequestParser.class)); FeatureContext context = mock(FeatureContext.class); runtime.configure(context); verify(adapterFeature).configure(context); }
@Override public Application configure() { LinkRestRuntime lrFeature = doConfigure().build(); Feature unitFeature = context -> { doAddResources(context); return true; }; return new ResourceConfig() .register(unitFeature) .register(lrFeature); }
@Override public Feature feature(Injector injector) { return context -> { context.register(SenchaDeletePayloadParser.class); return true; }; }
public SensorSafeResourceConfig() { // Register OAuthServerFeature Feature oauthFeature = new SensorSafeOAuth1ServerFeature(oauthProvider, REQUEST_TOKEN_API_PATH, ACCESS_TOKEN_API_PATH); register(oauthFeature); // Register RolesAllowedDynamicFeature register(RolesAllowedDynamicFeature.class); }
private boolean isJaxrsFeatureOrProvider(Object object) { Class<?> clazz = object.getClass(); boolean isFeature = Feature.class.isAssignableFrom(clazz); boolean isProvider = clazz.isAnnotationPresent(javax.ws.rs.ext.Provider.class); return isFeature || isProvider; }