sqoop-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a..@apache.org
Subject [12/52] [abbrv] SQOOP-1497: Sqoop2: Entity Nomenclature Revisited
Date Fri, 10 Oct 2014 02:51:41 GMT
http://git-wip-us.apache.org/repos/asf/sqoop/blob/049994a0/core/src/test/java/org/apache/sqoop/repository/TestJdbcRepository.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/sqoop/repository/TestJdbcRepository.java b/core/src/test/java/org/apache/sqoop/repository/TestJdbcRepository.java
index 0fcae75..796b021 100644
--- a/core/src/test/java/org/apache/sqoop/repository/TestJdbcRepository.java
+++ b/core/src/test/java/org/apache/sqoop/repository/TestJdbcRepository.java
@@ -17,6 +17,23 @@
  */
 package org.apache.sqoop.repository;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.anyObject;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
 import java.sql.Connection;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -26,39 +43,35 @@ import java.util.List;
 import org.apache.sqoop.common.Direction;
 import org.apache.sqoop.common.SqoopException;
 import org.apache.sqoop.connector.ConnectorManager;
-import org.apache.sqoop.connector.spi.MetadataUpgrader;
+import org.apache.sqoop.connector.spi.RepositoryUpgrader;
 import org.apache.sqoop.connector.spi.SqoopConnector;
-import org.apache.sqoop.framework.FrameworkManager;
-import org.apache.sqoop.framework.configuration.JobConfiguration;
+import org.apache.sqoop.driver.Driver;
+import org.apache.sqoop.driver.configuration.JobConfiguration;
 import org.apache.sqoop.model.ConfigurationClass;
 import org.apache.sqoop.model.FormUtils;
-import org.apache.sqoop.model.MConnection;
 import org.apache.sqoop.model.MConnectionForms;
 import org.apache.sqoop.model.MConnector;
+import org.apache.sqoop.model.MDriverConfig;
 import org.apache.sqoop.model.MForm;
-import org.apache.sqoop.model.MFramework;
 import org.apache.sqoop.model.MJob;
 import org.apache.sqoop.model.MJobForms;
+import org.apache.sqoop.model.MLink;
 import org.apache.sqoop.validation.Status;
 import org.apache.sqoop.validation.Validation;
-
 import org.apache.sqoop.validation.Validator;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.InOrder;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
-
 public class TestJdbcRepository {
 
   private JdbcRepository repoSpy;
   private JdbcRepositoryTransaction repoTransactionMock;
   private ConnectorManager connectorMgrMock;
-  private FrameworkManager frameworkMgrMock;
+  private Driver driverMock;
   private JdbcRepositoryHandler repoHandlerMock;
   private Validator validatorMock;
-  private MetadataUpgrader upgraderMock;
+  private RepositoryUpgrader upgraderMock;
 
   private Validation validRepoMock;
   private Validation invalidRepoMock;
@@ -67,16 +80,16 @@ public class TestJdbcRepository {
   public void setUp() throws Exception {
     repoTransactionMock = mock(JdbcRepositoryTransaction.class);
     connectorMgrMock = mock(ConnectorManager.class);
-    frameworkMgrMock = mock(FrameworkManager.class);
+    driverMock = mock(Driver.class);
     repoHandlerMock = mock(JdbcRepositoryHandler.class);
     validatorMock = mock(Validator.class);
-    upgraderMock = mock(MetadataUpgrader.class);
+    upgraderMock = mock(RepositoryUpgrader.class);
     repoSpy = spy(new JdbcRepository(repoHandlerMock, null));
 
     // setup transaction and connector manager
     doReturn(repoTransactionMock).when(repoSpy).getTransaction();
     ConnectorManager.setInstance(connectorMgrMock);
-    FrameworkManager.setInstance(frameworkMgrMock);
+    Driver.setInstance(driverMock);
 
     validRepoMock = mock(Validation.class);
     when(validRepoMock.getStatus()).thenReturn(Status.ACCEPTABLE);
@@ -138,26 +151,26 @@ public class TestJdbcRepository {
   }
 
   /**
-   * Test the procedure when the framework auto upgrade option is enabled
+   * Test the procedure when the driverConfig auto upgrade option is enabled
    */
   @Test
-  public void testFrameworkEnableAutoUpgrade() {
-    MFramework newFramework = framework();
-    MFramework oldFramework = anotherFramework();
+  public void testDriverConfigEnableAutoUpgrade() {
+    MDriverConfig newDriverConfig = driverConfig();
+    MDriverConfig oldDriverConfig = anotherDriverConfig();
 
-    when(repoHandlerMock.findFramework(any(Connection.class))).thenReturn(oldFramework);
+    when(repoHandlerMock.findDriverConfig(any(Connection.class))).thenReturn(oldDriverConfig);
 
-    // make the upgradeFramework to throw an exception to prove that it has been called
+    // make the upgradeDriverConfig to throw an exception to prove that it has been called
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
-        "upgradeFramework() has been called.");
-    doThrow(exception).when(repoHandlerMock).findConnections(any(Connection.class));
+        "upgradeDriverConfig() has been called.");
+    doThrow(exception).when(repoHandlerMock).findLinks(any(Connection.class));
 
     try {
-      repoSpy.registerFramework(newFramework, true);
+      repoSpy.registerDriverConfig(newDriverConfig, true);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findFramework(any(Connection.class));
-      verify(repoHandlerMock, times(1)).findConnections(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findDriverConfig(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinks(any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
     }
@@ -166,20 +179,20 @@ public class TestJdbcRepository {
   }
 
   /**
-   * Test the procedure when the framework auto upgrade option is disabled
+   * Test the procedure when the driverConfig auto upgrade option is disabled
    */
   @Test
-  public void testFrameworkDisableAutoUpgrade() {
-    MFramework newFramework = framework();
-    MFramework oldFramework = anotherFramework();
+  public void testDriverConfigDisableAutoUpgrade() {
+    MDriverConfig newDriverConfig = driverConfig();
+    MDriverConfig oldDriverConfig = anotherDriverConfig();
 
-    when(repoHandlerMock.findFramework(any(Connection.class))).thenReturn(oldFramework);
+    when(repoHandlerMock.findDriverConfig(any(Connection.class))).thenReturn(oldDriverConfig);
 
     try {
-      repoSpy.registerFramework(newFramework, false);
+      repoSpy.registerDriverConfig(newDriverConfig, false);
     } catch (SqoopException ex) {
       assertEquals(ex.getErrorCode(), RepositoryError.JDBCREPO_0026);
-      verify(repoHandlerMock, times(1)).findFramework(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findDriverConfig(any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
     }
@@ -188,32 +201,32 @@ public class TestJdbcRepository {
   }
 
   /**
-   * Test the connector upgrade procedure, when all the connections and
+   * Test the connector upgrade procedure, when all the links and
    * jobs using the old connector are still valid for the new connector
    */
   @Test
-  public void testConnectorUpgradeWithValidConnectionsAndJobs() {
+  public void testConnectorUpgradeWithValidLinksAndJobs() {
     MConnector newConnector = connector(1, "1.1");
     MConnector oldConnector = connector(1);
 
     // prepare the sqoop connector
     SqoopConnector sqconnector = mock(SqoopConnector.class);
-    when(validatorMock.validateConnection(any(MConnection.class))).thenReturn(validRepoMock);
+    when(validatorMock.validateLink(any(MLink.class))).thenReturn(validRepoMock);
     when(validatorMock.validateJob(any(MJob.class))).thenReturn(validRepoMock);
     when(sqconnector.getValidator()).thenReturn(validatorMock);
-    when(sqconnector.getMetadataUpgrader()).thenReturn(upgraderMock);
-    when(sqconnector.getConnectionConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
+    when(sqconnector.getRepositoryUpgrader()).thenReturn(upgraderMock);
+    when(sqconnector.getLinkConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
     when(sqconnector.getJobConfigurationClass(any(Direction.class))).thenReturn(JobConfiguration.class);
     when(connectorMgrMock.getConnector(anyString())).thenReturn(sqconnector);
 
-    // prepare the connections and jobs
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    // prepare the links and jobs
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
 
     // mock necessary methods for upgradeConnector() procedure
-    doReturn(connectionList).when(repoSpy).findConnectionsForConnector(anyLong());
+    doReturn(linkList).when(repoSpy).findLinksForConnector(anyLong());
     doReturn(jobList).when(repoSpy).findJobsForConnector(anyLong());
-    doNothing().when(repoSpy).updateConnection(any(MConnection.class), any(RepositoryTransaction.class));
+    doNothing().when(repoSpy).updateLink(any(MLink.class), any(RepositoryTransaction.class));
     doNothing().when(repoSpy).updateJob(any(MJob.class), any(RepositoryTransaction.class));
     doNothing().when(repoSpy).updateConnector(any(MConnector.class), any(RepositoryTransaction.class));
 
@@ -224,15 +237,15 @@ public class TestJdbcRepository {
     InOrder upgraderOrder = inOrder(upgraderMock);
     InOrder validatorOrder = inOrder(validatorMock);
 
-    repoOrder.verify(repoSpy, times(1)).findConnectionsForConnector(anyLong());
+    repoOrder.verify(repoSpy, times(1)).findLinksForConnector(anyLong());
     repoOrder.verify(repoSpy, times(1)).findJobsForConnector(anyLong());
     repoOrder.verify(repoSpy, times(1)).getTransaction();
     repoOrder.verify(repoSpy, times(1)).deleteJobInputs(1, repoTransactionMock);
     repoOrder.verify(repoSpy, times(1)).deleteJobInputs(2, repoTransactionMock);
-    repoOrder.verify(repoSpy, times(1)).deleteConnectionInputs(1, repoTransactionMock);
-    repoOrder.verify(repoSpy, times(1)).deleteConnectionInputs(2, repoTransactionMock);
+    repoOrder.verify(repoSpy, times(1)).deleteLinkInputs(1, repoTransactionMock);
+    repoOrder.verify(repoSpy, times(1)).deleteLinkInputs(2, repoTransactionMock);
     repoOrder.verify(repoSpy, times(1)).updateConnector(any(MConnector.class), any(RepositoryTransaction.class));
-    repoOrder.verify(repoSpy, times(2)).updateConnection(any(MConnection.class), any(RepositoryTransaction.class));
+    repoOrder.verify(repoSpy, times(2)).updateLink(any(MLink.class), any(RepositoryTransaction.class));
     repoOrder.verify(repoSpy, times(4)).updateJob(any(MJob.class), any(RepositoryTransaction.class));
     repoOrder.verifyNoMoreInteractions();
     txOrder.verify(repoTransactionMock, times(1)).begin();
@@ -242,7 +255,7 @@ public class TestJdbcRepository {
     upgraderOrder.verify(upgraderMock, times(2)).upgrade(any(MConnectionForms.class), any(MConnectionForms.class));
     upgraderOrder.verify(upgraderMock, times(4)).upgrade(any(MJobForms.class), any(MJobForms.class));
     upgraderOrder.verifyNoMoreInteractions();
-    validatorOrder.verify(validatorMock, times(2)).validateConnection(anyObject());
+    validatorOrder.verify(validatorMock, times(2)).validateLink(anyObject());
     // @TODO(Abe): Re-enable job validation?
     validatorOrder.verify(validatorMock, times(0)).validateJob(anyObject());
     validatorOrder.verifyNoMoreInteractions();
@@ -250,31 +263,31 @@ public class TestJdbcRepository {
 
   /**
    * @TODO(Abe): To re-enable with Validation in Repository upgrade.
-   * Test the connector upgrade procedure, when all the connections and
+   * Test the connector upgrade procedure, when all the links and
    * jobs using the old connector are invalid for the new connector
    */
 //  @Test
-//  public void testConnectorUpgradeWithInvalidConnectionsAndJobs() {
+//  public void testConnectorUpgradeWithInvalidLinksAndJobs() {
 //    MConnector newConnector = connector(1, "1.1");
 //    MConnector oldConnector = connector(1);
 //
 //    // prepare the sqoop connector
 //    SqoopConnector sqconnector = mock(SqoopConnector.class);
-//    when(validator.validateConnection(any(MConnection.class))).thenReturn(invalid);
+//    when(validator.validateLink(any(MLink.class))).thenReturn(invalid);
 //    when(validator.validateJob(any(MJob.class))).thenReturn(invalid);
 //    when(sqconnector.getValidator()).thenReturn(validator);
-//    when(sqconnector.getMetadataUpgrader()).thenReturn(upgrader);
-//    when(sqconnector.getConnectionConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
+//    when(sqconnector.getDriverConfigRepositoryUpgrader()).thenReturn(upgrader);
+//    when(sqconnector.getLinkConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
 //    when(sqconnector.getJobConfigurationClass(any(Direction.class))).thenReturn(JobConfiguration.class);
 //    when(connectorMgr.getConnector(anyString())).thenReturn(sqconnector);
 //
-//    // prepare the connections and jobs
-//    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+//    // prepare the links and jobs
+//    List<MLink> linkList = links(link(1,1), link(2,1));
 //    List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
 //
-//    doReturn(connectionList).when(repo).findConnectionsForConnector(anyLong());
+//    doReturn(linkList).when(repo).findLinksForConnector(anyLong());
 //    doReturn(jobList).when(repo).findJobsForConnector(anyLong());
-//    doNothing().when(repo).updateConnection(any(MConnection.class), any(RepositoryTransaction.class));
+//    doNothing().when(repo).updateLink(any(MLink.class), any(RepositoryTransaction.class));
 //    doNothing().when(repo).updateJob(any(MJob.class), any(RepositoryTransaction.class));
 //    doNothing().when(repo).updateConnector(any(MConnector.class), any(RepositoryTransaction.class));
 //
@@ -288,13 +301,13 @@ public class TestJdbcRepository {
 //      InOrder upgraderOrder = inOrder(upgrader);
 //      InOrder validatorOrder = inOrder(validator);
 //
-//      repoOrder.verify(repo, times(1)).findConnectionsForConnector(anyLong());
+//      repoOrder.verify(repo, times(1)).findLinksForConnector(anyLong());
 //      repoOrder.verify(repo, times(1)).findJobsForConnector(anyLong());
 //      repoOrder.verify(repo, times(1)).getTransaction();
 //      repoOrder.verify(repo, times(1)).deleteJobInputs(1, tx);
 //      repoOrder.verify(repo, times(1)).deleteJobInputs(2, tx);
-//      repoOrder.verify(repo, times(1)).deleteConnectionInputs(1, tx);
-//      repoOrder.verify(repo, times(1)).deleteConnectionInputs(2, tx);
+//      repoOrder.verify(repo, times(1)).deleteLinkInputs(1, tx);
+//      repoOrder.verify(repo, times(1)).deleteLinkInputs(2, tx);
 //      repoOrder.verify(repo, times(1)).updateConnector(any(MConnector.class), any(RepositoryTransaction.class));
 //      repoOrder.verifyNoMoreInteractions();
 //      txOrder.verify(tx, times(1)).begin();
@@ -304,7 +317,7 @@ public class TestJdbcRepository {
 //      upgraderOrder.verify(upgrader, times(2)).upgrade(any(MConnectionForms.class), any(MConnectionForms.class));
 //      upgraderOrder.verify(upgrader, times(2)).upgrade(any(MJobForms.class), any(MJobForms.class));
 //      upgraderOrder.verifyNoMoreInteractions();
-//      validatorOrder.verify(validator, times(2)).validateConnection(anyObject());
+//      validatorOrder.verify(validator, times(2)).validateLink(anyObject());
 //      validatorOrder.verify(validator, times(2)).validateJob(anyObject());
 //      validatorOrder.verifyNoMoreInteractions();
 //      return ;
@@ -314,45 +327,45 @@ public class TestJdbcRepository {
 //  }
 
   /**
-   * Test the framework upgrade procedure, when all the connections and
+   * Test the driverConfig upgrade procedure, when all the links and
    * jobs using the old connector are still valid for the new connector
    */
   @Test
-  public void testFrameworkUpgradeWithValidConnectionsAndJobs() {
-    MFramework newFramework = framework();
+  public void testDriverConfigUpgradeWithValidLinksAndJobs() {
+    MDriverConfig newDriverConfig = driverConfig();
 
-    when(validatorMock.validateConnection(any(MConnection.class))).thenReturn(validRepoMock);
+    when(validatorMock.validateLink(any(MLink.class))).thenReturn(validRepoMock);
     when(validatorMock.validateJob(any(MJob.class))).thenReturn(validRepoMock);
-    when(frameworkMgrMock.getValidator()).thenReturn(validatorMock);
-    when(frameworkMgrMock.getMetadataUpgrader()).thenReturn(upgraderMock);
-    when(frameworkMgrMock.getConnectionConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
-    when(frameworkMgrMock.getJobConfigurationClass()).thenReturn(JobConfiguration.class);
+    when(driverMock.getValidator()).thenReturn(validatorMock);
+    when(driverMock.getDriverConfigRepositoryUpgrader()).thenReturn(upgraderMock);
+    when(driverMock.getLinkConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
+    when(driverMock.getJobConfigurationClass()).thenReturn(JobConfiguration.class);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
 
-    doReturn(connectionList).when(repoSpy).findConnections();
+    doReturn(linkList).when(repoSpy).findLinks();
     doReturn(jobList).when(repoSpy).findJobs();
-    doNothing().when(repoSpy).updateConnection(any(MConnection.class), any(RepositoryTransaction.class));
+    doNothing().when(repoSpy).updateLink(any(MLink.class), any(RepositoryTransaction.class));
     doNothing().when(repoSpy).updateJob(any(MJob.class), any(RepositoryTransaction.class));
-    doNothing().when(repoSpy).updateFramework(any(MFramework.class), any(RepositoryTransaction.class));
+    doNothing().when(repoSpy).updateDriverConfig(any(MDriverConfig.class), any(RepositoryTransaction.class));
 
-    repoSpy.upgradeFramework(newFramework);
+    repoSpy.upgradeDriverConfig(newDriverConfig);
 
     InOrder repoOrder = inOrder(repoSpy);
     InOrder txOrder = inOrder(repoTransactionMock);
     InOrder upgraderOrder = inOrder(upgraderMock);
     InOrder validatorOrder = inOrder(validatorMock);
 
-    repoOrder.verify(repoSpy, times(1)).findConnections();
+    repoOrder.verify(repoSpy, times(1)).findLinks();
     repoOrder.verify(repoSpy, times(1)).findJobs();
     repoOrder.verify(repoSpy, times(1)).getTransaction();
     repoOrder.verify(repoSpy, times(1)).deleteJobInputs(1, repoTransactionMock);
     repoOrder.verify(repoSpy, times(1)).deleteJobInputs(2, repoTransactionMock);
-    repoOrder.verify(repoSpy, times(1)).deleteConnectionInputs(1, repoTransactionMock);
-    repoOrder.verify(repoSpy, times(1)).deleteConnectionInputs(2, repoTransactionMock);
-    repoOrder.verify(repoSpy, times(1)).updateFramework(any(MFramework.class), any(RepositoryTransaction.class));
-    repoOrder.verify(repoSpy, times(2)).updateConnection(any(MConnection.class), any(RepositoryTransaction.class));
+    repoOrder.verify(repoSpy, times(1)).deleteLinkInputs(1, repoTransactionMock);
+    repoOrder.verify(repoSpy, times(1)).deleteLinkInputs(2, repoTransactionMock);
+    repoOrder.verify(repoSpy, times(1)).updateDriverConfig(any(MDriverConfig.class), any(RepositoryTransaction.class));
+    repoOrder.verify(repoSpy, times(2)).updateLink(any(MLink.class), any(RepositoryTransaction.class));
     repoOrder.verify(repoSpy, times(2)).updateJob(any(MJob.class), any(RepositoryTransaction.class));
     repoOrder.verifyNoMoreInteractions();
     txOrder.verify(repoTransactionMock, times(1)).begin();
@@ -362,37 +375,37 @@ public class TestJdbcRepository {
     upgraderOrder.verify(upgraderMock, times(2)).upgrade(any(MConnectionForms.class), any(MConnectionForms.class));
     upgraderOrder.verify(upgraderMock, times(2)).upgrade(any(MJobForms.class), any(MJobForms.class));
     upgraderOrder.verifyNoMoreInteractions();
-    validatorOrder.verify(validatorMock, times(2)).validateConnection(anyObject());
+    validatorOrder.verify(validatorMock, times(2)).validateLink(anyObject());
     validatorOrder.verify(validatorMock, times(2)).validateJob(anyObject());
     validatorOrder.verifyNoMoreInteractions();
   }
 
   /**
-   * Test the framework upgrade procedure, when all the connections and
+   * Test the driverConfig upgrade procedure, when all the links and
    * jobs using the old connector are invalid for the new connector
    */
   @Test
-  public void testFrameworkUpgradeWithInvalidConnectionsAndJobs() {
-    MFramework newFramework = framework();
+  public void testDriverConfigUpgradeWithInvalidLinksAndJobs() {
+    MDriverConfig newDriverConfig = driverConfig();
 
-    when(validatorMock.validateConnection(any(MConnection.class))).thenReturn(invalidRepoMock);
+    when(validatorMock.validateLink(any(MLink.class))).thenReturn(invalidRepoMock);
     when(validatorMock.validateJob(any(MJob.class))).thenReturn(invalidRepoMock);
-    when(frameworkMgrMock.getValidator()).thenReturn(validatorMock);
-    when(frameworkMgrMock.getMetadataUpgrader()).thenReturn(upgraderMock);
-    when(frameworkMgrMock.getConnectionConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
-    when(frameworkMgrMock.getJobConfigurationClass()).thenReturn(JobConfiguration.class);
+    when(driverMock.getValidator()).thenReturn(validatorMock);
+    when(driverMock.getDriverConfigRepositoryUpgrader()).thenReturn(upgraderMock);
+    when(driverMock.getLinkConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
+    when(driverMock.getJobConfigurationClass()).thenReturn(JobConfiguration.class);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
 
-    doReturn(connectionList).when(repoSpy).findConnections();
+    doReturn(linkList).when(repoSpy).findLinks();
     doReturn(jobList).when(repoSpy).findJobs();
-    doNothing().when(repoSpy).updateConnection(any(MConnection.class), any(RepositoryTransaction.class));
+    doNothing().when(repoSpy).updateLink(any(MLink.class), any(RepositoryTransaction.class));
     doNothing().when(repoSpy).updateJob(any(MJob.class), any(RepositoryTransaction.class));
-    doNothing().when(repoSpy).updateFramework(any(MFramework.class), any(RepositoryTransaction.class));
+    doNothing().when(repoSpy).updateDriverConfig(any(MDriverConfig.class), any(RepositoryTransaction.class));
 
     try {
-      repoSpy.upgradeFramework(newFramework);
+      repoSpy.upgradeDriverConfig(newDriverConfig);
     } catch (SqoopException ex) {
       assertEquals(ex.getErrorCode(), RepositoryError.JDBCREPO_0027);
 
@@ -401,14 +414,14 @@ public class TestJdbcRepository {
       InOrder upgraderOrder = inOrder(upgraderMock);
       InOrder validatorOrder = inOrder(validatorMock);
 
-      repoOrder.verify(repoSpy, times(1)).findConnections();
+      repoOrder.verify(repoSpy, times(1)).findLinks();
       repoOrder.verify(repoSpy, times(1)).findJobs();
       repoOrder.verify(repoSpy, times(1)).getTransaction();
       repoOrder.verify(repoSpy, times(1)).deleteJobInputs(1, repoTransactionMock);
       repoOrder.verify(repoSpy, times(1)).deleteJobInputs(2, repoTransactionMock);
-      repoOrder.verify(repoSpy, times(1)).deleteConnectionInputs(1, repoTransactionMock);
-      repoOrder.verify(repoSpy, times(1)).deleteConnectionInputs(2, repoTransactionMock);
-      repoOrder.verify(repoSpy, times(1)).updateFramework(any(MFramework.class), any(RepositoryTransaction.class));
+      repoOrder.verify(repoSpy, times(1)).deleteLinkInputs(1, repoTransactionMock);
+      repoOrder.verify(repoSpy, times(1)).deleteLinkInputs(2, repoTransactionMock);
+      repoOrder.verify(repoSpy, times(1)).updateDriverConfig(any(MDriverConfig.class), any(RepositoryTransaction.class));
       repoOrder.verifyNoMoreInteractions();
       txOrder.verify(repoTransactionMock, times(1)).begin();
       txOrder.verify(repoTransactionMock, times(1)).rollback();
@@ -417,7 +430,7 @@ public class TestJdbcRepository {
       upgraderOrder.verify(upgraderMock, times(2)).upgrade(any(MConnectionForms.class), any(MConnectionForms.class));
       upgraderOrder.verify(upgraderMock, times(2)).upgrade(any(MJobForms.class), any(MJobForms.class));
       upgraderOrder.verifyNoMoreInteractions();
-      validatorOrder.verify(validatorMock, times(2)).validateConnection(anyObject());
+      validatorOrder.verify(validatorMock, times(2)).validateLink(anyObject());
       validatorOrder.verify(validatorMock, times(2)).validateJob(anyObject());
       validatorOrder.verifyNoMoreInteractions();
       return ;
@@ -428,27 +441,27 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * find connections for a given connector
+   * find links for a given connector
    */
   @Test
-  public void testConnectorUpgradeHandlerFindConnectionsForConnectorError() {
+  public void testConnectorUpgradeHandlerFindLinksForConnectorError() {
     MConnector newConnector = connector(1, "1.1");
     MConnector oldConnector = connector(1);
 
     SqoopConnector sqconnector = mock(SqoopConnector.class);
     when(sqconnector.getValidator()).thenReturn(validatorMock);
-    when(sqconnector.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(sqconnector.getRepositoryUpgrader()).thenReturn(upgraderMock);
     when(connectorMgrMock.getConnector(anyString())).thenReturn(sqconnector);
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
-        "find connections for connector error.");
-    doThrow(exception).when(repoHandlerMock).findConnectionsForConnector(anyLong(), any(Connection.class));
+        "find links for connector error.");
+    doThrow(exception).when(repoHandlerMock).findLinksForConnector(anyLong(), any(Connection.class));
 
     try {
       repoSpy.upgradeConnector(oldConnector, newConnector);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnectionsForConnector(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinksForConnector(anyLong(), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
     }
@@ -467,11 +480,11 @@ public class TestJdbcRepository {
 
     SqoopConnector sqconnector = mock(SqoopConnector.class);
     when(sqconnector.getValidator()).thenReturn(validatorMock);
-    when(sqconnector.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(sqconnector.getRepositoryUpgrader()).thenReturn(upgraderMock);
     when(connectorMgrMock.getConnector(anyString())).thenReturn(sqconnector);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnectionsForConnector(anyLong(), any(Connection.class));
+    List<MLink> linkList = links(link(1,1), link(2,1));
+    doReturn(linkList).when(repoHandlerMock).findLinksForConnector(anyLong(), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
         "find jobs for connector error.");
@@ -481,7 +494,7 @@ public class TestJdbcRepository {
       repoSpy.upgradeConnector(oldConnector, newConnector);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnectionsForConnector(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinksForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobsForConnector(anyLong(), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
@@ -501,12 +514,12 @@ public class TestJdbcRepository {
 
     SqoopConnector sqconnector = mock(SqoopConnector.class);
     when(sqconnector.getValidator()).thenReturn(validatorMock);
-    when(sqconnector.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(sqconnector.getRepositoryUpgrader()).thenReturn(upgraderMock);
     when(connectorMgrMock.getConnector(anyString())).thenReturn(sqconnector);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnectionsForConnector(anyLong(), any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinksForConnector(anyLong(), any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobsForConnector(anyLong(), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
@@ -517,7 +530,7 @@ public class TestJdbcRepository {
       repoSpy.upgradeConnector(oldConnector, newConnector);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnectionsForConnector(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinksForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobsForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).deleteJobInputs(anyLong(), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
@@ -529,36 +542,36 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * delete connection inputs for a given connector
+   * delete link inputs for a given connector
    */
   @Test
-  public void testConnectorUpgradeHandlerDeleteConnectionInputsError() {
+  public void testConnectorUpgradeHandlerDeleteLinkInputsError() {
     MConnector newConnector = connector(1, "1.1");
     MConnector oldConnector = connector(1);
 
     SqoopConnector sqconnector = mock(SqoopConnector.class);
     when(sqconnector.getValidator()).thenReturn(validatorMock);
-    when(sqconnector.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(sqconnector.getRepositoryUpgrader()).thenReturn(upgraderMock);
     when(connectorMgrMock.getConnector(anyString())).thenReturn(sqconnector);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnectionsForConnector(anyLong(), any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinksForConnector(anyLong(), any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobsForConnector(anyLong(), any(Connection.class));
     doNothing().when(repoHandlerMock).deleteJobInputs(anyLong(), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
-        "delete connection inputs for connector error.");
-    doThrow(exception).when(repoHandlerMock).deleteConnectionInputs(anyLong(), any(Connection.class));
+        "delete link inputs for connector error.");
+    doThrow(exception).when(repoHandlerMock).deleteLinkInputs(anyLong(), any(Connection.class));
 
     try {
       repoSpy.upgradeConnector(oldConnector, newConnector);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnectionsForConnector(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinksForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobsForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(2)).deleteJobInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(1)).deleteConnectionInputs(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).deleteLinkInputs(anyLong(), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
     }
@@ -568,7 +581,7 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * update the connector metadata
+   * update the connector entity
    */
   @Test
   public void testConnectorUpgradeHandlerUpdateConnectorError() {
@@ -577,15 +590,15 @@ public class TestJdbcRepository {
 
     SqoopConnector sqconnector = mock(SqoopConnector.class);
     when(sqconnector.getValidator()).thenReturn(validatorMock);
-    when(sqconnector.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(sqconnector.getRepositoryUpgrader()).thenReturn(upgraderMock);
     when(connectorMgrMock.getConnector(anyString())).thenReturn(sqconnector);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnectionsForConnector(anyLong(), any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinksForConnector(anyLong(), any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobsForConnector(anyLong(), any(Connection.class));
     doNothing().when(repoHandlerMock).deleteJobInputs(anyLong(), any(Connection.class));
-    doNothing().when(repoHandlerMock).deleteConnectionInputs(anyLong(), any(Connection.class));
+    doNothing().when(repoHandlerMock).deleteLinkInputs(anyLong(), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
         "update connector error.");
@@ -595,10 +608,10 @@ public class TestJdbcRepository {
       repoSpy.upgradeConnector(oldConnector, newConnector);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnectionsForConnector(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinksForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobsForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(2)).deleteJobInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(2)).deleteConnectionInputs(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(2)).deleteLinkInputs(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).updateConnector(any(MConnector.class), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
@@ -609,46 +622,46 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * update the connection metadata
+   * update the link entity
    */
   @Test
-  public void testConnectorUpgradeHandlerUpdateConnectionError() {
+  public void testConnectorUpgradeHandlerUpdateLinkError() {
     MConnector newConnector = connector(1, "1.1");
     MConnector oldConnector = connector(1);
 
     SqoopConnector sqconnector = mock(SqoopConnector.class);
-    when(validatorMock.validateConnection(any(MConnection.class))).thenReturn(validRepoMock);
+    when(validatorMock.validateLink(any(MLink.class))).thenReturn(validRepoMock);
     when(validatorMock.validateJob(any(MJob.class))).thenReturn(validRepoMock);
     when(sqconnector.getValidator()).thenReturn(validatorMock);
-    when(sqconnector.getMetadataUpgrader()).thenReturn(upgraderMock);
-    when(sqconnector.getConnectionConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
+    when(sqconnector.getRepositoryUpgrader()).thenReturn(upgraderMock);
+    when(sqconnector.getLinkConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
     when(sqconnector.getJobConfigurationClass(any(Direction.class))).thenReturn(JobConfiguration.class);
     when(connectorMgrMock.getConnector(anyString())).thenReturn(sqconnector);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnectionsForConnector(anyLong(), any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinksForConnector(anyLong(), any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobsForConnector(anyLong(), any(Connection.class));
     doNothing().when(repoHandlerMock).deleteJobInputs(anyLong(), any(Connection.class));
-    doNothing().when(repoHandlerMock).deleteConnectionInputs(anyLong(), any(Connection.class));
+    doNothing().when(repoHandlerMock).deleteLinkInputs(anyLong(), any(Connection.class));
     doNothing().when(repoHandlerMock).updateConnector(any(MConnector.class), any(Connection.class));
-    doReturn(true).when(repoHandlerMock).existsConnection(anyLong(), any(Connection.class));
+    doReturn(true).when(repoHandlerMock).existsLink(anyLong(), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
-        "update connection error.");
-    doThrow(exception).when(repoHandlerMock).updateConnection(any(MConnection.class), any(Connection.class));
+        "update link error.");
+    doThrow(exception).when(repoHandlerMock).updateLink(any(MLink.class), any(Connection.class));
 
     try {
       repoSpy.upgradeConnector(oldConnector, newConnector);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnectionsForConnector(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinksForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobsForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(2)).deleteJobInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(2)).deleteConnectionInputs(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(2)).deleteLinkInputs(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).updateConnector(any(MConnector.class), any(Connection.class));
-      verify(repoHandlerMock, times(1)).existsConnection(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(1)).updateConnection(any(MConnection.class), any(Connection.class));
+      verify(repoHandlerMock, times(1)).existsLink(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).updateLink(any(MLink.class), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
     }
@@ -658,7 +671,7 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * update the job metadata
+   * update the job entity
    */
   @Test
   public void testConnectorUpgradeHandlerUpdateJobError() {
@@ -666,23 +679,23 @@ public class TestJdbcRepository {
     MConnector oldConnector = connector(1);
 
     SqoopConnector sqconnector = mock(SqoopConnector.class);
-    when(validatorMock.validateConnection(any(MConnection.class))).thenReturn(validRepoMock);
+    when(validatorMock.validateLink(any(MLink.class))).thenReturn(validRepoMock);
     when(validatorMock.validateJob(any(MJob.class))).thenReturn(validRepoMock);
     when(sqconnector.getValidator()).thenReturn(validatorMock);
-    when(sqconnector.getMetadataUpgrader()).thenReturn(upgraderMock);
-    when(sqconnector.getConnectionConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
+    when(sqconnector.getRepositoryUpgrader()).thenReturn(upgraderMock);
+    when(sqconnector.getLinkConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
     when(sqconnector.getJobConfigurationClass(any(Direction.class))).thenReturn(JobConfiguration.class);
     when(connectorMgrMock.getConnector(anyString())).thenReturn(sqconnector);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnectionsForConnector(anyLong(), any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinksForConnector(anyLong(), any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobsForConnector(anyLong(), any(Connection.class));
     doNothing().when(repoHandlerMock).deleteJobInputs(anyLong(), any(Connection.class));
-    doNothing().when(repoHandlerMock).deleteConnectionInputs(anyLong(), any(Connection.class));
+    doNothing().when(repoHandlerMock).deleteLinkInputs(anyLong(), any(Connection.class));
     doNothing().when(repoHandlerMock).updateConnector(any(MConnector.class), any(Connection.class));
-    doNothing().when(repoHandlerMock).updateConnection(any(MConnection.class), any(Connection.class));
-    doReturn(true).when(repoHandlerMock).existsConnection(anyLong(), any(Connection.class));
+    doNothing().when(repoHandlerMock).updateLink(any(MLink.class), any(Connection.class));
+    doReturn(true).when(repoHandlerMock).existsLink(anyLong(), any(Connection.class));
     doReturn(true).when(repoHandlerMock).existsJob(anyLong(), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
@@ -693,13 +706,13 @@ public class TestJdbcRepository {
       repoSpy.upgradeConnector(oldConnector, newConnector);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnectionsForConnector(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinksForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobsForConnector(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(2)).deleteJobInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(2)).deleteConnectionInputs(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(2)).deleteLinkInputs(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).updateConnector(any(MConnector.class), any(Connection.class));
-      verify(repoHandlerMock, times(2)).existsConnection(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(2)).updateConnection(any(MConnection.class), any(Connection.class));
+      verify(repoHandlerMock, times(2)).existsLink(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(2)).updateLink(any(MLink.class), any(Connection.class));
       verify(repoHandlerMock, times(1)).existsJob(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).updateJob(any(MJob.class), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
@@ -711,24 +724,24 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * find connections for framework
+   * find links for driverConfig
    */
   @Test
-  public void testFrameworkUpgradeHandlerFindConnectionsError() {
-    MFramework newFramework = framework();
+  public void testDriverConfigUpgradeHandlerFindLinksError() {
+    MDriverConfig newDriverConfig = driverConfig();
 
-    when(frameworkMgrMock.getValidator()).thenReturn(validatorMock);
-    when(frameworkMgrMock.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(driverMock.getValidator()).thenReturn(validatorMock);
+    when(driverMock.getDriverConfigRepositoryUpgrader()).thenReturn(upgraderMock);
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
-        "find connections error.");
-    doThrow(exception).when(repoHandlerMock).findConnections(any(Connection.class));
+        "find links error.");
+    doThrow(exception).when(repoHandlerMock).findLinks(any(Connection.class));
 
     try {
-      repoSpy.upgradeFramework(newFramework);
+      repoSpy.upgradeDriverConfig(newDriverConfig);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnections(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinks(any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
     }
@@ -738,27 +751,27 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * find jobs for framework
+   * find jobs for driverConfig
    */
   @Test
-  public void testFrameworkUpgradeHandlerFindJobsError() {
-    MFramework newFramework = framework();
+  public void testDriverConfigUpgradeHandlerFindJobsError() {
+    MDriverConfig newDriverConfig = driverConfig();
 
-    when(frameworkMgrMock.getValidator()).thenReturn(validatorMock);
-    when(frameworkMgrMock.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(driverMock.getValidator()).thenReturn(validatorMock);
+    when(driverMock.getDriverConfigRepositoryUpgrader()).thenReturn(upgraderMock);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnections(any(Connection.class));
+    List<MLink> linkList = links(link(1,1), link(2,1));
+    doReturn(linkList).when(repoHandlerMock).findLinks(any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
         "find jobs error.");
     doThrow(exception).when(repoHandlerMock).findJobs(any(Connection.class));
 
     try {
-      repoSpy.upgradeFramework(newFramework);
+      repoSpy.upgradeDriverConfig(newDriverConfig);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnections(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinks(any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobs(any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
@@ -769,18 +782,18 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * delete job inputs for framework upgrade
+   * delete job inputs for driverConfig upgrade
    */
   @Test
-  public void testFrameworkUpgradeHandlerDeleteJobInputsError() {
-    MFramework newFramework = framework();
+  public void testDriverConfigUpgradeHandlerDeleteJobInputsError() {
+    MDriverConfig newDriverConfig = driverConfig();
 
-    when(frameworkMgrMock.getValidator()).thenReturn(validatorMock);
-    when(frameworkMgrMock.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(driverMock.getValidator()).thenReturn(validatorMock);
+    when(driverMock.getDriverConfigRepositoryUpgrader()).thenReturn(upgraderMock);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnections(any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinks(any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobs(any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
@@ -788,10 +801,10 @@ public class TestJdbcRepository {
     doThrow(exception).when(repoHandlerMock).deleteJobInputs(anyLong(), any(Connection.class));
 
     try {
-      repoSpy.upgradeFramework(newFramework);
+      repoSpy.upgradeDriverConfig(newDriverConfig);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnections(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinks(any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobs(any(Connection.class));
       verify(repoHandlerMock, times(1)).deleteJobInputs(anyLong(), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
@@ -803,33 +816,33 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * delete connection inputs for framework upgrade
+   * delete link inputs for driverConfig upgrade
    */
   @Test
-  public void testFrameworkUpgradeHandlerDeleteConnectionInputsError() {
-    MFramework newFramework = framework();
+  public void testDriverConfigUpgradeHandlerDeleteConnectionInputsError() {
+    MDriverConfig newDriverConfig = driverConfig();
 
-    when(frameworkMgrMock.getValidator()).thenReturn(validatorMock);
-    when(frameworkMgrMock.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(driverMock.getValidator()).thenReturn(validatorMock);
+    when(driverMock.getDriverConfigRepositoryUpgrader()).thenReturn(upgraderMock);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnections(any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinks(any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobs(any(Connection.class));
     doNothing().when(repoHandlerMock).deleteJobInputs(anyLong(), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
-        "delete connection inputs error.");
-    doThrow(exception).when(repoHandlerMock).deleteConnectionInputs(anyLong(), any(Connection.class));
+        "delete link inputs error.");
+    doThrow(exception).when(repoHandlerMock).deleteLinkInputs(anyLong(), any(Connection.class));
 
     try {
-      repoSpy.upgradeFramework(newFramework);
+      repoSpy.upgradeDriverConfig(newDriverConfig);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnections(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinks(any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobs(any(Connection.class));
       verify(repoHandlerMock, times(2)).deleteJobInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(1)).deleteConnectionInputs(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).deleteLinkInputs(anyLong(), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
     }
@@ -839,35 +852,35 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * update the framework metadata
+   * update the driverConfig entity
    */
   @Test
-  public void testFrameworkUpgradeHandlerUpdateFrameworkError() {
-    MFramework newFramework = framework();
+  public void testDriverConfigUpgradeHandlerUpdateDriverConfigError() {
+    MDriverConfig newDriverConfig = driverConfig();
 
-    when(frameworkMgrMock.getValidator()).thenReturn(validatorMock);
-    when(frameworkMgrMock.getMetadataUpgrader()).thenReturn(upgraderMock);
+    when(driverMock.getValidator()).thenReturn(validatorMock);
+    when(driverMock.getDriverConfigRepositoryUpgrader()).thenReturn(upgraderMock);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnections(any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinks(any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobs(any(Connection.class));
     doNothing().when(repoHandlerMock).deleteJobInputs(anyLong(), any(Connection.class));
-    doNothing().when(repoHandlerMock).deleteConnectionInputs(anyLong(), any(Connection.class));
+    doNothing().when(repoHandlerMock).deleteLinkInputs(anyLong(), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
-        "update framework metadata error.");
-    doThrow(exception).when(repoHandlerMock).updateFramework(any(MFramework.class), any(Connection.class));
+        "update driverConfig entity error.");
+    doThrow(exception).when(repoHandlerMock).updateDriverConfig(any(MDriverConfig.class), any(Connection.class));
 
     try {
-      repoSpy.upgradeFramework(newFramework);
+      repoSpy.upgradeDriverConfig(newDriverConfig);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnections(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinks(any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobs(any(Connection.class));
       verify(repoHandlerMock, times(2)).deleteJobInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(2)).deleteConnectionInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(1)).updateFramework(any(MFramework.class), any(Connection.class));
+      verify(repoHandlerMock, times(2)).deleteLinkInputs(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).updateDriverConfig(any(MDriverConfig.class), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
     }
@@ -877,43 +890,43 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * update the connection metadata
+   * update the link entity
    */
   @Test
-  public void testFrameworkUpgradeHandlerUpdateConnectionError() {
-    MFramework newFramework = framework();
+  public void testDriverConfigUpgradeHandlerUpdateConnectionError() {
+    MDriverConfig newDriverConfig = driverConfig();
 
-    when(validatorMock.validateConnection(any(MConnection.class))).thenReturn(validRepoMock);
+    when(validatorMock.validateLink(any(MLink.class))).thenReturn(validRepoMock);
     when(validatorMock.validateJob(any(MJob.class))).thenReturn(validRepoMock);
-    when(frameworkMgrMock.getValidator()).thenReturn(validatorMock);
-    when(frameworkMgrMock.getMetadataUpgrader()).thenReturn(upgraderMock);
-    when(frameworkMgrMock.getConnectionConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
-    when(frameworkMgrMock.getJobConfigurationClass()).thenReturn(JobConfiguration.class);
+    when(driverMock.getValidator()).thenReturn(validatorMock);
+    when(driverMock.getDriverConfigRepositoryUpgrader()).thenReturn(upgraderMock);
+    when(driverMock.getLinkConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
+    when(driverMock.getJobConfigurationClass()).thenReturn(JobConfiguration.class);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnections(any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinks(any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobs(any(Connection.class));
     doNothing().when(repoHandlerMock).deleteJobInputs(anyLong(), any(Connection.class));
-    doNothing().when(repoHandlerMock).deleteConnectionInputs(anyLong(), any(Connection.class));
-    doNothing().when(repoHandlerMock).updateFramework(any(MFramework.class), any(Connection.class));
-    doReturn(true).when(repoHandlerMock).existsConnection(anyLong(), any(Connection.class));
+    doNothing().when(repoHandlerMock).deleteLinkInputs(anyLong(), any(Connection.class));
+    doNothing().when(repoHandlerMock).updateDriverConfig(any(MDriverConfig.class), any(Connection.class));
+    doReturn(true).when(repoHandlerMock).existsLink(anyLong(), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
-        "update connection error.");
-    doThrow(exception).when(repoHandlerMock).updateConnection(any(MConnection.class), any(Connection.class));
+        "update link error.");
+    doThrow(exception).when(repoHandlerMock).updateLink(any(MLink.class), any(Connection.class));
 
     try {
-      repoSpy.upgradeFramework(newFramework);
+      repoSpy.upgradeDriverConfig(newDriverConfig);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnections(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinks(any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobs(any(Connection.class));
       verify(repoHandlerMock, times(2)).deleteJobInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(2)).deleteConnectionInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(1)).updateFramework(any(MFramework.class), any(Connection.class));
-      verify(repoHandlerMock, times(1)).existsConnection(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(1)).updateConnection(any(MConnection.class), any(Connection.class));
+      verify(repoHandlerMock, times(2)).deleteLinkInputs(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).updateDriverConfig(any(MDriverConfig.class), any(Connection.class));
+      verify(repoHandlerMock, times(1)).existsLink(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).updateLink(any(MLink.class), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
       return ;
     }
@@ -923,45 +936,45 @@ public class TestJdbcRepository {
 
   /**
    * Test the exception handling procedure when the database handler fails to
-   * update the job metadata
+   * update the job entity
    */
   @Test
-  public void testFrameworkUpgradeHandlerUpdateJobError() {
-    MFramework newFramework = framework();
+  public void testDriverConfigUpgradeHandlerUpdateJobError() {
+    MDriverConfig driverConfig = driverConfig();
 
-    when(validatorMock.validateConnection(any(MConnection.class))).thenReturn(validRepoMock);
+    when(validatorMock.validateLink(any(MLink.class))).thenReturn(validRepoMock);
     when(validatorMock.validateJob(any(MJob.class))).thenReturn(validRepoMock);
-    when(frameworkMgrMock.getValidator()).thenReturn(validatorMock);
-    when(frameworkMgrMock.getMetadataUpgrader()).thenReturn(upgraderMock);
-    when(frameworkMgrMock.getConnectionConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
-    when(frameworkMgrMock.getJobConfigurationClass()).thenReturn(JobConfiguration.class);
+    when(driverMock.getValidator()).thenReturn(validatorMock);
+    when(driverMock.getDriverConfigRepositoryUpgrader()).thenReturn(upgraderMock);
+    when(driverMock.getLinkConfigurationClass()).thenReturn(EmptyConfigurationClass.class);
+    when(driverMock.getJobConfigurationClass()).thenReturn(JobConfiguration.class);
 
-    List<MConnection> connectionList = connections(connection(1,1), connection(2,1));
+    List<MLink> linkList = links(link(1,1), link(2,1));
     List<MJob> jobList = jobs(job(1,1,1,1,1), job(2,1,1,2,1));
-    doReturn(connectionList).when(repoHandlerMock).findConnections(any(Connection.class));
+    doReturn(linkList).when(repoHandlerMock).findLinks(any(Connection.class));
     doReturn(jobList).when(repoHandlerMock).findJobs(any(Connection.class));
     doNothing().when(repoHandlerMock).deleteJobInputs(anyLong(), any(Connection.class));
-    doNothing().when(repoHandlerMock).deleteConnectionInputs(anyLong(), any(Connection.class));
-    doNothing().when(repoHandlerMock).updateFramework(any(MFramework.class), any(Connection.class));
-    doReturn(true).when(repoHandlerMock).existsConnection(anyLong(), any(Connection.class));
+    doNothing().when(repoHandlerMock).deleteLinkInputs(anyLong(), any(Connection.class));
+    doNothing().when(repoHandlerMock).updateDriverConfig(any(MDriverConfig.class), any(Connection.class));
+    doReturn(true).when(repoHandlerMock).existsLink(anyLong(), any(Connection.class));
     doReturn(true).when(repoHandlerMock).existsJob(anyLong(), any(Connection.class));
-    doNothing().when(repoHandlerMock).updateConnection(any(MConnection.class), any(Connection.class));
+    doNothing().when(repoHandlerMock).updateLink(any(MLink.class), any(Connection.class));
 
     SqoopException exception = new SqoopException(RepositoryError.JDBCREPO_0000,
         "update job error.");
     doThrow(exception).when(repoHandlerMock).updateJob(any(MJob.class), any(Connection.class));
 
     try {
-      repoSpy.upgradeFramework(newFramework);
+      repoSpy.upgradeDriverConfig(driverConfig);
     } catch (SqoopException ex) {
       assertEquals(ex.getMessage(), exception.getMessage());
-      verify(repoHandlerMock, times(1)).findConnections(any(Connection.class));
+      verify(repoHandlerMock, times(1)).findLinks(any(Connection.class));
       verify(repoHandlerMock, times(1)).findJobs(any(Connection.class));
       verify(repoHandlerMock, times(2)).deleteJobInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(2)).deleteConnectionInputs(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(1)).updateFramework(any(MFramework.class), any(Connection.class));
-      verify(repoHandlerMock, times(2)).existsConnection(anyLong(), any(Connection.class));
-      verify(repoHandlerMock, times(2)).updateConnection(any(MConnection.class), any(Connection.class));
+      verify(repoHandlerMock, times(2)).deleteLinkInputs(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(1)).updateDriverConfig(any(MDriverConfig.class), any(Connection.class));
+      verify(repoHandlerMock, times(2)).existsLink(anyLong(), any(Connection.class));
+      verify(repoHandlerMock, times(2)).updateLink(any(MLink.class), any(Connection.class));
       verify(repoHandlerMock, times(1)).existsJob(anyLong(), any(Connection.class));
       verify(repoHandlerMock, times(1)).updateJob(any(MJob.class), any(Connection.class));
       verifyNoMoreInteractions(repoHandlerMock);
@@ -971,44 +984,44 @@ public class TestJdbcRepository {
     fail("Should throw out an exception with message: " + exception.getMessage());
   }
 
-  private MConnector connector(long id, String version) {
-    MConnector connector = new MConnector("A" + id, "A" + id, version + id,
+  private MConnector connector(long connectorId, String version) {
+    MConnector connector = new MConnector("A" + connectorId, "A" + connectorId, version + connectorId,
         new MConnectionForms(new LinkedList<MForm>()),
         new MJobForms(FormUtils.toForms(JobConfiguration.class)),
         new MJobForms(FormUtils.toForms(JobConfiguration.class)));
-    connector.setPersistenceId(id);
+    connector.setPersistenceId(connectorId);
     return connector;
   }
 
-  private MConnector connector(long id) {
-    return connector(id, "1.0");
+  private MConnector connector(long connectoId) {
+    return connector(connectoId, "1.0");
   }
 
-  private MFramework framework() {
-    MFramework framework = new MFramework(
+  private MDriverConfig driverConfig() {
+    MDriverConfig driverConfig = new MDriverConfig(
         new MConnectionForms(new LinkedList<MForm>()),
         new MJobForms(FormUtils.toForms(JobConfiguration.class)),
-        FrameworkManager.CURRENT_FRAMEWORK_VERSION);
-    framework.setPersistenceId(1);
-    return framework;
+        Driver.CURRENT_DRIVER_VERSION);
+    driverConfig.setPersistenceId(1);
+    return driverConfig;
   }
 
-  private MFramework anotherFramework() {
-    MFramework framework = new MFramework(null, null,
-      FrameworkManager.CURRENT_FRAMEWORK_VERSION);
-    framework.setPersistenceId(1);
-    return framework;
+  private MDriverConfig anotherDriverConfig() {
+    MDriverConfig driverConfig = new MDriverConfig(null, null,
+      Driver.CURRENT_DRIVER_VERSION);
+    driverConfig.setPersistenceId(1);
+    return driverConfig;
   }
 
-  private MConnection connection(long id, long cid) {
-    MConnection connection = new MConnection(cid, new MConnectionForms(new LinkedList<MForm>()),
+  private MLink link(long linkId, long connectorId) {
+    MLink link = new MLink(connectorId, new MConnectionForms(new LinkedList<MForm>()),
         new MConnectionForms(new LinkedList<MForm>()));
-    connection.setPersistenceId(id);
-    return connection;
+    link.setPersistenceId(linkId);
+    return link;
   }
 
-  private MJob job(long id, long fromConnectorId, long toConnectorId, long fromConnectionId, long toConnectionId) {
-    MJob job = new MJob(fromConnectorId, toConnectorId, fromConnectionId, toConnectionId,
+  private MJob job(long id, long fromConnectorId, long toConnectorId, long fromLinkId, long toLinkId) {
+    MJob job = new MJob(fromConnectorId, toConnectorId, fromLinkId, toLinkId,
         new MJobForms(new LinkedList<MForm>()),
         new MJobForms(new LinkedList<MForm>()),
         new MJobForms(new LinkedList<MForm>()));
@@ -1016,10 +1029,10 @@ public class TestJdbcRepository {
     return job;
   }
 
-  private List<MConnection> connections(MConnection ... cs) {
-    List<MConnection> connections = new ArrayList<MConnection>();
-    Collections.addAll(connections, cs);
-    return connections;
+  private List<MLink> links(MLink ... ls) {
+    List<MLink> links = new ArrayList<MLink>();
+    Collections.addAll(links, ls);
+    return links;
   }
 
   private List<MJob> jobs(MJob ... js) {

http://git-wip-us.apache.org/repos/asf/sqoop/blob/049994a0/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MRJobRequest.java
----------------------------------------------------------------------
diff --git a/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MRJobRequest.java b/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MRJobRequest.java
index 2d53dd2..5248b7b 100644
--- a/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MRJobRequest.java
+++ b/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MRJobRequest.java
@@ -21,7 +21,7 @@ import org.apache.hadoop.io.Writable;
 import org.apache.hadoop.mapreduce.InputFormat;
 import org.apache.hadoop.mapreduce.Mapper;
 import org.apache.hadoop.mapreduce.OutputFormat;
-import org.apache.sqoop.framework.JobRequest;
+import org.apache.sqoop.driver.JobRequest;
 
 /**
  * Map-reduce specific submission request containing all extra information
@@ -99,4 +99,4 @@ public class MRJobRequest extends JobRequest {
   public void setOutputValueClass(Class<? extends Writable> outputValueClass) {
     this.outputValueClass = outputValueClass;
   }
-}
+}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/sqoop/blob/049994a0/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MapreduceExecutionEngine.java
----------------------------------------------------------------------
diff --git a/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MapreduceExecutionEngine.java b/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MapreduceExecutionEngine.java
index 049d183..47f8478 100644
--- a/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MapreduceExecutionEngine.java
+++ b/execution/mapreduce/src/main/java/org/apache/sqoop/execution/mapreduce/MapreduceExecutionEngine.java
@@ -19,8 +19,8 @@ package org.apache.sqoop.execution.mapreduce;
 
 import org.apache.hadoop.io.NullWritable;
 import org.apache.sqoop.common.MutableMapContext;
-import org.apache.sqoop.framework.ExecutionEngine;
-import org.apache.sqoop.framework.JobRequest;
+import org.apache.sqoop.driver.ExecutionEngine;
+import org.apache.sqoop.driver.JobRequest;
 import org.apache.sqoop.job.JobConstants;
 import org.apache.sqoop.job.etl.From;
 import org.apache.sqoop.job.etl.To;
@@ -63,8 +63,7 @@ public class MapreduceExecutionEngine extends ExecutionEngine {
 
     From from = (From) mrJobRequest.getFrom();
     To to = (To) mrJobRequest.getTo();
-
-    MutableMapContext context = mrJobRequest.getFrameworkContext();
+    MutableMapContext context = mrJobRequest.getDriverContext();
     context.setString(JobConstants.JOB_ETL_PARTITIONER, from.getPartitioner().getName());
     context.setString(JobConstants.JOB_ETL_EXTRACTOR, from.getExtractor().getName());
     context.setString(JobConstants.JOB_ETL_LOADER, to.getLoader().getName());
@@ -85,10 +84,10 @@ public class MapreduceExecutionEngine extends ExecutionEngine {
    * at mapreduce job time. This method will register all dependencies in the request
    * object.
    *
-   * @param request Active request object.
+   * @param jobrequest Active job request object.
    */
-  protected void addDependencies(MRJobRequest request) {
+  protected void addDependencies(MRJobRequest jobrequest) {
     // Guava
-    request.addJarForClass(ThreadFactoryBuilder.class);
+    jobrequest.addJarForClass(ThreadFactoryBuilder.class);
   }
 }

http://git-wip-us.apache.org/repos/asf/sqoop/blob/049994a0/execution/mapreduce/src/main/java/org/apache/sqoop/job/JobConstants.java
----------------------------------------------------------------------
diff --git a/execution/mapreduce/src/main/java/org/apache/sqoop/job/JobConstants.java b/execution/mapreduce/src/main/java/org/apache/sqoop/job/JobConstants.java
index 542607a..349bb60 100644
--- a/execution/mapreduce/src/main/java/org/apache/sqoop/job/JobConstants.java
+++ b/execution/mapreduce/src/main/java/org/apache/sqoop/job/JobConstants.java
@@ -18,7 +18,7 @@
 package org.apache.sqoop.job;
 
 import org.apache.sqoop.core.ConfigurationConstants;
-import org.apache.sqoop.framework.FrameworkConstants;
+import org.apache.sqoop.driver.DriverConstants;
 
 public final class JobConstants extends Constants {
   /**
@@ -73,7 +73,7 @@ public final class JobConstants extends Constants {
     "mapred.output.compression.codec";
 
   public static final String INTERMEDIATE_DATA_FORMAT =
-    FrameworkConstants.PREFIX_EXECUTION_CONFIG + "intermediate.format";
+    DriverConstants.PREFIX_EXECUTION_CONFIG + "intermediate.format";
 
   private JobConstants() {
     // Disable explicit object creation

http://git-wip-us.apache.org/repos/asf/sqoop/blob/049994a0/execution/mapreduce/src/main/java/org/apache/sqoop/job/mr/SqoopOutputFormatLoadExecutor.java
----------------------------------------------------------------------
diff --git a/execution/mapreduce/src/main/java/org/apache/sqoop/job/mr/SqoopOutputFormatLoadExecutor.java b/execution/mapreduce/src/main/java/org/apache/sqoop/job/mr/SqoopOutputFormatLoadExecutor.java
index 2996275..eea0623 100644
--- a/execution/mapreduce/src/main/java/org/apache/sqoop/job/mr/SqoopOutputFormatLoadExecutor.java
+++ b/execution/mapreduce/src/main/java/org/apache/sqoop/job/mr/SqoopOutputFormatLoadExecutor.java
@@ -250,7 +250,7 @@ public class SqoopOutputFormatLoadExecutor {
       } catch (Throwable t) {
         readerFinished = true;
         LOG.error("Error while loading data out of MR job.", t);
-        // Release so that the writer can tell the framework something went
+        // Release so that the writer can tell Sqoop something went
         // wrong.
         free.release();
         throw new SqoopException(MapreduceExecutionError.MAPRED_EXEC_0018, t);
@@ -262,7 +262,7 @@ public class SqoopOutputFormatLoadExecutor {
         // throw exception if data are not all consumed
         readerFinished = true;
         LOG.error("Reader terminated, but writer is still running!");
-        // Release so that the writer can tell the framework something went
+        // Release so that the writer can tell Sqoop something went
         // wrong.
         free.release();
         throw new SqoopException(MapreduceExecutionError.MAPRED_EXEC_0019);

http://git-wip-us.apache.org/repos/asf/sqoop/blob/049994a0/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoConstants.java
----------------------------------------------------------------------
diff --git a/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoConstants.java b/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoConstants.java
index fdcecf2..74e41df 100644
--- a/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoConstants.java
+++ b/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoConstants.java
@@ -23,7 +23,7 @@ public final class DerbyRepoConstants {
 
   public static final String SYSKEY_VERSION = "version";
 
-  public static final String SYSKEY_FRAMEWORK_VERSION = "framework.version";
+  public static final String SYSKEY_DRIVER_VERSION = "driver.version";
 
   /**
    * Expected version of the repository structures.

http://git-wip-us.apache.org/repos/asf/sqoop/blob/049994a0/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoError.java
----------------------------------------------------------------------
diff --git a/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoError.java b/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoError.java
index aae89fe..61dc3b4 100644
--- a/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoError.java
+++ b/repository/repository-derby/src/main/java/org/apache/sqoop/repository/derby/DerbyRepoError.java
@@ -1,7 +1,7 @@
 /**
  * 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
+ * distributed with this work for additional inconfigation
  * 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
@@ -33,35 +33,35 @@ public enum DerbyRepoError implements ErrorCode {
   /** The system was unable to run the specified query. */
   DERBYREPO_0003("Unable to run specified query"),
 
-  /** The system was unable to query the repository for metadata. */
-  DERBYREPO_0004("Unable to retrieve metadata"),
+  /** The system was unable to query the repository for given entity */
+  DERBYREPO_0004("Unable to retrieve entity data"),
 
-  /** The metadata repository contains more than one connector with same name */
-  DERBYREPO_0005("Invalid metadata state - multiple connectors with name"),
+  /** The repository contains more than one connector with same name */
+  DERBYREPO_0005("Invalid entity state - multiple connectors with name"),
 
   /** The system does not support the given input type.*/
   DERBYREPO_0006("Unknown input type encountered"),
 
-  /** The system does not support the given form type.*/
-  DERBYREPO_0007("Unknown form type encountered"),
+  /** The system does not support the given config type.*/
+  DERBYREPO_0007("Unknown config type encountered"),
 
-  /** No input metadata was found for the given form. */
-  DERBYREPO_0008("The form contains no input metadata"),
+  /** No input was found for the given config. */
+  DERBYREPO_0008("The config contains no input"),
 
-  /** The system could not load the form due to unexpected position of input.*/
-  DERBYREPO_0009("The form input retrieved does not match expected position"),
+  /** The system could not load the config due to unexpected position of input.*/
+  DERBYREPO_0009("The config input retrieved does not match expected position"),
 
   /**
    * The system could not load the connector due to unexpected position
-   * of form.
+   * of config.
    */
-  DERBYREPO_0010("The form retrieved does not match expected position"),
+  DERBYREPO_0010("The config retrieved does not match expected position"),
 
   /**
-   * The system was not able to register metadata due to a pre-assigned
+   * The system was not able to register entity due to a pre-assigned
    * persistence identifier.
    */
-  DERBYREPO_0011("Metadata cannot have preassigned persistence id"),
+  DERBYREPO_0011("Entity cannot have preassigned persistence id"),
 
   /**
    * The system was unable to register various entities.
@@ -69,91 +69,91 @@ public enum DerbyRepoError implements ErrorCode {
   DERBYREPO_0012("Unexpected update count when registering entity"),
 
   /**
-   * The system was unable to register metadata due to a failure to retrieve
+   * The system was unable to register entity due to a failure to retrieve
    * the generated identifier.
    */
   DERBYREPO_0013("Unable to retrieve generated identifier"),
 
   /**
-   * The system was unable to register connector metadata due to a server
+   * The system was unable to register connector due to a server
    * error.
    */
-  DERBYREPO_0014("Registration of connector metadata failed"),
+  DERBYREPO_0014("Registration of connector failed"),
 
   /**
-   * The system was not able to register connector metadata due to an unexpected
+   * The system was not able to register connector due to an unexpected
    * update count.
    */
-  DERBYREPO_0015("Unexpected update count on form registration"),
+  DERBYREPO_0015("Unexpected update count on config registration"),
 
   /**
-   * The system was unable to register connector metadata due to a failure to
-   * retrieve the generated identifier for a form.
+   * The system was unable to register connector due to a failure to
+   * retrieve the generated identifier for a config.
    */
-  DERBYREPO_0016("Unable to retrieve generated identifier for form"),
+  DERBYREPO_0016("Unable to retrieve generated identifier for config"),
 
   /**
-   * The system was unable to register connector metadata due to an unexpected
-   * update count for form input registration.
+   * The system was unable to register connector due to an unexpected
+   * update count for config input registration.
    */
-  DERBYREPO_0017("Unexpected update count for form input"),
+  DERBYREPO_0017("Unexpected update count for config input"),
 
   /**
-   * The system was unable to register connector metadata due to a failure to
-   * retrieve the generated identifier for a form input.
+   * The system was unable to register connector due to a failure to
+   * retrieve the generated identifier for a config input.
    */
-  DERBYREPO_0018("Unable to retrieve generated identifier for form input"),
+  DERBYREPO_0018("Unable to retrieve generated identifier for config input"),
 
-  /** We cant create new connection in metastore **/
-  DERBYREPO_0019("Unable to create new connection data"),
+  /** We cant create new link in repository **/
+  DERBYREPO_0019("Unable to create new link data"),
 
-  /** We can't save values for input to metastore **/
-  DERBYREPO_0020("Unable to save input values to metadata repository"),
+  /** We can't save values for input to repository **/
+  DERBYREPO_0020("Unable to save input values to the repository"),
 
-  /** We can't update connection in metastore **/
-  DERBYREPO_0021("Unable to update connection metadata in repository"),
+  /** We can't update link in repository **/
+  DERBYREPO_0021("Unable to update link in repository"),
 
-  /** We can't delete connection in metastore **/
-  DERBYREPO_0022("Unable to delete connection metadata in repository"),
+  /** We can't delete link in repository **/
+  DERBYREPO_0022("Unable to delete link in repository"),
 
-  /** We can't restore connection metadata from metastore **/
-  DERBYREPO_0023("Unable to load connection metadata from repository"),
+  /** We can't restore link from repository **/
+  DERBYREPO_0023("Unable to load link from repository"),
 
-  /** We can't restore specific connection metadata from metastore **/
-  DERBYREPO_0024("Unable to load specific connection metadata from repository"),
+  /** We can't restore specific link from repository **/
+  DERBYREPO_0024("Unable to load specific link from repository"),
 
-  /** We're unable to check if given connection already exists */
-  DERBYREPO_0025("Unable to check if given connection exists"),
+  /** We're unable to check if given link already exists */
+  DERBYREPO_0025("Unable to check if given link exists"),
 
-  /** We cant create new job in metastore **/
+  /** We cant create new job in repository **/
   DERBYREPO_0026("Unable to create new job data"),
 
-  /** We can't update job in metastore **/
-  DERBYREPO_0027("Unable to update job metadata in repository"),
+  /** We can't update job in repository **/
+  DERBYREPO_0027("Unable to update job in repository"),
 
-  /** We can't delete job in metastore **/
-  DERBYREPO_0028("Unable to delete job metadata in repository"),
+  /** We can't delete job in repository **/
+  DERBYREPO_0028("Unable to delete job in repository"),
 
   /** We're unable to check if given job already exists */
   DERBYREPO_0029("Unable to check if given job exists"),
 
-  /** We can't restore specific job metadata from metastore **/
-  DERBYREPO_0030("Unable to load specific job metadata from repository"),
+  /** We can't restore specific job from repository **/
+  DERBYREPO_0030("Unable to load specific job from repository"),
 
-  /** We can't restore job metadata from metastore **/
-  DERBYREPO_0031("Unable to load job metadata from repository"),
+  /** We can't restore job from repository **/
+  DERBYREPO_0031("Unable to load job from repository"),
 
-  /** Can't verify if connection is referenced from somewhere **/
-  DERBYREPO_0032("Unable to check if connection is in use"),
+  /** Can't verify if link is referenced from somewhere **/
+  DERBYREPO_0032("Unable to check if link is in use"),
 
   /** We're unable to check if given submission already exists */
   DERBYREPO_0033("Unable to check if given submission exists"),
 
-  /** We cant create new submission in metastore **/
+  /** We cant create new submission in repository **/
   DERBYREPO_0034("Unable to create new submission data"),
 
-  /** We can't update submission in metastore **/
-  DERBYREPO_0035("Unable to update submission metadata in repository"),
+  /** We can't update submission in repository **/
+  DERBYREPO_0035("Unable to update submission in the repository"),
 
   /** Can't purge old submissions **/
   DERBYREPO_0036("Unable to purge old submissions"),
@@ -172,15 +172,15 @@ public enum DerbyRepoError implements ErrorCode {
   /** Can't detect version of the database structures **/
   DERBYREPO_0041("Can't detect version of repository storage"),
 
-  /** Can't enable/disable connection **/
-  DERBYREPO_0042("Can't enable/disable connection"),
+  /** Can't enable/disable link **/
+  DERBYREPO_0042("Can't enable/disable link"),
 
   /** Can't enable/disable job **/
   DERBYREPO_0043("Can't enable/disable job"),
 
-  DERBYREPO_0044("Update of framework failed"),
+  DERBYREPO_0044("Update of driver config failed"),
 
-  DERBYREPO_0045("Can't retrieve all connector metadata"),
+  DERBYREPO_0045("Can't retrieve all connectors"),
             ;
 
   private final String message;


Mime
View raw message