private void buildCacheStore( OperationContext context, LoaderConfigurationBuilder builder, String containerName, ModelNode store, String storeKey, List<Dependency<?>> dependencies) throws OperationFailedException { final Properties properties = new TypedProperties(); if (store.hasDefined(ModelKeys.PROPERTY)) { for (Property property : store.get(ModelKeys.PROPERTY).asPropertyList()) { // the format of the property elements // "property" => { // "relative-to" => {"value" => "fred"}, // } String propertyName = property.getName(); Property complexValue = property.getValue().asProperty(); String propertyValue = complexValue.getValue().asString(); properties.setProperty(propertyName, propertyValue); } } builder.withProperties(properties); ModelNode resolvedValue = null; if (storeKey.equals(ModelKeys.FILE_STORE)) { builder.cacheLoader(new FileCacheStore()); final String path = ((resolvedValue = CommonAttributes.PATH.resolveModelAttribute(context, store)) .isDefined()) ? resolvedValue.asString() : InfinispanExtension.SUBSYSTEM_NAME + File.separatorChar + containerName; final String relativeTo = ((resolvedValue = CommonAttributes.RELATIVE_TO.resolveModelAttribute(context, store)) .isDefined()) ? resolvedValue.asString() : ServerEnvironment.SERVER_DATA_DIR; Injector<PathManager> injector = new SimpleInjector<PathManager>() { volatile PathManager.Callback.Handle callbackHandle; @Override public void inject(PathManager value) { callbackHandle = value.registerCallback( relativeTo, PathManager.ReloadServerCallback.create(), PathManager.Event.UPDATED, PathManager.Event.REMOVED); properties.setProperty("location", value.resolveRelativePathEntry(path, relativeTo)); } @Override public void uninject() { super.uninject(); if (callbackHandle != null) { callbackHandle.remove(); } } }; dependencies.add( new Dependency<PathManager>( PathManagerService.SERVICE_NAME, PathManager.class, injector)); properties.setProperty("fsyncMode", "perWrite"); } else if (storeKey.equals(ModelKeys.STRING_KEYED_JDBC_STORE) || storeKey.equals(ModelKeys.BINARY_KEYED_JDBC_STORE) || storeKey.equals(ModelKeys.MIXED_KEYED_JDBC_STORE)) { builder.cacheLoader(this.createJDBCStore(properties, context, store)); final String datasource = CommonAttributes.DATA_SOURCE.resolveModelAttribute(context, store).asString(); dependencies.add(new Dependency<Object>(ServiceName.JBOSS.append("data-source", datasource))); properties.setProperty("datasourceJndiLocation", datasource); properties.setProperty("connectionFactoryClass", ManagedConnectionFactory.class.getName()); } else if (storeKey.equals(ModelKeys.REMOTE_STORE)) { builder.cacheLoader(new RemoteCacheStore()); for (ModelNode server : store.require(ModelKeys.REMOTE_SERVERS).asList()) { String outboundSocketBinding = server.get(ModelKeys.OUTBOUND_SOCKET_BINDING).asString(); Injector<OutboundSocketBinding> injector = new SimpleInjector<OutboundSocketBinding>() { @Override public void inject(OutboundSocketBinding value) { try { String address = value.getDestinationAddress().getHostAddress() + ":" + value.getDestinationPort(); String serverList = properties.getProperty("serverList"); properties.setProperty( "serverList", (serverList == null) ? address : serverList + ";" + address); } catch (UnknownHostException e) { throw InfinispanMessages.MESSAGES.failedToInjectSocketBinding(e, value); } } }; dependencies.add( new Dependency<OutboundSocketBinding>( OutboundSocketBinding.OUTBOUND_SOCKET_BINDING_BASE_SERVICE_NAME.append( outboundSocketBinding), OutboundSocketBinding.class, injector)); } if (store.hasDefined(ModelKeys.CACHE)) { properties.setProperty("remoteCacheName", store.get(ModelKeys.CACHE).asString()); properties.setProperty("useDefaultRemoteCache", Boolean.toString(false)); } else { properties.setProperty("useDefaultRemoteCache", Boolean.toString(true)); } if (store.hasDefined(ModelKeys.SOCKET_TIMEOUT)) { properties.setProperty("soTimeout", store.require(ModelKeys.SOCKET_TIMEOUT).asString()); } if (store.hasDefined(ModelKeys.TCP_NO_DELAY)) { properties.setProperty("tcpNoDelay", store.require(ModelKeys.TCP_NO_DELAY).asString()); } } else { String className = store.require(ModelKeys.CLASS).asString(); try { CacheLoader loader = CacheLoader.class .getClassLoader() .loadClass(className) .asSubclass(CacheLoader.class) .newInstance(); builder.cacheLoader(loader); } catch (Exception e) { throw new IllegalArgumentException( String.format("%s is not a valid cache store", className), e); } } }
@SuppressWarnings("deprecation") private void parseJDBCStore( XMLExtendedStreamReader reader, ModelNode cache, List<ModelNode> operations) throws XMLStreamException { // ModelNode for the store add operation ModelNode storeAddress = cache.get(ModelDescriptionConstants.OP_ADDR).clone(); // we can't determine the full address until we know which tables are present ModelNode store = Util.getEmptyOperation(ModelDescriptionConstants.ADD, null); for (int i = 0; i < reader.getAttributeCount(); i++) { String value = reader.getAttributeValue(i); Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i)); switch (attribute) { case DATASOURCE: { CommonAttributes.DATA_SOURCE.parseAndSetParameter(value, store, reader); break; } default: { this.parseStoreAttribute(reader, i, attribute, value, store); } } } if (!store.hasDefined(ModelKeys.DATASOURCE)) { throw ParseUtils.missingRequired(reader, EnumSet.of(Attribute.DATASOURCE)); } while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { Element element = Element.forName(reader.getLocalName()); switch (element) { case ENTRY_TABLE: { this.parseJDBCStoreTable( reader, store.get(ModelKeys.STRING_KEYED_TABLE).setEmptyObject()); break; } case BUCKET_TABLE: { this.parseJDBCStoreTable( reader, store.get(ModelKeys.BINARY_KEYED_TABLE).setEmptyObject()); break; } default: { this.parseStoreProperty(reader, store); } } } // we determine the store address by the presence / absence of tables boolean isStringTableDefined = store.get(ModelKeys.STRING_KEYED_TABLE).isDefined(); boolean isBinaryTableDefined = store.get(ModelKeys.BINARY_KEYED_TABLE).isDefined(); // if no tables are defined, we default to mixed store if (isStringTableDefined && !isBinaryTableDefined) { storeAddress.add(ModelKeys.STRING_KEYED_JDBC_STORE, ModelKeys.STRING_KEYED_JDBC_STORE_NAME); storeAddress.protect(); } else if (!isStringTableDefined && isBinaryTableDefined) { storeAddress.add(ModelKeys.BINARY_KEYED_JDBC_STORE, ModelKeys.BINARY_KEYED_JDBC_STORE_NAME); storeAddress.protect(); } else { storeAddress.add(ModelKeys.MIXED_KEYED_JDBC_STORE, ModelKeys.MIXED_KEYED_JDBC_STORE_NAME); storeAddress.protect(); } // set the address store.get(OP_ADDR).set(storeAddress); operations.add(store); }