You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ozone.apache.org by av...@apache.org on 2020/04/10 00:24:45 UTC
[hadoop-ozone] branch master updated: HDDS-3335. Recon unit tests
cleanup. (#772)
This is an automated email from the ASF dual-hosted git repository.
avijayan pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/hadoop-ozone.git
The following commit(s) were added to refs/heads/master by this push:
new 216b41f HDDS-3335. Recon unit tests cleanup. (#772)
216b41f is described below
commit 216b41fce99fc904832c68dc33a36efac1a3d482
Author: avijayanhwx <14...@users.noreply.github.com>
AuthorDate: Thu Apr 9 17:24:36 2020 -0700
HDDS-3335. Recon unit tests cleanup. (#772)
---
.../hadoop/ozone/recon/ReconControllerModule.java | 53 ++--
.../hadoop/ozone/recon/ReconSchemaManager.java | 4 +-
.../recon/GuiceInjectorUtilsForTestsImpl.java | 28 --
...erTest.java => OMMetadataManagerTestUtils.java} | 60 +---
.../hadoop/ozone/recon/ReconTestInjector.java | 337 +++++++++++++++++++++
.../ozone/recon/api/TestContainerEndpoint.java | 93 +++---
.../hadoop/ozone/recon/api/TestEndpoints.java | 146 ++++-----
.../ozone/recon/api/TestTaskStatusService.java | 23 +-
.../ozone/recon/fsck/TestMissingContainerTask.java | 29 +-
...tabaseTest.java => AbstractReconSqlDBTest.java} | 131 ++++++--
.../TestReconInternalSchemaDefinition.java | 26 +-
.../persistence/TestStatsSchemaDefinition.java | 25 +-
.../TestUtilizationSchemaDefinition.java | 35 +--
.../scm/AbstractReconContainerManagerTest.java | 2 +-
.../ozone/recon/scm/TestReconContainerManager.java | 2 +-
.../ozone/recon/scm/TestReconPipelineManager.java | 2 +-
.../recon/scm/TestReconPipelineReportHandler.java | 2 +-
.../impl/TestContainerDBServiceProviderImpl.java | 56 ++--
.../impl/TestOzoneManagerServiceProviderImpl.java | 71 +++--
.../recon/tasks/TestContainerKeyMapperTask.java | 71 ++---
.../ozone/recon/tasks/TestFileSizeCountTask.java | 16 +-
.../recon/tasks/TestReconTaskControllerImpl.java | 28 +-
.../recon/types/GuiceInjectorUtilsForTests.java | 142 ---------
23 files changed, 724 insertions(+), 658 deletions(-)
diff --git a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconControllerModule.java b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconControllerModule.java
index 5992a92..36e4cbd 100644
--- a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconControllerModule.java
+++ b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconControllerModule.java
@@ -32,6 +32,8 @@ import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_SQ
import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_SQL_MAX_IDLE_CONNECTION_TEST_STMT;
import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.util.List;
import org.apache.hadoop.hdds.conf.OzoneConfiguration;
import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol;
@@ -60,14 +62,18 @@ import org.apache.hadoop.ozone.recon.tasks.ReconTaskControllerImpl;
import org.apache.hadoop.security.UserGroupInformation;
import org.apache.hadoop.hdds.utils.db.DBStore;
import org.apache.ratis.protocol.ClientId;
+import org.hadoop.ozone.recon.schema.tables.daos.ClusterGrowthDailyDao;
import org.hadoop.ozone.recon.schema.tables.daos.ContainerHistoryDao;
import org.hadoop.ozone.recon.schema.tables.daos.FileCountBySizeDao;
+import org.hadoop.ozone.recon.schema.tables.daos.GlobalStatsDao;
import org.hadoop.ozone.recon.schema.tables.daos.MissingContainersDao;
import org.hadoop.ozone.recon.schema.tables.daos.ReconTaskStatusDao;
import org.jooq.Configuration;
+import org.jooq.DAO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.collect.ImmutableList;
import com.google.inject.AbstractModule;
import com.google.inject.Provides;
import com.google.inject.Singleton;
@@ -101,6 +107,7 @@ public class ReconControllerModule extends AbstractModule {
getProvider(DataSourceConfiguration.class)));
install(new ReconOmTaskBindingModule());
+ install(new ReconDaoBindingModule());
bind(ReconTaskController.class)
.to(ReconTaskControllerImpl.class).in(Singleton.class);
@@ -110,26 +117,6 @@ public class ReconControllerModule extends AbstractModule {
.to(ReconStorageContainerManagerFacade.class).in(Singleton.class);
}
- @Provides
- ReconTaskStatusDao getReconTaskTableDao(final Configuration sqlConfig) {
- return new ReconTaskStatusDao(sqlConfig);
- }
-
- @Provides
- MissingContainersDao getMissingContainersDao(final Configuration sqlConfig) {
- return new MissingContainersDao(sqlConfig);
- }
-
- @Provides
- ContainerHistoryDao getContainerHistoryDao(final Configuration sqlConfig) {
- return new ContainerHistoryDao(sqlConfig);
- }
-
- @Provides
- FileCountBySizeDao getFileCountBySizeDao(final Configuration sqlConfig) {
- return new FileCountBySizeDao(sqlConfig);
- }
-
static class ReconOmTaskBindingModule extends AbstractModule {
@Override
protected void configure() {
@@ -140,6 +127,32 @@ public class ReconControllerModule extends AbstractModule {
}
}
+ /**
+ * Class that has all the DAO bindings in Recon.
+ */
+ public static class ReconDaoBindingModule extends AbstractModule {
+ public static final List<Class<? extends DAO>> RECON_DAO_LIST =
+ ImmutableList.of(
+ FileCountBySizeDao.class,
+ ReconTaskStatusDao.class,
+ MissingContainersDao.class,
+ GlobalStatsDao.class,
+ ClusterGrowthDailyDao.class,
+ ContainerHistoryDao.class);
+
+ @Override
+ protected void configure() {
+ RECON_DAO_LIST.forEach(aClass -> {
+ try {
+ bind(aClass).toConstructor(
+ (Constructor) aClass.getConstructor(Configuration.class));
+ } catch (NoSuchMethodException e) {
+ LOG.error("Error creating DAO {} ", aClass.getSimpleName(), e);
+ }
+ });
+ }
+ }
+
@Provides
OzoneManagerProtocol getOzoneManagerProtocol(
final OzoneConfiguration ozoneConfiguration) {
diff --git a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconSchemaManager.java b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconSchemaManager.java
index 1ca0b94..883f90a 100644
--- a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconSchemaManager.java
+++ b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconSchemaManager.java
@@ -26,6 +26,7 @@ import org.hadoop.ozone.recon.schema.ReconSchemaDefinition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.annotations.VisibleForTesting;
import com.google.inject.Inject;
/**
@@ -42,7 +43,8 @@ public class ReconSchemaManager {
this.reconSchemaDefinitions.addAll(reconSchemaDefinitions);
}
- void createReconSchema() {
+ @VisibleForTesting
+ public void createReconSchema() {
reconSchemaDefinitions.forEach(reconSchemaDefinition -> {
try {
reconSchemaDefinition.initializeSchema();
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/GuiceInjectorUtilsForTestsImpl.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/GuiceInjectorUtilsForTestsImpl.java
deleted file mode 100644
index 6f16c1c..0000000
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/GuiceInjectorUtilsForTestsImpl.java
+++ /dev/null
@@ -1,28 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.hadoop.ozone.recon;
-
-import org.apache.hadoop.ozone.recon.types.GuiceInjectorUtilsForTests;
-
-/**
- * Implementation for GuiceInjectorUtilsForTests.
- */
-public class GuiceInjectorUtilsForTestsImpl implements
- GuiceInjectorUtilsForTests {
-}
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/AbstractOMMetadataManagerTest.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/OMMetadataManagerTestUtils.java
similarity index 79%
rename from hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/AbstractOMMetadataManagerTest.java
rename to hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/OMMetadataManagerTestUtils.java
index 08da2b3..848a2af 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/AbstractOMMetadataManagerTest.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/OMMetadataManagerTestUtils.java
@@ -44,24 +44,22 @@ import org.apache.hadoop.ozone.om.helpers.OmVolumeArgs;
import org.apache.hadoop.ozone.recon.recovery.ReconOMMetadataManager;
import org.apache.hadoop.ozone.recon.recovery.ReconOmMetadataManagerImpl;
import org.apache.hadoop.hdds.utils.db.DBCheckpoint;
-import org.junit.Rule;
-import org.junit.rules.TemporaryFolder;
/**
- * Utility methods for test classes.
+ * Utility methods for creating OM related metadata managers and objects.
*/
-public abstract class AbstractOMMetadataManagerTest {
+public final class OMMetadataManagerTestUtils {
- @Rule
- public TemporaryFolder temporaryFolder = new TemporaryFolder();
+ private OMMetadataManagerTestUtils() {
+ }
/**
* Create a new OM Metadata manager instance with default volume and bucket.
* @throws IOException ioEx
*/
- protected OMMetadataManager initializeNewOmMetadataManager()
+ public static OMMetadataManager initializeNewOmMetadataManager(
+ File omDbDir)
throws IOException {
- File omDbDir = temporaryFolder.newFolder();
OzoneConfiguration omConfiguration = new OzoneConfiguration();
omConfiguration.set(OZONE_OM_DB_DIRS,
omDbDir.getAbsolutePath());
@@ -94,9 +92,9 @@ public abstract class AbstractOMMetadataManagerTest {
* Create an empty OM Metadata manager instance.
* @throws IOException ioEx
*/
- protected OMMetadataManager initializeEmptyOmMetadataManager()
+ public static OMMetadataManager initializeEmptyOmMetadataManager(
+ File omDbDir)
throws IOException {
- File omDbDir = temporaryFolder.newFolder();
OzoneConfiguration omConfiguration = new OzoneConfiguration();
omConfiguration.set(OZONE_OM_DB_DIRS,
omDbDir.getAbsolutePath());
@@ -104,19 +102,19 @@ public abstract class AbstractOMMetadataManagerTest {
}
/**
- * Get an instance of Recon OM Metadata manager.
+ * Given an underlying OM DB, return an instance of Recon OM Metadata
+ * manager.
* @return ReconOMMetadataManager
* @throws IOException when creating the RocksDB instance.
*/
- protected ReconOMMetadataManager getTestMetadataManager(
- OMMetadataManager omMetadataManager)
+ public static ReconOMMetadataManager getTestReconOmMetadataManager(
+ OMMetadataManager omMetadataManager, File reconOmDbDir)
throws IOException {
DBCheckpoint checkpoint = omMetadataManager.getStore()
.getCheckpoint(true);
assertNotNull(checkpoint.getCheckpointLocation());
- File reconOmDbDir = temporaryFolder.newFolder();
OzoneConfiguration configuration = new OzoneConfiguration();
configuration.set(OZONE_RECON_OM_SNAPSHOT_DB_DIR, reconOmDbDir
.getAbsolutePath());
@@ -134,7 +132,7 @@ public abstract class AbstractOMMetadataManagerTest {
* Write a key to OM instance.
* @throws IOException while writing.
*/
- protected void writeDataToOm(OMMetadataManager omMetadataManager,
+ public static void writeDataToOm(OMMetadataManager omMetadataManager,
String key) throws IOException {
String omKey = omMetadataManager.getOzoneKey("sampleVol",
@@ -154,7 +152,7 @@ public abstract class AbstractOMMetadataManagerTest {
* Write a key to OM instance.
* @throws IOException while writing.
*/
- protected void writeDataToOm(OMMetadataManager omMetadataManager,
+ public static void writeDataToOm(OMMetadataManager omMetadataManager,
String key,
String bucket,
String volume,
@@ -177,34 +175,6 @@ public abstract class AbstractOMMetadataManagerTest {
}
/**
- * Write a key to OM instance.
- * @throws IOException while writing.
- */
- protected void writeDataToOm(OMMetadataManager omMetadataManager,
- String key,
- String bucket,
- String volume,
- Long dataSize,
- List<OmKeyLocationInfoGroup>
- omKeyLocationInfoGroupList)
- throws IOException {
-
- String omKey = omMetadataManager.getOzoneKey(volume,
- bucket, key);
-
- omMetadataManager.getKeyTable().put(omKey,
- new OmKeyInfo.Builder()
- .setBucketName(bucket)
- .setVolumeName(volume)
- .setKeyName(key)
- .setDataSize(dataSize)
- .setReplicationFactor(HddsProtos.ReplicationFactor.ONE)
- .setReplicationType(HddsProtos.ReplicationType.STAND_ALONE)
- .setOmKeyLocationInfos(omKeyLocationInfoGroupList)
- .build());
- }
-
- /**
* Return random pipeline.
* @return pipeline
*/
@@ -232,7 +202,7 @@ public abstract class AbstractOMMetadataManagerTest {
* @param pipeline pipeline
* @return new instance of OmKeyLocationInfo
*/
- protected OmKeyLocationInfo getOmKeyLocationInfo(BlockID blockID,
+ public static OmKeyLocationInfo getOmKeyLocationInfo(BlockID blockID,
Pipeline pipeline) {
return new OmKeyLocationInfo.Builder()
.setBlockID(blockID)
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/ReconTestInjector.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/ReconTestInjector.java
new file mode 100644
index 0000000..b852953
--- /dev/null
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/ReconTestInjector.java
@@ -0,0 +1,337 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ * <p>
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.ozone.recon;
+
+import static org.apache.hadoop.hdds.recon.ReconConfigKeys.OZONE_RECON_DATANODE_ADDRESS_KEY;
+import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_DB_DIR;
+import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_OM_SNAPSHOT_DB_DIR;
+import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_SCM_DB_DIR;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.hadoop.hdds.conf.OzoneConfiguration;
+import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager;
+import org.apache.hadoop.hdds.utils.db.DBStore;
+import org.apache.hadoop.ozone.recon.persistence.AbstractReconSqlDBTest;
+import org.apache.hadoop.ozone.recon.recovery.ReconOMMetadataManager;
+import org.apache.hadoop.ozone.recon.spi.ContainerDBServiceProvider;
+import org.apache.hadoop.ozone.recon.spi.OzoneManagerServiceProvider;
+import org.apache.hadoop.ozone.recon.spi.impl.ContainerDBServiceProviderImpl;
+import org.apache.hadoop.ozone.recon.spi.impl.ReconContainerDBProvider;
+import org.junit.Assert;
+import org.junit.rules.TemporaryFolder;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.Module;
+import com.google.inject.Singleton;
+
+/**
+ * Class to setup a recon test injector, with any combination of sub modules
+ * that are specified. This Recon specific abstraction to Guice API has
+ * been created to simplify the process of setting up a test environment for
+ * unit testing.
+ */
+public class ReconTestInjector {
+
+ private Injector injector;
+ private OzoneManagerServiceProvider ozoneManagerServiceProvider;
+ private ReconOMMetadataManager reconOMMetadataManager;
+ private OzoneStorageContainerManager reconScm;
+ private AbstractReconSqlDBTest reconSqlDB;
+ private boolean withContainerDB = false;
+ private List<Module> additionalModules = new ArrayList<>();
+ private boolean withReconSqlDb = false;
+ private TemporaryFolder temporaryFolder;
+ private Map<Class, Class> extraInheritedBindings = new HashMap<>();
+ private Map<Class, Object> extraInstanceBindings = new HashMap<>();
+ private Set<Class> extraClassBindings = new HashSet<>();
+
+ public ReconTestInjector(TemporaryFolder temporaryFolder) {
+ this.temporaryFolder = temporaryFolder;
+ }
+
+ public void setWithReconSqlDb(boolean withReconSqlDb) {
+ this.withReconSqlDb = withReconSqlDb;
+ }
+
+ public void setOzoneManagerServiceProvider(
+ OzoneManagerServiceProvider ozoneManagerServiceProvider) {
+ this.ozoneManagerServiceProvider = ozoneManagerServiceProvider;
+ }
+
+ public void setReconOMMetadataManager(
+ ReconOMMetadataManager reconOMMetadataManager) {
+ this.reconOMMetadataManager = reconOMMetadataManager;
+ }
+
+ public void setReconScm(OzoneStorageContainerManager reconScm) {
+ this.reconScm = reconScm;
+ }
+
+ public void withContainerDB(boolean containerDbIncluded) {
+ this.withContainerDB = containerDbIncluded;
+ }
+
+ public OzoneManagerServiceProvider getOzoneManagerServiceProvider() {
+ return ozoneManagerServiceProvider;
+ }
+
+ public ReconOMMetadataManager getReconOMMetadataManager() {
+ return reconOMMetadataManager;
+ }
+
+ public OzoneStorageContainerManager getReconScm() {
+ return reconScm;
+ }
+
+ public List<Module> getAdditionalModules() {
+ return additionalModules;
+ }
+
+ public Map<Class, Object> getExtraInstanceBindings() {
+ return extraInstanceBindings;
+ }
+
+ public Map<Class, Class> getExtraInheritedBindings() {
+ return extraInheritedBindings;
+ }
+
+ public Set<Class> getExtraClassBindings() {
+ return extraClassBindings;
+ }
+
+ /**
+ * Wrapper to get the bound instance.
+ * @param type type
+ * @param <T> type
+ * @return bound instance of type T.
+ */
+ public <T> T getInstance(Class<T> type) {
+ return injector.getInstance(type);
+ }
+
+ /**
+ * The goal of the class is to discourage the use of injector to
+ * create more child injectors explicitly.
+ * Use this API wisely!
+ * @return injector.
+ */
+ public Injector getInjector() {
+ return injector;
+ }
+
+ void setupInjector() throws IOException {
+ List<Module> modules = new ArrayList<>();
+
+ modules.add(new AbstractModule() {
+ @Override
+ protected void configure() {
+ try {
+ bind(OzoneConfiguration.class).toInstance(
+ getTestOzoneConfiguration(temporaryFolder.newFolder()));
+
+ if (reconOMMetadataManager != null) {
+ bind(ReconOMMetadataManager.class)
+ .toInstance(reconOMMetadataManager);
+ }
+
+ if (ozoneManagerServiceProvider != null) {
+ bind(OzoneManagerServiceProvider.class)
+ .toInstance(ozoneManagerServiceProvider);
+ }
+
+ if (reconScm != null) {
+ bind(OzoneStorageContainerManager.class).toInstance(reconScm);
+ }
+
+ if (withContainerDB) {
+ bind(ContainerDBServiceProvider.class)
+ .to(ContainerDBServiceProviderImpl.class).in(Singleton.class);
+ bind(DBStore.class).toProvider(ReconContainerDBProvider.class).
+ in(Singleton.class);
+ }
+
+ for (Map.Entry<Class, Object> entry :
+ extraInstanceBindings.entrySet()) {
+ bind(entry.getKey()).toInstance(entry.getValue());
+ }
+
+ for (Map.Entry<Class, Class> entry :
+ extraInheritedBindings.entrySet()) {
+ bind(entry.getKey()).to(entry.getValue()).in(Singleton.class);
+ }
+
+ for (Class type : extraClassBindings) {
+ bind(type).in(Singleton.class);
+ }
+ } catch (IOException e) {
+ Assert.fail();
+ }
+ }
+ });
+
+ if (CollectionUtils.isNotEmpty(additionalModules)) {
+ modules.addAll(additionalModules);
+ }
+
+ if (withReconSqlDb) {
+ reconSqlDB = new AbstractReconSqlDBTest();
+ modules.addAll(reconSqlDB.getReconSqlDBModules());
+ }
+
+ injector = Guice.createInjector(modules);
+ if (reconSqlDB != null) {
+ reconSqlDB.createSchema(injector);
+ }
+ }
+
+ public OzoneConfiguration getTestOzoneConfiguration(
+ File dir) {
+ OzoneConfiguration configuration = new OzoneConfiguration();
+ configuration.set(OZONE_RECON_OM_SNAPSHOT_DB_DIR, dir.getAbsolutePath());
+ configuration.set(OZONE_RECON_DB_DIR, dir.getAbsolutePath());
+ configuration.set(OZONE_RECON_SCM_DB_DIR, dir.getAbsolutePath());
+ configuration.set(OZONE_RECON_DATANODE_ADDRESS_KEY,
+ "0.0.0.0:0");
+ return configuration;
+ }
+
+
+ /**
+ * Builder for Recon Test Injector.
+ */
+ public static class Builder {
+ private ReconTestInjector reconTestInjector;
+
+ public Builder(TemporaryFolder temporaryFolder) {
+ reconTestInjector = new ReconTestInjector(temporaryFolder);
+ }
+
+ /**
+ * Use if you need the Recon SQL DB instance.
+ */
+ public Builder withReconSqlDb() {
+ reconTestInjector.setWithReconSqlDb(true);
+ return this;
+ }
+
+ /**
+ * Pass in your Ozone manager service provider implementation, maybe with
+ * mocked behavior.
+ * @param ozoneManagerServiceProvider instance
+ */
+ public Builder withOmServiceProvider(
+ OzoneManagerServiceProvider ozoneManagerServiceProvider) {
+ reconTestInjector.setOzoneManagerServiceProvider(
+ ozoneManagerServiceProvider);
+ return this;
+ }
+
+ /**
+ * Pass in your ReconOMMetadataManager implementation, maybe with
+ * mocked behavior.
+ * @param reconOm instance
+ */
+ public Builder withReconOm(ReconOMMetadataManager reconOm) {
+ reconTestInjector.setReconOMMetadataManager(reconOm);
+ return this;
+ }
+
+ /**
+ * Pass in your Recon SCM implementation.
+ * @param reconScm instance
+ * @return Builder.
+ */
+ public Builder withReconScm(OzoneStorageContainerManager reconScm) {
+ reconTestInjector.setReconScm(reconScm);
+ return this;
+ }
+
+ /**
+ * Use if you need the ReconContainerDB. Bound to default implementation.
+ * @return Builder.
+ */
+ public Builder withContainerDB() {
+ reconTestInjector.withContainerDB(true);
+ return this;
+ }
+
+ /**
+ * Add binding of the type bind(A.class).toInstance(AImpl).
+ * @param type class type
+ * @param instance instance
+ * @return Builder.
+ */
+ public Builder addBinding(Class type, Object instance) {
+ reconTestInjector.getExtraInstanceBindings().put(type, instance);
+ return this;
+ }
+
+ /**
+ * Add binding of the type bind(A.class).
+ * @param type class type
+ * @return Builder.
+ */
+ public Builder addBinding(Class type) {
+ reconTestInjector.getExtraClassBindings().add(type);
+ return this;
+ }
+
+ /**
+ * Add binding of the type bind(A.class).to(B.class) where B extends A.
+ * @param type class type
+ * @return Builder.
+ */
+ public Builder addBinding(Class type, Class inheritedType) {
+ reconTestInjector.getExtraInheritedBindings().put(type, inheritedType);
+ return this;
+ }
+
+ /**
+ * If you really need to pass in more injector modules for extending the
+ * set of classes bound, use this.
+ * @param module external module.
+ * @return Builder.
+ */
+ public Builder addModule(Module module) {
+ reconTestInjector.getAdditionalModules().add(module);
+ return this;
+ }
+
+ /**
+ * Build the whole graph of classes.
+ * @return ReconTestInjector
+ * @throws IOException on error.
+ */
+ public ReconTestInjector build() throws IOException {
+ reconTestInjector.setupInjector();
+ return reconTestInjector;
+ }
+ }
+}
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestContainerEndpoint.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestContainerEndpoint.java
index daee217..c59c237 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestContainerEndpoint.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestContainerEndpoint.java
@@ -18,6 +18,11 @@
package org.apache.hadoop.ozone.recon.api;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getOmKeyLocationInfo;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getRandomPipeline;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getTestReconOmMetadataManager;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.initializeNewOmMetadataManager;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.writeDataToOm;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
@@ -46,8 +51,7 @@ import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager;
import org.apache.hadoop.ozone.om.OMMetadataManager;
import org.apache.hadoop.ozone.om.helpers.OmKeyLocationInfo;
import org.apache.hadoop.ozone.om.helpers.OmKeyLocationInfoGroup;
-import org.apache.hadoop.ozone.recon.AbstractOMMetadataManagerTest;
-import org.apache.hadoop.ozone.recon.GuiceInjectorUtilsForTestsImpl;
+import org.apache.hadoop.ozone.recon.ReconTestInjector;
import org.apache.hadoop.ozone.recon.api.types.ContainerMetadata;
import org.apache.hadoop.ozone.recon.api.types.ContainersResponse;
import org.apache.hadoop.ozone.recon.api.types.KeyMetadata;
@@ -64,42 +68,34 @@ import org.apache.hadoop.ozone.recon.spi.impl.OzoneManagerServiceProviderImpl;
import org.apache.hadoop.ozone.recon.spi.impl.StorageContainerServiceProviderImpl;
import org.apache.hadoop.ozone.recon.tasks.ContainerKeyMapperTask;
import org.apache.hadoop.hdds.utils.db.Table;
-import org.hadoop.ozone.recon.schema.ContainerSchemaDefinition;
-import org.hadoop.ozone.recon.schema.ReconTaskSchemaDefinition;
-import org.hadoop.ozone.recon.schema.StatsSchemaDefinition;
-import org.hadoop.ozone.recon.schema.tables.daos.ReconTaskStatusDao;
import org.hadoop.ozone.recon.schema.tables.pojos.ContainerHistory;
-import org.jooq.Configuration;
import org.junit.Assert;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
-
-import com.google.inject.AbstractModule;
-import com.google.inject.Injector;
+import org.junit.rules.TemporaryFolder;
/**
* Test for container endpoint.
*/
-public class TestContainerEndpoint extends AbstractOMMetadataManagerTest {
+public class TestContainerEndpoint {
+
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
private ContainerDBServiceProvider containerDbServiceProvider;
private ContainerEndpoint containerEndpoint;
- private GuiceInjectorUtilsForTestsImpl guiceInjectorTest =
- new GuiceInjectorUtilsForTestsImpl();
private boolean isSetupDone = false;
private ContainerSchemaManager containerSchemaManager;
private ReconOMMetadataManager reconOMMetadataManager;
private ContainerID containerID = new ContainerID(1L);
private PipelineID pipelineID;
private long keyCount = 5L;
- private void initializeInjector() throws Exception {
- reconOMMetadataManager = getTestMetadataManager(
- initializeNewOmMetadataManager());
- OzoneManagerServiceProviderImpl ozoneManagerServiceProvider =
- mock(OzoneManagerServiceProviderImpl.class);
- Injector parentInjector = guiceInjectorTest.getInjector(
- ozoneManagerServiceProvider, reconOMMetadataManager, temporaryFolder);
+ private void initializeInjector() throws Exception {
+ reconOMMetadataManager = getTestReconOmMetadataManager(
+ initializeNewOmMetadataManager(temporaryFolder.newFolder()),
+ temporaryFolder.newFolder());
Pipeline pipeline = getRandomPipeline();
pipelineID = pipeline.getId();
@@ -121,44 +117,24 @@ public class TestContainerEndpoint extends AbstractOMMetadataManagerTest {
when(mockReconSCM.getContainerManager())
.thenReturn(mockContainerManager);
- Configuration sqlConfiguration =
- parentInjector.getInstance((Configuration.class));
- Injector injector = parentInjector.createChildInjector(
- new AbstractModule() {
- @Override
- protected void configure() {
- try {
- ReconTaskSchemaDefinition taskSchemaDefinition = parentInjector
- .getInstance(ReconTaskSchemaDefinition.class);
- taskSchemaDefinition.initializeSchema();
- } catch (Exception e) {
- Assert.fail(e.getMessage());
- }
-
- ReconTaskStatusDao reconTaskStatusDao =
- new ReconTaskStatusDao(sqlConfiguration);
- bind(ReconTaskStatusDao.class).toInstance(reconTaskStatusDao);
-
- StorageContainerServiceProvider mockScmServiceProvider = mock(
- StorageContainerServiceProviderImpl.class);
- bind(StorageContainerServiceProvider.class)
- .toInstance(mockScmServiceProvider);
- bind(OzoneStorageContainerManager.class)
- .toInstance(mockReconSCM);
- bind(ContainerEndpoint.class);
- }
- });
-
- containerEndpoint = injector.getInstance(ContainerEndpoint.class);
- containerDbServiceProvider = injector.getInstance(
- ContainerDBServiceProvider.class);
- StatsSchemaDefinition schemaDefinition = injector.getInstance(
- StatsSchemaDefinition.class);
- schemaDefinition.initializeSchema();
- ContainerSchemaDefinition containerSchemaDefinition =
- injector.getInstance(ContainerSchemaDefinition.class);
- containerSchemaDefinition.initializeSchema();
- containerSchemaManager = injector.getInstance(ContainerSchemaManager.class);
+ ReconTestInjector reconTestInjector =
+ new ReconTestInjector.Builder(temporaryFolder)
+ .withReconSqlDb()
+ .withReconOm(reconOMMetadataManager)
+ .withOmServiceProvider(mock(OzoneManagerServiceProviderImpl.class))
+ .withReconScm(mockReconSCM)
+ .withContainerDB()
+ .addBinding(StorageContainerServiceProvider.class,
+ mock(StorageContainerServiceProviderImpl.class))
+ .addBinding(ContainerEndpoint.class)
+ .addBinding(ContainerSchemaManager.class)
+ .build();
+
+ containerDbServiceProvider =
+ reconTestInjector.getInstance(ContainerDBServiceProvider.class);
+ containerEndpoint = reconTestInjector.getInstance(ContainerEndpoint.class);
+ containerSchemaManager =
+ reconTestInjector.getInstance(ContainerSchemaManager.class);
}
@Before
@@ -168,7 +144,6 @@ public class TestContainerEndpoint extends AbstractOMMetadataManagerTest {
initializeInjector();
isSetupDone = true;
}
-
//Write Data to OM
Pipeline pipeline = getRandomPipeline();
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestEndpoints.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestEndpoints.java
index 07d5052..66c015c 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestEndpoints.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestEndpoints.java
@@ -18,9 +18,6 @@
package org.apache.hadoop.ozone.recon.api;
-import com.google.inject.AbstractModule;
-import com.google.inject.Injector;
-import com.google.inject.Singleton;
import org.apache.hadoop.hdds.protocol.DatanodeDetails;
import org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationType;
import org.apache.hadoop.hdds.protocol.proto.HddsProtos.LifeCycleState;
@@ -42,39 +39,44 @@ import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol;
import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager;
import org.apache.hadoop.ozone.om.helpers.OmBucketInfo;
import org.apache.hadoop.ozone.om.helpers.OmVolumeArgs;
-import org.apache.hadoop.ozone.recon.AbstractOMMetadataManagerTest;
-import org.apache.hadoop.ozone.recon.GuiceInjectorUtilsForTestsImpl;
+import org.apache.hadoop.ozone.recon.ReconTestInjector;
import org.apache.hadoop.ozone.recon.api.types.ClusterStateResponse;
import org.apache.hadoop.ozone.recon.api.types.DatanodeMetadata;
import org.apache.hadoop.ozone.recon.api.types.DatanodesResponse;
import org.apache.hadoop.ozone.recon.api.types.PipelineMetadata;
import org.apache.hadoop.ozone.recon.api.types.PipelinesResponse;
+import org.apache.hadoop.ozone.recon.persistence.AbstractReconSqlDBTest;
+import org.apache.hadoop.ozone.recon.persistence.ContainerSchemaManager;
import org.apache.hadoop.ozone.recon.recovery.ReconOMMetadataManager;
import org.apache.hadoop.ozone.recon.scm.ReconStorageContainerManagerFacade;
import org.apache.hadoop.ozone.recon.spi.StorageContainerServiceProvider;
import org.apache.hadoop.ozone.recon.spi.impl.OzoneManagerServiceProviderImpl;
import org.apache.hadoop.ozone.recon.spi.impl.StorageContainerServiceProviderImpl;
import org.apache.hadoop.test.LambdaTestUtils;
-import org.hadoop.ozone.recon.schema.ContainerSchemaDefinition;
-import org.hadoop.ozone.recon.schema.ReconTaskSchemaDefinition;
-import org.hadoop.ozone.recon.schema.tables.daos.ReconTaskStatusDao;
-import org.jooq.Configuration;
import org.junit.Assert;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import static org.apache.hadoop.hdds.protocol.MockDatanodeDetails.randomDatanodeDetails;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getRandomPipeline;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getTestReconOmMetadataManager;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.initializeNewOmMetadataManager;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.writeDataToOm;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import javax.ws.rs.core.Response;
+
+import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.Callable;
/**
* Test for Recon API endpoints.
*/
-public class TestEndpoints extends AbstractOMMetadataManagerTest {
+public class TestEndpoints extends AbstractReconSqlDBTest {
private NodeEndpoint nodeEndpoint;
private PipelineEndpoint pipelineEndpoint;
private ClusterStateEndpoint clusterStateEndpoint;
@@ -84,84 +86,64 @@ public class TestEndpoints extends AbstractOMMetadataManagerTest {
private String pipelineId;
private DatanodeDetails datanodeDetails;
private DatanodeDetails datanodeDetails2;
- private GuiceInjectorUtilsForTestsImpl guiceInjectorTest =
- new GuiceInjectorUtilsForTestsImpl();
private long containerId = 1L;
private ContainerReportsProto containerReportsProto;
private DatanodeDetailsProto datanodeDetailsProto;
private Pipeline pipeline;
- private void initializeInjector() throws Exception {
- reconOMMetadataManager = getTestMetadataManager(
- initializeNewOmMetadataManager());
- OzoneManagerServiceProviderImpl omServiceProviderMock =
- mock(OzoneManagerServiceProviderImpl.class);
- Injector parentInjector = guiceInjectorTest.getInjector(
- omServiceProviderMock, reconOMMetadataManager, temporaryFolder);
- Injector injector = parentInjector.createChildInjector(
- new AbstractModule() {
- @Override
- protected void configure() {
- try {
- datanodeDetails = randomDatanodeDetails();
- datanodeDetails2 = randomDatanodeDetails();
- pipeline = getRandomPipeline(datanodeDetails);
- pipelineId = pipeline.getId().getId().toString();
-
- Configuration sqlConfiguration =
- parentInjector.getInstance((Configuration.class));
-
- ContainerInfo containerInfo = new ContainerInfo.Builder()
- .setContainerID(containerId)
- .setReplicationFactor(ReplicationFactor.ONE)
- .setState(LifeCycleState.OPEN)
- .setOwner("test")
- .setPipelineID(pipeline.getId())
- .setReplicationType(ReplicationType.RATIS)
- .build();
- ContainerWithPipeline containerWithPipeline =
- new ContainerWithPipeline(containerInfo, pipeline);
-
- ReconTaskSchemaDefinition taskSchemaDefinition = parentInjector
- .getInstance(ReconTaskSchemaDefinition.class);
- taskSchemaDefinition.initializeSchema();
-
- ReconTaskStatusDao reconTaskStatusDao =
- new ReconTaskStatusDao(sqlConfiguration);
-
- bind(ReconTaskStatusDao.class).toInstance(reconTaskStatusDao);
-
- StorageContainerLocationProtocol mockScmClient = mock(
- StorageContainerLocationProtocol.class);
- StorageContainerServiceProvider mockScmServiceProvider = mock(
- StorageContainerServiceProviderImpl.class);
- when(mockScmServiceProvider.getPipeline(
- pipeline.getId().getProtobuf())).thenReturn(pipeline);
- when(mockScmServiceProvider.getContainerWithPipeline(containerId))
- .thenReturn(containerWithPipeline);
-
- bind(StorageContainerLocationProtocol.class)
- .toInstance(mockScmClient);
- bind(StorageContainerServiceProvider.class)
- .toInstance(mockScmServiceProvider);
- bind(OzoneStorageContainerManager.class)
- .to(ReconStorageContainerManagerFacade.class)
- .in(Singleton.class);
- bind(NodeEndpoint.class);
- } catch (Exception e) {
- Assert.fail(e.getMessage());
- }
- }
- });
-
- nodeEndpoint = injector.getInstance(NodeEndpoint.class);
- pipelineEndpoint = injector.getInstance(PipelineEndpoint.class);
- clusterStateEndpoint = injector.getInstance(ClusterStateEndpoint.class);
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+ private void initializeInjector() throws IOException {
+ reconOMMetadataManager = getTestReconOmMetadataManager(
+ initializeNewOmMetadataManager(temporaryFolder.newFolder()),
+ temporaryFolder.newFolder());
+ datanodeDetails = randomDatanodeDetails();
+ datanodeDetails2 = randomDatanodeDetails();
+ pipeline = getRandomPipeline(datanodeDetails);
+ pipelineId = pipeline.getId().getId().toString();
+
+ ContainerInfo containerInfo = new ContainerInfo.Builder()
+ .setContainerID(containerId)
+ .setReplicationFactor(ReplicationFactor.ONE)
+ .setState(LifeCycleState.OPEN)
+ .setOwner("test")
+ .setPipelineID(pipeline.getId())
+ .setReplicationType(ReplicationType.RATIS)
+ .build();
+ ContainerWithPipeline containerWithPipeline =
+ new ContainerWithPipeline(containerInfo, pipeline);
+
+ StorageContainerLocationProtocol mockScmClient = mock(
+ StorageContainerLocationProtocol.class);
+ StorageContainerServiceProvider mockScmServiceProvider = mock(
+ StorageContainerServiceProviderImpl.class);
+ when(mockScmServiceProvider.getPipeline(
+ pipeline.getId().getProtobuf())).thenReturn(pipeline);
+ when(mockScmServiceProvider.getContainerWithPipeline(containerId))
+ .thenReturn(containerWithPipeline);
+
+ ReconTestInjector reconTestInjector =
+ new ReconTestInjector.Builder(temporaryFolder)
+ .withReconSqlDb()
+ .withReconOm(reconOMMetadataManager)
+ .withOmServiceProvider(mock(OzoneManagerServiceProviderImpl.class))
+ .addBinding(StorageContainerServiceProvider.class,
+ mockScmServiceProvider)
+ .addBinding(OzoneStorageContainerManager.class,
+ ReconStorageContainerManagerFacade.class)
+ .addBinding(ClusterStateEndpoint.class)
+ .addBinding(NodeEndpoint.class)
+ .addBinding(ContainerSchemaManager.class)
+ .addBinding(StorageContainerLocationProtocol.class, mockScmClient)
+ .build();
+
+ nodeEndpoint = reconTestInjector.getInstance(NodeEndpoint.class);
+ pipelineEndpoint = reconTestInjector.getInstance(PipelineEndpoint.class);
+ clusterStateEndpoint =
+ reconTestInjector.getInstance(ClusterStateEndpoint.class);
reconScm = (ReconStorageContainerManagerFacade)
- injector.getInstance(OzoneStorageContainerManager.class);
- ContainerSchemaDefinition containerSchemaDefinition =
- injector.getInstance(ContainerSchemaDefinition.class);
- containerSchemaDefinition.initializeSchema();
+ reconTestInjector.getInstance(OzoneStorageContainerManager.class);
}
@Before
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestTaskStatusService.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestTaskStatusService.java
index fd792d8..9485dbf 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestTaskStatusService.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestTaskStatusService.java
@@ -20,51 +20,40 @@ package org.apache.hadoop.ozone.recon.api;
import com.google.inject.AbstractModule;
import com.google.inject.Injector;
-import org.apache.hadoop.ozone.recon.persistence.AbstractSqlDatabaseTest;
-import org.hadoop.ozone.recon.schema.ReconTaskSchemaDefinition;
+
+import org.apache.hadoop.ozone.recon.persistence.AbstractReconSqlDBTest;
import org.hadoop.ozone.recon.schema.tables.daos.ReconTaskStatusDao;
import org.hadoop.ozone.recon.schema.tables.pojos.ReconTaskStatus;
-import org.jooq.Configuration;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import javax.ws.rs.core.Response;
-import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
/**
* Test for Task Status Service.
*/
-public class TestTaskStatusService extends AbstractSqlDatabaseTest {
+public class TestTaskStatusService extends AbstractReconSqlDBTest {
private TaskStatusService taskStatusService;
- private Configuration sqlConfiguration;
- private Injector childInjector;
@Before
- public void setUp() throws SQLException {
- sqlConfiguration = getInjector().getInstance((Configuration.class));
+ public void setUp() {
Injector parentInjector = getInjector();
- childInjector = parentInjector.createChildInjector(new AbstractModule() {
+ parentInjector.createChildInjector(new AbstractModule() {
@Override
protected void configure() {
taskStatusService = new TaskStatusService();
- bind(ReconTaskStatusDao.class).
- toInstance(new ReconTaskStatusDao(sqlConfiguration));
bind(TaskStatusService.class).toInstance(taskStatusService);
}
});
- ReconTaskSchemaDefinition schemaDefinition = getInjector().
- getInstance(ReconTaskSchemaDefinition.class);
- schemaDefinition.initializeSchema();
}
@Test
public void testGetTaskTimes() {
- ReconTaskStatusDao reconTaskStatusDao =
- new ReconTaskStatusDao(sqlConfiguration);
+ ReconTaskStatusDao reconTaskStatusDao = getDao(ReconTaskStatusDao.class);
ReconTaskStatus reconTaskStatusRecord = new ReconTaskStatus(
"Dummy_Task", System.currentTimeMillis(), 0L);
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/fsck/TestMissingContainerTask.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/fsck/TestMissingContainerTask.java
index ba3357b..aea68a7 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/fsck/TestMissingContainerTask.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/fsck/TestMissingContainerTask.java
@@ -31,45 +31,34 @@ import org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolPro
import org.apache.hadoop.hdds.scm.container.ContainerID;
import org.apache.hadoop.hdds.scm.container.ContainerManager;
import org.apache.hadoop.hdds.scm.container.ContainerReplica;
-import org.apache.hadoop.ozone.recon.persistence.AbstractSqlDatabaseTest;
import org.apache.hadoop.ozone.recon.persistence.ContainerSchemaManager;
import org.apache.hadoop.ozone.recon.scm.ReconStorageContainerManagerFacade;
import org.apache.hadoop.test.LambdaTestUtils;
import org.hadoop.ozone.recon.schema.ContainerSchemaDefinition;
-import org.hadoop.ozone.recon.schema.ReconTaskSchemaDefinition;
import org.hadoop.ozone.recon.schema.tables.daos.ContainerHistoryDao;
+import org.apache.hadoop.ozone.recon.persistence.AbstractReconSqlDBTest;
import org.hadoop.ozone.recon.schema.tables.daos.MissingContainersDao;
import org.hadoop.ozone.recon.schema.tables.daos.ReconTaskStatusDao;
import org.hadoop.ozone.recon.schema.tables.pojos.MissingContainers;
import org.hadoop.ozone.recon.schema.tables.pojos.ReconTaskStatus;
-import org.jooq.Configuration;
import org.junit.Assert;
import org.junit.Test;
/**
* Class to test single run of Missing Container Task.
*/
-public class TestMissingContainerTask extends AbstractSqlDatabaseTest {
+public class TestMissingContainerTask extends AbstractReconSqlDBTest {
@Test
public void testRun() throws Exception {
- Configuration sqlConfiguration =
- getInjector().getInstance((Configuration.class));
-
- ReconTaskSchemaDefinition taskSchemaDefinition = getInjector().getInstance(
- ReconTaskSchemaDefinition.class);
- taskSchemaDefinition.initializeSchema();
-
- ContainerSchemaDefinition schemaDefinition =
- getInjector().getInstance(ContainerSchemaDefinition.class);
- schemaDefinition.initializeSchema();
-
MissingContainersDao missingContainersTableHandle =
- new MissingContainersDao(sqlConfiguration);
+ getDao(MissingContainersDao.class);
ContainerSchemaManager containerSchemaManager =
- new ContainerSchemaManager(mock(ContainerHistoryDao.class),
- schemaDefinition, missingContainersTableHandle);
+ new ContainerSchemaManager(
+ mock(ContainerHistoryDao.class),
+ getSchemaDefinition(ContainerSchemaDefinition.class),
+ missingContainersTableHandle);
ReconStorageContainerManagerFacade scmMock =
mock(ReconStorageContainerManagerFacade.class);
ContainerManager containerManagerMock = mock(ContainerManager.class);
@@ -97,8 +86,7 @@ public class TestMissingContainerTask extends AbstractSqlDatabaseTest {
Assert.assertTrue(all.isEmpty());
long currentTime = System.currentTimeMillis();
- ReconTaskStatusDao reconTaskStatusDao =
- new ReconTaskStatusDao(sqlConfiguration);
+ ReconTaskStatusDao reconTaskStatusDao = getDao(ReconTaskStatusDao.class);
MissingContainerTask missingContainerTask =
new MissingContainerTask(scmMock, reconTaskStatusDao,
containerSchemaManager);
@@ -107,7 +95,6 @@ public class TestMissingContainerTask extends AbstractSqlDatabaseTest {
LambdaTestUtils.await(6000, 1000, () ->
(containerSchemaManager.getAllMissingContainers().size() == 2));
-
all = containerSchemaManager.getAllMissingContainers();
// Container IDs 2 and 3 should be present in the missing containers table
Set<Long> missingContainerIDs = Collections.unmodifiableSet(
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/AbstractSqlDatabaseTest.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/AbstractReconSqlDBTest.java
similarity index 50%
rename from hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/AbstractSqlDatabaseTest.java
rename to hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/AbstractReconSqlDBTest.java
index 898dd19..ec6610c 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/AbstractSqlDatabaseTest.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/AbstractReconSqlDBTest.java
@@ -17,69 +17,150 @@
*/
package org.apache.hadoop.ozone.recon.persistence;
+import static org.apache.hadoop.ozone.recon.ReconControllerModule.ReconDaoBindingModule.RECON_DAO_LIST;
+import static org.junit.Assert.assertNotNull;
+
import java.io.File;
import java.io.IOException;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
import javax.sql.DataSource;
+import org.apache.hadoop.ozone.recon.ReconControllerModule.ReconDaoBindingModule;
+import org.apache.hadoop.ozone.recon.ReconSchemaManager;
+import org.hadoop.ozone.recon.codegen.ReconSchemaGenerationModule;
+import org.jooq.Configuration;
import org.jooq.DSLContext;
import org.jooq.SQLDialect;
import org.jooq.impl.DSL;
import org.jooq.impl.DefaultConfiguration;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.ClassRule;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
+import com.google.inject.Module;
import com.google.inject.Provider;
/**
- * Create an injector for tests that need to access the SQl database.
+ * Class that provides a Recon SQL DB with all the tables created, and APIs
+ * to access the DAOs easily.
*/
-public abstract class AbstractSqlDatabaseTest {
-
- @ClassRule
- public static TemporaryFolder temporaryFolder = new TemporaryFolder();
+public class AbstractReconSqlDBTest {
- private static Injector injector;
- private static DSLContext dslContext;
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
- @BeforeClass
- public static void setup() throws IOException {
- File tempDir = temporaryFolder.newFolder();
+ private Injector injector;
+ private DSLContext dslContext;
- DataSourceConfigurationProvider configurationProvider =
- new DataSourceConfigurationProvider(tempDir);
+ public AbstractReconSqlDBTest() {
+ try {
+ temporaryFolder.create();
+ } catch (IOException e) {
+ Assert.fail();
+ }
+ }
- JooqPersistenceModule persistenceModule =
- new JooqPersistenceModule(configurationProvider);
+ @Before
+ public void createReconSchemaForTest() throws IOException {
+ injector = Guice.createInjector(getReconSqlDBModules());
+ dslContext = DSL.using(new DefaultConfiguration().set(
+ injector.getInstance(DataSource.class)));
+ createSchema(injector);
+ }
- injector = Guice.createInjector(persistenceModule, new AbstractModule() {
+ /**
+ * Get set of Guice modules needed to setup a Recon SQL DB.
+ * @return List of modules.
+ * @throws IOException on Error.
+ */
+ public List<Module> getReconSqlDBModules() throws IOException {
+ List<Module> modules = new ArrayList<>();
+ DataSourceConfigurationProvider configurationProvider =
+ new DataSourceConfigurationProvider(temporaryFolder.newFolder());
+ modules.add(new JooqPersistenceModule(configurationProvider));
+ modules.add(new AbstractModule() {
@Override
- public void configure() {
+ protected void configure() {
bind(DataSourceConfiguration.class).toProvider(configurationProvider);
- }
+ bind(ReconSchemaManager.class);
+ }
});
- dslContext = DSL.using(new DefaultConfiguration().set(
- injector.getInstance(DataSource.class)));
+ modules.add(new ReconSchemaGenerationModule());
+ modules.add(new ReconDaoBindingModule());
+ return modules;
}
- @AfterClass
- public static void tearDown() {
- temporaryFolder.delete();
+ /**
+ * Method to create Recon SQL schema. Used externally from ReconTestInjector.
+ * @param inj injector
+ */
+ public void createSchema(Injector inj) {
+ ReconSchemaManager reconSchemaManager =
+ inj.getInstance(ReconSchemaManager.class);
+ reconSchemaManager.createReconSchema();
}
protected Injector getInjector() {
return injector;
}
+ protected Connection getConnection() throws SQLException {
+ return injector.getInstance(DataSource.class).getConnection();
+ }
+
protected DSLContext getDslContext() {
return dslContext;
}
+ protected Configuration getConfiguration() {
+ return injector.getInstance(Configuration.class);
+ }
+
+ /**
+ * Get DAO of a specific type.
+ * @param type DAO class type.
+ * @param <T> Dao type.
+ * @return Dao instance.
+ */
+ protected <T> T getDao(Class<T> type) {
+ return injector.getInstance(type);
+ }
+
+ /**
+ * Get Schema definition of a specific type. (Essentially same as last
+ * method. Just with a different name for easy understanding.)
+ * @param type Schema definition class type.
+ * @param <T> Schema definition type.
+ * @return Schema definition instance.
+ */
+ protected <T> T getSchemaDefinition(Class<T> type) {
+ return injector.getInstance(type);
+ }
+
+ /**
+ * Make sure schema was created correctly.
+ * @throws SQLException
+ */
+ @Test
+ public void testSchemaSetup() throws SQLException {
+ assertNotNull(injector);
+ assertNotNull(getConfiguration());
+ assertNotNull(dslContext);
+ assertNotNull(getConnection());
+ RECON_DAO_LIST.forEach(dao -> {
+ assertNotNull(getDao(dao));
+ });
+ }
+
/**
* Local Sqlite datasource provider.
*/
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestReconInternalSchemaDefinition.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestReconInternalSchemaDefinition.java
index 51d8f83..a771edd 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestReconInternalSchemaDefinition.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestReconInternalSchemaDefinition.java
@@ -27,31 +27,22 @@ import java.sql.Types;
import java.util.ArrayList;
import java.util.List;
-import javax.sql.DataSource;
-
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
-import org.hadoop.ozone.recon.schema.ReconTaskSchemaDefinition;
import org.hadoop.ozone.recon.schema.tables.daos.ReconTaskStatusDao;
import org.hadoop.ozone.recon.schema.tables.pojos.ReconTaskStatus;
-import org.jooq.Configuration;
import org.junit.Assert;
import org.junit.Test;
/**
* Class used to test ReconInternalSchemaDefinition.
*/
-public class TestReconInternalSchemaDefinition extends AbstractSqlDatabaseTest {
+public class TestReconInternalSchemaDefinition extends AbstractReconSqlDBTest {
@Test
public void testSchemaCreated() throws Exception {
- ReconTaskSchemaDefinition schemaDefinition = getInjector().getInstance(
- ReconTaskSchemaDefinition.class);
-
- schemaDefinition.initializeSchema();
- Connection connection =
- getInjector().getInstance(DataSource.class).getConnection();
+ Connection connection = getConnection();
// Verify table definition
DatabaseMetaData metaData = connection.getMetaData();
ResultSet resultSet = metaData.getColumns(null, null,
@@ -80,14 +71,7 @@ public class TestReconInternalSchemaDefinition extends AbstractSqlDatabaseTest {
@Test
public void testReconTaskStatusCRUDOperations() throws Exception {
// Verify table exists
- ReconTaskSchemaDefinition schemaDefinition = getInjector().getInstance(
- ReconTaskSchemaDefinition.class);
-
- schemaDefinition.initializeSchema();
-
- DataSource ds = getInjector().getInstance(DataSource.class);
- Connection connection = ds.getConnection();
-
+ Connection connection = getConnection();
DatabaseMetaData metaData = connection.getMetaData();
ResultSet resultSet = metaData.getTables(null, null,
RECON_TASK_STATUS_TABLE_NAME, null);
@@ -97,9 +81,7 @@ public class TestReconInternalSchemaDefinition extends AbstractSqlDatabaseTest {
resultSet.getString("TABLE_NAME"));
}
- ReconTaskStatusDao dao = new ReconTaskStatusDao(getInjector().getInstance(
- Configuration.class));
-
+ ReconTaskStatusDao dao = getDao(ReconTaskStatusDao.class);
long now = System.currentTimeMillis();
ReconTaskStatus newRecord = new ReconTaskStatus();
newRecord.setTaskName("HelloWorldTask");
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestStatsSchemaDefinition.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestStatsSchemaDefinition.java
index 864e59e..bb82119 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestStatsSchemaDefinition.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestStatsSchemaDefinition.java
@@ -19,14 +19,11 @@ package org.apache.hadoop.ozone.recon.persistence;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
-import org.hadoop.ozone.recon.schema.StatsSchemaDefinition;
import org.hadoop.ozone.recon.schema.tables.daos.GlobalStatsDao;
import org.hadoop.ozone.recon.schema.tables.pojos.GlobalStats;
-import org.jooq.Configuration;
import org.junit.Assert;
import org.junit.Test;
-import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
@@ -40,17 +37,11 @@ import static org.hadoop.ozone.recon.schema.StatsSchemaDefinition.GLOBAL_STATS_T
/**
* Class used to test StatsSchemaDefinition.
*/
-public class TestStatsSchemaDefinition extends AbstractSqlDatabaseTest {
+public class TestStatsSchemaDefinition extends AbstractReconSqlDBTest {
@Test
public void testIfStatsSchemaCreated() throws Exception {
- StatsSchemaDefinition schemaDefinition = getInjector().getInstance(
- StatsSchemaDefinition.class);
-
- schemaDefinition.initializeSchema();
-
- Connection connection =
- getInjector().getInstance(DataSource.class).getConnection();
+ Connection connection = getConnection();
// Verify table definition
DatabaseMetaData metaData = connection.getMetaData();
ResultSet resultSet = metaData.getColumns(null, null,
@@ -76,14 +67,7 @@ public class TestStatsSchemaDefinition extends AbstractSqlDatabaseTest {
@Test
public void testGlobalStatsCRUDOperations() throws Exception {
- // Verify table exists
- StatsSchemaDefinition schemaDefinition = getInjector().getInstance(
- StatsSchemaDefinition.class);
-
- schemaDefinition.initializeSchema();
-
- DataSource ds = getInjector().getInstance(DataSource.class);
- Connection connection = ds.getConnection();
+ Connection connection = getConnection();
DatabaseMetaData metaData = connection.getMetaData();
ResultSet resultSet = metaData.getTables(null, null,
@@ -94,8 +78,7 @@ public class TestStatsSchemaDefinition extends AbstractSqlDatabaseTest {
resultSet.getString("TABLE_NAME"));
}
- GlobalStatsDao dao = new GlobalStatsDao(
- getInjector().getInstance(Configuration.class));
+ GlobalStatsDao dao = getDao(GlobalStatsDao.class);
long now = System.currentTimeMillis();
GlobalStats newRecord = new GlobalStats();
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestUtilizationSchemaDefinition.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestUtilizationSchemaDefinition.java
index 0d7d102..ea2d08c 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestUtilizationSchemaDefinition.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/persistence/TestUtilizationSchemaDefinition.java
@@ -31,17 +31,13 @@ import java.sql.Types;
import java.util.ArrayList;
import java.util.List;
-import javax.sql.DataSource;
-
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.Pair;
-import org.hadoop.ozone.recon.schema.UtilizationSchemaDefinition;
import org.hadoop.ozone.recon.schema.tables.daos.ClusterGrowthDailyDao;
import org.hadoop.ozone.recon.schema.tables.daos.FileCountBySizeDao;
import org.hadoop.ozone.recon.schema.tables.pojos.ClusterGrowthDaily;
import org.hadoop.ozone.recon.schema.tables.pojos.FileCountBySize;
import org.hadoop.ozone.recon.schema.tables.records.FileCountBySizeRecord;
-import org.jooq.Configuration;
import org.jooq.Table;
import org.jooq.UniqueKey;
import org.junit.Assert;
@@ -50,17 +46,11 @@ import org.junit.Test;
/**
* Test persistence module provides connection and transaction awareness.
*/
-public class TestUtilizationSchemaDefinition extends AbstractSqlDatabaseTest {
+public class TestUtilizationSchemaDefinition extends AbstractReconSqlDBTest {
@Test
public void testReconSchemaCreated() throws Exception {
- UtilizationSchemaDefinition schemaDefinition = getInjector().getInstance(
- UtilizationSchemaDefinition.class);
-
- schemaDefinition.initializeSchema();
-
- Connection connection =
- getInjector().getInstance(DataSource.class).getConnection();
+ Connection connection = getConnection();
// Verify table definition
DatabaseMetaData metaData = connection.getMetaData();
ResultSet resultSet = metaData.getColumns(null, null,
@@ -111,12 +101,7 @@ public class TestUtilizationSchemaDefinition extends AbstractSqlDatabaseTest {
@Test
public void testClusterGrowthDailyCRUDOperations() throws Exception {
// Verify table exists
- UtilizationSchemaDefinition schemaDefinition = getInjector().getInstance(
- UtilizationSchemaDefinition.class);
- schemaDefinition.initializeSchema();
-
- DataSource ds = getInjector().getInstance(DataSource.class);
- Connection connection = ds.getConnection();
+ Connection connection = getConnection();
DatabaseMetaData metaData = connection.getMetaData();
ResultSet resultSet = metaData.getTables(null, null,
@@ -127,9 +112,7 @@ public class TestUtilizationSchemaDefinition extends AbstractSqlDatabaseTest {
resultSet.getString("TABLE_NAME"));
}
- ClusterGrowthDailyDao dao = new ClusterGrowthDailyDao(
- getInjector().getInstance(Configuration.class));
-
+ ClusterGrowthDailyDao dao = getDao(ClusterGrowthDailyDao.class);
long now = System.currentTimeMillis();
ClusterGrowthDaily newRecord = new ClusterGrowthDaily();
newRecord.setTimestamp(new Timestamp(now));
@@ -187,12 +170,7 @@ public class TestUtilizationSchemaDefinition extends AbstractSqlDatabaseTest {
@Test
public void testFileCountBySizeCRUDOperations() throws SQLException {
- UtilizationSchemaDefinition schemaDefinition = getInjector().getInstance(
- UtilizationSchemaDefinition.class);
- schemaDefinition.initializeSchema();
-
- DataSource ds = getInjector().getInstance(DataSource.class);
- Connection connection = ds.getConnection();
+ Connection connection = getConnection();
DatabaseMetaData metaData = connection.getMetaData();
ResultSet resultSet = metaData.getTables(null, null,
@@ -203,8 +181,7 @@ public class TestUtilizationSchemaDefinition extends AbstractSqlDatabaseTest {
resultSet.getString("TABLE_NAME"));
}
- FileCountBySizeDao fileCountBySizeDao = new FileCountBySizeDao(
- getInjector().getInstance(Configuration.class));
+ FileCountBySizeDao fileCountBySizeDao = getDao(FileCountBySizeDao.class);
FileCountBySize newRecord = new FileCountBySize();
newRecord.setFileSize(1024L);
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/AbstractReconContainerManagerTest.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/AbstractReconContainerManagerTest.java
index b0ecfe2..7f87806 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/AbstractReconContainerManagerTest.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/AbstractReconContainerManagerTest.java
@@ -23,7 +23,7 @@ import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor
import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationType.STAND_ALONE;
import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_NAMES;
import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_METADATA_DIRS;
-import static org.apache.hadoop.ozone.recon.AbstractOMMetadataManagerTest.getRandomPipeline;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getRandomPipeline;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconContainerManager.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconContainerManager.java
index 5fd6389..ccc1c80 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconContainerManager.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconContainerManager.java
@@ -22,7 +22,7 @@ import static org.apache.hadoop.hdds.protocol.MockDatanodeDetails.randomDatanode
import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.LifeCycleState.OPEN;
import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationFactor.ONE;
import static org.apache.hadoop.hdds.protocol.proto.HddsProtos.ReplicationType.STAND_ALONE;
-import static org.apache.hadoop.ozone.recon.AbstractOMMetadataManagerTest.getRandomPipeline;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getRandomPipeline;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconPipelineManager.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconPipelineManager.java
index be5ee07..3d4d239 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconPipelineManager.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconPipelineManager.java
@@ -21,7 +21,7 @@ package org.apache.hadoop.ozone.recon.scm;
import static org.apache.hadoop.hdds.protocol.MockDatanodeDetails.randomDatanodeDetails;
import static org.apache.hadoop.hdds.scm.ScmConfigKeys.OZONE_SCM_NAMES;
import static org.apache.hadoop.ozone.OzoneConfigKeys.OZONE_METADATA_DIRS;
-import static org.apache.hadoop.ozone.recon.AbstractOMMetadataManagerTest.getRandomPipeline;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getRandomPipeline;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconPipelineReportHandler.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconPipelineReportHandler.java
index e04101b..e72df36 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconPipelineReportHandler.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/scm/TestReconPipelineReportHandler.java
@@ -18,7 +18,7 @@
package org.apache.hadoop.ozone.recon.scm;
-import static org.apache.hadoop.ozone.recon.AbstractOMMetadataManagerTest.getRandomPipeline;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getRandomPipeline;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestContainerDBServiceProviderImpl.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestContainerDBServiceProviderImpl.java
index 2392f8a..727cfe3 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestContainerDBServiceProviderImpl.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestContainerDBServiceProviderImpl.java
@@ -26,13 +26,10 @@ import static org.junit.Assert.assertTrue;
import java.util.HashMap;
import java.util.Map;
-import org.apache.hadoop.ozone.recon.GuiceInjectorUtilsForTestsImpl;
+import org.apache.hadoop.ozone.recon.ReconTestInjector;
import org.apache.hadoop.ozone.recon.api.types.ContainerKeyPrefix;
import org.apache.hadoop.ozone.recon.api.types.ContainerMetadata;
import org.apache.hadoop.ozone.recon.spi.ContainerDBServiceProvider;
-import org.hadoop.ozone.recon.schema.StatsSchemaDefinition;
-import org.jooq.impl.DSL;
-import org.jooq.impl.DefaultConfiguration;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
@@ -40,10 +37,6 @@ import org.junit.ClassRule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
-import com.google.inject.Injector;
-
-import javax.sql.DataSource;
-
/**
* Unit Tests for ContainerDBServiceProviderImpl.
*/
@@ -52,14 +45,28 @@ public class TestContainerDBServiceProviderImpl {
@ClassRule
public static TemporaryFolder tempFolder = new TemporaryFolder();
private static ContainerDBServiceProvider containerDbServiceProvider;
- private static Injector injector;
- private static GuiceInjectorUtilsForTestsImpl guiceInjectorTest =
- new GuiceInjectorUtilsForTestsImpl();
private String keyPrefix1 = "V3/B1/K1";
private String keyPrefix2 = "V3/B1/K2";
private String keyPrefix3 = "V3/B2/K1";
+ @BeforeClass
+ public static void setupOnce() throws Exception {
+ ReconTestInjector reconTestInjector =
+ new ReconTestInjector.Builder(tempFolder)
+ .withReconSqlDb()
+ .withContainerDB()
+ .build();
+ containerDbServiceProvider =
+ reconTestInjector.getInstance(ContainerDBServiceProvider.class);
+ }
+
+ @Before
+ public void setUp() throws Exception {
+ // Reset containerDB before running each test
+ containerDbServiceProvider.initNewContainerDB(null);
+ }
+
private void populateKeysInContainers(long containerId1, long containerId2)
throws Exception {
@@ -80,33 +87,6 @@ public class TestContainerDBServiceProviderImpl {
3);
}
- private static void initializeInjector() throws Exception {
- injector = guiceInjectorTest.getInjector(
- null, null, tempFolder);
- }
-
- @BeforeClass
- public static void setupOnce() throws Exception {
-
- initializeInjector();
-
- DSL.using(new DefaultConfiguration().set(
- injector.getInstance(DataSource.class)));
-
- containerDbServiceProvider = injector.getInstance(
- ContainerDBServiceProvider.class);
-
- StatsSchemaDefinition schemaDefinition = injector.getInstance(
- StatsSchemaDefinition.class);
- schemaDefinition.initializeSchema();
- }
-
- @Before
- public void setUp() throws Exception {
- // Reset containerDB before running each test
- containerDbServiceProvider.initNewContainerDB(null);
- }
-
@Test
public void testInitNewContainerDB() throws Exception {
long containerId = System.currentTimeMillis();
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestOzoneManagerServiceProviderImpl.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestOzoneManagerServiceProviderImpl.java
index 29f4807..058c118 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestOzoneManagerServiceProviderImpl.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestOzoneManagerServiceProviderImpl.java
@@ -18,6 +18,27 @@
package org.apache.hadoop.ozone.recon.spi.impl;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getTestReconOmMetadataManager;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.initializeEmptyOmMetadataManager;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.initializeNewOmMetadataManager;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.writeDataToOm;
+import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_DB_DIR;
+import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_OM_SNAPSHOT_DB_DIR;
+import static org.apache.hadoop.ozone.recon.ReconUtils.createTarFile;
+import static org.apache.hadoop.ozone.recon.spi.impl.OzoneManagerServiceProviderImpl.OmSnapshotTaskName.OmDeltaRequest;
+import static org.apache.hadoop.ozone.recon.spi.impl.OzoneManagerServiceProviderImpl.OmSnapshotTaskName.OmSnapshotRequest;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
@@ -33,35 +54,20 @@ import org.apache.hadoop.ozone.om.OMMetadataManager;
import org.apache.hadoop.ozone.om.helpers.DBUpdates;
import org.apache.hadoop.ozone.om.protocol.OzoneManagerProtocol;
import org.apache.hadoop.ozone.protocol.proto.OzoneManagerProtocolProtos;
-import org.apache.hadoop.ozone.recon.AbstractOMMetadataManagerTest;
import org.apache.hadoop.ozone.recon.ReconUtils;
import org.apache.hadoop.ozone.recon.recovery.ReconOMMetadataManager;
import org.apache.hadoop.ozone.recon.tasks.OMDBUpdatesHandler;
import org.apache.hadoop.ozone.recon.tasks.OMUpdateEventBatch;
import org.apache.hadoop.ozone.recon.tasks.ReconTaskController;
-import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_DB_DIR;
-import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_OM_SNAPSHOT_DB_DIR;
-import static org.apache.hadoop.ozone.recon.ReconUtils.createTarFile;
-import static org.apache.hadoop.ozone.recon.spi.impl.OzoneManagerServiceProviderImpl.OmSnapshotTaskName.OmDeltaRequest;
-import static org.apache.hadoop.ozone.recon.spi.impl.OzoneManagerServiceProviderImpl.OmSnapshotTaskName.OmSnapshotRequest;
import org.hadoop.ozone.recon.schema.tables.daos.ReconTaskStatusDao;
import org.hadoop.ozone.recon.schema.tables.pojos.ReconTaskStatus;
import org.junit.Assert;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
import org.mockito.ArgumentCaptor;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.Mockito.doCallRealMethod;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
import org.rocksdb.RocksDB;
import org.rocksdb.TransactionLogIterator;
import org.rocksdb.WriteBatch;
@@ -69,8 +75,10 @@ import org.rocksdb.WriteBatch;
/**
* Class to test Ozone Manager Service Provider Implementation.
*/
-public class TestOzoneManagerServiceProviderImpl extends
- AbstractOMMetadataManagerTest {
+public class TestOzoneManagerServiceProviderImpl {
+
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
private OzoneConfiguration configuration;
private OzoneManagerProtocol ozoneManagerProtocol;
@@ -89,9 +97,11 @@ public class TestOzoneManagerServiceProviderImpl extends
@Test
public void testUpdateReconOmDBWithNewSnapshot() throws Exception {
- OMMetadataManager omMetadataManager = initializeNewOmMetadataManager();
+ OMMetadataManager omMetadataManager =
+ initializeNewOmMetadataManager(temporaryFolder.newFolder());
ReconOMMetadataManager reconOMMetadataManager =
- getTestMetadataManager(omMetadataManager);
+ getTestReconOmMetadataManager(omMetadataManager,
+ temporaryFolder.newFolder());
writeDataToOm(omMetadataManager, "key_one");
writeDataToOm(omMetadataManager, "key_two");
@@ -176,7 +186,8 @@ public class TestOzoneManagerServiceProviderImpl extends
// Writing 2 Keys into a source OM DB and collecting it in a
// DBUpdatesWrapper.
- OMMetadataManager sourceOMMetadataMgr = initializeNewOmMetadataManager();
+ OMMetadataManager sourceOMMetadataMgr =
+ initializeNewOmMetadataManager(temporaryFolder.newFolder());
writeDataToOm(sourceOMMetadataMgr, "key_one");
writeDataToOm(sourceOMMetadataMgr, "key_two");
@@ -194,11 +205,13 @@ public class TestOzoneManagerServiceProviderImpl extends
}
// OM Service Provider's Metadata Manager.
- OMMetadataManager omMetadataManager = initializeNewOmMetadataManager();
+ OMMetadataManager omMetadataManager =
+ initializeNewOmMetadataManager(temporaryFolder.newFolder());
OzoneManagerServiceProviderImpl ozoneManagerServiceProvider =
new OzoneManagerServiceProviderImpl(configuration,
- getTestMetadataManager(omMetadataManager),
+ getTestReconOmMetadataManager(omMetadataManager,
+ temporaryFolder.newFolder()),
getMockTaskController(), new ReconUtils(),
getMockOzoneManagerClient(dbUpdatesWrapper));
@@ -229,8 +242,9 @@ public class TestOzoneManagerServiceProviderImpl extends
public void testSyncDataFromOMFullSnapshot() throws Exception {
// Empty OM DB to start with.
- ReconOMMetadataManager omMetadataManager = getTestMetadataManager(
- initializeEmptyOmMetadataManager());
+ ReconOMMetadataManager omMetadataManager = getTestReconOmMetadataManager(
+ initializeEmptyOmMetadataManager(temporaryFolder.newFolder()),
+ temporaryFolder.newFolder());
ReconTaskStatusDao reconTaskStatusDaoMock =
mock(ReconTaskStatusDao.class);
doNothing().when(reconTaskStatusDaoMock)
@@ -263,8 +277,9 @@ public class TestOzoneManagerServiceProviderImpl extends
public void testSyncDataFromOMDeltaUpdates() throws Exception {
// Non-Empty OM DB to start with.
- ReconOMMetadataManager omMetadataManager = getTestMetadataManager(
- initializeNewOmMetadataManager());
+ ReconOMMetadataManager omMetadataManager = getTestReconOmMetadataManager(
+ initializeNewOmMetadataManager(temporaryFolder.newFolder()),
+ temporaryFolder.newFolder());
ReconTaskStatusDao reconTaskStatusDaoMock =
mock(ReconTaskStatusDao.class);
doNothing().when(reconTaskStatusDaoMock)
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestContainerKeyMapperTask.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestContainerKeyMapperTask.java
index 8634998..cb6f5b3 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestContainerKeyMapperTask.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestContainerKeyMapperTask.java
@@ -18,6 +18,11 @@
package org.apache.hadoop.ozone.recon.tasks;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getOmKeyLocationInfo;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getRandomPipeline;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.getTestReconOmMetadataManager;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.initializeNewOmMetadataManager;
+import static org.apache.hadoop.ozone.recon.OMMetadataManagerTestUtils.writeDataToOm;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
@@ -36,69 +41,47 @@ import org.apache.hadoop.ozone.om.OMMetadataManager;
import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
import org.apache.hadoop.ozone.om.helpers.OmKeyLocationInfo;
import org.apache.hadoop.ozone.om.helpers.OmKeyLocationInfoGroup;
-import org.apache.hadoop.ozone.recon.AbstractOMMetadataManagerTest;
-import org.apache.hadoop.ozone.recon.GuiceInjectorUtilsForTestsImpl;
+import org.apache.hadoop.ozone.recon.ReconTestInjector;
import org.apache.hadoop.ozone.recon.api.types.ContainerKeyPrefix;
import org.apache.hadoop.ozone.recon.recovery.ReconOMMetadataManager;
import org.apache.hadoop.ozone.recon.spi.ContainerDBServiceProvider;
import org.apache.hadoop.ozone.recon.spi.impl.OzoneManagerServiceProviderImpl;
import org.apache.hadoop.hdds.utils.db.Table;
-import org.hadoop.ozone.recon.schema.StatsSchemaDefinition;
-import org.jooq.impl.DSL;
-import org.jooq.impl.DefaultConfiguration;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
-import com.google.inject.Injector;
-import javax.sql.DataSource;
+import org.junit.rules.TemporaryFolder;
/**
* Unit test for Container Key mapper task.
*/
-public class TestContainerKeyMapperTask extends AbstractOMMetadataManagerTest {
+public class TestContainerKeyMapperTask {
+
+ @Rule
+ public TemporaryFolder temporaryFolder = new TemporaryFolder();
private ContainerDBServiceProvider containerDbServiceProvider;
private OMMetadataManager omMetadataManager;
private ReconOMMetadataManager reconOMMetadataManager;
- private Injector injector;
private OzoneManagerServiceProviderImpl ozoneManagerServiceProvider;
- private boolean setUpIsDone = false;
- private GuiceInjectorUtilsForTestsImpl guiceInjectorTest =
- new GuiceInjectorUtilsForTestsImpl();
-
- private Injector getInjector() {
- return injector;
- }
-
- private void initializeInjector() throws Exception {
- omMetadataManager = initializeNewOmMetadataManager();
- ozoneManagerServiceProvider = getMockOzoneManagerServiceProvider();
- reconOMMetadataManager = getTestMetadataManager(omMetadataManager);
-
- injector = guiceInjectorTest.getInjector(
- ozoneManagerServiceProvider, reconOMMetadataManager, temporaryFolder);
- }
@Before
public void setUp() throws Exception {
- // The following setup is run only once
- if (!setUpIsDone) {
- initializeInjector();
-
- DSL.using(new DefaultConfiguration().set(
- injector.getInstance(DataSource.class)));
-
- containerDbServiceProvider = injector.getInstance(
- ContainerDBServiceProvider.class);
-
- StatsSchemaDefinition schemaDefinition = getInjector().getInstance(
- StatsSchemaDefinition.class);
- schemaDefinition.initializeSchema();
-
- setUpIsDone = true;
- }
-
- containerDbServiceProvider = injector.getInstance(
- ContainerDBServiceProvider.class);
+ omMetadataManager = initializeNewOmMetadataManager(
+ temporaryFolder.newFolder());
+ ozoneManagerServiceProvider = getMockOzoneManagerServiceProvider();
+ reconOMMetadataManager = getTestReconOmMetadataManager(omMetadataManager,
+ temporaryFolder.newFolder());
+
+ ReconTestInjector reconTestInjector =
+ new ReconTestInjector.Builder(temporaryFolder)
+ .withReconSqlDb()
+ .withReconOm(reconOMMetadataManager)
+ .withOmServiceProvider(ozoneManagerServiceProvider)
+ .withContainerDB()
+ .build();
+ containerDbServiceProvider =
+ reconTestInjector.getInstance(ContainerDBServiceProvider.class);
}
@Test
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestFileSizeCountTask.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestFileSizeCountTask.java
index b63ddd7..e0e37b5 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestFileSizeCountTask.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestFileSizeCountTask.java
@@ -23,16 +23,13 @@ import org.apache.hadoop.ozone.om.OMMetadataManager;
import org.apache.hadoop.ozone.om.OmMetadataManagerImpl;
import org.apache.hadoop.ozone.om.helpers.OmKeyInfo;
import org.apache.hadoop.hdds.utils.db.TypedTable;
-import org.apache.hadoop.ozone.recon.persistence.AbstractSqlDatabaseTest;
+import org.apache.hadoop.ozone.recon.persistence.AbstractReconSqlDBTest;
import org.apache.hadoop.ozone.recon.tasks.OMDBUpdateEvent.OMUpdateEventBuilder;
-import org.hadoop.ozone.recon.schema.UtilizationSchemaDefinition;
import org.hadoop.ozone.recon.schema.tables.daos.FileCountBySizeDao;
-import org.jooq.Configuration;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
-import java.sql.SQLException;
import java.util.Arrays;
import static org.apache.hadoop.ozone.recon.tasks.OMDBUpdateEvent.OMDBUpdateAction.DELETE;
@@ -49,18 +46,13 @@ import static org.mockito.Mockito.when;
/**
* Unit test for File Size Count Task.
*/
-public class TestFileSizeCountTask extends AbstractSqlDatabaseTest {
+public class TestFileSizeCountTask extends AbstractReconSqlDBTest {
private FileCountBySizeDao fileCountBySizeDao;
@Before
- public void setUp() throws SQLException {
- UtilizationSchemaDefinition schemaDefinition =
- getInjector().getInstance(UtilizationSchemaDefinition.class);
- schemaDefinition.initializeSchema();
- Configuration sqlConfiguration =
- getInjector().getInstance((Configuration.class));
- fileCountBySizeDao = new FileCountBySizeDao(sqlConfiguration);
+ public void setUp() {
+ fileCountBySizeDao = getDao(FileCountBySizeDao.class);
}
@Test
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestReconTaskControllerImpl.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestReconTaskControllerImpl.java
index 81cc4e0..ad03e67 100644
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestReconTaskControllerImpl.java
+++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/tasks/TestReconTaskControllerImpl.java
@@ -33,12 +33,10 @@ import java.util.HashSet;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.hadoop.hdds.conf.OzoneConfiguration;
import org.apache.hadoop.ozone.om.OMMetadataManager;
-import org.apache.hadoop.ozone.recon.persistence.AbstractSqlDatabaseTest;
+import org.apache.hadoop.ozone.recon.persistence.AbstractReconSqlDBTest;
import org.apache.hadoop.ozone.recon.recovery.ReconOMMetadataManager;
-import org.hadoop.ozone.recon.schema.ReconTaskSchemaDefinition;
import org.hadoop.ozone.recon.schema.tables.daos.ReconTaskStatusDao;
import org.hadoop.ozone.recon.schema.tables.pojos.ReconTaskStatus;
-import org.jooq.Configuration;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
@@ -46,32 +44,22 @@ import org.junit.Test;
/**
* Class used to test ReconTaskControllerImpl.
*/
-public class TestReconTaskControllerImpl extends AbstractSqlDatabaseTest {
+public class TestReconTaskControllerImpl extends AbstractReconSqlDBTest {
private ReconTaskController reconTaskController;
- private Configuration sqlConfiguration;
private ReconTaskStatusDao reconTaskStatusDao;
@Before
- public void setUp() throws Exception {
-
+ public void setUp() {
OzoneConfiguration ozoneConfiguration = new OzoneConfiguration();
-
- sqlConfiguration = getInjector()
- .getInstance(Configuration.class);
-
- reconTaskStatusDao = new ReconTaskStatusDao(sqlConfiguration);
- ReconTaskSchemaDefinition schemaDefinition = getInjector().
- getInstance(ReconTaskSchemaDefinition.class);
- schemaDefinition.initializeSchema();
-
+ reconTaskStatusDao = getDao(ReconTaskStatusDao.class);
reconTaskController = new ReconTaskControllerImpl(ozoneConfiguration,
reconTaskStatusDao, new HashSet<>());
reconTaskController.start();
}
@Test
- public void testRegisterTask() throws Exception {
+ public void testRegisterTask() {
String taskName = "Dummy_" + System.currentTimeMillis();
DummyReconDBTask dummyReconDBTask =
new DummyReconDBTask(taskName, DummyReconDBTask.TaskType.ALWAYS_PASS);
@@ -102,7 +90,7 @@ public class TestReconTaskControllerImpl extends AbstractSqlDatabaseTest {
.process(any());
long endTime = System.currentTimeMillis();
- reconTaskStatusDao = new ReconTaskStatusDao(sqlConfiguration);
+ reconTaskStatusDao = getDao(ReconTaskStatusDao.class);
ReconTaskStatus reconTaskStatus = reconTaskStatusDao.findById("MockTask");
long taskTimeStamp = reconTaskStatus.getLastUpdatedTimestamp();
long seqNumber = reconTaskStatus.getLastUpdatedSeqNumber();
@@ -132,7 +120,7 @@ public class TestReconTaskControllerImpl extends AbstractSqlDatabaseTest {
assertEquals(dummyReconDBTask, reconTaskController.getRegisteredTasks()
.get(dummyReconDBTask.getTaskName()));
- reconTaskStatusDao = new ReconTaskStatusDao(sqlConfiguration);
+ reconTaskStatusDao = getDao(ReconTaskStatusDao.class);
ReconTaskStatus dbRecord = reconTaskStatusDao.findById(taskName);
Assert.assertEquals(taskName, dbRecord.getTaskName());
@@ -168,7 +156,7 @@ public class TestReconTaskControllerImpl extends AbstractSqlDatabaseTest {
omMetadataManagerMock);
assertTrue(reconTaskController.getRegisteredTasks().isEmpty());
- reconTaskStatusDao = new ReconTaskStatusDao(sqlConfiguration);
+ reconTaskStatusDao = getDao(ReconTaskStatusDao.class);
ReconTaskStatus dbRecord = reconTaskStatusDao.findById(taskName);
Assert.assertEquals(taskName, dbRecord.getTaskName());
diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/types/GuiceInjectorUtilsForTests.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/types/GuiceInjectorUtilsForTests.java
deleted file mode 100644
index 71218c0..0000000
--- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/types/GuiceInjectorUtilsForTests.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- * <p>
- * http://www.apache.org/licenses/LICENSE-2.0
- * <p>
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.hadoop.ozone.recon.types;
-
-import com.google.inject.AbstractModule;
-import com.google.inject.Guice;
-import com.google.inject.Injector;
-import com.google.inject.Singleton;
-import org.apache.hadoop.hdds.conf.OzoneConfiguration;
-import org.apache.hadoop.ozone.recon.persistence.AbstractSqlDatabaseTest;
-import org.apache.hadoop.ozone.recon.persistence.ContainerSchemaManager;
-import org.apache.hadoop.ozone.recon.persistence.DataSourceConfiguration;
-import org.apache.hadoop.ozone.recon.persistence.JooqPersistenceModule;
-import org.apache.hadoop.ozone.recon.recovery.ReconOMMetadataManager;
-import org.apache.hadoop.ozone.recon.spi.ContainerDBServiceProvider;
-import org.apache.hadoop.ozone.recon.spi.OzoneManagerServiceProvider;
-import org.apache.hadoop.ozone.recon.spi.impl.ContainerDBServiceProviderImpl;
-import org.apache.hadoop.ozone.recon.spi.impl.OzoneManagerServiceProviderImpl;
-import org.apache.hadoop.ozone.recon.spi.impl.ReconContainerDBProvider;
-import org.apache.hadoop.hdds.utils.db.DBStore;
-import org.hadoop.ozone.recon.schema.tables.daos.ContainerHistoryDao;
-import org.hadoop.ozone.recon.schema.tables.daos.MissingContainersDao;
-import org.jooq.Configuration;
-import org.junit.Assert;
-import org.junit.rules.TemporaryFolder;
-
-import java.io.File;
-import java.io.IOException;
-
-import static org.apache.hadoop.hdds.recon.ReconConfigKeys.OZONE_RECON_DATANODE_ADDRESS_KEY;
-import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_DB_DIR;
-import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_SCM_DB_DIR;
-import static org.apache.hadoop.ozone.recon.ReconServerConfigKeys.OZONE_RECON_OM_SNAPSHOT_DB_DIR;
-
-/**
- * Utility methods to get guice injector and ozone configuration.
- */
-public interface GuiceInjectorUtilsForTests {
-
- /**
- * Get Guice Injector with bindings.
- * @param ozoneManagerServiceProvider
- * @param reconOMMetadataManager
- * @param temporaryFolder
- * @return Injector
- * @throws IOException ioEx.
- */
- default Injector getInjector(
- OzoneManagerServiceProviderImpl ozoneManagerServiceProvider,
- ReconOMMetadataManager reconOMMetadataManager,
- TemporaryFolder temporaryFolder
- ) throws IOException {
-
- File tempDir = temporaryFolder.newFolder();
- AbstractSqlDatabaseTest.DataSourceConfigurationProvider
- configurationProvider =
- new AbstractSqlDatabaseTest.DataSourceConfigurationProvider(tempDir);
-
- JooqPersistenceModule jooqPersistenceModule =
- new JooqPersistenceModule(configurationProvider);
-
- Injector baseInjector = Guice.createInjector(jooqPersistenceModule,
- new AbstractModule() {
- @Override
- protected void configure() {
- try {
- bind(DataSourceConfiguration.class)
- .toProvider(configurationProvider);
- bind(OzoneConfiguration.class).toInstance(
- getTestOzoneConfiguration(temporaryFolder));
-
- if (reconOMMetadataManager != null) {
- bind(ReconOMMetadataManager.class)
- .toInstance(reconOMMetadataManager);
- }
-
- if (ozoneManagerServiceProvider != null) {
- bind(OzoneManagerServiceProvider.class)
- .toInstance(ozoneManagerServiceProvider);
- }
-
- bind(DBStore.class).toProvider(ReconContainerDBProvider.class).
- in(Singleton.class);
- } catch (IOException e) {
- Assert.fail();
- }
- }
- });
-
- return baseInjector.createChildInjector(new AbstractModule() {
- @Override
- protected void configure() {
- Configuration sqlConfiguration =
- baseInjector.getInstance((Configuration.class));
- MissingContainersDao missingContainersDao =
- new MissingContainersDao(sqlConfiguration);
- ContainerHistoryDao containerHistoryDao =
- new ContainerHistoryDao(sqlConfiguration);
- bind(MissingContainersDao.class).toInstance(missingContainersDao);
- bind(ContainerHistoryDao.class).toInstance(containerHistoryDao);
- bind(ContainerSchemaManager.class).in(Singleton.class);
- bind(ContainerDBServiceProvider.class).to(
- ContainerDBServiceProviderImpl.class).in(Singleton.class);
- }
- });
- }
-
- /**
- * Get Test OzoneConfiguration instance.
- * @return OzoneConfiguration
- * @throws IOException ioEx.
- */
- default OzoneConfiguration getTestOzoneConfiguration(
- TemporaryFolder temporaryFolder) throws IOException {
- OzoneConfiguration configuration = new OzoneConfiguration();
- configuration.set(OZONE_RECON_OM_SNAPSHOT_DB_DIR,
- temporaryFolder.newFolder().getAbsolutePath());
- configuration.set(OZONE_RECON_DB_DIR, temporaryFolder.newFolder()
- .getAbsolutePath());
- configuration.set(OZONE_RECON_SCM_DB_DIR, temporaryFolder.newFolder()
- .getAbsolutePath());
- configuration.set(OZONE_RECON_DATANODE_ADDRESS_KEY,
- "0.0.0.0:0");
- return configuration;
- }
-}
---------------------------------------------------------------------
To unsubscribe, e-mail: ozone-commits-unsubscribe@hadoop.apache.org
For additional commands, e-mail: ozone-commits-help@hadoop.apache.org