- Add the Codota plugin to your IDE and get smart completions
private void myMethod () {DateTime d =
new DateTime()
- Smart code suggestions by Codota
}
@Override public ConnectionPoolConfigurationBuilder connectionPool() { return builder.connectionPool(); }
@Override public RestStoreConfigurationBuilder host(String host) { return builder.host(host); }
@Override public RestStoreConfigurationBuilder path(String path) { return builder.path(path); }
} else if (storeKey.equals(ModelKeys.REST_STORE)) { final RestStoreConfigurationBuilder builder = persistenceBuilder.addStore(RestStoreConfigurationBuilder.class); builder.host("localhost"); // To pass builder validation, the builder will be configured properly when the outbound socket is ready to be injected for (ModelNode server : store.require(ModelKeys.REMOTE_SERVERS).asList()) { String outboundSocketBinding = server.get(ModelKeys.OUTBOUND_SOCKET_BINDING).asString(); dependencies.add(new Dependency<>(OutboundSocketBinding.OUTBOUND_SOCKET_BINDING_BASE_SERVICE_NAME.append(outboundSocketBinding), OutboundSocketBinding.class, injector)); builder.appendCacheNameToPath(RestStoreConfigurationResource.APPEND_CACHE_NAME_TO_PATH.resolveModelAttribute(context, store).asBoolean()); builder.path(RestStoreConfigurationResource.PATH.resolveModelAttribute(context, store).asString()); builder.maxContentLength(RestStoreConfigurationResource.MAX_CONTENT_LENGTH.resolveModelAttribute(context, store).asInt()); builder.rawValues(true); builder.connectionPool().bufferSize(RestStoreConfigurationResource.BUFFER_SIZE.resolveModelAttribute(context, pool).asInt()); builder.connectionPool().connectionTimeout(RestStoreConfigurationResource.CONNECTION_TIMEOUT.resolveModelAttribute(context, pool).asInt()); builder.connectionPool().maxConnectionsPerHost(RestStoreConfigurationResource.MAX_CONNECTIONS_PER_HOST.resolveModelAttribute(context, pool).asInt()); builder.connectionPool().maxTotalConnections(RestStoreConfigurationResource.MAX_TOTAL_CONNECTIONS.resolveModelAttribute(context, pool).asInt()); builder.connectionPool().socketTimeout(RestStoreConfigurationResource.SOCKET_TIMEOUT.resolveModelAttribute(context, pool).asInt()); builder.connectionPool().tcpNoDelay(RestStoreConfigurationResource.TCP_NO_DELAY.resolveModelAttribute(context, pool).asBoolean());
switch (attribute) { case APPEND_CACHE_NAME_TO_PATH: { builder.appendCacheNameToPath(Boolean.parseBoolean(value)); break; builder.host(value); break; builder.path(value); break; builder.port(Integer.parseInt(value)); break; builder.key2StringMapper(value); break;
protected void configurePersistence(ConfigurationBuilder cb) { localCacheManager = TestCacheManagerFactory.createServerModeCacheManager(); RestServerConfigurationBuilder restServerConfigurationBuilder = new RestServerConfigurationBuilder(); restServer = new RestServer(); restServer.start(restServerConfigurationBuilder.build(), localCacheManager); cb.persistence().addStore(RestStoreConfigurationBuilder.class) .host("localhost") .port(restServer.getPort()) .path("/rest/"+ BasicCacheContainer.DEFAULT_CACHE_NAME) .preload(false); }
@Override protected AdvancedLoadWriteStore createStore() throws Exception { ConfigurationBuilder localBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); localBuilder.memory().evictionType(EvictionType.COUNT).size(WRITE_DELETE_BATCH_MAX_ENTRIES).expiration().wakeUpInterval(10L); localCacheManager = TestCacheManagerFactory.createServerModeCacheManager(localBuilder); localCacheManager.defineConfiguration(REMOTE_CACHE, localCacheManager.getDefaultCacheConfiguration()); localCacheManager.getCache(REMOTE_CACHE); TestingUtil.replaceComponent(localCacheManager, TimeService.class, timeService, true); localCacheManager.getCache(REMOTE_CACHE).getAdvancedCache().getComponentRegistry().rewire(); RestServerConfigurationBuilder restServerConfigurationBuilder = new RestServerConfigurationBuilder(); restServerConfigurationBuilder.port(0); restServer = new RestServer(); restServer.start(restServerConfigurationBuilder.build(), localCacheManager); ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); RestStoreConfigurationBuilder storeConfigurationBuilder = builder.persistence() .addStore(RestStoreConfigurationBuilder.class); storeConfigurationBuilder.host(restServer.getHost()).port(restServer.getPort()).path("/rest/" + REMOTE_CACHE); storeConfigurationBuilder.connectionPool().maxTotalConnections(10).maxConnectionsPerHost(10); storeConfigurationBuilder.validate(); RestStore restStore = new RestStore(); restStore.init(createContext(builder.build())); return restStore; }
@BeforeClass public void setup() { RestServerConfigurationBuilder restServerConfigurationBuilder = new RestServerConfigurationBuilder(); restServerConfigurationBuilder.port(0); ConfigurationBuilder serverBuilder = getSourceServerBuilder(); sourceContainer = TestCacheManagerFactory.createServerModeCacheManager(serverBuilder); sourceServerCache = sourceContainer.getCache(); sourceServer = new RestServer(); sourceServer.start(restServerConfigurationBuilder.build(), sourceContainer); ConfigurationBuilder targetConfigurationBuilder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); targetConfigurationBuilder.persistence().addStore(RestStoreConfigurationBuilder.class).host("localhost").port(sourceServer.getPort()) .path("/rest/" + BasicCacheContainer.DEFAULT_CACHE_NAME).rawValues(true).locking().isolationLevel(IsolationLevel.NONE); targetConfigurationBuilder.encoding().key().mediaType(LEGACY_KEY_ENCODING); targetContainer = TestCacheManagerFactory.createServerModeCacheManager(targetConfigurationBuilder); targetServerCache = targetContainer.getCache(); targetServer = new RestServer(); targetServer.start(restServerConfigurationBuilder.build(), targetContainer); client = new HttpClient(); }
switch (attribute) { case APPEND_CACHE_NAME_TO_PATH: { builder.appendCacheNameToPath(Boolean.parseBoolean(value)); break; builder.path(value); break; builder.key2StringMapper(value); break; builder.rawValues(Boolean.parseBoolean(value)); break; builder.maxContentLength(Integer.parseInt(value)); break;
@Override public void inject(OutboundSocketBinding value) { try { builder.host(value.getResolvedDestinationAddress().getHostAddress()).port(value.getDestinationPort()); // FIXME: add support for multiple hosts } catch (UnknownHostException e) { throw InfinispanMessages.MESSAGES.failedToInjectSocketBinding(e, value); } } };
private void parseRestStore(final XMLExtendedStreamReader reader, PersistenceConfigurationBuilder loadersBuilder, ClassLoader classLoader) throws XMLStreamException { RestStoreConfigurationBuilder builder = new RestStoreConfigurationBuilder(loadersBuilder); parseRestStoreAttributes(reader, builder, classLoader); while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { Element element = Element.forName(reader.getLocalName()); switch (element) { case CONNECTION_POOL: { parseConnectionPool(reader, builder.connectionPool()); break; } default: { Parser60.parseCommonStoreChildren(reader, builder); break; } } } loadersBuilder.addStore(builder); }
@Override public RestStoreConfigurationBuilder port(int port) { return builder.port(port); }
@Override public RestStoreConfigurationBuilder appendCacheNameToPath(boolean appendCacheNameToPath) { return builder.appendCacheNameToPath(appendCacheNameToPath); }
@Override public RestStoreConfigurationBuilder rawValues(boolean rawValues) { return builder.rawValues(rawValues); }
@Override public RestStoreConfigurationBuilder key2StringMapper(Class<? extends MarshallingTwoWayKey2StringMapper> klass) { return builder.key2StringMapper(klass); }
@Override public RestStoreConfigurationBuilder maxContentLength(int maxContentLength) { return builder.maxContentLength(maxContentLength); } }
@Override protected PersistenceConfigurationBuilder createCacheStoreConfig(PersistenceConfigurationBuilder loaders, boolean preload) { localCacheManager = TestCacheManagerFactory.createServerModeCacheManager(); RestServerConfigurationBuilder restServerConfigurationBuilder = new RestServerConfigurationBuilder(); restServerConfigurationBuilder.port(0); restServer = new RestServer(); restServer.start(restServerConfigurationBuilder.build(), cacheManager); loaders.addStore(RestStoreConfigurationBuilder.class) .host("localhost") .port(restServer.getPort()) .path("/rest/"+BasicCacheContainer.DEFAULT_CACHE_NAME) .preload(preload); return loaders; }
private void parseServer(XMLExtendedStreamReader reader, RestStoreConfigurationBuilder builder) throws XMLStreamException { for (int i = 0; i < reader.getAttributeCount(); i++) { ParseUtils.requireNoNamespaceAttribute(reader, i); String value = replaceProperties(reader.getAttributeValue(i)); Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case HOST: builder.host(value); break; case PORT: builder.port(Integer.parseInt(value)); break; case OUTBOUND_SOCKET_BINDING: log.ignoreXmlAttribute(attribute); break; default: throw ParseUtils.unexpectedAttribute(reader, i); } } ParseUtils.requireNoContent(reader); }
private void parseRestStore(final XMLExtendedStreamReader reader, PersistenceConfigurationBuilder loadersBuilder) throws XMLStreamException { RestStoreConfigurationBuilder builder = new RestStoreConfigurationBuilder(loadersBuilder); parseRestStoreAttributes(reader, builder); while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { Element element = Element.forName(reader.getLocalName()); switch (element) { case CONNECTION_POOL: { parseConnectionPool(reader, builder.connectionPool()); break; } case SERVER: { parseServer(reader, builder); break; } default: { Parser.parseStoreElement(reader, builder); break; } } } loadersBuilder.addStore(builder); }
@Override public RestStoreConfigurationBuilder key2StringMapper(String key2StringMapper) { return builder.key2StringMapper(key2StringMapper); }