@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; }
@Test(expectedExceptions = CacheConfigurationException.class) public void testTwoPhaseCommitAsyncBackup() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb. sites().addBackup() .site("LON") .strategy(BackupConfiguration.BackupStrategy.ASYNC) .useTwoPhaseCommit(true); 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(); } }
private void testDefault(Configuration dcc) { assertEquals(dcc.sites().allBackups().size(), 2); BackupConfigurationBuilder nyc = new BackupConfigurationBuilder(null).site("NYC").strategy(BackupStrategy.SYNC) .backupFailurePolicy(BackupFailurePolicy.IGNORE).failurePolicyClass(null).replicationTimeout(12003) .useTwoPhaseCommit(false).enabled(true); assertTrue(dcc.sites().allBackups().contains(nyc.create())); BackupConfigurationBuilder sfo = new BackupConfigurationBuilder(null).site("SFO").strategy(BackupStrategy.ASYNC) .backupFailurePolicy(BackupFailurePolicy.WARN).failurePolicyClass(null).replicationTimeout(15000) .useTwoPhaseCommit(false).enabled(true); assertTrue(dcc.sites().allBackups().contains(sfo.create())); } }
private void reCreateNYC() { ConfigurationBuilder nyc = getNycActiveConfig(); nyc.sites().addBackup() .site(LON) .strategy(BackupConfiguration.BackupStrategy.SYNC) .sites().addInUseBackupSite(LON); createSite(NYC, initialClusterSize, globalConfigurationBuilderForSite(NYC), nyc); }
@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(); }
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(); }
public void testCustomBackupPolicy() { Configuration dcc = cacheManager.getCacheConfiguration("customBackupPolicy"); assertEquals(dcc.sites().allBackups().size(), 1); BackupConfigurationBuilder nyc2 = new BackupConfigurationBuilder(null).site("NYC2").strategy(BackupStrategy.SYNC) .backupFailurePolicy(BackupFailurePolicy.CUSTOM).failurePolicyClass(CountingCustomFailurePolicy.class.getName()).replicationTimeout(160000) .useTwoPhaseCommit(false).enabled(true); assertTrue(dcc.sites().allBackups().contains(nyc2.create())); assertEquals(dcc.sites().backupFor().remoteCache(), null); }
public void testTakeOfflineDifferentConfig() { Configuration dcc = cacheManager.getCacheConfiguration("takeOfflineDifferentConfig"); assertEquals(1, dcc.sites().allBackups().size()); BackupConfigurationBuilder nyc = new BackupConfigurationBuilder(null).site("NYC").strategy(BackupStrategy.SYNC) .backupFailurePolicy(BackupFailurePolicy.IGNORE).failurePolicyClass(null).replicationTimeout(12003) .useTwoPhaseCommit(false).enabled(true); nyc.takeOffline().afterFailures(321).minTimeToWait(3765); assertTrue(dcc.sites().allBackups().contains(nyc.create())); }
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; }
public void testMultipleCachesWithNoCacheName() { ConfigurationBuilder cb = new ConfigurationBuilder(); cb. sites().addBackup() .site("LON") .strategy(BackupConfiguration.BackupStrategy.SYNC) .sites().addBackup() .site("SFO") .sites().addBackup() .site("NYC"); cb.build(); } }
private void testDefault(Configuration dcc) { BackupConfiguration nyc = new BackupConfigurationBuilder(null).site("NYC").strategy(BackupStrategy.SYNC) .backupFailurePolicy(BackupFailurePolicy.IGNORE).failurePolicyClass(null).replicationTimeout(12003) .useTwoPhaseCommit(false).enabled(true).create(); BackupConfiguration sfo = new BackupConfigurationBuilder(null).site("SFO").strategy(BackupStrategy.ASYNC) .backupFailurePolicy(BackupFailurePolicy.WARN).failurePolicyClass(null).replicationTimeout(15000) .useTwoPhaseCommit(false).enabled(true).create(); BackupConfiguration lon = new BackupConfigurationBuilder(null).site("LON").strategy(BackupStrategy.SYNC) .backupFailurePolicy(BackupFailurePolicy.WARN).failurePolicyClass(null).replicationTimeout(15000) .useTwoPhaseCommit(false).enabled(false).create(); assertTrue(dcc.sites().allBackups().contains(nyc)); assertTrue(dcc.sites().allBackups().contains(sfo)); assertTrue(dcc.sites().allBackups().contains(lon)); assertTrue(dcc.sites().enabledBackups().contains(nyc)); assertTrue(dcc.sites().enabledBackups().contains(sfo)); assertTrue(!dcc.sites().enabledBackups().contains(lon)); assertEquals("someCache", dcc.sites().backupFor().remoteCache()); assertEquals("SFO", dcc.sites().backupFor().remoteSite()); }
public void testNoBackupFor() { Configuration dcc = cacheManager.getCacheConfiguration("noBackupFor"); assertEquals(1, dcc.sites().allBackups().size()); BackupConfiguration nyc = new BackupConfigurationBuilder(null).site("NYC").strategy(BackupStrategy.SYNC) .backupFailurePolicy(BackupFailurePolicy.WARN).failurePolicyClass(null).replicationTimeout(12003) .useTwoPhaseCommit(false).enabled(true).create(); assertTrue(dcc.sites().allBackups().contains(nyc)); assertNull(dcc.sites().backupFor().remoteSite()); assertNull(dcc.sites().backupFor().remoteCache()); }
public void testNoTakeOffline() { Configuration dcc = cacheManager.getCacheConfiguration("noTakeOffline"); assertEquals(1, dcc.sites().allBackups().size()); BackupConfiguration nyc = new BackupConfigurationBuilder(null).site("NYC").strategy(BackupStrategy.SYNC) .backupFailurePolicy(BackupFailurePolicy.WARN).failurePolicyClass(null).replicationTimeout(12003) .useTwoPhaseCommit(false).enabled(true).create(); assertTrue(dcc.sites().allBackups().contains(nyc)); assertNull(dcc.sites().backupFor().remoteSite()); assertNull(dcc.sites().backupFor().remoteCache()); } public void testTakeOfflineDifferentConfig() {
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 void testDefault(Configuration dcc) { BackupConfigurationBuilder nyc = new BackupConfigurationBuilder(null).site("NYC").strategy(BackupStrategy.SYNC) .backupFailurePolicy(BackupFailurePolicy.IGNORE).failurePolicyClass(null).replicationTimeout(12003) .useTwoPhaseCommit(false).enabled(true); nyc.takeOffline().afterFailures(123).minTimeToWait(5673); assertTrue(dcc.sites().allBackups().contains(nyc.create())); assertEquals("someCache", dcc.sites().backupFor().remoteCache()); assertEquals("SFO", dcc.sites().backupFor().remoteSite()); } }
@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); }
@Override protected void afterSitesCreated() { super.afterSitesCreated(); Security.doAs(ADMIN, (PrivilegedAction<Void>) () -> { ConfigurationBuilder builder = defaultConfigurationForSite(0); builder.sites().addBackup().site(siteName(1)).strategy(BackupConfiguration.BackupStrategy.SYNC); defineInSite(site(0), XSITECACHE, builder.build()); site(0).waitForClusterToForm(XSITECACHE); builder = defaultConfigurationForSite(1); defineInSite(site(1), XSITECACHE, builder.build()); site(1).waitForClusterToForm(XSITECACHE); return null; }); }
@Override protected void afterSitesCreated() { super.afterSitesCreated(); ConfigurationBuilder builder = newConfiguration(); builder.sites().addBackup().site(siteName(2)).strategy(BackupConfiguration.BackupStrategy.SYNC); defineInSite(site(0), CacheType.BACKUP_TO_SITE_2.name(), builder.build()); defineInSite(site(2), CacheType.BACKUP_TO_SITE_2.name(), newConfiguration().build()); builder = newConfiguration(); builder.sites().addBackup().site(siteName(1)).strategy(BackupConfiguration.BackupStrategy.SYNC); builder.sites().addBackup().site(siteName(2)).strategy(BackupConfiguration.BackupStrategy.SYNC); defineInSite(site(0), CacheType.BACKUP_TO_SITE_1_AND_2.name(), builder.build()); defineInSite(site(1), CacheType.BACKUP_TO_SITE_1_AND_2.name(), newConfiguration().build()); defineInSite(site(2), CacheType.BACKUP_TO_SITE_1_AND_2.name(), newConfiguration().build()); defineInSite(site(0), CacheType.NO_BACKUP.name(), newConfiguration().build()); //wait for caches in primary cluster site(0).waitForClusterToForm(null); site(0).waitForClusterToForm(CacheType.BACKUP_TO_SITE_1_AND_2.name()); site(0).waitForClusterToForm(CacheType.BACKUP_TO_SITE_1_AND_2.name()); site(0).waitForClusterToForm(CacheType.BACKUP_TO_SITE_2.name()); //wait for caches in backup site 1 site(1).waitForClusterToForm(null); site(1).waitForClusterToForm(CacheType.BACKUP_TO_SITE_1_AND_2.name()); //wait for caches in backup site 2 site(2).waitForClusterToForm(CacheType.BACKUP_TO_SITE_1_AND_2.name()); site(2).waitForClusterToForm(CacheType.BACKUP_TO_SITE_2.name()); }