How to use

host

method

in

org.infinispan.persistence.rest.configuration.RestStoreConfigurationBuilder

@Override
public RestStoreConfigurationBuilder host(String host) {
 return builder.host(host);
}

  @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 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);
}

builder.host(value);
break;

} 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();

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 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;
}

@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();
}

@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;
}