/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ambari.server.agent;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.DATANODE;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.DummyCluster;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.DummyHostStatus;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.DummyHostname1;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.DummyOSRelease;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.DummyOs;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.DummyOsType;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.DummyStackId;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.HBASE_MASTER;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.HDFS;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.HDFS_CLIENT;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.NAMENODE;
import static org.apache.ambari.server.agent.DummyHeartbeatConstants.SECONDARY_NAMENODE;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ambari.server.AmbariException;
import org.apache.ambari.server.H2DatabaseCleaner;
import org.apache.ambari.server.Role;
import org.apache.ambari.server.RoleCommand;
import org.apache.ambari.server.actionmanager.ActionDBAccessor;
import org.apache.ambari.server.actionmanager.ActionDBAccessorImpl;
import org.apache.ambari.server.actionmanager.ActionManager;
import org.apache.ambari.server.actionmanager.ActionManagerTestHelper;
import org.apache.ambari.server.actionmanager.HostRoleCommand;
import org.apache.ambari.server.actionmanager.HostRoleCommandFactory;
import org.apache.ambari.server.actionmanager.HostRoleStatus;
import org.apache.ambari.server.actionmanager.Request;
import org.apache.ambari.server.actionmanager.Stage;
import org.apache.ambari.server.actionmanager.StageFactory;
import org.apache.ambari.server.api.services.AmbariMetaInfo;
import org.apache.ambari.server.audit.AuditLogger;
import org.apache.ambari.server.configuration.Configuration;
import org.apache.ambari.server.orm.GuiceJpaInitializer;
import org.apache.ambari.server.orm.InMemoryDefaultTestModule;
import org.apache.ambari.server.orm.dao.HostDAO;
import org.apache.ambari.server.orm.dao.RepositoryVersionDAO;
import org.apache.ambari.server.orm.entities.HostEntity;
import org.apache.ambari.server.orm.entities.RepositoryVersionEntity;
import org.apache.ambari.server.state.Alert;
import org.apache.ambari.server.state.AlertState;
import org.apache.ambari.server.state.Cluster;
import org.apache.ambari.server.state.Clusters;
import org.apache.ambari.server.state.Host;
import org.apache.ambari.server.state.HostState;
import org.apache.ambari.server.state.SecurityState;
import org.apache.ambari.server.state.Service;
import org.apache.ambari.server.state.ServiceComponentHost;
import org.apache.ambari.server.state.StackId;
import org.apache.ambari.server.state.State;
import org.apache.ambari.server.state.fsm.InvalidStateTransitionException;
import org.apache.ambari.server.state.svccomphost.ServiceComponentHostInstallEvent;
import org.apache.ambari.server.state.svccomphost.ServiceComponentHostUpgradeEvent;
import org.apache.ambari.server.utils.CommandUtils;
import org.apache.ambari.server.utils.EventBusSynchronizer;
import org.apache.ambari.server.utils.StageUtils;
import org.easymock.EasyMock;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.gson.JsonObject;
import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.persist.UnitOfWork;
import junit.framework.Assert;
public class HeartbeatProcessorTest {
private static final Logger log = LoggerFactory.getLogger(TestHeartbeatHandler.class);
private Injector injector;
private long requestId = 23;
private long stageId = 31;
@Inject
private Clusters clusters;
@Inject
private UnitOfWork unitOfWork;
@Inject
Configuration config;
@Inject
private ActionDBAccessor actionDBAccessor;
@Inject
private HeartbeatTestHelper heartbeatTestHelper;
@Inject
private ActionManagerTestHelper actionManagerTestHelper;
@Inject
private HostRoleCommandFactory hostRoleCommandFactory;
@Inject
private HostDAO hostDAO;
@Inject
private StageFactory stageFactory;
@Inject
private AmbariMetaInfo metaInfo;
public HeartbeatProcessorTest(){
InMemoryDefaultTestModule module = HeartbeatTestHelper.getTestModule();
injector = Guice.createInjector(module);
}
@Before
public void setup() throws Exception {
H2DatabaseCleaner.resetSequences(injector);
injector.getInstance(GuiceJpaInitializer.class);
injector.injectMembers(this);
EasyMock.replay(injector.getInstance(AuditLogger.class));
}
@After
public void teardown() throws AmbariException, SQLException {
H2DatabaseCleaner.clearDatabaseAndStopPersistenceService(injector);
}
@Test
@SuppressWarnings("unchecked")
public void testHeartbeatWithConfigs() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(NAMENODE);
hdfs.getServiceComponent(NAMENODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(SECONDARY_NAMENODE);
hdfs.getServiceComponent(SECONDARY_NAMENODE).addServiceComponentHost(DummyHostname1);
ActionQueue aq = new ActionQueue();
ServiceComponentHost serviceComponentHost1 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost2 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(NAMENODE).getServiceComponentHost(DummyHostname1);
serviceComponentHost1.setState(State.INSTALLED);
serviceComponentHost2.setState(State.INSTALLED);
HeartBeat hb = new HeartBeat();
hb.setResponseId(0);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
hb.setHostname(DummyHostname1);
List<CommandReport> reports = new ArrayList<>();
CommandReport cr = new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId, stageId));
cr.setServiceName(HDFS);
cr.setTaskId(1);
cr.setRole(DATANODE);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setRoleCommand("START");
cr.setClusterName(DummyCluster);
cr.setConfigurationTags(new HashMap<String, Map<String, String>>() {{
put("global", new HashMap<String, String>() {{
put("tag", "version1");
}});
}});
reports.add(cr);
hb.setReports(reports);
HostEntity host1 = hostDAO.findByName(DummyHostname1);
Assert.assertNotNull(host1);
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
}});
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
// the heartbeat test passed if actual configs is populated
Assert.assertNotNull(serviceComponentHost1.getActualConfigs());
Assert.assertEquals(serviceComponentHost1.getActualConfigs().size(), 1);
}
@Test
@SuppressWarnings("unchecked")
public void testRestartRequiredAfterInstallClient() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(HDFS_CLIENT);
hdfs.getServiceComponent(HDFS_CLIENT).addServiceComponentHost(DummyHostname1);
ActionQueue aq = new ActionQueue();
ServiceComponentHost serviceComponentHost = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(HDFS_CLIENT).getServiceComponentHost(DummyHostname1);
serviceComponentHost.setState(State.INSTALLED);
serviceComponentHost.setRestartRequired(true);
HeartBeat hb = new HeartBeat();
hb.setResponseId(0);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
hb.setHostname(DummyHostname1);
List<CommandReport> reports = new ArrayList<>();
CommandReport cr = new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId, stageId));
cr.setServiceName(HDFS);
cr.setRoleCommand("INSTALL");
cr.setCustomCommand("EXECUTION_COMMAND");
cr.setTaskId(1);
cr.setRole(HDFS_CLIENT);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setClusterName(DummyCluster);
cr.setConfigurationTags(new HashMap<String, Map<String, String>>() {{
put("global", new HashMap<String, String>() {{
put("tag", "version1");
}});
}});
reports.add(cr);
hb.setReports(reports);
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
add(command);
}});
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
Assert.assertNotNull(serviceComponentHost.getActualConfigs());
Assert.assertFalse(serviceComponentHost.isRestartRequired());
Assert.assertEquals(serviceComponentHost.getActualConfigs().size(), 1);
}
@Test
@SuppressWarnings("unchecked")
public void testHeartbeatCustomCommandWithConfigs() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(NAMENODE);
hdfs.getServiceComponent(NAMENODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(SECONDARY_NAMENODE);
hdfs.getServiceComponent(SECONDARY_NAMENODE).addServiceComponentHost(DummyHostname1);
ActionQueue aq = new ActionQueue();
ServiceComponentHost serviceComponentHost1 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost2 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(NAMENODE).getServiceComponentHost(DummyHostname1);
serviceComponentHost1.setState(State.INSTALLED);
serviceComponentHost2.setState(State.INSTALLED);
HeartBeat hb = new HeartBeat();
hb.setResponseId(0);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
hb.setHostname(DummyHostname1);
List<CommandReport> reports = new ArrayList<>();
CommandReport cr = new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId, stageId));
cr.setServiceName(HDFS);
cr.setRoleCommand("CUSTOM_COMMAND");
cr.setCustomCommand("RESTART");
cr.setTaskId(1);
cr.setRole(DATANODE);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setClusterName(DummyCluster);
cr.setConfigurationTags(new HashMap<String, Map<String,String>>() {{
put("global", new HashMap<String,String>() {{ put("tag", "version1"); }});
}});
CommandReport crn = new CommandReport();
crn.setActionId(StageUtils.getActionId(requestId, stageId));
crn.setServiceName(HDFS);
crn.setRoleCommand("CUSTOM_COMMAND");
crn.setCustomCommand("START");
crn.setTaskId(1);
crn.setRole(NAMENODE);
crn.setStatus("COMPLETED");
crn.setStdErr("");
crn.setStdOut("");
crn.setExitCode(215);
crn.setClusterName(DummyCluster);
crn.setConfigurationTags(new HashMap<String, Map<String,String>>() {{
put("global", new HashMap<String,String>() {{ put("tag", "version1"); }});
}});
reports.add(cr);
reports.add(crn);
hb.setReports(reports);
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
add(command);
}});
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
// the heartbeat test passed if actual configs is populated
Assert.assertNotNull(serviceComponentHost1.getActualConfigs());
Assert.assertEquals(serviceComponentHost1.getActualConfigs().size(), 1);
Assert.assertNotNull(serviceComponentHost2.getActualConfigs());
Assert.assertEquals(serviceComponentHost2.getActualConfigs().size(), 1);
}
@Test
@SuppressWarnings("unchecked")
public void testHeartbeatCustomStartStop() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(NAMENODE);
hdfs.getServiceComponent(NAMENODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(SECONDARY_NAMENODE);
hdfs.getServiceComponent(SECONDARY_NAMENODE).addServiceComponentHost(DummyHostname1);
ActionQueue aq = new ActionQueue();
ServiceComponentHost serviceComponentHost1 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost2 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(NAMENODE).getServiceComponentHost(DummyHostname1);
serviceComponentHost1.setState(State.INSTALLED);
serviceComponentHost2.setState(State.STARTED);
serviceComponentHost1.setRestartRequired(true);
serviceComponentHost2.setRestartRequired(true);
HeartBeat hb = new HeartBeat();
hb.setResponseId(0);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
hb.setHostname(DummyHostname1);
List<CommandReport> reports = new ArrayList<>();
CommandReport cr = new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId, stageId));
cr.setServiceName(HDFS);
cr.setRoleCommand("CUSTOM_COMMAND");
cr.setCustomCommand("START");
cr.setTaskId(1);
cr.setRole(DATANODE);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setClusterName(DummyCluster);
CommandReport crn = new CommandReport();
crn.setActionId(StageUtils.getActionId(requestId, stageId));
crn.setServiceName(HDFS);
crn.setRoleCommand("CUSTOM_COMMAND");
crn.setCustomCommand("STOP");
crn.setTaskId(1);
crn.setRole(NAMENODE);
crn.setStatus("COMPLETED");
crn.setStdErr("");
crn.setStdOut("");
crn.setExitCode(215);
crn.setClusterName(DummyCluster);
reports.add(cr);
reports.add(crn);
hb.setReports(reports);
assertTrue(serviceComponentHost1.isRestartRequired());
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
add(command);
}});
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
// the heartbeat test passed if actual configs is populated
State componentState1 = serviceComponentHost1.getState();
assertEquals(State.STARTED, componentState1);
assertFalse(serviceComponentHost1.isRestartRequired());
State componentState2 = serviceComponentHost2.getState();
assertEquals(State.INSTALLED, componentState2);
assertTrue(serviceComponentHost2.isRestartRequired());
}
@Test
@SuppressWarnings("unchecked")
public void testStatusHeartbeat() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(NAMENODE);
hdfs.getServiceComponent(NAMENODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(SECONDARY_NAMENODE);
hdfs.getServiceComponent(SECONDARY_NAMENODE).addServiceComponentHost(DummyHostname1);
ActionQueue aq = new ActionQueue();
ServiceComponentHost serviceComponentHost1 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost2 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(NAMENODE).getServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost3 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(SECONDARY_NAMENODE).getServiceComponentHost(DummyHostname1);
serviceComponentHost1.setState(State.INSTALLED);
serviceComponentHost1.setSecurityState(SecurityState.UNSECURED);
serviceComponentHost2.setState(State.INSTALLED);
serviceComponentHost2.setSecurityState(SecurityState.SECURING);
serviceComponentHost3.setState(State.STARTING);
HeartBeat hb = new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
hb.setReports(new ArrayList<CommandReport>());
ArrayList<ComponentStatus> componentStatuses = new ArrayList<>();
ComponentStatus componentStatus1 = new ComponentStatus();
componentStatus1.setClusterName(DummyCluster);
componentStatus1.setServiceName(HDFS);
componentStatus1.setMessage(DummyHostStatus);
componentStatus1.setStatus(State.STARTED.name());
componentStatus1.setComponentName(DATANODE);
componentStatuses.add(componentStatus1);
ComponentStatus componentStatus2 = new ComponentStatus();
componentStatus2.setClusterName(DummyCluster);
componentStatus2.setServiceName(HDFS);
componentStatus2.setMessage(DummyHostStatus);
componentStatus2.setStatus(State.STARTED.name());
componentStatus2.setComponentName(SECONDARY_NAMENODE);
componentStatuses.add(componentStatus2);
hb.setComponentStatus(componentStatuses);
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
add(command);
}});
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
State componentState1 = serviceComponentHost1.getState();
State componentState2 = serviceComponentHost2.getState();
State componentState3 = serviceComponentHost3.getState();
assertEquals(State.STARTED, componentState1);
assertEquals(State.INSTALLED, componentState2);
assertEquals(SecurityState.SECURING, serviceComponentHost2.getSecurityState());
//starting state will not be overridden by status command
assertEquals(State.STARTING, componentState3);
assertEquals(SecurityState.UNSECURED, serviceComponentHost3.getSecurityState());
}
@Test
public void testCommandReport() throws AmbariException {
injector.injectMembers(this);
clusters.addHost(DummyHostname1);
StackId dummyStackId = new StackId(DummyStackId);
clusters.addCluster(DummyCluster, dummyStackId);
ActionDBAccessor db = injector.getInstance(ActionDBAccessorImpl.class);
ActionManager am = injector.getInstance(ActionManager.class);
heartbeatTestHelper.populateActionDB(db, DummyHostname1, requestId, stageId);
Stage stage = db.getAllStages(requestId).get(0);
Assert.assertEquals(stageId, stage.getStageId());
stage.setHostRoleStatus(DummyHostname1, HBASE_MASTER, HostRoleStatus.QUEUED);
db.hostRoleScheduled(stage, DummyHostname1, HBASE_MASTER);
List<CommandReport> reports = new ArrayList<>();
CommandReport cr = new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId, stageId));
cr.setTaskId(1);
cr.setRole(HBASE_MASTER);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setConfigurationTags(new HashMap<String, Map<String,String>>() {{
put("global", new HashMap<String,String>() {{ put("tag", "version1"); }});
}});
reports.add(cr);
am.processTaskResponse(DummyHostname1, reports, CommandUtils.convertToTaskIdCommandMap(stage.getOrderedHostRoleCommands()));
assertEquals(215,
am.getAction(requestId, stageId).getExitCode(DummyHostname1, HBASE_MASTER));
assertEquals(HostRoleStatus.COMPLETED, am.getAction(requestId, stageId)
.getHostRoleStatus(DummyHostname1, HBASE_MASTER));
Stage s = db.getAllStages(requestId).get(0);
assertEquals(HostRoleStatus.COMPLETED,
s.getHostRoleStatus(DummyHostname1, HBASE_MASTER));
assertEquals(215,
s.getExitCode(DummyHostname1, HBASE_MASTER));
}
/**
* Tests the fact that when START and STOP commands are in progress, and heartbeat
* forces the host component state to STARTED or INSTALLED, there are no undesired
* side effects.
* @throws AmbariException
* @throws InvalidStateTransitionException
*/
@Test
@SuppressWarnings("unchecked")
public void testCommandReportOnHeartbeatUpdatedState()
throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
ActionQueue aq = new ActionQueue();
ServiceComponentHost serviceComponentHost1 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
serviceComponentHost1.setState(State.INSTALLED);
HeartBeat hb = new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
List<CommandReport> reports = new ArrayList<>();
CommandReport cr = new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId, stageId));
cr.setTaskId(1);
cr.setClusterName(DummyCluster);
cr.setServiceName(HDFS);
cr.setRole(DATANODE);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setStdErr("none");
cr.setStdOut("dummy output");
cr.setExitCode(777);
cr.setRoleCommand("START");
reports.add(cr);
hb.setReports(reports);
hb.setComponentStatus(new ArrayList<ComponentStatus>());
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
}}).anyTimes();
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.INSTALLED,
State.INSTALLED, serviceComponentHost1.getState());
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(1);
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.STARTED,
State.STARTED, serviceComponentHost1.getState());
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(2);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setRoleCommand("STOP");
cr.setExitCode(777);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.STARTED,
State.STARTED, serviceComponentHost1.getState());
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(3);
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.INSTALLED,
State.INSTALLED, serviceComponentHost1.getState());
// validate the transitions when there is no heartbeat
serviceComponentHost1.setState(State.STARTING);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setExitCode(777);
cr.setRoleCommand("START");
hb.setResponseId(4);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.STARTING,
State.STARTING, serviceComponentHost1.getState());
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
hb.setResponseId(5);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.STARTED,
State.STARTED, serviceComponentHost1.getState());
serviceComponentHost1.setState(State.STOPPING);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setExitCode(777);
cr.setRoleCommand("STOP");
hb.setResponseId(6);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.STOPPING,
State.STOPPING, serviceComponentHost1.getState());
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
hb.setResponseId(7);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.INSTALLED,
State.INSTALLED, serviceComponentHost1.getState());
}
@Test
@SuppressWarnings("unchecked")
public void testUpgradeSpecificHandling() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
ActionQueue aq = new ActionQueue();
ServiceComponentHost serviceComponentHost1 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
serviceComponentHost1.setState(State.UPGRADING);
HeartBeat hb = new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
List<CommandReport> reports = new ArrayList<>();
CommandReport cr = new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId, stageId));
cr.setTaskId(1);
cr.setClusterName(DummyCluster);
cr.setServiceName(HDFS);
cr.setRole(DATANODE);
cr.setRoleCommand("INSTALL");
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setStdErr("none");
cr.setStdOut("dummy output");
cr.setExitCode(777);
reports.add(cr);
hb.setReports(reports);
hb.setComponentStatus(new ArrayList<ComponentStatus>());
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
}}).anyTimes();
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.UPGRADING,
State.UPGRADING, serviceComponentHost1.getState());
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(1);
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.INSTALLED,
State.INSTALLED, serviceComponentHost1.getState());
serviceComponentHost1.setState(State.UPGRADING);
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(2);
cr.setStatus(HostRoleStatus.FAILED.toString());
cr.setExitCode(3);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.UPGRADING,
State.UPGRADING, serviceComponentHost1.getState());
serviceComponentHost1.setState(State.UPGRADING);
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(3);
cr.setStatus(HostRoleStatus.PENDING.toString());
cr.setExitCode(55);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.UPGRADING,
State.UPGRADING, serviceComponentHost1.getState());
serviceComponentHost1.setState(State.UPGRADING);
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(4);
cr.setStatus(HostRoleStatus.QUEUED.toString());
cr.setExitCode(55);
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Host state should be " + State.UPGRADING,
State.UPGRADING, serviceComponentHost1.getState());
}
@Test
@SuppressWarnings("unchecked")
public void testCommandStatusProcesses() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
hdfs.getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1).setState(State.STARTED);
ActionQueue aq = new ActionQueue();
HeartBeat hb = new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
hb.setReports(new ArrayList<CommandReport>());
List<Map<String, String>> procs = new ArrayList<>();
Map<String, String> proc1info = new HashMap<>();
proc1info.put("name", "a");
proc1info.put("status", "RUNNING");
procs.add(proc1info);
Map<String, String> proc2info = new HashMap<>();
proc2info.put("name", "b");
proc2info.put("status", "NOT_RUNNING");
procs.add(proc2info);
Map<String, Object> extra = new HashMap<>();
extra.put("processes", procs);
ArrayList<ComponentStatus> componentStatuses = new ArrayList<>();
ComponentStatus componentStatus1 = new ComponentStatus();
componentStatus1.setClusterName(DummyCluster);
componentStatus1.setServiceName(HDFS);
componentStatus1.setMessage(DummyHostStatus);
componentStatus1.setStatus(State.STARTED.name());
componentStatus1.setComponentName(DATANODE);
componentStatus1.setExtra(extra);
componentStatuses.add(componentStatus1);
hb.setComponentStatus(componentStatuses);
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
}}).anyTimes();
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
ServiceComponentHost sch = hdfs.getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
Assert.assertEquals(Integer.valueOf(2), Integer.valueOf(sch.getProcesses().size()));
hb = new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(1);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
hb.setReports(new ArrayList<CommandReport>());
componentStatus1 = new ComponentStatus();
componentStatus1.setClusterName(DummyCluster);
componentStatus1.setServiceName(HDFS);
componentStatus1.setMessage(DummyHostStatus);
componentStatus1.setStatus(State.STARTED.name());
componentStatus1.setComponentName(DATANODE);
hb.setComponentStatus(Collections.singletonList(componentStatus1));
heartbeatProcessor.processHeartbeat(hb);
}
@Test
@SuppressWarnings("unchecked")
public void testComponentUpgradeCompleteReport() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(NAMENODE);
hdfs.getServiceComponent(NAMENODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(HDFS_CLIENT);
hdfs.getServiceComponent(HDFS_CLIENT).addServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost1 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost2 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(NAMENODE).getServiceComponentHost(DummyHostname1);
StackId stack130 = new StackId("HDP-1.3.0");
StackId stack120 = new StackId("HDP-1.2.0");
serviceComponentHost1.setState(State.UPGRADING);
serviceComponentHost2.setState(State.INSTALLING);
serviceComponentHost1.setStackVersion(stack120);
serviceComponentHost1.setDesiredStackVersion(stack130);
serviceComponentHost2.setStackVersion(stack120);
HeartBeat hb = new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
CommandReport cr1 = new CommandReport();
cr1.setActionId(StageUtils.getActionId(requestId, stageId));
cr1.setTaskId(1);
cr1.setClusterName(DummyCluster);
cr1.setServiceName(HDFS);
cr1.setRole(DATANODE);
cr1.setStatus(HostRoleStatus.COMPLETED.toString());
cr1.setStdErr("none");
cr1.setStdOut("dummy output");
cr1.setExitCode(0);
cr1.setRoleCommand(RoleCommand.UPGRADE.toString());
CommandReport cr2 = new CommandReport();
cr2.setActionId(StageUtils.getActionId(requestId, stageId));
cr2.setTaskId(2);
cr2.setClusterName(DummyCluster);
cr2.setServiceName(HDFS);
cr2.setRole(NAMENODE);
cr2.setStatus(HostRoleStatus.COMPLETED.toString());
cr2.setStdErr("none");
cr2.setStdOut("dummy output");
cr2.setExitCode(0);
cr2.setRoleCommand(RoleCommand.UPGRADE.toString());
ArrayList<CommandReport> reports = new ArrayList<>();
reports.add(cr1);
reports.add(cr2);
hb.setReports(reports);
ActionQueue aq = new ActionQueue();
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
add(command);
}});
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
assertEquals("Stack version for SCH should be updated to " +
serviceComponentHost1.getDesiredStackVersion(),
stack130, serviceComponentHost1.getStackVersion());
assertEquals("Stack version for SCH should not change ",
stack120, serviceComponentHost2.getStackVersion());
}
@Test
@SuppressWarnings("unchecked")
public void testComponentUpgradeFailReport() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(NAMENODE);
hdfs.getServiceComponent(NAMENODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(HDFS_CLIENT);
hdfs.getServiceComponent(HDFS_CLIENT).addServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost1 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost2 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(NAMENODE).getServiceComponentHost(DummyHostname1);
StackId stack130 = new StackId("HDP-1.3.0");
StackId stack120 = new StackId("HDP-1.2.0");
serviceComponentHost1.setState(State.UPGRADING);
serviceComponentHost2.setState(State.INSTALLING);
serviceComponentHost1.setStackVersion(stack120);
serviceComponentHost1.setDesiredStackVersion(stack130);
serviceComponentHost2.setStackVersion(stack120);
Stage s = stageFactory.createNew(requestId, "/a/b", "cluster1", 1L, "action manager test",
"commandParamsStage", "hostParamsStage");
s.setStageId(stageId);
s.addHostRoleExecutionCommand(DummyHostname1, Role.DATANODE, RoleCommand.UPGRADE,
new ServiceComponentHostUpgradeEvent(Role.DATANODE.toString(),
DummyHostname1, System.currentTimeMillis(), "HDP-1.3.0"),
DummyCluster, "HDFS", false, false);
s.addHostRoleExecutionCommand(DummyHostname1, Role.NAMENODE, RoleCommand.INSTALL,
new ServiceComponentHostInstallEvent(Role.NAMENODE.toString(),
DummyHostname1, System.currentTimeMillis(), "HDP-1.3.0"),
DummyCluster, "HDFS", false, false);
List<Stage> stages = new ArrayList<>();
stages.add(s);
Request request = new Request(stages, "clusterHostInfo", clusters);
actionDBAccessor.persistActions(request);
CommandReport cr = new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId, stageId));
cr.setTaskId(1);
cr.setClusterName(DummyCluster);
cr.setServiceName(HDFS);
cr.setRole(DATANODE);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setStdErr("none");
cr.setStdOut("dummy output");
actionDBAccessor.updateHostRoleState(DummyHostname1, requestId, stageId,
Role.DATANODE.name(), cr);
cr.setRole(NAMENODE);
cr.setTaskId(2);
actionDBAccessor.updateHostRoleState(DummyHostname1, requestId, stageId,
Role.NAMENODE.name(), cr);
HeartBeat hb = new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
CommandReport cr1 = new CommandReport();
cr1.setActionId(StageUtils.getActionId(requestId, stageId));
cr1.setTaskId(1);
cr1.setClusterName(DummyCluster);
cr1.setServiceName(HDFS);
cr1.setRole(DATANODE);
cr1.setRoleCommand("INSTALL");
cr1.setStatus(HostRoleStatus.FAILED.toString());
cr1.setStdErr("none");
cr1.setStdOut("dummy output");
cr1.setExitCode(0);
CommandReport cr2 = new CommandReport();
cr2.setActionId(StageUtils.getActionId(requestId, stageId));
cr2.setTaskId(2);
cr2.setClusterName(DummyCluster);
cr2.setServiceName(HDFS);
cr2.setRole(NAMENODE);
cr2.setRoleCommand("INSTALL");
cr2.setStatus(HostRoleStatus.FAILED.toString());
cr2.setStdErr("none");
cr2.setStdOut("dummy output");
cr2.setExitCode(0);
ArrayList<CommandReport> reports = new ArrayList<>();
reports.add(cr1);
reports.add(cr2);
hb.setReports(reports);
ActionQueue aq = new ActionQueue();
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
add(command);
}});
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
assertEquals("State of SCH should change after fail report",
State.UPGRADING, serviceComponentHost1.getState());
assertEquals("State of SCH should change after fail report",
State.INSTALL_FAILED, serviceComponentHost2.getState());
assertEquals("Stack version of SCH should not change after fail report",
stack120, serviceComponentHost1.getStackVersion());
assertEquals("Stack version of SCH should not change after fail report",
stack130, serviceComponentHost1.getDesiredStackVersion());
assertEquals("Stack version of SCH should not change after fail report",
State.INSTALL_FAILED, serviceComponentHost2.getState());
}
@Test
@SuppressWarnings("unchecked")
public void testComponentUpgradeInProgressReport() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(NAMENODE);
hdfs.getServiceComponent(NAMENODE).addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(HDFS_CLIENT);
hdfs.getServiceComponent(HDFS_CLIENT).addServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost1 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost2 = clusters.getCluster(DummyCluster).getService(HDFS).
getServiceComponent(NAMENODE).getServiceComponentHost(DummyHostname1);
StackId stack130 = new StackId("HDP-1.3.0");
StackId stack120 = new StackId("HDP-1.2.0");
serviceComponentHost1.setState(State.UPGRADING);
serviceComponentHost2.setState(State.INSTALLING);
serviceComponentHost1.setStackVersion(stack120);
serviceComponentHost1.setDesiredStackVersion(stack130);
serviceComponentHost2.setStackVersion(stack120);
HeartBeat hb = new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
CommandReport cr1 = new CommandReport();
cr1.setActionId(StageUtils.getActionId(requestId, stageId));
cr1.setTaskId(1);
cr1.setClusterName(DummyCluster);
cr1.setServiceName(HDFS);
cr1.setRole(DATANODE);
cr1.setRoleCommand("INSTALL");
cr1.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr1.setStdErr("none");
cr1.setStdOut("dummy output");
cr1.setExitCode(777);
CommandReport cr2 = new CommandReport();
cr2.setActionId(StageUtils.getActionId(requestId, stageId));
cr2.setTaskId(2);
cr2.setClusterName(DummyCluster);
cr2.setServiceName(HDFS);
cr2.setRole(NAMENODE);
cr2.setRoleCommand("INSTALL");
cr2.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr2.setStdErr("none");
cr2.setStdOut("dummy output");
cr2.setExitCode(777);
ArrayList<CommandReport> reports = new ArrayList<>();
reports.add(cr1);
reports.add(cr2);
hb.setReports(reports);
ActionQueue aq = new ActionQueue();
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
add(command);
}});
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
handler.handleHeartBeat(hb);
assertEquals("State of SCH not change while operation is in progress",
State.UPGRADING, serviceComponentHost1.getState());
assertEquals("Stack version of SCH should not change after in progress report",
stack130, serviceComponentHost1.getDesiredStackVersion());
assertEquals("State of SCH not change while operation is in progress",
State.INSTALLING, serviceComponentHost2.getState());
}
/**
* Tests that if there is an invalid cluster in heartbeat data, the heartbeat
* doesn't fail.
*
* @throws Exception
*/
@Test
@SuppressWarnings("unchecked")
public void testHeartBeatWithAlertAndInvalidCluster() throws Exception {
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>());
replay(am);
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Clusters fsm = clusters;
Host hostObject = clusters.getHost(DummyHostname1);
hostObject.setIPv4("ipv4");
hostObject.setIPv6("ipv6");
hostObject.setOsType(DummyOsType);
ActionQueue aq = new ActionQueue();
HeartBeatHandler handler = new HeartBeatHandler(fsm, aq, am, injector);
Register reg = new Register();
HostInfo hi = new HostInfo();
hi.setHostName(DummyHostname1);
hi.setOS(DummyOs);
hi.setOSRelease(DummyOSRelease);
reg.setHostname(DummyHostname1);
reg.setHardwareProfile(hi);
reg.setAgentVersion(metaInfo.getServerVersion());
handler.handleRegistration(reg);
hostObject.setState(HostState.UNHEALTHY);
ExecutionCommand execCmd = new ExecutionCommand();
execCmd.setRequestAndStage(2, 34);
execCmd.setHostname(DummyHostname1);
aq.enqueue(DummyHostname1, new ExecutionCommand());
HeartBeat hb = new HeartBeat();
HostStatus hs = new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus);
hb.setResponseId(0);
hb.setNodeStatus(hs);
hb.setHostname(DummyHostname1);
Alert alert = new Alert("foo", "bar", "baz", "foobar", "foobarbaz",
AlertState.OK);
alert.setCluster("BADCLUSTER");
List<Alert> alerts = Collections.singletonList(alert);
hb.setAlerts(alerts);
// should NOT throw AmbariException from alerts.
handler.getHeartbeatProcessor().processHeartbeat(hb);
}
@Test
public void testInstallPackagesWithVersion() throws Exception {
// required since this test method checks the DAO result of handling a
// heartbeat which performs some async tasks
EventBusSynchronizer.synchronizeAmbariEventPublisher(injector);
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
Collections.singletonList(command)).anyTimes();
replay(am);
Cluster cluster = heartbeatTestHelper.getDummyCluster();
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, new ActionQueue());
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
HeartBeat hb = new HeartBeat();
JsonObject json = new JsonObject();
json.addProperty("actual_version", "2.2.1.0-2222");
json.addProperty("package_installation_result", "SUCCESS");
json.addProperty("installed_repository_version", "0.1");
json.addProperty("stack_id", cluster.getDesiredStackVersion().getStackId());
CommandReport cmdReport = new CommandReport();
cmdReport.setActionId(StageUtils.getActionId(requestId, stageId));
cmdReport.setTaskId(1);
cmdReport.setCustomCommand("install_packages");
cmdReport.setStructuredOut(json.toString());
cmdReport.setRoleCommand(RoleCommand.ACTIONEXECUTE.name());
cmdReport.setStatus(HostRoleStatus.COMPLETED.name());
cmdReport.setRole("install_packages");
cmdReport.setClusterName(DummyCluster);
List<CommandReport> reports = new ArrayList<>();
reports.add(cmdReport);
hb.setReports(reports);
hb.setTimestamp(0L);
hb.setResponseId(0);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
hb.setHostname(DummyHostname1);
hb.setComponentStatus(new ArrayList<ComponentStatus>());
StackId stackId = new StackId("HDP", "0.1");
RepositoryVersionDAO dao = injector.getInstance(RepositoryVersionDAO.class);
RepositoryVersionEntity entity = dao.findByStackAndVersion(stackId, "0.1");
Assert.assertNotNull(entity);
heartbeatProcessor.processHeartbeat(hb);
entity = dao.findByStackAndVersion(stackId, "0.1");
Assert.assertNull(entity);
entity = dao.findByStackAndVersion(stackId, "2.2.1.0-2222");
Assert.assertNotNull(entity);
}
@Test
@SuppressWarnings("unchecked")
public void testComponentInProgressStatusSafeAfterStatusReport() throws Exception {
Cluster cluster = heartbeatTestHelper.getDummyCluster();
Service hdfs = cluster.addService(HDFS);
hdfs.addServiceComponent(DATANODE);
hdfs.getServiceComponent(DATANODE).
addServiceComponentHost(DummyHostname1);
hdfs.addServiceComponent(NAMENODE);
hdfs.getServiceComponent(NAMENODE).
addServiceComponentHost(DummyHostname1);
ActionQueue aq = new ActionQueue();
ServiceComponentHost serviceComponentHost1 = clusters.
getCluster(DummyCluster).getService(HDFS).
getServiceComponent(DATANODE).
getServiceComponentHost(DummyHostname1);
ServiceComponentHost serviceComponentHost2 = clusters.
getCluster(DummyCluster).getService(HDFS).
getServiceComponent(NAMENODE).
getServiceComponentHost(DummyHostname1);
serviceComponentHost1.setState(State.STARTING);
serviceComponentHost2.setState(State.STOPPING);
HeartBeat hb = new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY, DummyHostStatus));
hb.setReports(new ArrayList<CommandReport>());
ArrayList<ComponentStatus> componentStatuses = new ArrayList<>();
ComponentStatus componentStatus1 = new ComponentStatus();
componentStatus1.setClusterName(DummyCluster);
componentStatus1.setServiceName(HDFS);
componentStatus1.setMessage(DummyHostStatus);
componentStatus1.setStatus(State.INSTALLED.name());
componentStatus1.setComponentName(DATANODE);
componentStatuses.add(componentStatus1);
ComponentStatus componentStatus2 = new ComponentStatus();
componentStatus2.setClusterName(DummyCluster);
componentStatus2.setServiceName(HDFS);
componentStatus2.setMessage(DummyHostStatus);
componentStatus2.setStatus(State.INSTALLED.name());
componentStatus2.setComponentName(NAMENODE);
componentStatuses.add(componentStatus2);
hb.setComponentStatus(componentStatuses);
final HostRoleCommand command = hostRoleCommandFactory.create(DummyHostname1,
Role.DATANODE, null, null);
ActionManager am = actionManagerTestHelper.getMockActionManager();
expect(am.getTasks(EasyMock.<List<Long>>anyObject())).andReturn(
new ArrayList<HostRoleCommand>() {{
add(command);
add(command);
}});
replay(am);
HeartBeatHandler handler = heartbeatTestHelper.getHeartBeatHandler(am, aq);
HeartbeatProcessor heartbeatProcessor = handler.getHeartbeatProcessor();
heartbeatProcessor.processHeartbeat(hb);
State componentState1 = serviceComponentHost1.getState();
State componentState2 = serviceComponentHost2.getState();
assertEquals(State.STARTING, componentState1);
assertEquals(State.STOPPING, componentState2);
}
}