You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ambari.apache.org by dm...@apache.org on 2016/03/02 16:29:06 UTC
ambari git commit: AMBARI-15260. Upgrade Warning on Non-Versioned
Components (dlysnichenko)
Repository: ambari
Updated Branches:
refs/heads/trunk db7945d20 -> d6fddcddf
AMBARI-15260. Upgrade Warning on Non-Versioned Components (dlysnichenko)
Project: http://git-wip-us.apache.org/repos/asf/ambari/repo
Commit: http://git-wip-us.apache.org/repos/asf/ambari/commit/d6fddcdd
Tree: http://git-wip-us.apache.org/repos/asf/ambari/tree/d6fddcdd
Diff: http://git-wip-us.apache.org/repos/asf/ambari/diff/d6fddcdd
Branch: refs/heads/trunk
Commit: d6fddcddf4209c77106e6db0c73f6743b8fae01e
Parents: db7945d
Author: Lisnichenko Dmitro <dl...@hortonworks.com>
Authored: Wed Mar 2 17:28:53 2016 +0200
Committer: Lisnichenko Dmitro <dl...@hortonworks.com>
Committed: Wed Mar 2 17:29:42 2016 +0200
----------------------------------------------------------------------
.../listeners/upgrade/StackVersionListener.java | 12 +-
.../upgrade/StackVersionListenerTest.java | 268 ++++++++++++++++---
2 files changed, 244 insertions(+), 36 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/ambari/blob/d6fddcdd/ambari-server/src/main/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListener.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/main/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListener.java b/ambari-server/src/main/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListener.java
index 9d989f1..2153113 100644
--- a/ambari-server/src/main/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListener.java
+++ b/ambari-server/src/main/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListener.java
@@ -54,6 +54,7 @@ public class StackVersionListener {
* Logger.
*/
private final static Logger LOG = LoggerFactory.getLogger(StackVersionListener.class);
+ private static final String UNKNOWN_VERSION = State.UNKNOWN.toString();
/**
* Used to prevent multiple threads from trying to create host alerts
@@ -87,13 +88,12 @@ public class StackVersionListener {
try {
ServiceComponent sc = cluster.getService(sch.getServiceName()).getServiceComponent(sch.getServiceComponentName());
if (newVersion == null) {
- processComponentVersionNotAdvertised(sch);
- } else if (sc.getDesiredVersion().equals(State.UNKNOWN.toString())) {
+ processComponentVersionNotAdvertised(sc, sch);
+ } else if (UNKNOWN_VERSION.equals(sc.getDesiredVersion())) {
processUnknownDesiredVersion(cluster, sc, sch, newVersion);
} else if (StringUtils.isNotBlank(newVersion)) {
String previousVersion = sch.getVersion();
- String unknownVersion = State.UNKNOWN.toString();
- if (previousVersion == null || previousVersion.equalsIgnoreCase(unknownVersion)) {
+ if (previousVersion == null || UNKNOWN_VERSION.equalsIgnoreCase(previousVersion)) {
// value may be "UNKNOWN" when upgrading from older Ambari versions
// or if host component reports it's version for the first time
sch.setUpgradeState(UpgradeState.NONE);
@@ -179,9 +179,11 @@ public class StackVersionListener {
/**
* Focuses on cases when component does not advertise it's version
*/
- private void processComponentVersionNotAdvertised(ServiceComponentHost sch) {
+ private void processComponentVersionNotAdvertised(ServiceComponent sc, ServiceComponentHost sch) {
if (UpgradeState.ONGOING_UPGRADE_STATES.contains(sch.getUpgradeState())) {
sch.setUpgradeState(UpgradeState.FAILED);
+ } else if (!sc.isVersionAdvertised()) {
+ sch.setUpgradeState(UpgradeState.NONE);
} else {
sch.setUpgradeState(UpgradeState.VERSION_MISMATCH);
}
http://git-wip-us.apache.org/repos/asf/ambari/blob/d6fddcdd/ambari-server/src/test/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListenerTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListenerTest.java b/ambari-server/src/test/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListenerTest.java
index aa405ae..12f1f83 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListenerTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/events/listeners/upgrade/StackVersionListenerTest.java
@@ -17,64 +17,270 @@
*/
package org.apache.ambari.server.events.listeners.upgrade;
-import static org.easymock.EasyMock.anyObject;
-import static org.easymock.EasyMock.anyString;
-import static org.easymock.EasyMock.createNiceMock;
import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.replay;
-import static org.easymock.EasyMock.verify;
+import static org.easymock.EasyMock.expectLastCall;
+import org.apache.ambari.server.AmbariException;
import org.apache.ambari.server.events.HostComponentVersionAdvertisedEvent;
import org.apache.ambari.server.events.publishers.VersionEventPublisher;
import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
+import org.apache.ambari.server.orm.entities.UpgradeEntity;
import org.apache.ambari.server.state.Cluster;
import org.apache.ambari.server.state.Service;
import org.apache.ambari.server.state.ServiceComponent;
import org.apache.ambari.server.state.ServiceComponentHost;
-import org.apache.ambari.server.state.ServiceImpl;
-import org.easymock.EasyMock;
-import org.junit.Ignore;
+import org.apache.ambari.server.state.UpgradeState;
+import org.easymock.EasyMockSupport;
+import org.junit.After;
+import org.junit.Before;
import org.junit.Test;
/**
* StackVersionListener tests.
*/
-public class StackVersionListenerTest {
+public class StackVersionListenerTest extends EasyMockSupport {
- private static final String DESIRED_VERSION = "1.2.3.4-5678";
+ private static final String INVALID_NEW_VERSION = "1.2.3.4-5678";
+ private static final String VALID_NEW_VERSION = "2.4.0.0-1000";
private static final String SERVICE_COMPONENT_NAME = "Some component name";
private static final String SERVICE_NAME = "Service name";
+ private static final Long CLUSTER_ID = 1L;
+ private static final String UNKNOWN_VERSION = "UNKNOWN";
+ private static final String VALID_PREVIOUS_VERSION = "2.2.0.0";
+ private static final RepositoryVersionEntity DUMMY_REPOSITORY_VERSION_ENTITY = new RepositoryVersionEntity();
+ private static final UpgradeEntity DUMMY_UPGRADE_ENTITY = new UpgradeEntity();
- @Test
- public void testOnAmbariEvent() throws Exception {
- VersionEventPublisher publisher = createNiceMock(VersionEventPublisher.class);
- Cluster cluster = createNiceMock(Cluster.class);
- ServiceComponentHost sch = createNiceMock(ServiceComponentHost.class);
- RepositoryVersionEntity repositoryVersionEntity = createNiceMock(RepositoryVersionEntity.class);
- Service service = createNiceMock(Service.class);
- ServiceComponent serviceComponent = createNiceMock(ServiceComponent.class);
-
- expect(serviceComponent.getDesiredVersion()).andReturn(DESIRED_VERSION);
- expect(service.getServiceComponent(SERVICE_COMPONENT_NAME)).andReturn(serviceComponent);
+ private Cluster cluster;
+ private ServiceComponentHost sch;
+ private Service service;
+ private ServiceComponent serviceComponent;
+ private VersionEventPublisher publisher;
- expect(cluster.getClusterId()).andReturn(99L);
- expect(cluster.getService(anyString())).andReturn(service);
+ @Before
+ public void setup() throws Exception {
+ cluster = createNiceMock(Cluster.class);
+ sch = createNiceMock(ServiceComponentHost.class);
+ service = createNiceMock(Service.class);
+ serviceComponent = createNiceMock(ServiceComponent.class);
+ publisher = createNiceMock(VersionEventPublisher.class);
+ expect(cluster.getClusterId()).andReturn(CLUSTER_ID);
+ expect(cluster.getService(SERVICE_NAME)).andReturn(service);
+ expect(service.getServiceComponent(SERVICE_COMPONENT_NAME)).andReturn(serviceComponent);
expect(sch.getServiceName()).andReturn(SERVICE_NAME);
expect(sch.getServiceComponentName()).andReturn(SERVICE_COMPONENT_NAME);
- expect(sch.recalculateHostVersionState()).andReturn(repositoryVersionEntity).atLeastOnce();
+ }
- cluster.recalculateClusterVersionState(repositoryVersionEntity);
- EasyMock.expectLastCall().atLeastOnce();
+ @Test
+ public void testRecalculateHostVersionStateWhenVersionIsNullAndNewVersionIsNotBlank() throws AmbariException {
+ expect(sch.getVersion()).andReturn(null);
+ sch.setVersion(INVALID_NEW_VERSION);
+ expectLastCall().once();
+ expect(sch.recalculateHostVersionState()).andReturn(null).once();
- // Replay and assert expectations
- replay(cluster, sch, serviceComponent, service);
+ replayAll();
- HostComponentVersionAdvertisedEvent event = new HostComponentVersionAdvertisedEvent(cluster, sch, DESIRED_VERSION);
- StackVersionListener listener = new StackVersionListener(publisher);
+ sendEventAndVerify(INVALID_NEW_VERSION);
+ }
+
+ @Test
+ public void testRecalculateHostVersionStateWhenVersionIsUnknownAndNewVersionIsNotBlank() throws AmbariException {
+ expect(sch.getVersion()).andReturn(UNKNOWN_VERSION);
+ sch.setVersion(INVALID_NEW_VERSION);
+ expectLastCall().once();
+ expect(sch.recalculateHostVersionState()).andReturn(null).once();
+
+ replayAll();
+
+ sendEventAndVerify(INVALID_NEW_VERSION);
+ }
+
+ @Test
+ public void testRecalculateClusterVersionStateWhenVersionIsNullAndNewVersionIsValid() throws AmbariException {
+ expect(sch.getVersion()).andReturn(null);
+ sch.setVersion(VALID_NEW_VERSION);
+ expectLastCall().once();
+ expect(sch.recalculateHostVersionState()).andReturn(DUMMY_REPOSITORY_VERSION_ENTITY).once();
+ cluster.recalculateClusterVersionState(DUMMY_REPOSITORY_VERSION_ENTITY);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(VALID_NEW_VERSION);
+ }
+
+ @Test
+ public void testRecalculateClusterVersionStateWhenVersionIsUnknownAndNewVersionIsValid() throws AmbariException {
+ expect(sch.getVersion()).andReturn(UNKNOWN_VERSION);
+ sch.setVersion(VALID_NEW_VERSION);
+ expectLastCall().once();
+ expect(sch.recalculateHostVersionState()).andReturn(DUMMY_REPOSITORY_VERSION_ENTITY).once();
+ cluster.recalculateClusterVersionState(DUMMY_REPOSITORY_VERSION_ENTITY);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(VALID_NEW_VERSION);
+ }
+
+ @Test
+ public void testRecalculateHostVersionStateWhenComponentDesiredVersionIsUnknownAndNewVersionIsNotValid() throws AmbariException {
+ expect(serviceComponent.getDesiredVersion()).andReturn(UNKNOWN_VERSION);
+ serviceComponent.setDesiredVersion(INVALID_NEW_VERSION);
+ expectLastCall().once();
+ sch.setUpgradeState(UpgradeState.NONE);
+ expectLastCall().once();
+ sch.setVersion(INVALID_NEW_VERSION);
+ expectLastCall().once();
+ expect(sch.recalculateHostVersionState()).andReturn(null).once();
+
+ replayAll();
+
+ sendEventAndVerify(INVALID_NEW_VERSION);
+ }
+
+ @Test
+ public void testRecalculateClusterVersionStateWhenComponentDesiredVersionIsUnknownAndNewVersionIsValid() throws AmbariException {
+ expect(serviceComponent.getDesiredVersion()).andReturn(UNKNOWN_VERSION);
+ serviceComponent.setDesiredVersion(VALID_NEW_VERSION);
+ expectLastCall().once();
+ sch.setUpgradeState(UpgradeState.NONE);
+ expectLastCall().once();
+ sch.setVersion(VALID_NEW_VERSION);
+ expectLastCall().once();
+ expect(sch.recalculateHostVersionState()).andReturn(DUMMY_REPOSITORY_VERSION_ENTITY).once();
+ cluster.recalculateClusterVersionState(DUMMY_REPOSITORY_VERSION_ENTITY);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(VALID_NEW_VERSION);
+ }
+
+ @Test
+ public void testSetUpgradeStateToFailedWhenNewVersionIsNullAndUpgradeIsInProgress() {
+ expect(sch.getUpgradeState()).andReturn(UpgradeState.IN_PROGRESS);
+ sch.setUpgradeState(UpgradeState.FAILED);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(null);
+ }
+
+ @Test
+ public void testSetUpgradeStateToFailedWhenNewVersionIsNullAndUpgradeHasComplete() {
+ expect(sch.getUpgradeState()).andReturn(UpgradeState.COMPLETE);
+ sch.setUpgradeState(UpgradeState.FAILED);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(null);
+ }
+
+ @Test
+ public void testSetUpgradeStateToFailedWhenNewVersionIsNullAndUpgradeHasFailed() {
+ expect(sch.getUpgradeState()).andReturn(UpgradeState.FAILED);
+ sch.setUpgradeState(UpgradeState.FAILED);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(null);
+ }
+
+ @Test
+ public void testSetUpgradeStateToNoneWhenNewVersionIsNullAndComponentVersionIsNotAdvertised() {
+ expect(serviceComponent.isVersionAdvertised()).andReturn(false);
+ sch.setUpgradeState(UpgradeState.NONE);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(null);
+ }
+
+ @Test
+ public void testSetUpgradeStateToVersionMismatchByDefaultWhenNewVersionIsNull() {
+ expect(serviceComponent.isVersionAdvertised()).andReturn(true);
+ sch.setUpgradeState(UpgradeState.VERSION_MISMATCH);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(null);
+ }
+
+ @Test
+ public void testSetUpgradeStateToCompleteWhenUpgradeIsInProgressAndNewVersionIsEqualToComponentDesiredVersion() {
+ expect(sch.getVersion()).andReturn(VALID_PREVIOUS_VERSION);
+ expect(sch.getUpgradeState()).andReturn(UpgradeState.IN_PROGRESS);
+ sch.setUpgradeState(UpgradeState.COMPLETE);
+ expectLastCall().once();
+
+ expect(serviceComponent.getDesiredVersion()).andStubReturn(VALID_NEW_VERSION);
+ replayAll();
+
+ sendEventAndVerify(VALID_NEW_VERSION);
+ }
+ @Test
+ public void testSetUpgradeStateToVersionMismatchWhenUpgradeIsInProgressAndNewVersionIsNotEqualToComponentDesiredVersion() {
+ expect(sch.getVersion()).andReturn(VALID_PREVIOUS_VERSION);
+ expect(sch.getUpgradeState()).andReturn(UpgradeState.IN_PROGRESS);
+ sch.setUpgradeState(UpgradeState.VERSION_MISMATCH);
+ expectLastCall().once();
+
+ expect(serviceComponent.getDesiredVersion()).andStubReturn(VALID_PREVIOUS_VERSION);
+ replayAll();
+
+ sendEventAndVerify(VALID_NEW_VERSION);
+ }
+
+ @Test
+ public void testSetUpgradeStateToCompleteWhenHostHasVersionMismatchAndNewVersionIsEqualToComponentDesiredVersionAndClusterUpgradeIsInProgress() {
+ expect(sch.getVersion()).andReturn(VALID_PREVIOUS_VERSION);
+ expect(sch.getUpgradeState()).andReturn(UpgradeState.VERSION_MISMATCH);
+ expect(cluster.getUpgradeEntity()).andReturn(DUMMY_UPGRADE_ENTITY);
+ expect(serviceComponent.getDesiredVersion()).andStubReturn(VALID_NEW_VERSION);
+ sch.setUpgradeState(UpgradeState.COMPLETE);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(VALID_NEW_VERSION);
+ }
+
+ @Test
+ public void testSetUpgradeStateToNoneWhenHostHasVersionMismatchAndNewVersionIsEqualToComponentDesiredVersion() {
+ expect(sch.getVersion()).andReturn(VALID_PREVIOUS_VERSION);
+ expect(sch.getUpgradeState()).andReturn(UpgradeState.VERSION_MISMATCH);
+ expect(serviceComponent.getDesiredVersion()).andStubReturn(VALID_NEW_VERSION);
+ sch.setUpgradeState(UpgradeState.NONE);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(VALID_NEW_VERSION);
+ }
+
+ @Test
+ public void testSetUpgradeStateToVersionMismatchByDefaultWhenHostAndNewVersionsAreValid() {
+ expect(sch.getVersion()).andReturn(VALID_PREVIOUS_VERSION);
+ sch.setUpgradeState(UpgradeState.VERSION_MISMATCH);
+ expectLastCall().once();
+
+ replayAll();
+
+ sendEventAndVerify(VALID_NEW_VERSION);
+ }
+
+ private void sendEventAndVerify(String newVersion) {
+ HostComponentVersionAdvertisedEvent event = new HostComponentVersionAdvertisedEvent(cluster, sch, newVersion);
+ StackVersionListener listener = new StackVersionListener(publisher);
listener.onAmbariEvent(event);
- verify(cluster, sch);
+ verifyAll();
}
}
\ No newline at end of file