Skip to content

Commit 186b8e0

Browse files
terrymanuterrymanu
authored
Refactor StandaloneMetaDataManagerPersistService (#35013)
* Refactor StandaloneMetaDataManagerPersistService * Refactor StandaloneMetaDataManagerPersistService
1 parent 71b8236 commit 186b8e0

File tree

4 files changed

+46
-49
lines changed

4 files changed

+46
-49
lines changed

‎mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java

+2-2
Original file line numberDiff line numberDiff line change
@@ -195,9 +195,9 @@ public void removeRuleConfigurationItem(final ShardingSphereDatabase database, f
195195
metaDataPersistFacade.getDatabaseMetaDataFacade().persistAlteredTables(database.getName(), getReloadedMetaDataContexts(originalMetaDataContexts), needReloadTables);
196196
}
197197

198-
private Collection<String> getNeedReloadTables(final ShardingSphereDatabase originalShardingDatabase, final RuleConfiguration toBeAlteredRuleConfig) {
198+
private Collection<String> getNeedReloadTables(final ShardingSphereDatabase originalDatabase, final RuleConfiguration toBeAlteredRuleConfig) {
199199
if (toBeAlteredRuleConfig instanceof SingleRuleConfiguration) {
200-
Collection<String> originalSingleTables = originalShardingDatabase.getRuleMetaData().getSingleRule(SingleRule.class).getConfiguration().getLogicTableNames();
200+
Collection<String> originalSingleTables = originalDatabase.getRuleMetaData().getSingleRule(SingleRule.class).getConfiguration().getLogicTableNames();
201201
return toBeAlteredRuleConfig.getLogicTableNames().stream().filter(each -> !originalSingleTables.contains(each)).collect(Collectors.toList());
202202
}
203203
return toBeAlteredRuleConfig.getLogicTableNames();

‎mode/type/standalone/core/pom.xml

+6
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,12 @@
4949
<version>${project.version}</version>
5050
<scope>test</scope>
5151
</dependency>
52+
<dependency>
53+
<groupId>org.apache.shardingsphere</groupId>
54+
<artifactId>shardingsphere-test-fixture-infra</artifactId>
55+
<version>${project.version}</version>
56+
<scope>test</scope>
57+
</dependency>
5258
<dependency>
5359
<groupId>org.apache.shardingsphere</groupId>
5460
<artifactId>shardingsphere-test-fixture-database</artifactId>

‎mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java

+30-22
Original file line numberDiff line numberDiff line change
@@ -58,12 +58,9 @@ public final class StandaloneMetaDataManagerPersistService implements MetaDataMa
5858

5959
private final MetaDataPersistFacade metaDataPersistFacade;
6060

61-
private final RuleItemChangedNodePathBuilder ruleItemChangedNodePathBuilder;
62-
6361
public StandaloneMetaDataManagerPersistService(final MetaDataContextManager metaDataContextManager) {
6462
this.metaDataContextManager = metaDataContextManager;
6563
metaDataPersistFacade = metaDataContextManager.getMetaDataPersistFacade();
66-
ruleItemChangedNodePathBuilder = new RuleItemChangedNodePathBuilder();
6764
}
6865

6966
@Override
@@ -208,54 +205,65 @@ public void alterRuleConfiguration(final ShardingSphereDatabase database, final
208205
return;
209206
}
210207
Collection<String> needReloadTables = getNeedReloadTables(database, toBeAlteredRuleConfig);
211-
for (MetaDataVersion each : metaDataPersistFacade.getDatabaseRuleService().persist(database.getName(), Collections.singleton(toBeAlteredRuleConfig))) {
212-
Optional<DatabaseRuleNodePath> databaseRuleNodePath = ruleItemChangedNodePathBuilder.build(database.getName(), new VersionNodePath(each.getNodePath()).getActiveVersionPath());
213-
if (databaseRuleNodePath.isPresent()
214-
&& new ActiveVersionChecker(metaDataPersistFacade.getRepository()).checkSame(new VersionNodePath(databaseRuleNodePath.get()), each.getActiveVersion())) {
215-
metaDataContextManager.getDatabaseRuleItemManager().alter(databaseRuleNodePath.get());
216-
}
217-
}
208+
Collection<MetaDataVersion> metaDataVersions = metaDataPersistFacade.getDatabaseRuleService().persist(database.getName(), Collections.singleton(toBeAlteredRuleConfig));
209+
alterRuleItem(database.getName(), metaDataVersions);
218210
Map<String, Collection<ShardingSphereTable>> schemaAndTablesMap = metaDataPersistFacade.getDatabaseMetaDataFacade().persistAlteredTables(
219211
database.getName(), metaDataContextManager.getMetaDataContexts(), needReloadTables);
220212
alterTables(database, schemaAndTablesMap);
221213
OrderedServicesCache.clearCache();
222214
}
223215

216+
private void alterRuleItem(final String databaseName, final Collection<MetaDataVersion> metaDataVersions) throws SQLException {
217+
RuleItemChangedNodePathBuilder ruleItemChangedNodePathBuilder = new RuleItemChangedNodePathBuilder();
218+
ActiveVersionChecker activeVersionChecker = new ActiveVersionChecker(metaDataPersistFacade.getRepository());
219+
for (MetaDataVersion each : metaDataVersions) {
220+
Optional<DatabaseRuleNodePath> databaseRuleNodePath = ruleItemChangedNodePathBuilder.build(databaseName, new VersionNodePath(each.getNodePath()).getActiveVersionPath());
221+
if (databaseRuleNodePath.isPresent() && activeVersionChecker.checkSame(new VersionNodePath(databaseRuleNodePath.get()), each.getActiveVersion())) {
222+
metaDataContextManager.getDatabaseRuleItemManager().alter(databaseRuleNodePath.get());
223+
}
224+
}
225+
}
226+
224227
@Override
225228
public void removeRuleConfigurationItem(final ShardingSphereDatabase database, final RuleConfiguration toBeRemovedRuleConfig) throws SQLException {
226229
if (null == toBeRemovedRuleConfig) {
227230
return;
228231
}
229232
Collection<String> needReloadTables = getNeedReloadTables(database, toBeRemovedRuleConfig);
230233
Collection<MetaDataVersion> metaDataVersions = metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(), Collections.singleton(toBeRemovedRuleConfig));
231-
for (MetaDataVersion each : metaDataVersions) {
232-
Optional<DatabaseRuleNodePath> databaseRuleNodePath = ruleItemChangedNodePathBuilder.build(database.getName(), new VersionNodePath(each.getNodePath()).getActiveVersionPath());
233-
if (databaseRuleNodePath.isPresent()) {
234-
metaDataContextManager.getDatabaseRuleItemManager().drop(databaseRuleNodePath.get());
235-
}
236-
}
234+
removeRuleItem(database.getName(), metaDataVersions);
237235
Map<String, Collection<ShardingSphereTable>> schemaAndTablesMap = metaDataPersistFacade.getDatabaseMetaDataFacade().persistAlteredTables(
238236
database.getName(), metaDataContextManager.getMetaDataContexts(), needReloadTables);
239237
alterTables(database, schemaAndTablesMap);
240238
OrderedServicesCache.clearCache();
241239
}
242240

243-
private void alterTables(final ShardingSphereDatabase database, final Map<String, Collection<ShardingSphereTable>> schemaAndTablesMap) {
244-
for (Entry<String, Collection<ShardingSphereTable>> entry : schemaAndTablesMap.entrySet()) {
245-
for (ShardingSphereTable each : entry.getValue()) {
246-
metaDataContextManager.getDatabaseMetaDataManager().alterTable(database.getName(), entry.getKey(), each);
241+
private void removeRuleItem(final String databaseName, final Collection<MetaDataVersion> metaDataVersions) throws SQLException {
242+
RuleItemChangedNodePathBuilder ruleItemChangedNodePathBuilder = new RuleItemChangedNodePathBuilder();
243+
for (MetaDataVersion each : metaDataVersions) {
244+
Optional<DatabaseRuleNodePath> databaseRuleNodePath = ruleItemChangedNodePathBuilder.build(databaseName, new VersionNodePath(each.getNodePath()).getActiveVersionPath());
245+
if (databaseRuleNodePath.isPresent()) {
246+
metaDataContextManager.getDatabaseRuleItemManager().drop(databaseRuleNodePath.get());
247247
}
248248
}
249249
}
250250

251-
private Collection<String> getNeedReloadTables(final ShardingSphereDatabase originalShardingDatabase, final RuleConfiguration toBeAlteredRuleConfig) {
251+
private Collection<String> getNeedReloadTables(final ShardingSphereDatabase originalDatabase, final RuleConfiguration toBeAlteredRuleConfig) {
252252
if (toBeAlteredRuleConfig instanceof SingleRuleConfiguration) {
253-
Collection<String> originalSingleTables = originalShardingDatabase.getRuleMetaData().getSingleRule(SingleRule.class).getConfiguration().getLogicTableNames();
253+
Collection<String> originalSingleTables = originalDatabase.getRuleMetaData().getSingleRule(SingleRule.class).getConfiguration().getLogicTableNames();
254254
return toBeAlteredRuleConfig.getLogicTableNames().stream().filter(each -> !originalSingleTables.contains(each)).collect(Collectors.toList());
255255
}
256256
return toBeAlteredRuleConfig.getLogicTableNames();
257257
}
258258

259+
private void alterTables(final ShardingSphereDatabase database, final Map<String, Collection<ShardingSphereTable>> schemaAndTablesMap) {
260+
for (Entry<String, Collection<ShardingSphereTable>> entry : schemaAndTablesMap.entrySet()) {
261+
for (ShardingSphereTable each : entry.getValue()) {
262+
metaDataContextManager.getDatabaseMetaDataManager().alterTable(database.getName(), entry.getKey(), each);
263+
}
264+
}
265+
}
266+
259267
@Override
260268
public void removeRuleConfiguration(final ShardingSphereDatabase database, final String ruleType) {
261269
metaDataPersistFacade.getDatabaseRuleService().delete(database.getName(), ruleType);

‎mode/type/standalone/core/src/test/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistServiceTest.java

+8-25
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,6 @@
2929
import org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
3030
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
3131
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
32-
import org.apache.shardingsphere.mode.metadata.changed.RuleItemChangedNodePathBuilder;
3332
import org.apache.shardingsphere.mode.metadata.manager.MetaDataContextManager;
3433
import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistFacade;
3534
import org.apache.shardingsphere.mode.metadata.persist.metadata.DatabaseMetaDataPersistFacade;
@@ -48,9 +47,9 @@
4847

4948
import java.sql.SQLException;
5049
import java.util.Collections;
51-
import java.util.Optional;
5250
import java.util.Properties;
5351

52+
import static org.apache.shardingsphere.test.matcher.ShardingSphereArgumentVerifyMatchers.deepEq;
5453
import static org.mockito.ArgumentMatchers.any;
5554
import static org.mockito.ArgumentMatchers.anyCollection;
5655
import static org.mockito.ArgumentMatchers.eq;
@@ -173,16 +172,11 @@ void assertAlterRuleConfiguration() throws SQLException {
173172
ShardingSphereMetaData metaData = new ShardingSphereMetaData(Collections.singleton(database), mock(), mock(), new ConfigurationProperties(new Properties()));
174173
when(metaDataContextManager.getMetaDataContexts().getMetaData()).thenReturn(metaData);
175174
RuleConfiguration ruleConfig = mock(RuleConfiguration.class, RETURNS_DEEP_STUBS);
176-
MetaDataVersion metaDataVersion = mock(MetaDataVersion.class);
177-
DatabaseRuleNodePath databaseRuleNodePath = new DatabaseRuleNodePath("foo_db", "fixture", new DatabaseRuleItem("foo_type"));
178-
when(metaDataVersion.getNodePath()).thenReturn(databaseRuleNodePath);
179-
when(metaDataPersistFacade.getDatabaseRuleService().persist("foo_db", Collections.singleton(ruleConfig))).thenReturn(Collections.singleton(metaDataVersion));
180-
RuleItemChangedNodePathBuilder ruleItemChangedNodePathBuilder = mock(RuleItemChangedNodePathBuilder.class);
181-
when(ruleItemChangedNodePathBuilder.build(eq("foo_db"), any())).thenReturn(Optional.of(databaseRuleNodePath));
182-
setRuleItemChangedBuildExecutor(ruleItemChangedNodePathBuilder);
183-
when(metaDataPersistFacade.getRepository().query("/metadata/foo_db/rules/fixture/foo_type/active_version")).thenReturn("0");
175+
DatabaseRuleNodePath databaseRuleNodePath = new DatabaseRuleNodePath("foo_db", "fixture", new DatabaseRuleItem("unique"));
176+
when(metaDataPersistFacade.getDatabaseRuleService().persist("foo_db", Collections.singleton(ruleConfig))).thenReturn(Collections.singleton(new MetaDataVersion(databaseRuleNodePath)));
177+
when(metaDataPersistFacade.getRepository().query("/metadata/foo_db/rules/fixture/unique/active_version")).thenReturn("0");
184178
metaDataManagerPersistService.alterRuleConfiguration(database, ruleConfig);
185-
verify(metaDataContextManager.getDatabaseRuleItemManager()).alter(databaseRuleNodePath);
179+
verify(metaDataContextManager.getDatabaseRuleItemManager()).alter(deepEq(databaseRuleNodePath));
186180
}
187181

188182
@Test
@@ -201,15 +195,10 @@ void assertRemoveRuleConfigurationItem() throws SQLException {
201195
ShardingSphereMetaData metaData = new ShardingSphereMetaData(Collections.singleton(database), mock(), mock(), new ConfigurationProperties(new Properties()));
202196
when(metaDataContextManager.getMetaDataContexts().getMetaData()).thenReturn(metaData);
203197
RuleConfiguration ruleConfig = mock(RuleConfiguration.class, RETURNS_DEEP_STUBS);
204-
MetaDataVersion metaDataVersion = mock(MetaDataVersion.class);
205-
when(metaDataPersistFacade.getDatabaseRuleService().delete("foo_db", Collections.singleton(ruleConfig))).thenReturn(Collections.singleton(metaDataVersion));
206-
RuleItemChangedNodePathBuilder ruleItemChangedNodePathBuilder = mock(RuleItemChangedNodePathBuilder.class);
207-
DatabaseRuleNodePath databaseRuleNodePath = mock(DatabaseRuleNodePath.class);
208-
when(metaDataVersion.getNodePath()).thenReturn(databaseRuleNodePath);
209-
when(ruleItemChangedNodePathBuilder.build(eq("foo_db"), any())).thenReturn(Optional.of(databaseRuleNodePath));
210-
setRuleItemChangedBuildExecutor(ruleItemChangedNodePathBuilder);
198+
DatabaseRuleNodePath databaseRuleNodePath = new DatabaseRuleNodePath("foo_db", "fixture", new DatabaseRuleItem("unique"));
199+
when(metaDataPersistFacade.getDatabaseRuleService().delete("foo_db", Collections.singleton(ruleConfig))).thenReturn(Collections.singleton(new MetaDataVersion(databaseRuleNodePath)));
211200
metaDataManagerPersistService.removeRuleConfigurationItem(database, ruleConfig);
212-
verify(metaDataContextManager.getDatabaseRuleItemManager()).drop(databaseRuleNodePath);
201+
verify(metaDataContextManager.getDatabaseRuleItemManager()).drop(deepEq(databaseRuleNodePath));
213202
}
214203

215204
@Test
@@ -247,10 +236,4 @@ void assertDropTables() throws SQLException {
247236
"foo_db", mock(), mock(), mock(), Collections.emptyList()), "foo_schema", Collections.singleton("foo_tbl"));
248237
verify(metaDataPersistFacade.getDatabaseMetaDataFacade().getTable()).drop("foo_db", "foo_schema", "foo_tbl");
249238
}
250-
251-
@SneakyThrows(ReflectiveOperationException.class)
252-
private void setRuleItemChangedBuildExecutor(final RuleItemChangedNodePathBuilder ruleItemChangedNodePathBuilder) {
253-
Plugins.getMemberAccessor().set(
254-
StandaloneMetaDataManagerPersistService.class.getDeclaredField("ruleItemChangedNodePathBuilder"), metaDataManagerPersistService, ruleItemChangedNodePathBuilder);
255-
}
256239
}

0 commit comments

Comments
 (0)