@Override public ServiceConfigurator configure(OperationContext context, ModelNode model) throws OperationFailedException { this.backups.clear(); if (model.hasDefined(BackupResourceDefinition.WILDCARD_PATH.getKey())) { SitesConfigurationBuilder builder = new ConfigurationBuilder().sites(); for (Property property : model.get(BackupResourceDefinition.WILDCARD_PATH.getKey()).asPropertyList()) { String siteName = property.getName(); ModelNode backup = property.getValue(); BackupConfigurationBuilder backupBuilder = builder.addBackup(); backupBuilder.site(siteName) .enabled(ENABLED.resolveModelAttribute(context, backup).asBoolean()) .backupFailurePolicy(ModelNodes.asEnum(FAILURE_POLICY.resolveModelAttribute(context, backup), BackupFailurePolicy.class)) .replicationTimeout(TIMEOUT.resolveModelAttribute(context, backup).asLong()) .strategy(ModelNodes.asEnum(STRATEGY.resolveModelAttribute(context, backup), BackupStrategy.class)) .takeOffline() .afterFailures(AFTER_FAILURES.resolveModelAttribute(context, backup).asInt()) .minTimeToWait(MIN_WAIT.resolveModelAttribute(context, backup).asLong()) ; this.backups.put(siteName, backupBuilder.create()); } } return this; }
private static BackupConfiguration createDefault() { BackupConfigurationBuilder builder = new BackupConfigurationBuilder(null).site("NYC") .strategy(BackupStrategy.SYNC).backupFailurePolicy(BackupFailurePolicy.WARN).failurePolicyClass(null) .replicationTimeout(12003).useTwoPhaseCommit(false).enabled(true); return builder.create(); }
switch (attribute) { case TIMEOUT: backup.replicationTimeout(Long.parseLong(value)); break; case STRATEGY: backup.strategy(BackupConfiguration.BackupStrategy.valueOf(value)); break; case SITE: backup.site(value); break; case BACKUP_FAILURE_POLICY: backup.backupFailurePolicy(BackupFailurePolicy.valueOf(value)); break; case USE_TWO_PHASE_COMMIT: backup.useTwoPhaseCommit(Boolean.parseBoolean(value)); break; case FAILURE_POLICY_CLASS: backup.failurePolicyClass(value); break; case ENABLED: backup.enabled(Boolean.parseBoolean(value)); break; default:
@Override protected void createSites() { GlobalConfigurationBuilder lonGc = GlobalConfigurationBuilder.defaultClusteredBuilder(); lonGc .site().localSite("LON"); ConfigurationBuilder lon = getLonActiveConfig(); lon.sites().addBackup() .site("NYC") .backupFailurePolicy(lonBackupFailurePolicy) .replicationTimeout(100) //keep it small so that the test doesn't take long to run .takeOffline().afterFailures(failures). backup() .strategy(lonBackupStrategy) .failurePolicyClass(lonCustomFailurePolicyClass); lon.sites().addInUseBackupSite("NYC"); createSite("LON", 2, lonGc, lon); }
protected ConfigurationBuilder lonConfigurationBuilder() { ConfigurationBuilder lon = getLonActiveConfig(); BackupConfigurationBuilder lonBackupConfigurationBuilder = lon.sites().addBackup(); lonBackupConfigurationBuilder .site(NYC) .backupFailurePolicy(lonBackupFailurePolicy) .strategy(lonBackupStrategy) .failurePolicyClass(lonCustomFailurePolicyClass) .useTwoPhaseCommit(use2Pc) .sites().addInUseBackupSite(NYC); adaptLONConfiguration(lonBackupConfigurationBuilder); return lon; }
ModelNode site = property.getValue(); BackupConfigurationBuilder backupConfigurationBuilder = sitesBuilder.addBackup(); backupConfigurationBuilder.site(siteName) .backupFailurePolicy(BackupFailurePolicy.valueOf(BackupSiteConfigurationResource.FAILURE_POLICY.resolveModelAttribute(context, site).asString())) .strategy(BackupStrategy.valueOf(BackupSiteConfigurationResource.STRATEGY.resolveModelAttribute(context, site).asString())) .replicationTimeout(BackupSiteConfigurationResource.REPLICATION_TIMEOUT.resolveModelAttribute(context, site).asLong()); if (BackupSiteConfigurationResource.ENABLED.resolveModelAttribute(context, site).asBoolean()) { sitesBuilder.addInUseBackupSite(siteName); backupConfigurationBuilder.takeOffline() .afterFailures(BackupSiteConfigurationResource.TAKE_OFFLINE_AFTER_FAILURES.resolveModelAttribute(context, site).asInt()) .minTimeToWait(BackupSiteConfigurationResource.TAKE_OFFLINE_MIN_WAIT.resolveModelAttribute(context, site).asLong()); if (site.hasDefined(ModelKeys.STATE_TRANSFER) && site.get(ModelKeys.STATE_TRANSFER, ModelKeys.STATE_TRANSFER_NAME).isDefined()) { ModelNode stateTransferModel = site.get(ModelKeys.STATE_TRANSFER, ModelKeys.STATE_TRANSFER_NAME); backupConfigurationBuilder.stateTransfer() .chunkSize(BackupSiteStateTransferConfigurationResource.STATE_TRANSFER_CHUNK_SIZE.resolveModelAttribute(context, stateTransferModel).asInt()) .timeout(BackupSiteStateTransferConfigurationResource.STATE_TRANSFER_TIMEOUT.resolveModelAttribute(context, stateTransferModel).asLong())
@Test (expectedExceptions = CacheConfigurationException.class) public void testSameBackupDefinedMultipleTimes() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb. sites().addBackup() .site("LON") .strategy(BackupConfiguration.BackupStrategy.SYNC) .sites().addBackup() .site("LON") .sites().addBackup() .site("NYC"); cb.build(); }
@Override protected ConfigurationBuilder defaultConfigurationForSite(int siteIndex) { if (siteIndex == 0) { //default cache will backup to site_1 ConfigurationBuilder builder = newConfiguration(); builder.sites().addBackup().site(siteName(1)).strategy(BackupConfiguration.BackupStrategy.SYNC); return builder; } else { return newConfiguration(); } }
@Override protected void createSites() { GlobalConfigurationBuilder lonGc = GlobalConfigurationBuilder.defaultClusteredBuilder(); lonGc.site().localSite("LON"); ConfigurationBuilder lonDefault = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); lonDefault.sites().addBackup() .site("NYC") .backupFailurePolicy(BackupFailurePolicy.FAIL) .strategy(BackupConfiguration.BackupStrategy.SYNC) .sites().addInUseBackupSite("NYC"); ConfigurationBuilder someCache = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); GlobalConfigurationBuilder nycGc = GlobalConfigurationBuilder.defaultClusteredBuilder(); nycGc.site().localSite("NYC"); ConfigurationBuilder nycDefault = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); nycDefault.sites().addBackup() .site("LON") .strategy(BackupConfiguration.BackupStrategy.SYNC) .sites().addInUseBackupSite("LON"); ConfigurationBuilder someCacheBackup = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true); someCacheBackup.sites().backupFor().remoteCache("someCache").remoteSite("LON"); someCacheBackup.sites().disableBackups(true); createSite("LON", 2, lonGc, lonDefault); createSite("NYC", 2, nycGc, nycDefault); startCache("LON", "backup", getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC, true)); startCache("NYC", "backup", getDefaultClusteredCacheConfig(CacheMode.REPL_SYNC, true)); startCache("LON", "someCache", someCache); startCache("NYC", "someCacheBackup", someCacheBackup); }
@Test(expectedExceptions = CacheConfigurationException.class) public void testTwoPhaseCommitAsyncBackup() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb. sites().addBackup() .site("LON") .strategy(BackupConfiguration.BackupStrategy.ASYNC) .useTwoPhaseCommit(true); cb.build(); }
@Test(expectedExceptions = CacheConfigurationException.class) public void testCustomBackupFailurePolicyClassNotSpecified() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb. sites().addBackup() .site("LON") .backupFailurePolicy(BackupFailurePolicy.CUSTOM) .failurePolicyClass(); cb.build(); }
@Override protected void adaptLONConfiguration(BackupConfigurationBuilder builder) { builder.site(NYC).stateTransfer().chunkSize(10); }
@Test(expectedExceptions = CacheConfigurationException.class) public void testBackupSiteNotSpecified() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb. sites().addBackup() .site(); cb.build(); }
private void parseTakeOffline(XMLExtendedStreamReader reader, BackupConfigurationBuilder backup) throws XMLStreamException { int count = 0; while (reader.hasNext() && (reader.nextTag() != XMLStreamConstants.END_ELEMENT)) { count++; Element takeOffline = Element.forName(reader.getLocalName()); 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 AFTER_FAILURES: backup.takeOffline().afterFailures(Integer.parseInt(value)); break; case MIN_TIME_TO_WAIT: backup.takeOffline().minTimeToWait(Long.parseLong(value)); break; default: throw ParseUtils.unexpectedElement(reader); } } ParseUtils.requireNoContent(reader); } if (count > 1) throw new CacheConfigurationException("Only one 'takeOffline' element allowed within a 'backup'"); }
@Override protected void adaptLONConfiguration(BackupConfigurationBuilder builder) { builder.stateTransfer().chunkSize(2).timeout(2000); }
private static BackupConfiguration create(int chunkSize, long timeout, int maxRetries, long waitingTimeBetweenRetries) { BackupConfigurationBuilder builder = new BackupConfigurationBuilder(null).site("NYC") .strategy(BackupStrategy.SYNC).backupFailurePolicy(BackupFailurePolicy.WARN).failurePolicyClass(null) .replicationTimeout(12003).useTwoPhaseCommit(false).enabled(true); builder.stateTransfer().chunkSize(chunkSize).timeout(timeout).maxRetries(maxRetries) .waitTime(waitingTimeBetweenRetries); return builder.create(); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { GlobalConfigurationBuilder lonGc = GlobalConfigurationBuilder.defaultClusteredBuilder(); lonGc.site().localSite("LON"); ConfigurationBuilder lon = getDefaultClusteredCacheConfig(CacheMode.LOCAL, false); lon.sites().addBackup() .site("NYC") .strategy(BackupConfiguration.BackupStrategy.SYNC); nycBackup = getDefaultClusteredCacheConfig(CacheMode.LOCAL, false); nycBackup.sites().backupFor().remoteSite("NYC").defaultRemoteCache(); // Remember to not do nothing else other than // creating the cache manager in order to avoid leaks return TestCacheManagerFactory.createClusteredCacheManager(lonGc, lon); }
private ConfigurationBuilder configurationBuilderForSite(String backupSiteName) { ConfigurationBuilder builder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC); builder.sites().addBackup().site(backupSiteName) .stateTransfer().chunkSize(1); return builder; }
@Override protected void adaptLONConfiguration(BackupConfigurationBuilder builder) { builder.stateTransfer().chunkSize(2).timeout(2000); }