ambari-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ababiic...@apache.org
Subject [34/50] [abbrv] ambari git commit: AMBARI-21672 - Update Orchestration to support MAINT (jonathanhurley)
Date Thu, 10 Aug 2017 10:27:40 GMT
AMBARI-21672 - Update Orchestration to support MAINT (jonathanhurley)


Project: http://git-wip-us.apache.org/repos/asf/ambari/repo
Commit: http://git-wip-us.apache.org/repos/asf/ambari/commit/3155a43e
Tree: http://git-wip-us.apache.org/repos/asf/ambari/tree/3155a43e
Diff: http://git-wip-us.apache.org/repos/asf/ambari/diff/3155a43e

Branch: refs/heads/branch-feature-logsearch-ui
Commit: 3155a43e591499e9501ee3b2f6e5f095a9883177
Parents: 2d69fc7
Author: Jonathan Hurley <jhurley@hortonworks.com>
Authored: Mon Aug 7 11:03:09 2017 -0400
Committer: Jonathan Hurley <jhurley@hortonworks.com>
Committed: Tue Aug 8 10:11:53 2017 -0400

----------------------------------------------------------------------
 .../ambari/server/state/UpgradeContext.java     | 140 +++++++----
 .../ambari/server/state/UpgradeContextTest.java | 246 ++++++++++++++++---
 2 files changed, 309 insertions(+), 77 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ambari/blob/3155a43e/ambari-server/src/main/java/org/apache/ambari/server/state/UpgradeContext.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/main/java/org/apache/ambari/server/state/UpgradeContext.java
b/ambari-server/src/main/java/org/apache/ambari/server/state/UpgradeContext.java
index 0e409a4..a4ed080 100644
--- a/ambari-server/src/main/java/org/apache/ambari/server/state/UpgradeContext.java
+++ b/ambari-server/src/main/java/org/apache/ambari/server/state/UpgradeContext.java
@@ -65,6 +65,7 @@ import org.apache.ambari.server.orm.entities.UpgradeEntity;
 import org.apache.ambari.server.orm.entities.UpgradeHistoryEntity;
 import org.apache.ambari.server.stack.MasterHostResolver;
 import org.apache.ambari.server.stageplanner.RoleGraphFactory;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
 import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.PrereqCheckStatus;
 import org.apache.ambari.server.state.stack.UpgradePack;
@@ -114,17 +115,17 @@ public class UpgradeContext {
   /*
    * The cluster that the upgrade is for.
    */
-  final private Cluster m_cluster;
+  private final Cluster m_cluster;
 
   /**
    * The direction of the upgrade.
    */
-  final private Direction m_direction;
+  private final Direction m_direction;
 
   /**
    * The type of upgrade.
    */
-  final private UpgradeType m_type;
+  private final UpgradeType m_type;
 
   /**
    * The upgrade pack for this upgrade.
@@ -187,7 +188,7 @@ public class UpgradeContext {
    * A set of services which are included in this upgrade. If this is empty,
    * then all cluster services are included.
    */
-  private Set<String> m_services = new HashSet<>();
+  private final Set<String> m_services = new HashSet<>();
 
   /**
    * A mapping of service to target repository. On an upgrade, this will be the
@@ -252,7 +253,7 @@ public class UpgradeContext {
   /**
    * Used as a quick way to tell if the upgrade is to revert a patch.
    */
-  private boolean m_isRevert = false;
+  private final boolean m_isRevert;
 
   /**
    * Defines orchestration type.  This is not the repository type when reverting a patch.
@@ -356,48 +357,8 @@ public class UpgradeContext {
           m_repositoryVersion = m_repoVersionDAO.findByPK(Long.valueOf(repositoryVersionId));
           m_orchestration = m_repositoryVersion.getType();
 
-          if (m_orchestration == RepositoryType.STANDARD) {
-            m_services.addAll(cluster.getServices().keySet());
-          } else {
-            try {
-              VersionDefinitionXml vdf = m_repositoryVersion.getRepositoryXml();
-              m_services.addAll(vdf.getAvailableServiceNames());
-
-              // if this is every true, then just stop the upgrade attempt and
-              // throw an exception
-              if (m_services.isEmpty()) {
-                String message = String.format(
-                    "When using a VDF of type %s, the available services must be defined
in the VDF",
-                    m_repositoryVersion.getType());
-
-                throw new AmbariException(message);
-              }
-
-            } catch (Exception e) {
-              String msg = String.format(
-                  "Could not parse version definition for %s.  Upgrade will not proceed.",
-                  m_repositoryVersion.getVersion());
-
-              throw new AmbariException(msg);
-            }
-          }
-
-          Set<String> installedServices = new HashSet<>();
-          // populate the target repository map for all services in the upgrade
-          for (String serviceName : m_services) {
-            try {
-              Service service = cluster.getService(serviceName);
-              m_sourceRepositoryMap.put(serviceName, service.getDesiredRepositoryVersion());
-              m_targetRepositoryMap.put(serviceName, m_repositoryVersion);
-              installedServices.add(serviceName);
-            } catch (ServiceNotFoundException e) {
-              LOG.warn("Skipping orchestraction for service {}, as it was defined to upgrade,
but is not installed in cluster {}",
-                  serviceName, cluster.getClusterName());
-            }
-          }
-
-          m_services = installedServices;
-
+          // add all of the services participating in the upgrade
+          m_services.addAll(getServicesForUpgrade(cluster, m_repositoryVersion));
           break;
         }
         case DOWNGRADE:{
@@ -417,8 +378,8 @@ public class UpgradeContext {
           break;
         }
         default:
-          m_repositoryVersion = null;
-          break;
+          throw new AmbariException(
+              String.format("%s is not a valid upgrade direction.", m_direction));
       }
     }
 
@@ -907,6 +868,87 @@ public class UpgradeContext {
   }
 
   /**
+   * Gets the set of services which will participate in the upgrade. The
+   * services available in the repository are comapred against those installed
+   * in the cluster to arrive at the final subset.
+   * <p/>
+   * In some cases, such as with a {@link RepositoryType#MAINT} repository, the
+   * subset can be further trimmed by determing that an installed services is
+   * already at a high enough version and doesn't need to be upgraded.
+   * <p/>
+   * This method will also populate the source ({@link #m_sourceRepositoryMap})
+   * and target ({@link #m_targetRepositoryMap}) repository maps.
+   *
+   * @param cluster
+   *          the cluster (not {@code null}).
+   * @param repositoryVersion
+   *          the repository to use for the upgrade (not {@code null}).
+   * @return the set of services which will participate in the upgrade.
+   * @throws AmbariException
+   */
+  private Set<String> getServicesForUpgrade(Cluster cluster,
+      RepositoryVersionEntity repositoryVersion) throws AmbariException {
+
+    // keep track of the services which will be in this upgrade
+    Set<String> servicesForUpgrade = new HashSet<>();
+
+    // standard repo types use all services of the cluster
+    if (repositoryVersion.getType() == RepositoryType.STANDARD) {
+      servicesForUpgrade = cluster.getServices().keySet();
+    } else {
+      try {
+        // use the VDF and cluster to determine what services should be in this
+        // upgrade - this will take into account the type (such as patch/maint)
+        // and the version of services installed in the cluster
+        VersionDefinitionXml vdf = repositoryVersion.getRepositoryXml();
+        ClusterVersionSummary clusterVersionSummary = vdf.getClusterSummary(cluster);
+        servicesForUpgrade = clusterVersionSummary.getAvailableServiceNames();
+
+        // if this is every true, then just stop the upgrade attempt and
+        // throw an exception
+        if (servicesForUpgrade.isEmpty()) {
+          String message = String.format(
+              "When using a VDF of type %s, the available services must be defined in the
VDF",
+              repositoryVersion.getType());
+
+          throw new AmbariException(message);
+        }
+      } catch (Exception e) {
+        String msg = String.format(
+            "Could not parse version definition for %s.  Upgrade will not proceed.",
+            repositoryVersion.getVersion());
+
+        throw new AmbariException(msg);
+      }
+    }
+
+    // now that we have a list of the services defined by the VDF, only include
+    // services which are actually installed
+    Iterator<String> iterator = servicesForUpgrade.iterator();
+    while (iterator.hasNext()) {
+      String serviceName = null;
+      try {
+        serviceName = iterator.next();
+        Service service = cluster.getService(serviceName);
+
+        m_sourceRepositoryMap.put(serviceName, service.getDesiredRepositoryVersion());
+        m_targetRepositoryMap.put(serviceName, repositoryVersion);
+      } catch (ServiceNotFoundException e) {
+        // remove the service which is not part of the cluster - this should
+        // never happen since the summary from the VDF does this already, but
+        // can't hurt to be safe
+        iterator.remove();
+
+        LOG.warn(
+            "Skipping orchestration for service {}, as it was defined to upgrade, but is
not installed in cluster {}",
+            serviceName, cluster.getClusterName());
+      }
+    }
+
+    return servicesForUpgrade;
+  }
+
+  /**
    * Builds a chain of {@link UpgradeRequestValidator}s to ensure that the
    * incoming request to create a new upgrade is valid.
    *

http://git-wip-us.apache.org/repos/asf/ambari/blob/3155a43e/ambari-server/src/test/java/org/apache/ambari/server/state/UpgradeContextTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/state/UpgradeContextTest.java
b/ambari-server/src/test/java/org/apache/ambari/server/state/UpgradeContextTest.java
index e2bb27e..e04be5e 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/state/UpgradeContextTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/state/UpgradeContextTest.java
@@ -33,6 +33,8 @@ import org.apache.ambari.server.orm.dao.UpgradeDAO;
 import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
 import org.apache.ambari.server.orm.entities.UpgradeEntity;
 import org.apache.ambari.server.orm.entities.UpgradeHistoryEntity;
+import org.apache.ambari.server.state.repository.ClusterVersionSummary;
+import org.apache.ambari.server.state.repository.VersionDefinitionXml;
 import org.apache.ambari.server.state.stack.UpgradePack;
 import org.apache.ambari.server.state.stack.upgrade.Direction;
 import org.apache.ambari.server.state.stack.upgrade.UpgradeType;
@@ -43,39 +45,93 @@ import org.easymock.Mock;
 import org.junit.Before;
 import org.junit.Test;
 
+import com.google.common.collect.Sets;
+
 /**
  * Tests {@link UpgradeContext}.
  */
 public class UpgradeContextTest extends EasyMockSupport {
 
+  private final static String HDFS_SERVICE_NAME = "HDFS";
+  private final static String ZOOKEEPER_SERVICE_NAME = "ZOOKEEPER";
+
+  /**
+   * An existing upgrade which can be reverted.
+   */
   @Mock
   private UpgradeEntity m_completedRevertableUpgrade;
 
+  /**
+   * The target repository of a completed upgrade.
+   */
   @Mock
-  private RepositoryVersionEntity m_completedUpgradeTargetRepositoryVersion;
+  private RepositoryVersionEntity m_targetRepositoryVersion;
 
+  /**
+   * The source repository of a completed upgrade.
+   */
   @Mock
-  private RepositoryVersionEntity m_completedUpgradeSourceRepositoryVersion;
+  private RepositoryVersionEntity m_sourceRepositoryVersion;
 
+  /**
+   * The cluster performing the upgrade.
+   */
+  @Mock
+  private Cluster m_cluster;
+
+  /**
+   * HDFS
+   */
+  @Mock
+  private Service m_hdfsService;
+
+  /**
+   * ZooKeeper
+   */
+  @Mock
+  private Service m_zookeeperService;
 
   @Mock
   private UpgradeDAO m_upgradeDAO;
 
+  @Mock
+  private RepositoryVersionDAO m_repositoryVersionDAO;
+
+  /**
+   * Used to mock out what services will be provided to us by the VDF/cluster.
+   */
+  @Mock
+  private ClusterVersionSummary m_clusterVersionSummary;
+
+  /**
+   *
+   */
+  @Mock
+  private VersionDefinitionXml m_vdfXml;
+
+  /**
+   * The cluster services.
+   */
+  private Map<String, Service> m_services = new HashMap<>();
+
   @Before
-  public void setup() {
+  public void setup() throws Exception {
     injectMocks(this);
 
-    expect(m_completedUpgradeSourceRepositoryVersion.getId()).andReturn(1L).anyTimes();
-    expect(m_completedUpgradeSourceRepositoryVersion.getStackId()).andReturn(new StackId("HDP",
"2.6")).anyTimes();
-    expect(m_completedUpgradeTargetRepositoryVersion.getId()).andReturn(1L).anyTimes();
-    expect(m_completedUpgradeTargetRepositoryVersion.getStackId()).andReturn(new StackId("HDP",
"2.6")).anyTimes();
+    expect(m_sourceRepositoryVersion.getId()).andReturn(1L).anyTimes();
+    expect(m_sourceRepositoryVersion.getStackId()).andReturn(new StackId("HDP", "2.6")).anyTimes();
+    expect(m_targetRepositoryVersion.getId()).andReturn(99L).anyTimes();
+    expect(m_targetRepositoryVersion.getStackId()).andReturn(new StackId("HDP", "2.6")).anyTimes();
 
     UpgradeHistoryEntity upgradeHistoryEntity = createNiceMock(UpgradeHistoryEntity.class);
-    expect(upgradeHistoryEntity.getServiceName()).andReturn("HDFS").atLeastOnce();
-    expect(upgradeHistoryEntity.getFromReposistoryVersion()).andReturn(m_completedUpgradeSourceRepositoryVersion).anyTimes();
-    expect(upgradeHistoryEntity.getTargetRepositoryVersion()).andReturn(m_completedUpgradeTargetRepositoryVersion).anyTimes();
+    expect(upgradeHistoryEntity.getServiceName()).andReturn(HDFS_SERVICE_NAME).anyTimes();
+    expect(upgradeHistoryEntity.getFromReposistoryVersion()).andReturn(m_sourceRepositoryVersion).anyTimes();
+    expect(upgradeHistoryEntity.getTargetRepositoryVersion()).andReturn(m_targetRepositoryVersion).anyTimes();
     List<UpgradeHistoryEntity> upgradeHistory = Lists.newArrayList(upgradeHistoryEntity);
 
+    expect(m_repositoryVersionDAO.findByPK(1L)).andReturn(m_sourceRepositoryVersion).anyTimes();
+    expect(m_repositoryVersionDAO.findByPK(99L)).andReturn(m_targetRepositoryVersion).anyTimes();
+
     expect(m_upgradeDAO.findUpgrade(1L)).andReturn(m_completedRevertableUpgrade).anyTimes();
 
     expect(
@@ -83,10 +139,156 @@ public class UpgradeContextTest extends EasyMockSupport {
             eq(Direction.UPGRADE))).andReturn(m_completedRevertableUpgrade).anyTimes();
 
     expect(m_completedRevertableUpgrade.getDirection()).andReturn(Direction.UPGRADE).anyTimes();
-    expect(m_completedRevertableUpgrade.getRepositoryVersion()).andReturn(m_completedUpgradeTargetRepositoryVersion).anyTimes();
+    expect(m_completedRevertableUpgrade.getRepositoryVersion()).andReturn(m_targetRepositoryVersion).anyTimes();
     expect(m_completedRevertableUpgrade.getOrchestration()).andReturn(RepositoryType.PATCH).anyTimes();
     expect(m_completedRevertableUpgrade.getHistory()).andReturn(upgradeHistory).anyTimes();
     expect(m_completedRevertableUpgrade.getUpgradePackage()).andReturn(null).anyTimes();
+
+    RepositoryVersionEntity hdfsRepositoryVersion = createNiceMock(RepositoryVersionEntity.class);
+
+    expect(m_hdfsService.getDesiredRepositoryVersion()).andReturn(hdfsRepositoryVersion).anyTimes();
+    expect(m_cluster.getService(HDFS_SERVICE_NAME)).andReturn(m_hdfsService).anyTimes();
+    m_services.put(HDFS_SERVICE_NAME, m_hdfsService);
+
+    expect(m_cluster.getServices()).andReturn(m_services).anyTimes();
+    expect(m_cluster.getClusterId()).andReturn(1L).anyTimes();
+    expect(m_cluster.getClusterName()).andReturn("c1").anyTimes();
+    expect(m_cluster.getUpgradeInProgress()).andReturn(null).atLeastOnce();
+
+    // VDF stuff
+    expect(m_vdfXml.getClusterSummary(EasyMock.anyObject(Cluster.class))).andReturn(
+        m_clusterVersionSummary).anyTimes();
+  }
+
+  /**
+   * Tests that the {@link UpgradeContext} for a normal upgrade.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testFullUpgrade() throws Exception {
+    UpgradeHelper upgradeHelper = createNiceMock(UpgradeHelper.class);
+    ConfigHelper configHelper = createNiceMock(ConfigHelper.class);
+    UpgradePack upgradePack = createNiceMock(UpgradePack.class);
+
+    expect(m_targetRepositoryVersion.getType()).andReturn(RepositoryType.STANDARD).atLeastOnce();
+
+    expect(upgradeHelper.suggestUpgradePack(EasyMock.anyString(), EasyMock.anyObject(StackId.class),
+        EasyMock.anyObject(StackId.class), EasyMock.anyObject(Direction.class),
+        EasyMock.anyObject(UpgradeType.class), EasyMock.anyString())).andReturn(upgradePack).once();
+
+    replayAll();
+
+    Map<String, Object> requestMap = new HashMap<>();
+    requestMap.put(UpgradeResourceProvider.UPGRADE_TYPE, UpgradeType.ROLLING.name());
+    requestMap.put(UpgradeResourceProvider.UPGRADE_DIRECTION, Direction.UPGRADE.name());
+    requestMap.put(UpgradeResourceProvider.UPGRADE_REPO_VERSION_ID,
+        m_targetRepositoryVersion.getId().toString());
+    requestMap.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS, "true");
+
+    UpgradeContext context = new UpgradeContext(m_cluster, requestMap, null, upgradeHelper,
+        m_upgradeDAO, m_repositoryVersionDAO, configHelper);
+
+    assertEquals(Direction.UPGRADE, context.getDirection());
+    assertEquals(RepositoryType.STANDARD, context.getOrchestrationType());
+    assertEquals(1, context.getSupportedServices().size());
+    assertFalse(context.isPatchRevert());
+
+    verifyAll();
+  }
+
+  /**
+   * Tests that the {@link UpgradeContext} for a patch upgrade.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testPatchUpgrade() throws Exception {
+    UpgradeHelper upgradeHelper = createNiceMock(UpgradeHelper.class);
+    ConfigHelper configHelper = createNiceMock(ConfigHelper.class);
+    UpgradePack upgradePack = createNiceMock(UpgradePack.class);
+
+    expect(m_clusterVersionSummary.getAvailableServiceNames()).andReturn(
+        Sets.newHashSet(HDFS_SERVICE_NAME)).once();
+
+    expect(m_targetRepositoryVersion.getType()).andReturn(RepositoryType.PATCH).atLeastOnce();
+    expect(m_targetRepositoryVersion.getRepositoryXml()).andReturn(m_vdfXml).once();
+
+    expect(upgradeHelper.suggestUpgradePack(EasyMock.anyString(), EasyMock.anyObject(StackId.class),
+        EasyMock.anyObject(StackId.class), EasyMock.anyObject(Direction.class),
+        EasyMock.anyObject(UpgradeType.class), EasyMock.anyString())).andReturn(upgradePack).once();
+
+    // make the cluster have 2 services just for fun (the VDF only has 1
+    // service)
+    expect(m_cluster.getService(ZOOKEEPER_SERVICE_NAME)).andReturn(m_zookeeperService).anyTimes();
+    m_services.put(ZOOKEEPER_SERVICE_NAME, m_zookeeperService);
+    assertEquals(2, m_services.size());
+
+    replayAll();
+
+    Map<String, Object> requestMap = new HashMap<>();
+    requestMap.put(UpgradeResourceProvider.UPGRADE_TYPE, UpgradeType.NON_ROLLING.name());
+    requestMap.put(UpgradeResourceProvider.UPGRADE_DIRECTION, Direction.UPGRADE.name());
+    requestMap.put(UpgradeResourceProvider.UPGRADE_REPO_VERSION_ID, m_targetRepositoryVersion.getId().toString());
+    requestMap.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS, "true");
+
+    UpgradeContext context = new UpgradeContext(m_cluster, requestMap, null, upgradeHelper,
+        m_upgradeDAO, m_repositoryVersionDAO, configHelper);
+
+    assertEquals(Direction.UPGRADE, context.getDirection());
+    assertEquals(RepositoryType.PATCH, context.getOrchestrationType());
+    assertEquals(1, context.getSupportedServices().size());
+    assertFalse(context.isPatchRevert());
+
+    verifyAll();
+  }
+
+  /**
+   * Tests that the {@link UpgradeContext} for a maintenance upgrade.
+   * Maintenance upgrades will only upgrade services which require it by
+   * examining the versions included in the VDF.
+   *
+   * @throws Exception
+   */
+  @Test
+  public void testMaintUpgrade() throws Exception {
+    UpgradeHelper upgradeHelper = createNiceMock(UpgradeHelper.class);
+    ConfigHelper configHelper = createNiceMock(ConfigHelper.class);
+    UpgradePack upgradePack = createNiceMock(UpgradePack.class);
+
+    expect(m_clusterVersionSummary.getAvailableServiceNames()).andReturn(
+        Sets.newHashSet(HDFS_SERVICE_NAME)).once();
+
+    expect(m_targetRepositoryVersion.getType()).andReturn(RepositoryType.MAINT).atLeastOnce();
+    expect(m_targetRepositoryVersion.getRepositoryXml()).andReturn(m_vdfXml).once();
+
+    expect(upgradeHelper.suggestUpgradePack(EasyMock.anyString(), EasyMock.anyObject(StackId.class),
+        EasyMock.anyObject(StackId.class), EasyMock.anyObject(Direction.class),
+        EasyMock.anyObject(UpgradeType.class), EasyMock.anyString())).andReturn(upgradePack).once();
+
+    // make the cluster have 2 services - one is already upgraded to a new
+    // enough version
+    expect(m_cluster.getService(ZOOKEEPER_SERVICE_NAME)).andReturn(m_zookeeperService).anyTimes();
+    m_services.put(ZOOKEEPER_SERVICE_NAME, m_zookeeperService);
+    assertEquals(2, m_services.size());
+
+    replayAll();
+
+    Map<String, Object> requestMap = new HashMap<>();
+    requestMap.put(UpgradeResourceProvider.UPGRADE_TYPE, UpgradeType.NON_ROLLING.name());
+    requestMap.put(UpgradeResourceProvider.UPGRADE_DIRECTION, Direction.UPGRADE.name());
+    requestMap.put(UpgradeResourceProvider.UPGRADE_REPO_VERSION_ID, m_targetRepositoryVersion.getId().toString());
+    requestMap.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS, "true");
+
+    UpgradeContext context = new UpgradeContext(m_cluster, requestMap, null, upgradeHelper,
+        m_upgradeDAO, m_repositoryVersionDAO, configHelper);
+
+    assertEquals(Direction.UPGRADE, context.getDirection());
+    assertEquals(RepositoryType.MAINT, context.getOrchestrationType());
+    assertEquals(1, context.getSupportedServices().size());
+    assertFalse(context.isPatchRevert());
+
+    verifyAll();
   }
 
   /**
@@ -97,21 +299,15 @@ public class UpgradeContextTest extends EasyMockSupport {
    */
   @Test
   public void testRevert() throws Exception {
-    Cluster cluster = createNiceMock(Cluster.class);
     UpgradeHelper upgradeHelper = createNiceMock(UpgradeHelper.class);
     ConfigHelper configHelper = createNiceMock(ConfigHelper.class);
-    RepositoryVersionDAO repositoryVersionDAO = createNiceMock(RepositoryVersionDAO.class);
-    RepositoryVersionEntity hdfsRepositoryVersion = createNiceMock(RepositoryVersionEntity.class);
 
-    Service service = createNiceMock(Service.class);
     UpgradePack upgradePack = createNiceMock(UpgradePack.class);
 
     expect(upgradeHelper.suggestUpgradePack(EasyMock.anyString(), EasyMock.anyObject(StackId.class),
         EasyMock.anyObject(StackId.class), EasyMock.anyObject(Direction.class),
         EasyMock.anyObject(UpgradeType.class), EasyMock.anyString())).andReturn(upgradePack).once();
 
-    expect(service.getDesiredRepositoryVersion()).andReturn(hdfsRepositoryVersion).once();
-    expect(cluster.getService("HDFS")).andReturn(service).atLeastOnce();
 
     Map<String, Object> requestMap = new HashMap<>();
     requestMap.put(UpgradeResourceProvider.UPGRADE_TYPE, UpgradeType.ROLLING.name());
@@ -119,8 +315,8 @@ public class UpgradeContextTest extends EasyMockSupport {
 
     replayAll();
 
-    UpgradeContext context = new UpgradeContext(cluster, requestMap, null, upgradeHelper,
-        m_upgradeDAO, repositoryVersionDAO, configHelper);
+    UpgradeContext context = new UpgradeContext(m_cluster, requestMap, null, upgradeHelper,
+        m_upgradeDAO, m_repositoryVersionDAO, configHelper);
 
     assertEquals(Direction.DOWNGRADE, context.getDirection());
     assertEquals(RepositoryType.PATCH, context.getOrchestrationType());
@@ -137,21 +333,15 @@ public class UpgradeContextTest extends EasyMockSupport {
    * @throws Exception
    */
   @Test
-  public void testDowngradeScope() throws Exception {
-    Cluster cluster = createNiceMock(Cluster.class);
+  public void testDowngradeForPatch() throws Exception {
     UpgradeHelper upgradeHelper = createNiceMock(UpgradeHelper.class);
     ConfigHelper configHelper = createNiceMock(ConfigHelper.class);
-    RepositoryVersionDAO repositoryVersionDAO = createNiceMock(RepositoryVersionDAO.class);
-    RepositoryVersionEntity hdfsRepositoryVersion = createNiceMock(RepositoryVersionEntity.class);
-    Service service = createNiceMock(Service.class);
     UpgradePack upgradePack = createNiceMock(UpgradePack.class);
 
     expect(upgradeHelper.suggestUpgradePack(EasyMock.anyString(), EasyMock.anyObject(StackId.class),
         EasyMock.anyObject(StackId.class), EasyMock.anyObject(Direction.class),
         EasyMock.anyObject(UpgradeType.class), EasyMock.anyString())).andReturn(upgradePack).once();
 
-    expect(service.getDesiredRepositoryVersion()).andReturn(hdfsRepositoryVersion).once();
-    expect(cluster.getService("HDFS")).andReturn(service).atLeastOnce();
 
     Map<String, Object> requestMap = new HashMap<>();
     requestMap.put(UpgradeResourceProvider.UPGRADE_TYPE, UpgradeType.NON_ROLLING.name());
@@ -159,8 +349,8 @@ public class UpgradeContextTest extends EasyMockSupport {
 
     replayAll();
 
-    UpgradeContext context = new UpgradeContext(cluster, requestMap, null, upgradeHelper,
-        m_upgradeDAO, repositoryVersionDAO, configHelper);
+    UpgradeContext context = new UpgradeContext(m_cluster, requestMap, null, upgradeHelper,
+        m_upgradeDAO, m_repositoryVersionDAO, configHelper);
 
     assertEquals(Direction.DOWNGRADE, context.getDirection());
     assertEquals(RepositoryType.PATCH, context.getOrchestrationType());


Mime
View raw message