/**
* 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.controller;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.persistence.EntityManager;
import junit.framework.Assert;
import org.apache.ambari.server.AmbariException;
import org.apache.ambari.server.ClusterNotFoundException;
import org.apache.ambari.server.DuplicateResourceException;
import org.apache.ambari.server.ParentObjectNotFoundException;
import org.apache.ambari.server.Role;
import org.apache.ambari.server.RoleCommand;
import org.apache.ambari.server.StackAccessException;
import org.apache.ambari.server.actionmanager.ActionDBAccessor;
import org.apache.ambari.server.actionmanager.ExecutionCommandWrapper;
import org.apache.ambari.server.actionmanager.HostRoleCommand;
import org.apache.ambari.server.actionmanager.HostRoleStatus;
import org.apache.ambari.server.actionmanager.Stage;
import org.apache.ambari.server.agent.ExecutionCommand;
import org.apache.ambari.server.api.services.AmbariMetaInfo;
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.RoleDAO;
import org.apache.ambari.server.orm.entities.RoleEntity;
import org.apache.ambari.server.security.authorization.Users;
import org.apache.ambari.server.serveraction.ServerAction;
import org.apache.ambari.server.serveraction.ServerActionManager;
import org.apache.ambari.server.serveraction.ServerActionManagerImpl;
import org.apache.ambari.server.state.Cluster;
import org.apache.ambari.server.state.Clusters;
import org.apache.ambari.server.state.Config;
import org.apache.ambari.server.state.ConfigFactory;
import org.apache.ambari.server.state.ConfigImpl;
import org.apache.ambari.server.state.Host;
import org.apache.ambari.server.state.HostState;
import org.apache.ambari.server.state.Service;
import org.apache.ambari.server.state.ServiceComponent;
import org.apache.ambari.server.state.ServiceComponentFactory;
import org.apache.ambari.server.state.ServiceComponentHost;
import org.apache.ambari.server.state.ServiceComponentHostFactory;
import org.apache.ambari.server.state.ServiceFactory;
import org.apache.ambari.server.state.StackId;
import org.apache.ambari.server.state.State;
import org.apache.ambari.server.state.svccomphost.ServiceComponentHostStartEvent;
import org.apache.ambari.server.utils.StageUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.persist.PersistService;
public class AmbariManagementControllerTest {
private static final Logger LOG =
LoggerFactory.getLogger(AmbariManagementControllerTest.class);
private static final String STACK_NAME = "HDP";
private static final String STACK_VERSION = "0.2";
private static final String OS_TYPE = "centos5";
private static final String REPO_ID = "HDP-1.1.1.16";
private static final String PROPERTY_NAME = "hbase.regionserver.msginterval";
private static final String SERVICE_NAME = "HDFS";
private static final int STACK_VERSIONS_CNT = 3;
private static final int REPOS_CNT = 3;
private static final int STACKS_CNT = 1;
private static final int STACK_SERVICES_CNT = 5 ;
private static final int STACK_PROPERTIES_CNT = 81;
private static final int STACK_COMPONENTS_CNT = 3;
private static final int OS_CNT = 2;
private static final String NON_EXT_VALUE = "XXX";
private static final String COMPONENT_NAME = "NAMENODE";
private static final String REQUEST_CONTEXT_PROPERTY = "context";
private AmbariManagementController controller;
private Clusters clusters;
private ActionDBAccessor actionDB;
private Injector injector;
private ServiceFactory serviceFactory;
private ServiceComponentFactory serviceComponentFactory;
private ServiceComponentHostFactory serviceComponentHostFactory;
private AmbariMetaInfo ambariMetaInfo;
private Users users;
private EntityManager entityManager;
@Before
public void setup() throws Exception {
injector = Guice.createInjector(new InMemoryDefaultTestModule());
injector.getInstance(GuiceJpaInitializer.class);
entityManager = injector.getInstance(EntityManager.class);
clusters = injector.getInstance(Clusters.class);
actionDB = injector.getInstance(ActionDBAccessor.class);
controller = injector.getInstance(AmbariManagementController.class);
serviceFactory = injector.getInstance(ServiceFactory.class);
serviceComponentFactory = injector.getInstance(
ServiceComponentFactory.class);
serviceComponentHostFactory = injector.getInstance(
ServiceComponentHostFactory.class);
ambariMetaInfo = injector.getInstance(AmbariMetaInfo.class);
ambariMetaInfo.init();
users = injector.getInstance(Users.class);
}
@After
public void teardown() {
injector.getInstance(PersistService.class).stop();
actionDB = null;
}
private void createCluster(String clusterName) throws AmbariException {
ClusterRequest r = new ClusterRequest(null, clusterName, "HDP-0.1", null);
controller.createCluster(r);
}
private void createService(String clusterName,
String serviceName, State desiredState) throws AmbariException {
String dStateStr = null;
if (desiredState != null) {
dStateStr = desiredState.toString();
}
ServiceRequest r1 = new ServiceRequest(clusterName, serviceName, null,
dStateStr);
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r1);
controller.createServices(requests);
}
private void createServiceComponent(String clusterName,
String serviceName, String componentName, State desiredState)
throws AmbariException {
String dStateStr = null;
if (desiredState != null) {
dStateStr = desiredState.toString();
}
ServiceComponentRequest r = new ServiceComponentRequest(clusterName,
serviceName, componentName, null, dStateStr);
Set<ServiceComponentRequest> requests =
new HashSet<ServiceComponentRequest>();
requests.add(r);
controller.createComponents(requests);
}
private void createServiceComponentHost(String clusterName,
String serviceName, String componentName, String hostname,
State desiredState) throws AmbariException {
String dStateStr = null;
if (desiredState != null) {
dStateStr = desiredState.toString();
}
ServiceComponentHostRequest r = new ServiceComponentHostRequest(clusterName,
serviceName, componentName, hostname, null, dStateStr);
Set<ServiceComponentHostRequest> requests =
new HashSet<ServiceComponentHostRequest>();
requests.add(r);
controller.createHostComponents(requests);
}
private long stopService(String clusterName, String serviceName,
boolean runSmokeTests, boolean reconfigureClients) throws
AmbariException {
ServiceRequest r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r);
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
RequestStatusResponse resp = controller.updateServices(requests,
mapRequestProps, runSmokeTests, reconfigureClients);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
// manually change live state to stopped as no running action manager
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
return resp.getRequestId();
}
private long startService(String clusterName, String serviceName,
boolean runSmokeTests, boolean reconfigureClients) throws
AmbariException {
ServiceRequest r = new ServiceRequest(clusterName, serviceName, null,
State.STARTED.toString());
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r);
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
RequestStatusResponse resp = controller.updateServices(requests,
mapRequestProps, runSmokeTests, reconfigureClients);
Assert.assertEquals(State.STARTED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
// manually change live state to started as no running action manager
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.STARTED);
}
}
return resp.getRequestId();
}
private long installService(String clusterName, String serviceName,
boolean runSmokeTests, boolean reconfigureClients) throws
AmbariException {
ServiceRequest r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r);
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
RequestStatusResponse resp = controller.updateServices(requests,
mapRequestProps, runSmokeTests, reconfigureClients);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
// manually change live state to stopped as no running action manager
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
return resp.getRequestId();
}
@Test
public void testCreateClusterSimple() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
Set<ClusterResponse> r =
controller.getClusters(Collections.singleton(
new ClusterRequest(null, clusterName, null, null)));
Assert.assertEquals(1, r.size());
ClusterResponse c = r.iterator().next();
Assert.assertEquals(clusterName, c.getClusterName());
try {
createCluster(clusterName);
fail("Duplicate cluster creation should fail");
} catch (AmbariException e) {
// Expected
}
}
@Test
public void testCreateClusterWithInvalidStack() {
// TODO implement test after meta data integration
}
@Test
public void testCreateClusterWithHostMapping() throws AmbariException {
Set<String> hostNames = new HashSet<String>();
hostNames.add("h1");
hostNames.add("h2");
ClusterRequest r = new ClusterRequest(null, "c1", "HDP-0.1", hostNames);
try {
controller.createCluster(r);
fail("Expected create cluster to fail for invalid hosts");
} catch (Exception e) {
// Expected
}
try {
clusters.getCluster("c1");
fail("Expected to fail for non created cluster");
} catch (ClusterNotFoundException e) {
// Expected
}
clusters.addHost("h1");
clusters.addHost("h2");
clusters.getHost("h1").setOsType("redhat6");
clusters.getHost("h2").setOsType("redhat6");
clusters.getHost("h1").persist();
clusters.getHost("h2").persist();
controller.createCluster(r);
Assert.assertNotNull(clusters.getCluster("c1"));
}
@Test
public void testCreateClusterWithDesiredClusterConfigs() {
// TODO implement after configs integration
}
@Test
public void testCreateClusterWithInvalidRequest() {
ClusterRequest r = new ClusterRequest(null, null, null, null);
r.toString();
try {
controller.createCluster(r);
fail("Expected create cluster for invalid request");
} catch (Exception e) {
// Expected
}
r.setClusterId(new Long(1));
try {
controller.createCluster(r);
fail("Expected create cluster for invalid request");
} catch (Exception e) {
// Expected
}
r.setClusterId(null);
r.setClusterName("foo");
try {
controller.createCluster(r);
fail("Expected create cluster for invalid request - no stack version");
} catch (Exception e) {
// Expected
}
}
@Test
public void testCreateServicesSimple() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
String serviceName = "HDFS";
clusters.getCluster("foo1").setDesiredStackVersion(
new StackId("HDP-0.1"));
createService(clusterName, serviceName, State.INIT);
Service s =
clusters.getCluster(clusterName).getService(serviceName);
Assert.assertNotNull(s);
Assert.assertEquals(serviceName, s.getName());
Assert.assertEquals(clusterName, s.getCluster().getClusterName());
ServiceRequest req = new ServiceRequest(clusterName, serviceName,
null, null);
Set<ServiceResponse> r =
controller.getServices(Collections.singleton(req));
Assert.assertEquals(1, r.size());
ServiceResponse resp = r.iterator().next();
Assert.assertEquals(serviceName, resp.getServiceName());
Assert.assertEquals(clusterName, resp.getClusterName());
Assert.assertEquals(State.INIT.toString(),
resp.getDesiredState());
Assert.assertEquals("HDP-0.1", resp.getDesiredStackVersion());
// TODO test resp.getConfigVersions()
}
@Test
public void testCreateServicesWithInvalidRequest() throws AmbariException {
// invalid request
// dups in requests
// multi cluster updates
Set<ServiceRequest> set1 = new HashSet<ServiceRequest>();
try {
set1.clear();
ServiceRequest rInvalid = new ServiceRequest(null, null, null, null);
set1.add(rInvalid);
controller.createServices(set1);
fail("Expected failure for invalid requests");
} catch (Exception e) {
// Expected
}
try {
set1.clear();
ServiceRequest rInvalid = new ServiceRequest("foo", null, null, null);
set1.add(rInvalid);
controller.createServices(set1);
fail("Expected failure for invalid requests");
} catch (Exception e) {
// Expected
}
try {
set1.clear();
ServiceRequest rInvalid = new ServiceRequest("foo", "bar", null, null);
set1.add(rInvalid);
controller.createServices(set1);
fail("Expected failure for invalid cluster");
} catch (ParentObjectNotFoundException e) {
// Expected
}
clusters.addCluster("foo");
clusters.addCluster("bar");
clusters.getCluster("foo").setDesiredStackVersion(new StackId("HDP-0.1"));
clusters.getCluster("bar").setDesiredStackVersion(new StackId("HDP-0.1"));
try {
set1.clear();
ServiceRequest valid1 = new ServiceRequest("foo", "HDFS", null, null);
ServiceRequest valid2 = new ServiceRequest("foo", "HDFS", null, null);
set1.add(valid1);
set1.add(valid2);
controller.createServices(set1);
fail("Expected failure for invalid requests");
} catch (Exception e) {
// Expected
}
try {
set1.clear();
ServiceRequest valid1 = new ServiceRequest("foo", "bar", null, null);
set1.add(valid1);
controller.createServices(set1);
fail("Expected failure for invalid service");
} catch (Exception e) {
// Expected
}
try {
set1.clear();
ServiceRequest valid1 = new ServiceRequest("foo", "HDFS", null, null);
ServiceRequest valid2 = new ServiceRequest("bar", "HDFS", null, null);
set1.add(valid1);
set1.add(valid2);
controller.createServices(set1);
fail("Expected failure for multiple clusters");
} catch (Exception e) {
// Expected
}
Assert.assertNotNull(clusters.getCluster("foo"));
Assert.assertEquals(0, clusters.getCluster("foo").getServices().size());
set1.clear();
ServiceRequest valid = new ServiceRequest("foo", "HDFS", null, null);
set1.add(valid);
controller.createServices(set1);
try {
set1.clear();
ServiceRequest valid1 = new ServiceRequest("foo", "HDFS", null, null);
ServiceRequest valid2 = new ServiceRequest("foo", "HDFS", null, null);
set1.add(valid1);
set1.add(valid2);
controller.createServices(set1);
fail("Expected failure for existing service");
} catch (Exception e) {
// Expected
}
Assert.assertEquals(1, clusters.getCluster("foo").getServices().size());
}
@Test
public void testCreateServiceWithInvalidInfo() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
String serviceName = "HDFS";
try {
createService(clusterName, serviceName, State.INSTALLING);
fail("Service creation should fail for invalid state");
} catch (Exception e) {
// Expected
}
try {
clusters.getCluster(clusterName).getService(serviceName);
fail("Service creation should have failed");
} catch (Exception e) {
// Expected
}
try {
createService(clusterName, serviceName, State.INSTALLED);
fail("Service creation should fail for invalid initial state");
} catch (Exception e) {
// Expected
}
createService(clusterName, serviceName, null);
String serviceName2 = "MAPREDUCE";
createService(clusterName, serviceName2, State.INIT);
ServiceRequest r = new ServiceRequest(clusterName, null, null, null);
Set<ServiceResponse> response = controller.getServices(Collections.singleton(r));
Assert.assertEquals(2, response.size());
for (ServiceResponse svc : response) {
Assert.assertTrue(svc.getServiceName().equals(serviceName)
|| svc.getServiceName().equals(serviceName2));
Assert.assertEquals("HDP-0.1", svc.getDesiredStackVersion());
Assert.assertEquals(State.INIT.toString(), svc.getDesiredState());
}
}
@Test
public void testCreateServicesMultiple() throws AmbariException {
Set<ServiceRequest> set1 = new HashSet<ServiceRequest>();
clusters.addCluster("foo");
clusters.getCluster("foo").setDesiredStackVersion(new StackId("HDP-0.1"));
ServiceRequest valid1 = new ServiceRequest("foo", "HDFS", null, null);
ServiceRequest valid2 = new ServiceRequest("foo", "MAPREDUCE", null, null);
set1.add(valid1);
set1.add(valid2);
controller.createServices(set1);
try {
valid1 = new ServiceRequest("foo", "bar", null, null);
valid2 = new ServiceRequest("foo", "MAPREDUCE", null, null);
set1.add(valid1);
set1.add(valid2);
controller.createServices(set1);
fail("Expected failure for invalid services");
} catch (DuplicateResourceException e) {
// Expected
}
Assert.assertNotNull(clusters.getCluster("foo"));
Assert.assertEquals(2, clusters.getCluster("foo").getServices().size());
Assert.assertNotNull(clusters.getCluster("foo").getService("HDFS"));
Assert.assertNotNull(clusters.getCluster("foo").getService("MAPREDUCE"));
}
@Test
public void testCreateServiceComponentSimple() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName = "NAMENODE";
try {
createServiceComponent(clusterName, serviceName, componentName,
State.INSTALLING);
fail("ServiceComponent creation should fail for invalid state");
} catch (Exception e) {
// Expected
}
try {
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponent(componentName);
fail("ServiceComponent creation should have failed");
} catch (Exception e) {
// Expected
}
createServiceComponent(clusterName, serviceName, componentName,
State.INIT);
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName).getServiceComponent(componentName));
ServiceComponentRequest r =
new ServiceComponentRequest(clusterName, serviceName, null, null, null);
Set<ServiceComponentResponse> response = controller.getComponents(Collections.singleton(r));
Assert.assertEquals(1, response.size());
ServiceComponentResponse sc = response.iterator().next();
Assert.assertEquals(State.INIT.toString(), sc.getDesiredState());
Assert.assertEquals(componentName, sc.getComponentName());
Assert.assertEquals(clusterName, sc.getClusterName());
Assert.assertEquals(serviceName, sc.getServiceName());
}
@Test
public void testCreateServiceComponentWithInvalidRequest()
throws AmbariException {
// multiple clusters
// dup objects
// existing components
// invalid request params
// invalid service
// invalid cluster
Set<ServiceComponentRequest> set1 = new HashSet<ServiceComponentRequest>();
try {
set1.clear();
ServiceComponentRequest rInvalid =
new ServiceComponentRequest(null, null, null, null, null);
set1.add(rInvalid);
controller.createComponents(set1);
fail("Expected failure for invalid requests");
} catch (Exception e) {
// Expected
}
try {
set1.clear();
ServiceComponentRequest rInvalid =
new ServiceComponentRequest("c1", null, null, null, null);
set1.add(rInvalid);
controller.createComponents(set1);
fail("Expected failure for invalid requests");
} catch (Exception e) {
// Expected
}
try {
set1.clear();
ServiceComponentRequest rInvalid =
new ServiceComponentRequest("c1", "s1", null, null, null);
set1.add(rInvalid);
controller.createComponents(set1);
fail("Expected failure for invalid requests");
} catch (Exception e) {
// Expected
}
try {
set1.clear();
ServiceComponentRequest rInvalid =
new ServiceComponentRequest("c1", "s1", "sc1", null, null);
set1.add(rInvalid);
controller.createComponents(set1);
fail("Expected failure for invalid cluster");
} catch (ParentObjectNotFoundException e) {
// Expected
}
clusters.addCluster("c1");
clusters.addCluster("c2");
try {
set1.clear();
ServiceComponentRequest rInvalid =
new ServiceComponentRequest("c1", "HDFS", "NAMENODE", null, null);
set1.add(rInvalid);
controller.createComponents(set1);
fail("Expected failure for invalid service");
} catch (ParentObjectNotFoundException e) {
// Expected
}
Cluster c1 = clusters.getCluster("c1");
c1.setDesiredStackVersion(new StackId("HDP-0.1"));
Service s1 = serviceFactory.createNew(c1, "HDFS");
Service s2 = serviceFactory.createNew(c1, "MAPREDUCE");
c1.addService(s1);
c1.addService(s2);
s1.persist();
s2.persist();
set1.clear();
ServiceComponentRequest valid1 =
new ServiceComponentRequest("c1", "HDFS", "NAMENODE", null, null);
ServiceComponentRequest valid2 =
new ServiceComponentRequest("c1", "MAPREDUCE", "JOBTRACKER", null, null);
ServiceComponentRequest valid3 =
new ServiceComponentRequest("c1", "MAPREDUCE", "TASKTRACKER", null,
null);
set1.add(valid1);
set1.add(valid2);
set1.add(valid3);
controller.createComponents(set1);
try {
set1.clear();
ServiceComponentRequest rInvalid1 =
new ServiceComponentRequest("c1", "HDFS", "HDFS_CLIENT", null, null);
ServiceComponentRequest rInvalid2 =
new ServiceComponentRequest("c1", "HDFS", "HDFS_CLIENT", null, null);
set1.add(rInvalid1);
set1.add(rInvalid2);
controller.createComponents(set1);
fail("Expected failure for dups in requests");
} catch (Exception e) {
// Expected
}
try {
set1.clear();
ServiceComponentRequest rInvalid1 =
new ServiceComponentRequest("c1", "HDFS", "HDFS_CLIENT", null, null);
ServiceComponentRequest rInvalid2 =
new ServiceComponentRequest("c2", "HDFS", "HDFS_CLIENT", null, null);
set1.add(rInvalid1);
set1.add(rInvalid2);
controller.createComponents(set1);
fail("Expected failure for multiple clusters");
} catch (Exception e) {
// Expected
}
try {
set1.clear();
ServiceComponentRequest rInvalid =
new ServiceComponentRequest("c1", "HDFS", "NAMENODE", null, null);
set1.add(rInvalid);
controller.createComponents(set1);
fail("Expected failure for already existing component");
} catch (Exception e) {
// Expected
}
Assert.assertEquals(1, s1.getServiceComponents().size());
Assert.assertNotNull(s1.getServiceComponent("NAMENODE"));
Assert.assertEquals(2, s2.getServiceComponents().size());
Assert.assertNotNull(s2.getServiceComponent("JOBTRACKER"));
Assert.assertNotNull(s2.getServiceComponent("TASKTRACKER"));
}
@Test
public void testCreateServiceComponentWithConfigs() {
// FIXME after config impl
}
@Test
public void testCreateServiceComponentMultiple() throws AmbariException {
clusters.addCluster("c1");
clusters.addCluster("c2");
Cluster c1 = clusters.getCluster("c1");
c1.setDesiredStackVersion(new StackId("HDP-0.2"));
Service s1 = serviceFactory.createNew(c1, "HDFS");
Service s2 = serviceFactory.createNew(c1, "MAPREDUCE");
c1.addService(s1);
c1.addService(s2);
s1.persist();
s2.persist();
Set<ServiceComponentRequest> set1 = new HashSet<ServiceComponentRequest>();
ServiceComponentRequest valid1 =
new ServiceComponentRequest("c1", "HDFS", "NAMENODE", null, null);
ServiceComponentRequest valid2 =
new ServiceComponentRequest("c1", "MAPREDUCE", "JOBTRACKER", null, null);
ServiceComponentRequest valid3 =
new ServiceComponentRequest("c1", "MAPREDUCE", "TASKTRACKER", null,
null);
set1.add(valid1);
set1.add(valid2);
set1.add(valid3);
controller.createComponents(set1);
Assert.assertEquals(1, c1.getService("HDFS").getServiceComponents().size());
Assert.assertEquals(2, c1.getService("MAPREDUCE").getServiceComponents().size());
Assert.assertNotNull(c1.getService("HDFS")
.getServiceComponent("NAMENODE"));
Assert.assertNotNull(c1.getService("MAPREDUCE")
.getServiceComponent("JOBTRACKER"));
Assert.assertNotNull(c1.getService("MAPREDUCE")
.getServiceComponent("TASKTRACKER"));
}
@Test
public void testCreateServiceComponentHostSimple() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h2").persist();
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h2").setOsType("centos6");
try {
createServiceComponentHost(clusterName, serviceName, componentName1,
host1, State.INIT);
fail("ServiceComponentHost creation should fail for invalid host"
+ " as host not mapped to cluster");
} catch (Exception e) {
// Expected
}
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
try {
createServiceComponentHost(clusterName, serviceName, componentName1,
host1, State.INSTALLING);
fail("ServiceComponentHost creation should fail for invalid state");
} catch (Exception e) {
// Expected
e.printStackTrace();
}
try {
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponent(componentName1).getServiceComponentHost(host1);
fail("ServiceComponentHost creation should have failed earlier");
} catch (Exception e) {
// Expected
}
// null service should work
createServiceComponentHost(clusterName, null, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
try {
createServiceComponentHost(clusterName, serviceName, componentName1,
host1, null);
fail("ServiceComponentHost creation should fail as duplicate");
} catch (Exception e) {
// Expected
}
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName1)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName2)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName2)
.getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName3)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName3)
.getServiceComponentHost(host2));
ServiceComponentHostRequest r =
new ServiceComponentHostRequest(clusterName, serviceName,
componentName2, null, null, null);
Set<ServiceComponentHostResponse> response =
controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2, response.size());
}
@Test
public void testCreateServiceComponentHostMultiple()
throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
Set<ServiceComponentHostRequest> set1 =
new HashSet<ServiceComponentHostRequest>();
ServiceComponentHostRequest r1 =
new ServiceComponentHostRequest(clusterName, serviceName,
componentName1, host1, null, State.INIT.toString());
ServiceComponentHostRequest r2 =
new ServiceComponentHostRequest(clusterName, serviceName,
componentName2, host1, null, State.INIT.toString());
ServiceComponentHostRequest r3 =
new ServiceComponentHostRequest(clusterName, serviceName,
componentName1, host2, null, State.INIT.toString());
ServiceComponentHostRequest r4 =
new ServiceComponentHostRequest(clusterName, serviceName,
componentName2, host2, null, State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
set1.add(r4);
controller.createHostComponents(set1);
Assert.assertEquals(2,
clusters.getCluster(clusterName).getServiceComponentHosts(host1).size());
Assert.assertEquals(2,
clusters.getCluster(clusterName).getServiceComponentHosts(host2).size());
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName).getServiceComponent(componentName1)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName).getServiceComponent(componentName1)
.getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName).getServiceComponent(componentName2)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName).getServiceComponent(componentName2)
.getServiceComponentHost(host2));
}
@Test
public void testCreateServiceComponentHostWithInvalidRequest()
throws AmbariException {
// multiple clusters
// dup objects
// existing components
// invalid request params
// invalid service
// invalid cluster
// invalid component
// invalid host
Set<ServiceComponentHostRequest> set1 =
new HashSet<ServiceComponentHostRequest>();
try {
set1.clear();
ServiceComponentHostRequest rInvalid =
new ServiceComponentHostRequest(null, null, null, null, null, null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid requests");
} catch (IllegalArgumentException e) {
// Expected
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid =
new ServiceComponentHostRequest("foo", null, null, null, null, null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid requests");
} catch (IllegalArgumentException e) {
// Expected
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid =
new ServiceComponentHostRequest("foo", "HDFS", null, null,
null, null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid requests");
} catch (IllegalArgumentException e) {
// Expected
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", null,
null, null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid requests");
} catch (IllegalArgumentException e) {
// Expected
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h1",
null, null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid cluster");
} catch (ParentObjectNotFoundException e) {
// Expected
}
clusters.addCluster("foo");
clusters.addCluster("c1");
clusters.addCluster("c2");
Cluster foo = clusters.getCluster("foo");
Cluster c1 = clusters.getCluster("c1");
Cluster c2 = clusters.getCluster("c2");
foo.setDesiredStackVersion(new StackId("HDP-0.2"));
c1.setDesiredStackVersion(new StackId("HDP-0.2"));
c2.setDesiredStackVersion(new StackId("HDP-0.2"));
try {
set1.clear();
ServiceComponentHostRequest rInvalid =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h1",
null, null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid service");
} catch (IllegalArgumentException e) {
// Expected
}
Service s1 = serviceFactory.createNew(foo, "HDFS");
foo.addService(s1);
s1.persist();
Service s2 = serviceFactory.createNew(c1, "HDFS");
c1.addService(s2);
s2.persist();
Service s3 = serviceFactory.createNew(c2, "HDFS");
c2.addService(s3);
s3.persist();
try {
set1.clear();
ServiceComponentHostRequest rInvalid =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h1",
null, null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid service");
} catch (AmbariException e) {
// Expected
}
ServiceComponent sc1 = serviceComponentFactory.createNew(s1, "NAMENODE");
s1.addServiceComponent(sc1);
sc1.persist();
ServiceComponent sc2 = serviceComponentFactory.createNew(s2, "NAMENODE");
s2.addServiceComponent(sc2);
sc2.persist();
ServiceComponent sc3 = serviceComponentFactory.createNew(s3, "NAMENODE");
s3.addServiceComponent(sc3);
sc3.persist();
try {
set1.clear();
ServiceComponentHostRequest rInvalid =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h1",
null, null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid host");
} catch (AmbariException e) {
// Expected
}
clusters.addHost("h1");
Host h1 = clusters.getHost("h1");
h1.setIPv4("ipv41");
h1.setIPv6("ipv61");
h1.setOsType("centos6");
h1.persist();
clusters.addHost("h2");
Host h2 = clusters.getHost("h2");
h2.setIPv4("ipv42");
h2.setIPv6("ipv62");
h2.setOsType("centos6");
h2.persist();
clusters.addHost("h3");
Host h3 = clusters.getHost("h3");
h3.setIPv4("ipv43");
h3.setIPv6("ipv63");
h3.setOsType("centos6");
h3.persist();
try {
set1.clear();
ServiceComponentHostRequest rInvalid =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h1",
null, null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid host cluster mapping");
} catch (AmbariException e) {
// Expected
}
Set<String> hostnames = new HashSet<String>();
hostnames.add("h1");
hostnames.add("h2");
hostnames.add("h3");
clusters.mapHostsToCluster(hostnames, "foo");
clusters.mapHostsToCluster(hostnames, "c1");
clusters.mapHostsToCluster(hostnames, "c2");
set1.clear();
ServiceComponentHostRequest valid =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h1",
null, null);
set1.add(valid);
controller.createHostComponents(set1);
try {
set1.clear();
ServiceComponentHostRequest rInvalid1 =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h2",
null, null);
ServiceComponentHostRequest rInvalid2 =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h2",
null, null);
set1.add(rInvalid1);
set1.add(rInvalid2);
controller.createHostComponents(set1);
fail("Expected failure for dup requests");
} catch (DuplicateResourceException e) {
// Expected
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid1 =
new ServiceComponentHostRequest("c1", "HDFS", "NAMENODE", "h2",
null, null);
ServiceComponentHostRequest rInvalid2 =
new ServiceComponentHostRequest("c2", "HDFS", "NAMENODE", "h3",
null, null);
set1.add(rInvalid1);
set1.add(rInvalid2);
controller.createHostComponents(set1);
fail("Expected failure for multiple clusters");
} catch (IllegalArgumentException e) {
// Expected
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid1 =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h1",
null, null);
ServiceComponentHostRequest rInvalid2 =
new ServiceComponentHostRequest("foo", "HDFS", "NAMENODE", "h2",
null, null);
set1.add(rInvalid1);
set1.add(rInvalid2);
controller.createHostComponents(set1);
fail("Expected failure for already existing");
} catch (DuplicateResourceException e) {
// Expected
}
Assert.assertEquals(1, foo.getServiceComponentHosts("h1").size());
Assert.assertEquals(0, foo.getServiceComponentHosts("h2").size());
Assert.assertEquals(0, foo.getServiceComponentHosts("h3").size());
set1.clear();
ServiceComponentHostRequest valid1 =
new ServiceComponentHostRequest("c1", "HDFS", "NAMENODE", "h1",
null, null);
set1.add(valid1);
controller.createHostComponents(set1);
set1.clear();
ServiceComponentHostRequest valid2 =
new ServiceComponentHostRequest("c2", "HDFS", "NAMENODE", "h1",
null, null);
set1.add(valid2);
controller.createHostComponents(set1);
Assert.assertEquals(1, foo.getServiceComponentHosts("h1").size());
Assert.assertEquals(1, c1.getServiceComponentHosts("h1").size());
Assert.assertEquals(1, c2.getServiceComponentHosts("h1").size());
}
@Test
public void testCreateHostSimple() throws AmbariException {
Map<String, String> hostAttributes = null;
HostRequest r1 = new HostRequest("h1", null, hostAttributes);
r1.toString();
Set<HostRequest> requests = new HashSet<HostRequest>();
requests.add(r1);
try {
controller.createHosts(requests);
fail("Create host should fail for non-bootstrapped host");
} catch (Exception e) {
// Expected
}
clusters.addHost("h1");
clusters.addHost("h2");
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h1").persist();
clusters.getHost("h2").persist();
requests.add(new HostRequest("h2", "foo", new HashMap<String, String>()));
try {
controller.createHosts(requests);
fail("Create host should fail for invalid clusters");
} catch (Exception e) {
// Expected
}
clusters.addCluster("foo");
clusters.getCluster("foo").setDesiredStackVersion(new StackId("HDP-0.1"));
controller.createHosts(requests);
Assert.assertNotNull(clusters.getHost("h1"));
Assert.assertNotNull(clusters.getHost("h2"));
Assert.assertEquals(0, clusters.getClustersForHost("h1").size());
Assert.assertEquals(1, clusters.getClustersForHost("h2").size());
}
@Test
public void testCreateHostMultiple() throws AmbariException {
clusters.addHost("h1");
clusters.addHost("h2");
clusters.addHost("h3");
clusters.addCluster("c1");
clusters.getCluster("c1").setDesiredStackVersion(new StackId("HDP-0.1"));
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h3").setOsType("centos5");
clusters.getHost("h1").persist();
clusters.getHost("h2").persist();
clusters.getHost("h3").persist();
Map<String, String> hostAttrs =
new HashMap<String, String>();
hostAttrs.put("attr1", "val1");
hostAttrs.put("attr2", "val2");
String clusterName = "c1";
HostRequest r1 = new HostRequest("h1", clusterName, null);
HostRequest r2 = new HostRequest("h2", clusterName, hostAttrs);
HostRequest r3 = new HostRequest("h3", null, hostAttrs);
Set<HostRequest> set1 = new HashSet<HostRequest>();
set1.add(r1);
set1.add(r2);
set1.add(r3);
controller.createHosts(set1);
Assert.assertEquals(1, clusters.getClustersForHost("h1").size());
Assert.assertEquals(1, clusters.getClustersForHost("h2").size());
Assert.assertEquals(0, clusters.getClustersForHost("h3").size());
Assert.assertEquals(2, clusters.getHost("h2").getHostAttributes().size());
Assert.assertEquals(2, clusters.getHost("h3").getHostAttributes().size());
Assert.assertEquals("val1",
clusters.getHost("h2").getHostAttributes().get("attr1"));
Assert.assertEquals("val2",
clusters.getHost("h2").getHostAttributes().get("attr2"));
}
@Test
public void testCreateHostWithInvalidRequests() throws AmbariException {
// unknown host
// invalid clusters
// duplicate host
Set<HostRequest> set1 = new HashSet<HostRequest>();
try {
set1.clear();
HostRequest rInvalid =
new HostRequest("h1", null, null);
set1.add(rInvalid);
controller.createHosts(set1);
fail("Expected failure for invalid host");
} catch (Exception e) {
// Expected
}
clusters.addHost("h1");
String clusterName = "c1";
try {
set1.clear();
HostRequest rInvalid =
new HostRequest("h1", clusterName, null);
set1.add(rInvalid);
controller.createHosts(set1);
fail("Expected failure for invalid cluster");
} catch (Exception e) {
// Expected
}
clusters.addCluster("c1");
try {
set1.clear();
HostRequest rInvalid1 =
new HostRequest("h1", clusterName, null);
HostRequest rInvalid2 =
new HostRequest("h1", clusterName, null);
set1.add(rInvalid1);
set1.add(rInvalid2);
controller.createHosts(set1);
fail("Expected failure for dup requests");
} catch (Exception e) {
// Expected
}
}
@Test
public void testInstallAndStartService() throws Exception {
testCreateServiceComponentHostSimple();
String clusterName = "foo1";
String serviceName = "HDFS";
Cluster cluster = clusters.getCluster(clusterName);
Service s1 = cluster.getService(serviceName);
Map<String, Config> configs = new HashMap<String, Config>();
Map<String, String> properties = new HashMap<String, String>();
properties.put("a", "a1");
properties.put("b", "b1");
Config c1 = new ConfigImpl(cluster, "hdfs-site", properties, injector);
properties.put("c", "c1");
properties.put("d", "d1");
Config c2 = new ConfigImpl(cluster, "core-site", properties, injector);
Config c3 = new ConfigImpl(cluster, "foo-site", properties, injector);
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
c1.setVersionTag("v1");
c2.setVersionTag("v1");
c3.setVersionTag("v1");
cluster.addConfig(c1);
cluster.addConfig(c2);
cluster.addConfig(c3);
c1.persist();
c2.persist();
c3.persist();
configs.put(c1.getType(), c1);
configs.put(c2.getType(), c2);
s1.updateDesiredConfigs(configs);
s1.persist();
ServiceRequest r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r);
RequestStatusResponse trackAction =
controller.updateServices(requests, mapRequestProps, true, false);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
Assert.assertEquals(State.INSTALLED, sc.getDesiredState());
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INSTALLED, sch.getDesiredState());
Assert.assertEquals(State.INIT, sch.getState());
}
}
List<ShortTaskStatus> taskStatuses = trackAction.getTasks();
Assert.assertEquals(5, taskStatuses.size());
boolean foundH1NN = false;
boolean foundH1DN = false;
boolean foundH2DN = false;
boolean foundH1CLT = false;
boolean foundH2CLT = false;
for (ShortTaskStatus taskStatus : taskStatuses) {
LOG.debug("Task dump :"
+ taskStatus.toString());
Assert.assertEquals(RoleCommand.INSTALL.toString(),
taskStatus.getCommand());
Assert.assertEquals(HostRoleStatus.PENDING.toString(),
taskStatus.getStatus());
if (taskStatus.getHostName().equals("h1")) {
if (Role.NAMENODE.toString().equals(taskStatus.getRole())) {
foundH1NN = true;
} else if (Role.DATANODE.toString().equals(taskStatus.getRole())) {
foundH1DN = true;
} else if (Role.HDFS_CLIENT.toString().equals(taskStatus.getRole())) {
foundH1CLT = true;
} else {
fail("Found invalid role for host h1");
}
} else if (taskStatus.getHostName().equals("h2")) {
if (Role.DATANODE.toString().equals(taskStatus.getRole())) {
foundH2DN = true;
} else if (Role.HDFS_CLIENT.toString().equals(taskStatus.getRole())) {
foundH2CLT = true;
} else {
fail("Found invalid role for host h2");
}
} else {
fail("Found invalid host in task list");
}
}
Assert.assertTrue(foundH1DN && foundH1NN && foundH2DN
&& foundH1CLT && foundH2CLT);
// TODO validate stages?
List<Stage> stages = actionDB.getAllStages(trackAction.getRequestId());
Assert.assertEquals(1, stages.size());
for (Stage stage : stages) {
LOG.info("Stage Details for Install Service"
+ ", stageId="+ stage.getStageId()
+ ", actionId=" + stage.getActionId());
for (String host : stage.getHosts()) {
for (ExecutionCommandWrapper ecw : stage.getExecutionCommands(host)) {
Assert.assertFalse(
ecw.getExecutionCommand().getHostLevelParams().get("repo_info").isEmpty());
LOG.info("Dumping host action details"
+ ", stageId=" + stage.getStageId()
+ ", actionId=" + stage.getActionId()
+ ", commandDetails="
+ StageUtils.jaxbToString(ecw.getExecutionCommand()));
}
}
}
RequestStatusRequest statusRequest =
new RequestStatusRequest(trackAction.getRequestId(), null);
Set<RequestStatusResponse> statusResponses =
controller.getRequestStatus(statusRequest);
Assert.assertEquals(1, statusResponses.size());
RequestStatusResponse statusResponse =
statusResponses.iterator().next();
Assert.assertNotNull(statusResponse);
Assert.assertEquals(trackAction.getRequestId(),
statusResponse.getRequestId());
Set<TaskStatusRequest> taskRequests = new HashSet<TaskStatusRequest>();
TaskStatusRequest t1, t2;
t1 = new TaskStatusRequest();
t2 = new TaskStatusRequest();
t1.setRequestId(trackAction.getRequestId());
taskRequests.add(t1);
Set<TaskStatusResponse> taskResponses =
controller.getTaskStatus(taskRequests);
Assert.assertEquals(5, taskResponses.size());
t1.setTaskId(1L);
t2.setRequestId(trackAction.getRequestId());
t2.setTaskId(2L);
taskRequests.clear();
taskRequests.add(t1);
taskRequests.add(t2);
taskResponses = controller.getTaskStatus(taskRequests);
Assert.assertEquals(2, taskResponses.size());
// manually change live state to installed as no running action manager
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
r = new ServiceRequest(clusterName, serviceName, null,
State.STARTED.toString());
requests.clear();
requests.add(r);
trackAction = controller.updateServices(requests, mapRequestProps, true,
false);
Assert.assertEquals(State.STARTED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
if (sc.getName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED, sc.getDesiredState());
} else {
Assert.assertEquals(State.STARTED, sc.getDesiredState());
}
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (sch.getServiceComponentName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED, sch.getDesiredState());
} else {
Assert.assertEquals(State.STARTED, sch.getDesiredState());
}
}
}
// TODO validate stages?
stages = actionDB.getAllStages(trackAction.getRequestId());
Assert.assertEquals(2, stages.size());
for (Stage stage : stages) {
LOG.info("Stage Details for Start Service"
+ ", stageId="+ stage.getStageId()
+ ", actionId=" + stage.getActionId());
for (String host : stage.getHosts()) {
LOG.info("Dumping host action details"
+ ", stageId=" + stage.getStageId()
+ ", actionId=" + stage.getActionId()
+ ", commandDetails="
+ StageUtils.jaxbToString(stage.getExecutionCommands(host).get(0)));
}
}
StringBuilder sb = new StringBuilder();
clusters.debugDump(sb);
LOG.info("Cluster Dump: " + sb.toString());
statusRequest = new RequestStatusRequest(null, null);
statusResponses = controller.getRequestStatus(statusRequest);
Assert.assertEquals(2, statusResponses.size());
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (sc.isClientComponent()) {
sch.setState(State.INSTALLED);
} else {
sch.setState(State.INSTALL_FAILED);
}
}
}
r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
requests.clear();
requests.add(r);
trackAction = controller.updateServices(requests, mapRequestProps, true,
false);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
Assert.assertEquals(State.INSTALLED, sc.getDesiredState());
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INSTALLED, sch.getDesiredState());
}
}
// TODO validate stages?
stages = actionDB.getAllStages(trackAction.getRequestId());
for (Stage stage : stages) {
LOG.info("Stage Details for Stop Service : " + stage.toString());
}
Assert.assertEquals(1, stages.size());
}
@Test
public void testGetClusters() throws AmbariException {
clusters.addCluster("c1");
Cluster c1 = clusters.getCluster("c1");
c1.setDesiredStackVersion(new StackId("HDP-0.1"));
ClusterRequest r = new ClusterRequest(null, null, null, null);
Set<ClusterResponse> resp = controller.getClusters(Collections.singleton(r));
Assert.assertEquals(1, resp.size());
ClusterResponse resp1 = resp.iterator().next();
Assert.assertEquals(c1.getClusterId(), resp1.getClusterId().longValue());
Assert.assertEquals(c1.getClusterName(), resp1.getClusterName());
Assert.assertEquals(c1.getDesiredStackVersion().getStackId(),
resp1.getDesiredStackVersion());
}
@Test
public void testGetClustersWithFilters() throws AmbariException {
clusters.addCluster("c1");
clusters.addCluster("c2");
clusters.addCluster("c3");
clusters.addCluster("c4");
Cluster c1 = clusters.getCluster("c1");
Cluster c2 = clusters.getCluster("c2");
Cluster c3 = clusters.getCluster("c3");
Cluster c4 = clusters.getCluster("c4");
c1.setDesiredStackVersion(new StackId("HDP-0.1"));
c2.setDesiredStackVersion(new StackId("HDP-0.1"));
c3.setDesiredStackVersion(new StackId("HDP-1.1.0"));
ClusterRequest r = new ClusterRequest(null, null, null, null);
Set<ClusterResponse> resp = controller.getClusters(Collections.singleton(r));
Assert.assertEquals(4, resp.size());
r = new ClusterRequest(null, "c1", null, null);
resp = controller.getClusters(Collections.singleton(r));
Assert.assertEquals(1, resp.size());
Assert.assertEquals(c1.getClusterId(),
resp.iterator().next().getClusterId().longValue());
r = new ClusterRequest(null, null, "HDP-0.1", null);
resp = controller.getClusters(Collections.singleton(r));
Assert.assertEquals(2, resp.size());
r = new ClusterRequest(null, null, "", null);
resp = controller.getClusters(Collections.singleton(r));
Assert.assertEquals(1, resp.size());
Assert.assertEquals(c4.getClusterId(),
resp.iterator().next().getClusterId().longValue());
}
@Test
public void testGetServices() throws AmbariException {
clusters.addCluster("c1");
Cluster c1 = clusters.getCluster("c1");
c1.setDesiredStackVersion(new StackId("HDP-0.1"));
Service s1 = serviceFactory.createNew(c1, "HDFS");
c1.addService(s1);
s1.setDesiredStackVersion(new StackId("HDP-0.1"));
s1.setDesiredState(State.INSTALLED);
s1.persist();
ServiceRequest r = new ServiceRequest("c1", null, null, null);
Set<ServiceResponse> resp = controller.getServices(Collections.singleton(r));
ServiceResponse resp1 = resp.iterator().next();
Assert.assertEquals(s1.getClusterId(), resp1.getClusterId().longValue());
Assert.assertEquals(s1.getCluster().getClusterName(),
resp1.getClusterName());
Assert.assertEquals(s1.getName(), resp1.getServiceName());
Assert.assertEquals("HDP-0.1", s1.getDesiredStackVersion().getStackId());
Assert.assertEquals(s1.getDesiredStackVersion().getStackId(),
resp1.getDesiredStackVersion());
Assert.assertEquals(State.INSTALLED.toString(), resp1.getDesiredState());
}
@Test
public void testGetServicesWithFilters() throws AmbariException {
clusters.addCluster("c1");
clusters.addCluster("c2");
Cluster c1 = clusters.getCluster("c1");
Cluster c2 = clusters.getCluster("c2");
c1.setDesiredStackVersion(new StackId("HDP-0.2"));
c2.setDesiredStackVersion(new StackId("HDP-0.2"));
Service s1 = serviceFactory.createNew(c1, "HDFS");
Service s2 = serviceFactory.createNew(c1, "MAPREDUCE");
Service s3 = serviceFactory.createNew(c1, "HBASE");
Service s4 = serviceFactory.createNew(c2, "HIVE");
Service s5 = serviceFactory.createNew(c2, "ZOOKEEPER");
c1.addService(s1);
c1.addService(s2);
c1.addService(s3);
c2.addService(s4);
c2.addService(s5);
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
s4.setDesiredState(State.INSTALLED);
s1.persist();
s2.persist();
s3.persist();
s4.persist();
s5.persist();
ServiceRequest r = new ServiceRequest(null, null, null, null);
Set<ServiceResponse> resp;
try {
controller.getServices(Collections.singleton(r));
fail("Expected failure for invalid request");
} catch (Exception e) {
// Expected
}
r = new ServiceRequest(c1.getClusterName(), null, null, null);
resp = controller.getServices(Collections.singleton(r));
Assert.assertEquals(3, resp.size());
r = new ServiceRequest(c1.getClusterName(), s2.getName(), null, null);
resp = controller.getServices(Collections.singleton(r));
Assert.assertEquals(1, resp.size());
Assert.assertEquals(s2.getName(), resp.iterator().next().getServiceName());
try {
r = new ServiceRequest(c2.getClusterName(), s1.getName(), null, null);
controller.getServices(Collections.singleton(r));
fail("Expected failure for invalid service");
} catch (Exception e) {
// Expected
}
r = new ServiceRequest(c1.getClusterName(), null, null, "INSTALLED");
resp = controller.getServices(Collections.singleton(r));
Assert.assertEquals(2, resp.size());
r = new ServiceRequest(c2.getClusterName(), null, null, "INIT");
resp = controller.getServices(Collections.singleton(r));
Assert.assertEquals(1, resp.size());
ServiceRequest r1, r2, r3;
r1 = new ServiceRequest(c1.getClusterName(), null, null, "INSTALLED");
r2 = new ServiceRequest(c2.getClusterName(), null, null, "INIT");
r3 = new ServiceRequest(c2.getClusterName(), null, null, "INIT");
Set<ServiceRequest> reqs = new HashSet<ServiceRequest>();
reqs.addAll(Arrays.asList(r1, r2, r3));
resp = controller.getServices(reqs);
Assert.assertEquals(3, resp.size());
}
@Test
public void testGetServiceComponents() throws AmbariException {
clusters.addCluster("c1");
Cluster c1 = clusters.getCluster("c1");
c1.setDesiredStackVersion(new StackId("HDP-0.2"));
Service s1 = serviceFactory.createNew(c1, "HDFS");
c1.addService(s1);
s1.setDesiredState(State.INSTALLED);
s1.persist();
ServiceComponent sc1 = serviceComponentFactory.createNew(s1, "DATANODE");
s1.addServiceComponent(sc1);
sc1.persist();
sc1.setDesiredStackVersion(new StackId("HDP-0.1"));
sc1.setDesiredState(State.UNINSTALLED);
ServiceComponentRequest r = new ServiceComponentRequest("c1",
s1.getName(), sc1.getName(), null, null);
Set<ServiceComponentResponse> resps = controller.getComponents(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
ServiceComponentResponse resp = resps.iterator().next();
Assert.assertEquals(c1.getClusterName(), resp.getClusterName());
Assert.assertEquals(sc1.getName(), resp.getComponentName());
Assert.assertEquals(s1.getName(), resp.getServiceName());
Assert.assertEquals("HDP-0.1", resp.getDesiredStackVersion());
Assert.assertEquals(sc1.getDesiredState().toString(),
resp.getDesiredState());
Assert.assertEquals(c1.getClusterId(), resp.getClusterId().longValue());
}
@Test
public void testGetServiceComponentsWithFilters() throws AmbariException {
clusters.addCluster("c1");
clusters.addCluster("c2");
Cluster c1 = clusters.getCluster("c1");
Cluster c2 = clusters.getCluster("c2");
c1.setDesiredStackVersion(new StackId("HDP-0.2"));
c2.setDesiredStackVersion(new StackId("HDP-0.2"));
Service s1 = serviceFactory.createNew(c1, "HDFS");
Service s2 = serviceFactory.createNew(c1, "MAPREDUCE");
Service s3 = serviceFactory.createNew(c1, "HBASE");
Service s4 = serviceFactory.createNew(c2, "HIVE");
Service s5 = serviceFactory.createNew(c2, "ZOOKEEPER");
c1.addService(s1);
c1.addService(s2);
c1.addService(s3);
c2.addService(s4);
c2.addService(s5);
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
s4.setDesiredState(State.INSTALLED);
s1.persist();
s2.persist();
s3.persist();
s4.persist();
s5.persist();
ServiceComponent sc1 = serviceComponentFactory.createNew(s1, "DATANODE");
ServiceComponent sc2 = serviceComponentFactory.createNew(s1, "NAMENODE");
ServiceComponent sc3 = serviceComponentFactory.createNew(s3,
"HBASE_REGIONSERVER");
ServiceComponent sc4 = serviceComponentFactory.createNew(s4, "HIVE_SERVER");
ServiceComponent sc5 = serviceComponentFactory.createNew(s4, "HIVE_CLIENT");
ServiceComponent sc6 = serviceComponentFactory.createNew(s4,
"MYSQL_SERVER");
ServiceComponent sc7 = serviceComponentFactory.createNew(s5,
"ZOOKEEPER_SERVER");
ServiceComponent sc8 = serviceComponentFactory.createNew(s5,
"ZOOKEEPER_CLIENT");
s1.addServiceComponent(sc1);
s1.addServiceComponent(sc2);
s3.addServiceComponent(sc3);
s4.addServiceComponent(sc4);
s4.addServiceComponent(sc5);
s4.addServiceComponent(sc6);
s5.addServiceComponent(sc7);
s5.addServiceComponent(sc8);
sc1.setDesiredState(State.UNINSTALLED);
sc3.setDesiredState(State.UNINSTALLED);
sc5.setDesiredState(State.UNINSTALLED);
sc6.setDesiredState(State.UNINSTALLED);
sc7.setDesiredState(State.UNINSTALLED);
sc8.setDesiredState(State.UNINSTALLED);
sc1.persist();
sc2.persist();
sc3.persist();
sc4.persist();
sc5.persist();
sc6.persist();
sc7.persist();
sc8.persist();
ServiceComponentRequest r = new ServiceComponentRequest(null, null,
null, null, null);
try {
controller.getComponents(Collections.singleton(r));
fail("Expected failure for invalid cluster");
} catch (Exception e) {
// Expected
}
// all comps per cluster
r = new ServiceComponentRequest(c1.getClusterName(),
null, null, null, null);
Set<ServiceComponentResponse> resps = controller.getComponents(Collections.singleton(r));
Assert.assertEquals(3, resps.size());
// all comps per cluster filter on state
r = new ServiceComponentRequest(c2.getClusterName(),
null, null, null, State.UNINSTALLED.toString());
resps = controller.getComponents(Collections.singleton(r));
Assert.assertEquals(4, resps.size());
// all comps for given service
r = new ServiceComponentRequest(c2.getClusterName(),
s5.getName(), null, null, null);
resps = controller.getComponents(Collections.singleton(r));
Assert.assertEquals(2, resps.size());
// all comps for given service filter by state
r = new ServiceComponentRequest(c2.getClusterName(),
s4.getName(), null, null, State.INIT.toString());
resps = controller.getComponents(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
Assert.assertEquals(sc4.getName(),
resps.iterator().next().getComponentName());
// get single given comp
r = new ServiceComponentRequest(c2.getClusterName(),
null, sc5.getName(), null, State.INIT.toString());
resps = controller.getComponents(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
Assert.assertEquals(sc5.getName(),
resps.iterator().next().getComponentName());
// get single given comp and given svc
r = new ServiceComponentRequest(c2.getClusterName(),
s4.getName(), sc5.getName(), null, State.INIT.toString());
resps = controller.getComponents(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
Assert.assertEquals(sc5.getName(),
resps.iterator().next().getComponentName());
ServiceComponentRequest r1, r2, r3;
Set<ServiceComponentRequest> reqs = new HashSet<ServiceComponentRequest>();
r1 = new ServiceComponentRequest(c2.getClusterName(),
null, null, null, State.UNINSTALLED.toString());
r2 = new ServiceComponentRequest(c1.getClusterName(),
null, null, null, null);
r3 = new ServiceComponentRequest(c1.getClusterName(),
null, null, null, State.INIT.toString());
reqs.addAll(Arrays.asList(r1, r2, r3));
resps = controller.getComponents(reqs);
Assert.assertEquals(7, resps.size());
}
@Test
public void testGetServiceComponentHosts() throws AmbariException {
clusters.addCluster("c1");
Cluster c1 = clusters.getCluster("c1");
c1.setDesiredStackVersion(new StackId("HDP-0.1"));
clusters.addHost("h1");
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
clusters.mapHostToCluster("h1", "c1");
Service s1 = serviceFactory.createNew(c1, "HDFS");
c1.addService(s1);
s1.persist();
ServiceComponent sc1 = serviceComponentFactory.createNew(s1, "DATANODE");
s1.addServiceComponent(sc1);
sc1.setDesiredState(State.UNINSTALLED);
sc1.persist();
ServiceComponentHost sch1 = serviceComponentHostFactory.createNew(sc1, "h1",
false);
sc1.addServiceComponentHost(sch1);
sch1.setDesiredState(State.INSTALLED);
sch1.setState(State.INSTALLING);
sch1.setDesiredStackVersion(new StackId("HDP-1.1.0"));
sch1.setStackVersion(new StackId("HDP-0.1"));
sch1.persist();
sch1.updateActualConfigs(new HashMap<String, Map<String,String>>() {{
put("global", new HashMap<String,String>() {{ put("tag", "version1"); }});
}});
ServiceComponentHostRequest r =
new ServiceComponentHostRequest(c1.getClusterName(),
null, null, null, null, null);
Set<ServiceComponentHostResponse> resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
ServiceComponentHostResponse resp =
resps.iterator().next();
Assert.assertEquals(c1.getClusterName(), resp.getClusterName());
Assert.assertEquals(sc1.getName(), resp.getComponentName());
Assert.assertEquals(s1.getName(), resp.getServiceName());
Assert.assertEquals(sch1.getHostName(), resp.getHostname());
Assert.assertEquals(sch1.getDesiredState().toString(),
resp.getDesiredState());
Assert.assertEquals(sch1.getState().toString(),
resp.getLiveState());
Assert.assertEquals(sch1.getStackVersion().getStackId(),
resp.getStackVersion());
Assert.assertNotNull(resp.getActualConfigs());
Assert.assertEquals(1, resp.getActualConfigs().size());
}
@Test
public void testGetServiceComponentHostsWithFilters() throws AmbariException {
clusters.addCluster("c1");
Cluster c1 = clusters.getCluster("c1");
c1.setDesiredStackVersion(new StackId("HDP-0.2"));
clusters.addHost("h1");
clusters.addHost("h2");
clusters.addHost("h3");
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h3").setOsType("centos5");
clusters.getHost("h1").persist();
clusters.getHost("h2").persist();
clusters.getHost("h3").persist();
clusters.mapHostToCluster("h1", "c1");
clusters.mapHostToCluster("h2", "c1");
clusters.mapHostToCluster("h3", "c1");
Service s1 = serviceFactory.createNew(c1, "HDFS");
Service s2 = serviceFactory.createNew(c1, "MAPREDUCE");
Service s3 = serviceFactory.createNew(c1, "HBASE");
c1.addService(s1);
c1.addService(s2);
c1.addService(s3);
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
s1.persist();
s2.persist();
s3.persist();
ServiceComponent sc1 = serviceComponentFactory.createNew(s1, "DATANODE");
ServiceComponent sc2 = serviceComponentFactory.createNew(s1, "NAMENODE");
ServiceComponent sc3 = serviceComponentFactory.createNew(s3,
"HBASE_REGIONSERVER");
s1.addServiceComponent(sc1);
s1.addServiceComponent(sc2);
s3.addServiceComponent(sc3);
sc1.setDesiredState(State.UNINSTALLED);
sc3.setDesiredState(State.UNINSTALLED);
sc1.persist();
sc2.persist();
sc3.persist();
ServiceComponentHost sch1 = serviceComponentHostFactory.createNew(sc1, "h1",
false);
ServiceComponentHost sch2 = serviceComponentHostFactory.createNew(sc1, "h2",
false);
ServiceComponentHost sch3 = serviceComponentHostFactory.createNew(sc1, "h3",
false);
ServiceComponentHost sch4 = serviceComponentHostFactory.createNew(sc2, "h1",
false);
ServiceComponentHost sch5 = serviceComponentHostFactory.createNew(sc2, "h2",
false);
ServiceComponentHost sch6 = serviceComponentHostFactory.createNew(sc3, "h3",
false);
sc1.addServiceComponentHost(sch1);
sc1.addServiceComponentHost(sch2);
sc1.addServiceComponentHost(sch3);
sc2.addServiceComponentHost(sch4);
sc2.addServiceComponentHost(sch5);
sc3.addServiceComponentHost(sch6);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INIT);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.UNINSTALLED);
sch1.persist();
sch2.persist();
sch3.persist();
sch4.persist();
sch5.persist();
sch6.persist();
ServiceComponentHostRequest r =
new ServiceComponentHostRequest(null, null, null, null, null, null);
try {
controller.getHostComponents(Collections.singleton(r));
fail("Expected failure for invalid cluster");
} catch (Exception e) {
// Expected
}
// all across cluster
r = new ServiceComponentHostRequest(c1.getClusterName(), null,
null, null, null, null);
Set<ServiceComponentHostResponse> resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(6, resps.size());
// all for service
r = new ServiceComponentHostRequest(c1.getClusterName(), s1.getName(),
null, null, null, null);
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(5, resps.size());
// all for component
r = new ServiceComponentHostRequest(c1.getClusterName(), null,
sc3.getName(), null, null, null);
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
// all for host
r = new ServiceComponentHostRequest(c1.getClusterName(), null,
null, "h2", null, null);
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2, resps.size());
// all across cluster with state filter
r = new ServiceComponentHostRequest(c1.getClusterName(), null,
null, null, null, State.UNINSTALLED.toString());
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
// all for service with state filter
r = new ServiceComponentHostRequest(c1.getClusterName(), s1.getName(),
null, null, null, State.INIT.toString());
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2, resps.size());
// all for component with state filter
r = new ServiceComponentHostRequest(c1.getClusterName(), null,
sc3.getName(), null, null, State.INSTALLED.toString());
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(0, resps.size());
// all for host with state filter
r = new ServiceComponentHostRequest(c1.getClusterName(), null,
null, "h2", null, State.INIT.toString());
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
// for service and host
r = new ServiceComponentHostRequest(c1.getClusterName(), s3.getName(),
null, "h1", null, null);
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(0, resps.size());
// single sch - given service and host and component
r = new ServiceComponentHostRequest(c1.getClusterName(), s3.getName(),
sc3.getName(), "h3", null, State.INSTALLED.toString());
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(0, resps.size());
// single sch - given service and host and component
r = new ServiceComponentHostRequest(c1.getClusterName(), s3.getName(),
sc3.getName(), "h3", null, null);
resps = controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
ServiceComponentHostRequest r1, r2, r3;
r1 = new ServiceComponentHostRequest(c1.getClusterName(), null,
null, "h3", null, null);
r2 = new ServiceComponentHostRequest(c1.getClusterName(), s3.getName(),
sc3.getName(), "h2", null, null);
r3 = new ServiceComponentHostRequest(c1.getClusterName(), null,
null, "h2", null, null);
Set<ServiceComponentHostRequest> reqs =
new HashSet<ServiceComponentHostRequest>();
reqs.addAll(Arrays.asList(r1, r2, r3));
resps = controller.getHostComponents(reqs);
Assert.assertEquals(4, resps.size());
}
@Test
public void testGetHosts() throws AmbariException {
clusters.addCluster("c1");
clusters.addCluster("c2");
clusters.getCluster("c1").setDesiredStackVersion(new StackId("HDP-0.2"));
clusters.getCluster("c2").setDesiredStackVersion(new StackId("HDP-0.2"));
clusters.addHost("h1");
clusters.addHost("h2");
clusters.addHost("h3");
clusters.addHost("h4");
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h3").setOsType("centos5");
clusters.getHost("h4").setOsType("centos5");
clusters.getHost("h1").persist();
clusters.getHost("h2").persist();
clusters.getHost("h3").persist();
clusters.getHost("h4").persist();
clusters.mapHostToCluster("h1", "c1");
clusters.mapHostToCluster("h2", "c1");
clusters.mapHostToCluster("h3", "c2");
Map<String, String> attrs = new HashMap<String, String>();
attrs.put("a1", "b1");
clusters.getHost("h3").setHostAttributes(attrs);
attrs.put("a2", "b2");
clusters.getHost("h4").setHostAttributes(attrs);
HostRequest r = new HostRequest(null, null, null);
Set<HostResponse> resps = controller.getHosts(Collections.singleton(r));
Assert.assertEquals(4, resps.size());
Set<String> foundHosts = new HashSet<String>();
for (HostResponse resp : resps) {
foundHosts.add(resp.getHostname());
if (resp.getHostname().equals("h1")) {
Assert.assertEquals("c1", resp.getClusterName());
Assert.assertEquals(0, resp.getHostAttributes().size());
} else if (resp.getHostname().equals("h2")) {
Assert.assertEquals("c1", resp.getClusterName());
Assert.assertEquals(0, resp.getHostAttributes().size());
} else if (resp.getHostname().equals("h3")) {
Assert.assertEquals("c2", resp.getClusterName());
Assert.assertEquals(1, resp.getHostAttributes().size());
} else if (resp.getHostname().equals("h4")) {
//todo: why wouldn't this be null?
Assert.assertEquals("", resp.getClusterName());
Assert.assertEquals(2, resp.getHostAttributes().size());
} else {
fail("Found invalid host");
}
}
Assert.assertEquals(4, foundHosts.size());
r = new HostRequest("h1", null, null);
resps = controller.getHosts(Collections.singleton(r));
Assert.assertEquals(1, resps.size());
HostResponse resp = resps.iterator().next();
Assert.assertEquals("h1", resp.getHostname());
Assert.assertEquals("c1", resp.getClusterName());
Assert.assertEquals(0, resp.getHostAttributes().size());
}
@Test
public void testServiceUpdateBasic() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
String serviceName = "HDFS";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
clusters.getCluster("foo1").setDesiredStackVersion(
new StackId("HDP-0.2"));
createService(clusterName, serviceName, State.INIT);
Service s =
clusters.getCluster(clusterName).getService(serviceName);
Assert.assertNotNull(s);
Assert.assertEquals(serviceName, s.getName());
Assert.assertEquals(State.INIT, s.getDesiredState());
Assert.assertEquals(clusterName, s.getCluster().getClusterName());
Set<ServiceRequest> reqs = new HashSet<ServiceRequest>();
ServiceRequest r;
try {
r = new ServiceRequest(clusterName, serviceName,
null, State.INSTALLING.toString());
reqs.clear();
reqs.add(r);
controller.updateServices(reqs, mapRequestProps, true, false);
fail("Expected fail for invalid state transition");
} catch (Exception e) {
// Expected
}
r = new ServiceRequest(clusterName, serviceName,
null, State.INSTALLED.toString());
reqs.clear();
reqs.add(r);
RequestStatusResponse trackAction = controller.updateServices(reqs,
mapRequestProps, true, false);
Assert.assertNull(trackAction);
}
@Test
public void testServiceUpdateInvalidRequest() throws AmbariException {
// multiple clusters
// dup services
// multiple diff end states
String clusterName1 = "foo1";
createCluster(clusterName1);
String clusterName2 = "foo2";
createCluster(clusterName2);
String serviceName1 = "HDFS";
createService(clusterName1, serviceName1, null);
String serviceName2 = "HBASE";
String serviceName3 = "HBASE";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
try {
createService(clusterName2, serviceName3, null);
fail("Expected fail for invalid service for stack 0.1");
} catch (Exception e) {
// Expected
}
clusters.getCluster(clusterName1).setDesiredStackVersion(
new StackId("HDP-0.2"));
clusters.getCluster(clusterName2).setDesiredStackVersion(
new StackId("HDP-0.2"));
createService(clusterName1, serviceName2, null);
createService(clusterName2, serviceName3, null);
Set<ServiceRequest> reqs = new HashSet<ServiceRequest>();
ServiceRequest req1, req2;
try {
reqs.clear();
req1 = new ServiceRequest(clusterName1, serviceName1, null,
State.INSTALLED.toString());
req2 = new ServiceRequest(clusterName2, serviceName2, null,
State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
controller.updateServices(reqs, mapRequestProps, true, false);
fail("Expected failure for multi cluster update");
} catch (Exception e) {
// Expected
}
try {
reqs.clear();
req1 = new ServiceRequest(clusterName1, serviceName1, null,
State.INSTALLED.toString());
req2 = new ServiceRequest(clusterName1, serviceName1, null,
State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
controller.updateServices(reqs, mapRequestProps, true, false);
fail("Expected failure for dups services");
} catch (Exception e) {
// Expected
}
clusters.getCluster(clusterName1).getService(serviceName2)
.setDesiredState(State.INSTALLED);
try {
reqs.clear();
req1 = new ServiceRequest(clusterName1, serviceName1, null,
State.INSTALLED.toString());
req2 = new ServiceRequest(clusterName1, serviceName2, null,
State.STARTED.toString());
reqs.add(req1);
reqs.add(req2);
controller.updateServices(reqs, mapRequestProps, true, false);
fail("Expected failure for different states");
} catch (Exception e) {
// Expected
}
}
@Test
public void testServiceUpdateInvalidUpdates() {
// FIXME test all invalid transitions
}
@Test
public void testServiceUpdateRecursive() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.2"));
String serviceName1 = "HDFS";
createService(clusterName, serviceName1, null);
String serviceName2 = "HBASE";
createService(clusterName, serviceName2, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HBASE_MASTER";
String componentName4 = "HDFS_CLIENT";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createServiceComponent(clusterName, serviceName1, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName1, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName2, componentName3,
State.INIT);
createServiceComponent(clusterName, serviceName1, componentName4,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
Set<ServiceComponentHostRequest> set1 =
new HashSet<ServiceComponentHostRequest>();
ServiceComponentHostRequest r1 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1, null, State.INIT.toString());
ServiceComponentHostRequest r2 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host1, null, State.INIT.toString());
ServiceComponentHostRequest r3 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2, null, State.INIT.toString());
ServiceComponentHostRequest r4 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host2, null, State.INIT.toString());
ServiceComponentHostRequest r5 =
new ServiceComponentHostRequest(clusterName, serviceName2,
componentName3, host1, null, State.INIT.toString());
ServiceComponentHostRequest r6 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName4, host2, null, State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
set1.add(r4);
set1.add(r5);
set1.add(r6);
controller.createHostComponents(set1);
Cluster c1 = clusters.getCluster(clusterName);
Service s1 = c1.getService(serviceName1);
Service s2 = c1.getService(serviceName2);
ServiceComponent sc1 = s1.getServiceComponent(componentName1);
ServiceComponent sc2 = s1.getServiceComponent(componentName2);
ServiceComponent sc3 = s2.getServiceComponent(componentName3);
ServiceComponent sc4 = s1.getServiceComponent(componentName4);
ServiceComponentHost sch1 = sc1.getServiceComponentHost(host1);
ServiceComponentHost sch2 = sc2.getServiceComponentHost(host1);
ServiceComponentHost sch3 = sc1.getServiceComponentHost(host2);
ServiceComponentHost sch4 = sc2.getServiceComponentHost(host2);
ServiceComponentHost sch5 = sc3.getServiceComponentHost(host1);
ServiceComponentHost sch6 = sc4.getServiceComponentHost(host2);
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INIT);
sc3.setDesiredState(State.STARTED);
sc4.setDesiredState(State.INSTALLED);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INSTALLED);
sch3.setDesiredState(State.INSTALLED);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.INSTALLED);
sch6.setDesiredState(State.INSTALLED);
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.INSTALLED);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
sch6.setState(State.INSTALLED);
Set<ServiceRequest> reqs = new HashSet<ServiceRequest>();
ServiceRequest req1, req2;
try {
reqs.clear();
req1 = new ServiceRequest(clusterName, serviceName1, null,
State.STARTED.toString());
reqs.add(req1);
controller.updateServices(reqs, mapRequestProps, true, false);
fail("Expected failure for invalid state update");
} catch (Exception e) {
// Expected
}
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INSTALLED);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INSTALLED);
sch3.setDesiredState(State.INSTALLED);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.INSTALLED);
sch1.setState(State.INIT);
sch2.setState(State.INSTALLED);
sch3.setState(State.INIT);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
try {
reqs.clear();
req1 = new ServiceRequest(clusterName, serviceName1, null,
State.STARTED.toString());
reqs.add(req1);
controller.updateServices(reqs, mapRequestProps, true, false);
fail("Expected failure for invalid state update");
} catch (Exception e) {
// Expected
}
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INSTALLED);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.STARTED);
sch2.setDesiredState(State.STARTED);
sch3.setDesiredState(State.STARTED);
sch4.setDesiredState(State.STARTED);
sch5.setDesiredState(State.STARTED);
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.INSTALLED);
sch4.setState(State.STARTED);
sch5.setState(State.INSTALLED);
reqs.clear();
req1 = new ServiceRequest(clusterName, serviceName1, null,
State.STARTED.toString());
req2 = new ServiceRequest(clusterName, serviceName2, null,
State.STARTED.toString());
reqs.add(req1);
reqs.add(req2);
RequestStatusResponse trackAction = controller.updateServices(reqs,
mapRequestProps, true, false);
Assert.assertEquals(State.STARTED, s1.getDesiredState());
Assert.assertEquals(State.STARTED, s2.getDesiredState());
Assert.assertEquals(State.STARTED, sc1.getDesiredState());
Assert.assertEquals(State.STARTED, sc2.getDesiredState());
Assert.assertEquals(State.STARTED, sc3.getDesiredState());
Assert.assertEquals(State.INSTALLED, sc4.getDesiredState());
Assert.assertEquals(State.STARTED, sch1.getDesiredState());
Assert.assertEquals(State.STARTED, sch2.getDesiredState());
Assert.assertEquals(State.STARTED, sch3.getDesiredState());
Assert.assertEquals(State.STARTED, sch4.getDesiredState());
Assert.assertEquals(State.STARTED, sch5.getDesiredState());
Assert.assertEquals(State.INSTALLED, sch6.getDesiredState());
Assert.assertEquals(State.INSTALLED, sch1.getState());
Assert.assertEquals(State.INSTALLED, sch2.getState());
Assert.assertEquals(State.INSTALLED, sch3.getState());
Assert.assertEquals(State.STARTED, sch4.getState());
Assert.assertEquals(State.INSTALLED, sch5.getState());
Assert.assertEquals(State.INSTALLED, sch6.getState());
long requestId = trackAction.getRequestId();
List<Stage> stages = actionDB.getAllStages(requestId);
for (Stage stage : stages) {
LOG.debug("Stage dump: " + stage.toString());
}
Assert.assertTrue(!stages.isEmpty());
Assert.assertEquals(3, stages.size());
// expected
// sch1 to start
// sch2 to start
// sch3 to start
// sch5 to start
Stage stage1 = null, stage2 = null, stage3 = null;
for (Stage s : stages) {
if (s.getStageId() == 1) { stage1 = s; }
if (s.getStageId() == 2) { stage2 = s; }
if (s.getStageId() == 3) { stage3 = s; }
}
Assert.assertEquals(2, stage1.getExecutionCommands(host1).size());
Assert.assertEquals(1, stage1.getExecutionCommands(host2).size());
Assert.assertEquals(1, stage2.getExecutionCommands(host1).size());
Assert.assertNotNull(stage1.getExecutionCommandWrapper(host1, "NAMENODE"));
Assert.assertNotNull(stage1.getExecutionCommandWrapper(host1, "DATANODE"));
Assert.assertNotNull(stage1.getExecutionCommandWrapper(host2, "NAMENODE"));
Assert.assertNotNull(stage2.getExecutionCommandWrapper(host1, "HBASE_MASTER"));
Assert.assertNull(stage1.getExecutionCommandWrapper(host2, "DATANODE"));
Assert.assertNotNull(stage3.getExecutionCommandWrapper(host1, "HBASE_SERVICE_CHECK"));
Assert.assertNotNull(stage2.getExecutionCommandWrapper(host2, "HDFS_SERVICE_CHECK"));
// manually set live state
sch1.setState(State.STARTED);
sch2.setState(State.STARTED);
sch3.setState(State.STARTED);
sch4.setState(State.STARTED);
sch5.setState(State.STARTED);
// test no-op
reqs.clear();
req1 = new ServiceRequest(clusterName, serviceName1, null,
State.STARTED.toString());
req2 = new ServiceRequest(clusterName, serviceName2, null,
State.STARTED.toString());
reqs.add(req1);
reqs.add(req2);
trackAction = controller.updateServices(reqs, mapRequestProps, true,
false);
Assert.assertNull(trackAction);
}
@Test
public void testServiceComponentUpdateRecursive() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
String serviceName1 = "HDFS";
createService(clusterName, serviceName1, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
createServiceComponent(clusterName, serviceName1, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName1, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName1, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
Set<ServiceComponentHostRequest> set1 =
new HashSet<ServiceComponentHostRequest>();
ServiceComponentHostRequest r1 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1, null, State.INIT.toString());
ServiceComponentHostRequest r2 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host1, null, State.INIT.toString());
ServiceComponentHostRequest r3 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2, null, State.INIT.toString());
ServiceComponentHostRequest r4 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host2, null, State.INIT.toString());
ServiceComponentHostRequest r5 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName3, host1, null, State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
set1.add(r4);
set1.add(r5);
controller.createHostComponents(set1);
Cluster c1 = clusters.getCluster(clusterName);
Service s1 = c1.getService(serviceName1);
ServiceComponent sc1 = s1.getServiceComponent(componentName1);
ServiceComponent sc2 = s1.getServiceComponent(componentName2);
ServiceComponent sc3 = s1.getServiceComponent(componentName3);
ServiceComponentHost sch1 = sc1.getServiceComponentHost(host1);
ServiceComponentHost sch2 = sc2.getServiceComponentHost(host1);
ServiceComponentHost sch3 = sc1.getServiceComponentHost(host2);
ServiceComponentHost sch4 = sc2.getServiceComponentHost(host2);
ServiceComponentHost sch5 = sc3.getServiceComponentHost(host1);
s1.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.INIT);
sc2.setDesiredState(State.INIT);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INSTALLED);
sch3.setDesiredState(State.STARTED);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.INSTALLED);
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.STARTED);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
Set<ServiceComponentRequest> reqs =
new HashSet<ServiceComponentRequest>();
ServiceComponentRequest req1, req2, req3;
try {
reqs.clear();
req1 = new ServiceComponentRequest(clusterName, serviceName1,
sc1.getName(), null, State.INIT.toString());
reqs.add(req1);
controller.updateComponents(reqs, Collections.<String, String>emptyMap(), true);
fail("Expected failure for invalid state update");
} catch (Exception e) {
// Expected
}
s1.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INSTALLED);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.INIT);
sch2.setDesiredState(State.INIT);
sch3.setDesiredState(State.INIT);
sch4.setDesiredState(State.INIT);
sch5.setDesiredState(State.INIT);
sch1.setState(State.INIT);
sch2.setState(State.INSTALLED);
sch3.setState(State.INIT);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
try {
reqs.clear();
req1 = new ServiceComponentRequest(clusterName, serviceName1,
sc1.getName(), null, State.STARTED.toString());
reqs.add(req1);
controller.updateComponents(reqs, Collections.<String, String>emptyMap(), true);
fail("Expected failure for invalid state update");
} catch (Exception e) {
// Expected
}
s1.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INIT);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.INIT);
sch2.setDesiredState(State.INIT);
sch3.setDesiredState(State.INIT);
sch4.setDesiredState(State.INIT);
sch5.setDesiredState(State.INIT);
sch1.setState(State.STARTED);
sch2.setState(State.INIT);
sch3.setState(State.INSTALLED);
sch4.setState(State.STARTED);
sch5.setState(State.INIT);
reqs.clear();
req1 = new ServiceComponentRequest(clusterName, serviceName1,
sc1.getName(), null, State.INSTALLED.toString());
req2 = new ServiceComponentRequest(clusterName, serviceName1,
sc2.getName(), null, State.INSTALLED.toString());
req3 = new ServiceComponentRequest(clusterName, serviceName1,
sc3.getName(), null, State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
reqs.add(req3);
RequestStatusResponse trackAction = controller.updateComponents(reqs, Collections.<String, String>emptyMap(), true);
Assert.assertEquals(State.INSTALLED, s1.getDesiredState());
Assert.assertEquals(State.INSTALLED, sc1.getDesiredState());
Assert.assertEquals(State.INSTALLED, sc2.getDesiredState());
Assert.assertEquals(State.INSTALLED, sc3.getDesiredState());
Assert.assertEquals(State.INSTALLED, sch1.getDesiredState());
Assert.assertEquals(State.INSTALLED, sch2.getDesiredState());
Assert.assertEquals(State.INSTALLED, sch3.getDesiredState());
Assert.assertEquals(State.INSTALLED, sch4.getDesiredState());
Assert.assertEquals(State.INSTALLED, sch5.getDesiredState());
Assert.assertEquals(State.STARTED, sch1.getState());
Assert.assertEquals(State.INIT, sch2.getState());
Assert.assertEquals(State.INSTALLED, sch3.getState());
Assert.assertEquals(State.STARTED, sch4.getState());
Assert.assertEquals(State.INIT, sch5.getState());
long requestId = trackAction.getRequestId();
List<Stage> stages = actionDB.getAllStages(requestId);
Assert.assertTrue(!stages.isEmpty());
// FIXME check stage count
for (Stage stage : stages) {
LOG.debug("Stage dump: " + stage.toString());
}
// FIXME verify stages content - execution commands, etc
// maually set live state
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.INSTALLED);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
// test no-op
reqs.clear();
req1 = new ServiceComponentRequest(clusterName, serviceName1,
sc1.getName(), null, State.INSTALLED.toString());
req2 = new ServiceComponentRequest(clusterName, serviceName1,
sc2.getName(), null, State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
trackAction = controller.updateComponents(reqs, Collections.<String, String>emptyMap(), true);
Assert.assertNull(trackAction);
}
@Test
public void testServiceComponentHostUpdateRecursive() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
String serviceName1 = "HDFS";
createService(clusterName, serviceName1, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
createServiceComponent(clusterName, serviceName1, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName1, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName1, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
Set<ServiceComponentHostRequest> set1 =
new HashSet<ServiceComponentHostRequest>();
ServiceComponentHostRequest r1 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1, null, State.INIT.toString());
ServiceComponentHostRequest r2 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host1, null, State.INIT.toString());
ServiceComponentHostRequest r3 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2, null, State.INIT.toString());
ServiceComponentHostRequest r4 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host2, null, State.INIT.toString());
ServiceComponentHostRequest r5 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName3, host1, null, State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
set1.add(r4);
set1.add(r5);
controller.createHostComponents(set1);
Cluster c1 = clusters.getCluster(clusterName);
Service s1 = c1.getService(serviceName1);
ServiceComponent sc1 = s1.getServiceComponent(componentName1);
ServiceComponent sc2 = s1.getServiceComponent(componentName2);
ServiceComponent sc3 = s1.getServiceComponent(componentName3);
ServiceComponentHost sch1 = sc1.getServiceComponentHost(host1);
ServiceComponentHost sch2 = sc2.getServiceComponentHost(host1);
ServiceComponentHost sch3 = sc1.getServiceComponentHost(host2);
ServiceComponentHost sch4 = sc2.getServiceComponentHost(host2);
ServiceComponentHost sch5 = sc3.getServiceComponentHost(host1);
s1.setDesiredState(State.INIT);
sc1.setDesiredState(State.INIT);
sc2.setDesiredState(State.INIT);
sc3.setDesiredState(State.INIT);
sch1.setDesiredState(State.INIT);
sch2.setDesiredState(State.INIT);
sch3.setDesiredState(State.INIT);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.INSTALLED);
sch1.setState(State.INIT);
sch2.setState(State.INSTALL_FAILED);
sch3.setState(State.INIT);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
ServiceComponentHostRequest req1, req2, req3, req4, req5;
Set<ServiceComponentHostRequest> reqs =
new HashSet<ServiceComponentHostRequest>();
try {
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.STARTED.toString());
reqs.add(req1);
controller.updateHostComponents(reqs, Collections.<String, String>emptyMap(), true);
fail("Expected failure for invalid transition");
} catch (Exception e) {
// Expected
}
try {
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.INSTALLED.toString());
req2 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2,
null, State.INSTALLED.toString());
req3 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host1,
null, State.INSTALLED.toString());
req4 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host2,
null, State.INSTALLED.toString());
req5 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName3, host1,
null, State.STARTED.toString());
reqs.add(req1);
reqs.add(req2);
reqs.add(req3);
reqs.add(req4);
reqs.add(req5);
controller.updateHostComponents(reqs, Collections.<String, String>emptyMap(), true);
fail("Expected failure for invalid states");
} catch (Exception e) {
// Expected
}
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, null,
componentName1, host1,
null, State.INSTALLED.toString());
req2 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2,
null, State.INSTALLED.toString());
req3 = new ServiceComponentHostRequest(clusterName, null,
componentName2, host1,
null, State.INSTALLED.toString());
req4 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host2,
null, State.INSTALLED.toString());
req5 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName3, host1,
null, State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
reqs.add(req3);
reqs.add(req4);
reqs.add(req5);
RequestStatusResponse trackAction = controller.updateHostComponents(reqs,
Collections.<String, String>emptyMap(), true);
Assert.assertNotNull(trackAction);
long requestId = trackAction.getRequestId();
Assert.assertFalse(actionDB.getAllStages(requestId).isEmpty());
List<Stage> stages = actionDB.getAllStages(requestId);
// FIXME check stage count
for (Stage stage : stages) {
LOG.debug("Stage dump: " + stage.toString());
}
// FIXME verify stages content - execution commands, etc
// manually set live state
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.INSTALLED);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
// test no-op
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.INSTALLED.toString());
req2 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2,
null, State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
trackAction = controller.updateHostComponents(reqs, Collections.<String,
String>emptyMap(), true);
Assert.assertNull(trackAction);
}
@Test
public void testServiceComponentHostUpdateStackId() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
String serviceName1 = "HDFS";
createService(clusterName, serviceName1, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
createServiceComponent(clusterName, serviceName1, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName1, componentName2,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
Set<ServiceComponentHostRequest> set1 =
new HashSet<ServiceComponentHostRequest>();
ServiceComponentHostRequest r1 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1, null, State.INIT.toString());
ServiceComponentHostRequest r2 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2, null, State.INIT.toString());
ServiceComponentHostRequest r3 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host1, null, State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
controller.createHostComponents(set1);
Cluster c1 = clusters.getCluster(clusterName);
Service s1 = c1.getService(serviceName1);
ServiceComponent sc1 = s1.getServiceComponent(componentName1);
ServiceComponent sc2 = s1.getServiceComponent(componentName2);
ServiceComponentHost sch1 = sc1.getServiceComponentHost(host1);
ServiceComponentHost sch2 = sc1.getServiceComponentHost(host2);
ServiceComponentHost sch3 = sc2.getServiceComponentHost(host1);
s1.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.INSTALLED);
sc2.setDesiredState(State.INSTALLED);
ServiceComponentHostRequest req1;
ServiceComponentHostRequest req2;
ServiceComponentHostRequest req3;
Set<ServiceComponentHostRequest> reqs =
new HashSet<ServiceComponentHostRequest>();
StackId newStack = new StackId("HDP-0.2");
StackId oldStack = new StackId("HDP-0.1");
c1.setCurrentStackVersion(newStack);
c1.setDesiredStackVersion(newStack);
sch1.setState(State.INSTALLED);
sch2.setState(State.UPGRADING);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INSTALLED);
sch1.setStackVersion(oldStack);
sch2.setStackVersion(oldStack);
sch1.setDesiredStackVersion(newStack);
sch2.setDesiredStackVersion(oldStack);
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.INSTALLED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
req2 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2,
null, State.INSTALLED.toString());
req2.setDesiredStackId("HDP-0.2");
reqs.add(req2);
Map<String,String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "testServiceComponentHostUpdateStackId");
RequestStatusResponse resp = controller.updateHostComponents(reqs, mapRequestProps, true);
List<Stage> stages = actionDB.getAllStages(resp.getRequestId());
Assert.assertEquals(1, stages.size());
Assert.assertEquals(2, stages.get(0).getOrderedHostRoleCommands().size());
Assert.assertEquals("testServiceComponentHostUpdateStackId", stages.get(0).getRequestContext());
Assert.assertEquals(State.UPGRADING, sch1.getState());
Assert.assertEquals(State.UPGRADING, sch2.getState());
sch1.refresh();
Assert.assertTrue(sch1.getDesiredStackVersion().compareTo(newStack) == 0);
sch2.refresh();
Assert.assertTrue(sch2.getDesiredStackVersion().compareTo(newStack) == 0);
for (HostRoleCommand command : stages.get(0).getOrderedHostRoleCommands()) {
ExecutionCommand execCommand = command.getExecutionCommandWrapper().getExecutionCommand();
Assert.assertTrue(execCommand.getCommandParams().containsKey("source_stack_version"));
Assert.assertTrue(execCommand.getCommandParams().containsKey("target_stack_version"));
Assert.assertEquals(RoleCommand.UPGRADE, execCommand.getRoleCommand());
}
sch1.setState(State.INSTALLED);
sch1.setDesiredState(State.INSTALLED);
sch2.setState(State.UPGRADING);
sch2.setDesiredState(State.INSTALLED);
sch3.setState(State.UPGRADING);
sch3.setDesiredState(State.INSTALLED);
sch3.setStackVersion(oldStack);
sch3.setDesiredStackVersion(newStack);
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.INSTALLED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
req2 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2,
null, State.INSTALLED.toString());
req2.setDesiredStackId("HDP-0.2");
reqs.add(req2);
req3 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName2, host1,
null, State.INSTALLED.toString());
req3.setDesiredStackId("HDP-0.2");
reqs.add(req3);
resp = controller.updateHostComponents(reqs, Collections.<String, String>emptyMap(), true);
stages = actionDB.getAllStages(resp.getRequestId());
Assert.assertEquals(2, stages.size());
Assert.assertEquals(2, stages.get(0).getOrderedHostRoleCommands().size());
Assert.assertEquals("", stages.get(0).getRequestContext());
Assert.assertEquals(State.UPGRADING, sch1.getState());
Assert.assertEquals(State.UPGRADING, sch2.getState());
Assert.assertEquals(State.UPGRADING, sch3.getState());
sch1.refresh();
Assert.assertTrue(sch1.getDesiredStackVersion().compareTo(newStack) == 0);
sch2.refresh();
Assert.assertTrue(sch2.getDesiredStackVersion().compareTo(newStack) == 0);
sch3.refresh();
Assert.assertTrue(sch3.getDesiredStackVersion().compareTo(newStack) == 0);
for (Stage stage : stages) {
for (HostRoleCommand command : stage.getOrderedHostRoleCommands()) {
ExecutionCommand execCommand = command.getExecutionCommandWrapper().getExecutionCommand();
Assert.assertTrue(execCommand.getCommandParams().containsKey("source_stack_version"));
Assert.assertTrue(execCommand.getCommandParams().containsKey("target_stack_version"));
Assert.assertEquals("{\"stackName\":\"HDP\",\"stackVersion\":\"0.2\"}",
execCommand.getCommandParams().get("target_stack_version"));
Assert.assertEquals(RoleCommand.UPGRADE, execCommand.getRoleCommand());
}
}
}
@Test
public void testServiceComponentHostUpdateStackIdError() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
String serviceName1 = "HDFS";
createService(clusterName, serviceName1, null);
String componentName1 = "NAMENODE";
createServiceComponent(clusterName, serviceName1, componentName1,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
Set<ServiceComponentHostRequest> set1 =
new HashSet<ServiceComponentHostRequest>();
ServiceComponentHostRequest r1 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1, null, State.INIT.toString());
ServiceComponentHostRequest r2 =
new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2, null, State.INIT.toString());
set1.add(r1);
set1.add(r2);
controller.createHostComponents(set1);
Cluster c1 = clusters.getCluster(clusterName);
Service s1 = c1.getService(serviceName1);
ServiceComponent sc1 = s1.getServiceComponent(componentName1);
ServiceComponentHost sch1 = sc1.getServiceComponentHost(host1);
ServiceComponentHost sch2 = sc1.getServiceComponentHost(host2);
s1.setDesiredState(State.INIT);
sc1.setDesiredState(State.INIT);
ServiceComponentHostRequest req1;
ServiceComponentHostRequest req2;
Set<ServiceComponentHostRequest> reqs =
new HashSet<ServiceComponentHostRequest>();
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.STARTED.toString());
req1.setDesiredStackId("invalid stack id");
reqs.add(req1);
updateHostAndCompareExpectedFailure(reqs, "Invalid desired stack id");
c1.setCurrentStackVersion(null);
sch1.setStackVersion(new StackId("HDP-0.1"));
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.STARTED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
updateHostAndCompareExpectedFailure(reqs, "Cluster has not been upgraded yet");
c1.setCurrentStackVersion(new StackId("HDP2-0.1"));
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.STARTED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
updateHostAndCompareExpectedFailure(reqs, "Deployed stack name and requested stack names");
c1.setCurrentStackVersion(new StackId("HDP-0.2"));
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.STARTED.toString());
req1.setDesiredStackId("HDP-0.3");
reqs.add(req1);
updateHostAndCompareExpectedFailure(reqs, "Component host can only be upgraded to the same version");
c1.setCurrentStackVersion(new StackId("HDP-0.2"));
sch1.setState(State.STARTED);
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.STARTED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
updateHostAndCompareExpectedFailure(reqs, "Component host is in an invalid state for upgrade");
c1.setCurrentStackVersion(new StackId("HDP-0.2"));
sch1.setState(State.UPGRADING);
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
new HashMap<String, String>(), State.STARTED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
updateHostAndCompareExpectedFailure(reqs, "Upgrade cannot be accompanied with config");
c1.setCurrentStackVersion(new StackId("HDP-0.2"));
sch1.setState(State.UPGRADING);
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.STARTED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
updateHostAndCompareExpectedFailure(reqs, "The desired state for an upgrade request must be");
c1.setCurrentStackVersion(new StackId("HDP-0.2"));
sch1.setState(State.UPGRADING);
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1, null, null);
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
updateHostAndCompareExpectedFailure(reqs, "The desired state for an upgrade request must be");
c1.setCurrentStackVersion(new StackId("HDP-0.2"));
sch1.setState(State.INSTALLED);
sch1.setDesiredState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch2.setDesiredState(State.INSTALLED);
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.INSTALLED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
req2 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host2,
null, State.STARTED.toString());
reqs.add(req2);
updateHostAndCompareExpectedFailure(reqs, "An upgrade request cannot be combined with other");
c1.setCurrentStackVersion(new StackId("HDP-0.2"));
sch1.setState(State.INSTALLED);
sch1.setStackVersion(new StackId("HDP-0.2"));
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, null);
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
RequestStatusResponse resp = controller.updateHostComponents(reqs,
Collections.<String,String>emptyMap(), true);
Assert.assertNull(resp);
c1.setCurrentStackVersion(new StackId("HDP-0.2"));
sch1.setState(State.INSTALLED);
sch1.setStackVersion(new StackId("HDP-0.2"));
reqs.clear();
req1 = new ServiceComponentHostRequest(clusterName, serviceName1,
componentName1, host1,
null, State.INSTALLED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
resp = controller.updateHostComponents(reqs, Collections.<String,String>emptyMap(), true);
Assert.assertNull(resp);
}
private void updateHostAndCompareExpectedFailure(Set<ServiceComponentHostRequest> reqs,
String expectedMessage) {
try {
controller.updateHostComponents(reqs, Collections.<String,String>emptyMap(), true);
fail("Expected failure: " + expectedMessage);
} catch (Exception e) {
LOG.info("Actual exception message: " + e.getMessage());
Assert.assertTrue(e.getMessage().contains(expectedMessage));
}
}
@Test
public void testStartClientComponent() {
// FIXME write test after meta data integration
// start should fail
}
@Test
public void testStartClientHostComponent() {
// FIXME write test after meta data integration
// start should fail
}
@SuppressWarnings("serial")
@Test
public void testGetRequestAndTaskStatus() throws AmbariException {
long requestId = 3;
long stageId = 4;
String clusterName = "c1";
final String hostName1 = "h1";
final String hostName2 = "h2";
String context = "Test invocation";
clusters.addCluster(clusterName);
clusters.getCluster(clusterName).setDesiredStackVersion(
new StackId("HDP-0.1"));
clusters.addHost(hostName1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost(hostName1).persist();
clusters.addHost(hostName2);
clusters.getHost("h2").setOsType("centos5");
clusters.getHost(hostName2).persist();
clusters.mapHostsToCluster(new HashSet<String>(){
{add(hostName1); add(hostName2);}}, clusterName);
List<Stage> stages = new ArrayList<Stage>();
stages.add(new Stage(requestId, "/a1", clusterName, context));
stages.get(0).setStageId(stageId++);
stages.get(0).addHostRoleExecutionCommand(hostName1, Role.HBASE_MASTER,
RoleCommand.START,
new ServiceComponentHostStartEvent(Role.HBASE_MASTER.toString(),
hostName1, System.currentTimeMillis(),
new HashMap<String, String>()),
clusterName, "HBASE");
stages.add(new Stage(requestId, "/a2", clusterName, context));
stages.get(1).setStageId(stageId);
stages.get(1).addHostRoleExecutionCommand(hostName1, Role.HBASE_CLIENT,
RoleCommand.START,
new ServiceComponentHostStartEvent(Role.HBASE_CLIENT.toString(),
hostName1, System.currentTimeMillis(),
new HashMap<String, String>()), clusterName, "HBASE");
actionDB.persistActions(stages);
Set<RequestStatusResponse> requestStatusResponses =
controller.getRequestStatus(new RequestStatusRequest(requestId, null));
RequestStatusResponse requestStatusResponse =
requestStatusResponses.iterator().next();
assertEquals(requestId, requestStatusResponse.getRequestId());
assertEquals(context, requestStatusResponse.getRequestContext());
Set<TaskStatusRequest> taskStatusRequests = new HashSet<TaskStatusRequest>();
taskStatusRequests.add(new TaskStatusRequest(requestId, null));
Set<TaskStatusResponse> taskStatusResponses =
controller.getTaskStatus(taskStatusRequests);
assertEquals(2, taskStatusResponses.size());
}
@SuppressWarnings("serial")
@Test
public void testGetActions() throws Exception {
Set<ActionResponse> responses = controller.getActions(
new HashSet<ActionRequest>() {{
add(new ActionRequest(null, "HDFS", null, null));
}});
assertFalse(responses.isEmpty());
assertEquals(1, responses.size());
ActionResponse response = responses.iterator().next();
assertEquals(Role.HDFS_SERVICE_CHECK.name(), response.getActionName());
}
@SuppressWarnings("serial")
@Test
public void testCreateActions() throws Exception {
clusters.addCluster("c1");
clusters.getCluster("c1").setDesiredStackVersion(new StackId("HDP-0.1"));
clusters.addHost("h1");
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
clusters.addHost("h2");
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h2").persist();
Set<String> hostNames = new HashSet<String>(){{
add("h1");
add("h2");
}};
clusters.mapHostsToCluster(hostNames, "c1");
Cluster cluster = clusters.getCluster("c1");
cluster.setDesiredStackVersion(new StackId("HDP-0.1"));
ConfigFactory cf = injector.getInstance(ConfigFactory.class);
Config config1 = cf.createNew(cluster, "global",
new HashMap<String, String>(){{ put("key1", "value1"); }});
config1.setVersionTag("version1");
Config config2 = cf.createNew(cluster, "core-site",
new HashMap<String, String>(){{ put("key1", "value1"); }});
config2.setVersionTag("version1");
cluster.addConfig(config1);
cluster.addConfig(config2);
cluster.addDesiredConfig(config1);
cluster.addDesiredConfig(config2);
Service hdfs = cluster.addService("HDFS");
Service mapReduce = cluster.addService("MAPREDUCE");
hdfs.persist();
mapReduce.persist();
hdfs.addServiceComponent(Role.HDFS_CLIENT.name()).persist();
mapReduce.addServiceComponent(Role.MAPREDUCE_CLIENT.name()).persist();
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).addServiceComponentHost("h1").persist();
mapReduce.getServiceComponent(Role.MAPREDUCE_CLIENT.name()).addServiceComponentHost("h2").persist();
Set<ActionRequest> actionRequests = new HashSet<ActionRequest>();
Map<String, String> params = new HashMap<String, String>(){{
put("test", "test");
}};
ActionRequest actionRequest = new ActionRequest("c1", "HDFS", Role.HDFS_SERVICE_CHECK.name(), params);
actionRequests.add(actionRequest);
Map<String, String> requestProperties = new HashMap<String, String>();
requestProperties.put(REQUEST_CONTEXT_PROPERTY, "Called from a test");
RequestStatusResponse response = controller.createActions(actionRequests, requestProperties);
assertEquals(1, response.getTasks().size());
ShortTaskStatus task = response.getTasks().get(0);
List<HostRoleCommand> storedTasks = actionDB.getRequestTasks(response.getRequestId());
Stage stage = actionDB.getAllStages(response.getRequestId()).get(0);
assertEquals(1, storedTasks.size());
HostRoleCommand hostRoleCommand = storedTasks.get(0);
assertEquals(task.getTaskId(), hostRoleCommand.getTaskId());
assertEquals(actionRequest.getServiceName(), hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getServiceName());
assertEquals(actionRequest.getClusterName(), hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getClusterName());
assertEquals(actionRequest.getActionName(), hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getRole().name());
assertEquals(Role.HDFS_CLIENT.name(), hostRoleCommand.getEvent().getEvent().getServiceComponentName());
assertEquals(actionRequest.getParameters(), hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getRoleParams());
assertNotNull(hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getConfigurations());
assertEquals(2, hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().size());
assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY), stage.getRequestContext());
actionRequests.add(new ActionRequest("c1", "MAPREDUCE", Role.MAPREDUCE_SERVICE_CHECK.name(), null));
response = controller.createActions(actionRequests, requestProperties);
assertEquals(2, response.getTasks().size());
List<HostRoleCommand> tasks = actionDB.getRequestTasks(response.getRequestId());
assertEquals(2, tasks.size());
requestProperties.put(REQUEST_CONTEXT_PROPERTY, null);
response = controller.createActions(actionRequests, requestProperties);
assertEquals(2, response.getTasks().size());
}
private void createUser(String userName) throws Exception {
UserRequest request = new UserRequest(userName);
request.setPassword("password");
controller.createUsers(new HashSet<UserRequest>(Collections.singleton(request)));
}
@Test
public void testCreateAndGetUsers() throws Exception {
createUser("user1");
Set<UserResponse> r =
controller.getUsers(Collections.singleton(new UserRequest("user1")));
Assert.assertEquals(1, r.size());
UserResponse resp = r.iterator().next();
Assert.assertEquals("user1", resp.getUsername());
}
@Test
public void testGetUsers() throws Exception {
createUser("user1");
createUser("user2");
createUser("user3");
UserRequest request = new UserRequest(null);
Set<UserResponse> responses = controller.getUsers(Collections.singleton(request));
Assert.assertEquals(3, responses.size());
}
@SuppressWarnings("serial")
@Test
public void testUpdateUsers() throws Exception {
createUser("user1");
users.createDefaultRoles();
UserRequest request = new UserRequest("user1");
request.setRoles(new HashSet<String>(){{
add("user");
add("admin");
}});
controller.updateUsers(Collections.singleton(request));
}
@SuppressWarnings("serial")
@Test
public void testDeleteUsers() throws Exception {
createUser("user1");
users.createDefaultRoles();
UserRequest request = new UserRequest("user1");
request.setRoles(new HashSet<String>(){{
add("user");
add("admin");
}});
controller.updateUsers(Collections.singleton(request));
request = new UserRequest("user1");
controller.deleteUsers(Collections.singleton(request));
Set<UserResponse> responses = controller.getUsers(
Collections.singleton(new UserRequest(null)));
Assert.assertEquals(0, responses.size());
RoleDAO roleDao = injector.getInstance(RoleDAO.class);
RoleEntity re1 = roleDao.findByName("user");
RoleEntity re2 = roleDao.findByName("admin");
Assert.assertNotNull(re1);
Assert.assertNotNull(re2);
}
@Test
public void testRcaOnJobtrackerHost() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "MAPREDUCE";
createService(clusterName, serviceName, null);
String componentName1 = "JOBTRACKER";
String componentName2 = "TASKTRACKER";
String componentName3 = "MAPREDUCE_CLIENT";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
createServiceComponentHost(clusterName, serviceName, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
Map<String, String> configs = new HashMap<String, String>();
configs.put("a", "b");
configs.put("rca_enabled", "true");
ClusterRequest cr = new ClusterRequest(null, clusterName, null, null);
cr.setDesiredConfig(new ConfigurationRequest(clusterName, "global",
"v1", configs));
controller.updateCluster(cr, Collections.<String,String>emptyMap());
Set<ServiceRequest> sReqs = new HashSet<ServiceRequest>();
Map<String, String> configVersions = new HashMap<String, String>();
configVersions.put("global", "v1");
sReqs.clear();
sReqs.add(new ServiceRequest(clusterName, serviceName, configVersions,
"INSTALLED"));
RequestStatusResponse trackAction = controller.updateServices(sReqs,
mapRequestProps, true, false);
List<Stage> stages = actionDB.getAllStages(trackAction.getRequestId());
for (ExecutionCommandWrapper cmd : stages.get(0)
.getExecutionCommands(host1)) {
assertEquals(
"true",
cmd.getExecutionCommand().getConfigurations().get("global")
.get("rca_enabled"));
}
for (ExecutionCommandWrapper cmd : stages.get(0)
.getExecutionCommands(host2)) {
assertEquals(
"false",
cmd.getExecutionCommand().getConfigurations().get("global")
.get("rca_enabled"));
}
}
@Test
public void testUpdateConfigForRunningService() throws Exception {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
// null service should work
createServiceComponentHost(clusterName, null, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName1)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName2)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName2)
.getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName3)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName3)
.getServiceComponentHost(host2));
// Install
ServiceRequest r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r);
controller.updateServices(requests, mapRequestProps, true, false);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
// manually change live state to installed as no running action manager
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
// Start
r = new ServiceRequest(clusterName, serviceName, null,
State.STARTED.toString());
requests.clear();
requests.add(r);
controller.updateServices(requests, mapRequestProps, true, false);
// manually change live state to started as no running action manager
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.STARTED);
}
}
Assert.assertEquals(State.STARTED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
if (sc.getName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED, sc.getDesiredState());
} else {
Assert.assertEquals(State.STARTED, sc.getDesiredState());
}
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (sch.getServiceComponentName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED, sch.getDesiredState());
} else {
Assert.assertEquals(State.STARTED, sch.getDesiredState());
}
}
}
Map<String, String> configs = new HashMap<String, String>();
configs.put("a", "b");
ConfigurationRequest cr1, cr2, cr3, cr4, cr5, cr6, cr7, cr8;
cr1 = new ConfigurationRequest(clusterName, "typeA","v1", configs);
cr2 = new ConfigurationRequest(clusterName, "typeB","v1", configs);
cr3 = new ConfigurationRequest(clusterName, "typeC","v1", configs);
cr4 = new ConfigurationRequest(clusterName, "typeD","v1", configs);
cr5 = new ConfigurationRequest(clusterName, "typeA","v2", configs);
cr6 = new ConfigurationRequest(clusterName, "typeB","v2", configs);
cr7 = new ConfigurationRequest(clusterName, "typeC","v2", configs);
cr8 = new ConfigurationRequest(clusterName, "typeE","v1", configs);
controller.createConfiguration(cr1);
controller.createConfiguration(cr2);
controller.createConfiguration(cr3);
controller.createConfiguration(cr4);
controller.createConfiguration(cr5);
controller.createConfiguration(cr6);
controller.createConfiguration(cr7);
controller.createConfiguration(cr8);
Cluster cluster = clusters.getCluster(clusterName);
Service s = cluster.getService(serviceName);
ServiceComponent sc1 = s.getServiceComponent(componentName1);
ServiceComponent sc2 = s.getServiceComponent(componentName2);
ServiceComponentHost sch1 = sc1.getServiceComponentHost(host1);
Set<ServiceComponentHostRequest> schReqs =
new HashSet<ServiceComponentHostRequest>();
Set<ServiceComponentRequest> scReqs =
new HashSet<ServiceComponentRequest>();
Set<ServiceRequest> sReqs = new HashSet<ServiceRequest>();
Map<String, String> configVersions = new HashMap<String, String>();
// update configs at SCH and SC level
configVersions.clear();
configVersions.put("typeA", "v1");
configVersions.put("typeB", "v1");
configVersions.put("typeC", "v1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName, serviceName,
componentName1, host1, configVersions, null));
Assert.assertNull(controller.updateHostComponents(schReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(0, s.getDesiredConfigs().size());
Assert.assertEquals(0, sc1.getDesiredConfigs().size());
Assert.assertEquals(3, sch1.getDesiredConfigs().size());
configVersions.clear();
configVersions.put("typeC", "v1");
configVersions.put("typeD", "v1");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName, serviceName,
componentName2, configVersions, null));
Assert.assertNull(controller.updateComponents(scReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(0, s.getDesiredConfigs().size());
Assert.assertEquals(0, sc1.getDesiredConfigs().size());
Assert.assertEquals(2, sc2.getDesiredConfigs().size());
Assert.assertEquals(3, sch1.getDesiredConfigs().size());
// update configs at service level
configVersions.clear();
configVersions.put("typeA", "v2");
configVersions.put("typeC", "v2");
configVersions.put("typeE", "v1");
sReqs.clear();
sReqs.add(new ServiceRequest(clusterName, serviceName, configVersions,
null));
Assert.assertNull(controller.updateServices(sReqs, mapRequestProps, true, false));
Assert.assertEquals(3, s.getDesiredConfigs().size());
Assert.assertEquals(3, sc1.getDesiredConfigs().size());
Assert.assertEquals(4, sc2.getDesiredConfigs().size());
Assert.assertEquals(4, sch1.getDesiredConfigs().size());
Assert.assertEquals("v2",
s.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
s.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
s.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v2",
sc1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sc1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sc1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v2",
sc2.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sc2.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sc2.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sc2.getDesiredConfigs().get("typeD").getVersionTag());
Assert.assertEquals("v2",
sch1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sch1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeB").getVersionTag());
// update configs at SCH level
configVersions.clear();
configVersions.put("typeA", "v1");
configVersions.put("typeB", "v1");
configVersions.put("typeC", "v1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName, serviceName,
componentName1, host1, configVersions, null));
Assert.assertNull(controller.updateHostComponents(schReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(3, s.getDesiredConfigs().size());
Assert.assertEquals(3, sc1.getDesiredConfigs().size());
Assert.assertEquals(4, sc2.getDesiredConfigs().size());
Assert.assertEquals(4, sch1.getDesiredConfigs().size());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeB").getVersionTag());
// update configs at SC level
configVersions.clear();
configVersions.put("typeC", "v2");
configVersions.put("typeD", "v1");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName, serviceName,
componentName1, configVersions, null));
Assert.assertNull(controller.updateComponents(scReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(3, s.getDesiredConfigs().size());
Assert.assertEquals(4, sc1.getDesiredConfigs().size());
Assert.assertEquals(4, sc2.getDesiredConfigs().size());
Assert.assertEquals(5, sch1.getDesiredConfigs().size());
Assert.assertEquals("v2",
sc1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sc1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sc2.getDesiredConfigs().get("typeD").getVersionTag());
Assert.assertEquals("v1",
sc1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sch1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeD").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeB").getVersionTag());
}
@Test
public void testConfigUpdates() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
// null service should work
createServiceComponentHost(clusterName, null, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName1)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName2)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName2)
.getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName3)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName3)
.getServiceComponentHost(host2));
Map<String, String> configs = new HashMap<String, String>();
configs.put("a", "b");
ConfigurationRequest cr1, cr2, cr3, cr4, cr5, cr6, cr7, cr8;
cr1 = new ConfigurationRequest(clusterName, "typeA","v1", configs);
cr2 = new ConfigurationRequest(clusterName, "typeB","v1", configs);
cr3 = new ConfigurationRequest(clusterName, "typeC","v1", configs);
cr4 = new ConfigurationRequest(clusterName, "typeD","v1", configs);
cr5 = new ConfigurationRequest(clusterName, "typeA","v2", configs);
cr6 = new ConfigurationRequest(clusterName, "typeB","v2", configs);
cr7 = new ConfigurationRequest(clusterName, "typeC","v2", configs);
cr8 = new ConfigurationRequest(clusterName, "typeE","v1", configs);
controller.createConfiguration(cr1);
controller.createConfiguration(cr2);
controller.createConfiguration(cr3);
controller.createConfiguration(cr4);
controller.createConfiguration(cr5);
controller.createConfiguration(cr6);
controller.createConfiguration(cr7);
controller.createConfiguration(cr8);
Cluster cluster = clusters.getCluster(clusterName);
Service s = cluster.getService(serviceName);
ServiceComponent sc1 = s.getServiceComponent(componentName1);
ServiceComponent sc2 = s.getServiceComponent(componentName2);
ServiceComponentHost sch1 = sc1.getServiceComponentHost(host1);
Set<ServiceComponentHostRequest> schReqs =
new HashSet<ServiceComponentHostRequest>();
Set<ServiceComponentRequest> scReqs =
new HashSet<ServiceComponentRequest>();
Set<ServiceRequest> sReqs = new HashSet<ServiceRequest>();
Map<String, String> configVersions = new HashMap<String, String>();
// update configs at SCH and SC level
configVersions.clear();
configVersions.put("typeA", "v1");
configVersions.put("typeB", "v1");
configVersions.put("typeC", "v1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName, serviceName,
componentName1, host1, configVersions, null));
Assert.assertNull(controller.updateHostComponents(schReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(0, s.getDesiredConfigs().size());
Assert.assertEquals(0, sc1.getDesiredConfigs().size());
Assert.assertEquals(3, sch1.getDesiredConfigs().size());
configVersions.clear();
configVersions.put("typeC", "v1");
configVersions.put("typeD", "v1");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName, serviceName,
componentName2, configVersions, null));
Assert.assertNull(controller.updateComponents(scReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(0, s.getDesiredConfigs().size());
Assert.assertEquals(0, sc1.getDesiredConfigs().size());
Assert.assertEquals(2, sc2.getDesiredConfigs().size());
Assert.assertEquals(3, sch1.getDesiredConfigs().size());
// update configs at service level
configVersions.clear();
configVersions.put("typeA", "v2");
configVersions.put("typeC", "v2");
configVersions.put("typeE", "v1");
sReqs.clear();
sReqs.add(new ServiceRequest(clusterName, serviceName, configVersions,
null));
Assert.assertNull(controller.updateServices(sReqs, mapRequestProps, true, false));
Assert.assertEquals(3, s.getDesiredConfigs().size());
Assert.assertEquals(3, sc1.getDesiredConfigs().size());
Assert.assertEquals(4, sc2.getDesiredConfigs().size());
Assert.assertEquals(4, sch1.getDesiredConfigs().size());
Assert.assertEquals("v2",
s.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
s.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
s.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v2",
sc1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sc1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sc1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v2",
sc2.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sc2.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sc2.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sc2.getDesiredConfigs().get("typeD").getVersionTag());
Assert.assertEquals("v2",
sch1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sch1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeB").getVersionTag());
// update configs at SCH level
configVersions.clear();
configVersions.put("typeA", "v1");
configVersions.put("typeB", "v1");
configVersions.put("typeC", "v1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName, serviceName,
componentName1, host1, configVersions, null));
Assert.assertNull(controller.updateHostComponents(schReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(3, s.getDesiredConfigs().size());
Assert.assertEquals(3, sc1.getDesiredConfigs().size());
Assert.assertEquals(4, sc2.getDesiredConfigs().size());
Assert.assertEquals(4, sch1.getDesiredConfigs().size());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeB").getVersionTag());
// update configs at SC level
configVersions.clear();
configVersions.put("typeC", "v2");
configVersions.put("typeD", "v1");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName, serviceName,
componentName1, configVersions, null));
Assert.assertNull(controller.updateComponents(scReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(3, s.getDesiredConfigs().size());
Assert.assertEquals(4, sc1.getDesiredConfigs().size());
Assert.assertEquals(4, sc2.getDesiredConfigs().size());
Assert.assertEquals(5, sch1.getDesiredConfigs().size());
Assert.assertEquals("v2",
sc1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sc1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sc2.getDesiredConfigs().get("typeD").getVersionTag());
Assert.assertEquals("v1",
sc1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeA").getVersionTag());
Assert.assertEquals("v2",
sch1.getDesiredConfigs().get("typeC").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeD").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeE").getVersionTag());
Assert.assertEquals("v1",
sch1.getDesiredConfigs().get("typeB").getVersionTag());
}
@Test
public void testReConfigureService() throws Exception {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
// null service should work
createServiceComponentHost(clusterName, null, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
// Install
ServiceRequest r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r);
controller.updateServices(requests, mapRequestProps, true, false);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
// manually change live state to installed as no running action manager
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
// Create and attach config
Map<String, String> configs = new HashMap<String, String>();
configs.put("a", "b");
ConfigurationRequest cr1,cr2,cr3;
cr1 = new ConfigurationRequest(clusterName, "core-site","version1",
configs);
cr2 = new ConfigurationRequest(clusterName, "hdfs-site","version1",
configs);
cr3 = new ConfigurationRequest(clusterName, "core-site","version122",
configs);
controller.createConfiguration(cr1);
controller.createConfiguration(cr2);
controller.createConfiguration(cr3);
Cluster cluster = clusters.getCluster(clusterName);
Service s = cluster.getService(serviceName);
ServiceComponent sc1 = s.getServiceComponent(componentName1);
ServiceComponent sc2 = s.getServiceComponent(componentName2);
ServiceComponentHost sch1 = sc1.getServiceComponentHost(host1);
Set<ServiceComponentHostRequest> schReqs =
new HashSet<ServiceComponentHostRequest>();
Set<ServiceComponentRequest> scReqs =
new HashSet<ServiceComponentRequest>();
Set<ServiceRequest> sReqs = new HashSet<ServiceRequest>();
Map<String, String> configVersions = new HashMap<String, String>();
// SCH level
configVersions.clear();
configVersions.put("core-site", "version1");
configVersions.put("hdfs-site", "version1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName, serviceName,
componentName1, host1, configVersions, null));
Assert.assertNull(controller.updateHostComponents(schReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(2, sch1.getDesiredConfigs().size());
// Reconfigure SCH level
configVersions.clear();
configVersions.put("core-site", "version122");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName, serviceName,
componentName1, host1, configVersions, null));
Assert.assertNull(controller.updateHostComponents(schReqs, Collections.<String, String>emptyMap(), true));
// Clear Entity Manager
entityManager.clear();
Assert.assertEquals(2, sch1.getDesiredConfigs().size());
Assert.assertEquals("version122", sch1.getDesiredConfigs().get
("core-site").getVersionTag());
//SC Level
configVersions.clear();
configVersions.put("core-site", "version1");
configVersions.put("hdfs-site", "version1");
scReqs.add(new ServiceComponentRequest(clusterName, serviceName,
componentName2, configVersions, null));
Assert.assertNull(controller.updateComponents(scReqs, Collections.<String, String>emptyMap(), true));
scReqs.add(new ServiceComponentRequest(clusterName, serviceName,
componentName1, configVersions, null));
Assert.assertNull(controller.updateComponents(scReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(2, sc1.getDesiredConfigs().size());
Assert.assertEquals(2, sc2.getDesiredConfigs().size());
// Reconfigure SC level
configVersions.clear();
configVersions.put("core-site", "version122");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName, serviceName,
componentName2, configVersions, null));
Assert.assertNull(controller.updateComponents(scReqs, Collections.<String, String>emptyMap(), true));
Assert.assertEquals(2, sc2.getDesiredConfigs().size());
Assert.assertEquals("version122", sc2.getDesiredConfigs().get
("core-site").getVersionTag());
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName, serviceName,
componentName1, configVersions, null));
Assert.assertNull(controller.updateComponents(scReqs, Collections.<String, String>emptyMap(), true));
entityManager.clear();
Assert.assertEquals(2, sc1.getDesiredConfigs().size());
Assert.assertEquals("version122", sc1.getDesiredConfigs().get
("core-site").getVersionTag());
// S level
configVersions.clear();
configVersions.put("core-site", "version1");
configVersions.put("hdfs-site", "version1");
sReqs.clear();
sReqs.add(new ServiceRequest(clusterName, serviceName, configVersions,
null));
Assert.assertNull(controller.updateServices(sReqs, mapRequestProps, true, false));
Assert.assertEquals(2, s.getDesiredConfigs().size());
// Reconfigure S Level
configVersions.clear();
configVersions.put("core-site", "version122");
sReqs.clear();
sReqs.add(new ServiceRequest(clusterName, serviceName, configVersions,
null));
Assert.assertNull(controller.updateServices(sReqs, mapRequestProps, true, false));
entityManager.clear();
Assert.assertEquals(2, s.getDesiredConfigs().size());
Assert.assertEquals("version122", s.getDesiredConfigs().get
("core-site").getVersionTag());
}
@Test
public void testReConfigureServiceClient() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName1 = "HDFS";
String serviceName2 = "MAPREDUCE";
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
String componentName4 = "JOBTRACKER";
String componentName5 = "TASKTRACKER";
String componentName6 = "MAPREDUCE_CLIENT";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createService(clusterName, serviceName1, null);
createService(clusterName, serviceName2, null);
createServiceComponent(clusterName, serviceName1, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName1, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName1, componentName3,
State.INIT);
createServiceComponent(clusterName, serviceName2, componentName4,
State.INIT);
createServiceComponent(clusterName, serviceName2, componentName5,
State.INIT);
createServiceComponent(clusterName, serviceName2, componentName6,
State.INIT);
String host1 = "h1";
String host2 = "h2";
String host3 = "h3";
clusters.addHost(host1);
clusters.addHost(host2);
clusters.addHost(host3);
clusters.getHost("h1").setOsType("centos6");
clusters.getHost("h1").persist();
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
clusters.getHost("h3").setOsType("centos6");
clusters.getHost("h3").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
clusters.mapHostToCluster(host3, clusterName);
createServiceComponentHost(clusterName, serviceName1, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName1, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName2, componentName4,
host1, null);
createServiceComponentHost(clusterName, serviceName2, componentName5,
host1, null);
createServiceComponentHost(clusterName, serviceName1, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName1, componentName3,
host2, null);
createServiceComponentHost(clusterName, serviceName2, componentName6,
host2, null);
createServiceComponentHost(clusterName, serviceName1, componentName3,
host3, null);
createServiceComponentHost(clusterName, serviceName2, componentName6,
host3, null);
// Create and attach config
Map<String, String> configs = new HashMap<String, String>();
configs.put("a", "b");
ConfigurationRequest cr1,cr2,cr3;
cr1 = new ConfigurationRequest(clusterName, "core-site","version1",
configs);
cr2 = new ConfigurationRequest(clusterName, "hdfs-site","version1",
configs);
ClusterRequest crReq = new ClusterRequest(null, clusterName, null, null);
crReq.setDesiredConfig(cr1);
controller.updateCluster(crReq, null);
crReq = new ClusterRequest(null, clusterName, null, null);
crReq.setDesiredConfig(cr2);
controller.updateCluster(crReq, null);
// Install
long requestId1 = installService(clusterName, serviceName1, true, false);
List<Stage> stages = actionDB.getAllStages(requestId1);
Assert.assertEquals(2, stages.get(0).getOrderedHostRoleCommands().get(0)
.getExecutionCommandWrapper().getExecutionCommand()
.getConfigurationTags().size());
installService(clusterName, serviceName2, false, false);
// Start
startService(clusterName, serviceName1, true, false);
startService(clusterName, serviceName2, true, false);
// Reconfigure
configs.clear();
configs.put("c", "d");
cr3 = new ConfigurationRequest(clusterName, "core-site","version122",
configs);
crReq = new ClusterRequest(null, clusterName, null, null);
crReq.setDesiredConfig(cr3);
controller.updateCluster(crReq, null);
// Stop HDFS & MAPREDUCE
stopService(clusterName, serviceName1, false, false);
stopService(clusterName, serviceName2, false, false);
// Start
long requestId2 = startService(clusterName, serviceName1, true, true);
long requestId3 = startService(clusterName, serviceName2, true, true);
stages = actionDB.getAllStages(requestId2);
stages.addAll(actionDB.getAllStages(requestId3));
HostRoleCommand hdfsCmdHost3 = null;
HostRoleCommand hdfsCmdHost2 = null;
HostRoleCommand mapRedCmdHost2 = null;
HostRoleCommand mapRedCmdHost3 = null;
for (Stage stage : stages) {
List<HostRoleCommand> hrcs = stage.getOrderedHostRoleCommands();
for (HostRoleCommand hrc : hrcs) {
LOG.debug("role: " + hrc.getRole());
if (hrc.getRole().toString().equals("HDFS_CLIENT")) {
if (hrc.getHostName().equals(host3))
hdfsCmdHost3 = hrc;
else if (hrc.getHostName().equals(host2))
hdfsCmdHost2 = hrc;
}
if (hrc.getRole().toString().equals("MAPREDUCE_CLIENT")) {
if (hrc.getHostName().equals(host2))
mapRedCmdHost2 = hrc;
else if (hrc.getHostName().equals(host3))
mapRedCmdHost3 = hrc;
}
}
}
Assert.assertNotNull(hdfsCmdHost3);
Assert.assertNotNull(hdfsCmdHost2);
ExecutionCommand execCmd = hdfsCmdHost3.getExecutionCommandWrapper()
.getExecutionCommand();
Assert.assertEquals(2, execCmd.getConfigurationTags().size());
Assert.assertEquals("version122", execCmd.getConfigurationTags().get
("core-site").get("tag"));
Assert.assertEquals("d", execCmd.getConfigurations().get("core-site")
.get("c"));
// Check if MapReduce client is reinstalled
Assert.assertNotNull(mapRedCmdHost2);
Assert.assertNotNull(mapRedCmdHost3);
/**
* Test for lost host
*/
// Stop HDFS & MAPREDUCE
stopService(clusterName, serviceName1, false, false);
stopService(clusterName, serviceName2, false, false);
clusters.getHost(host2).setState(HostState.HEARTBEAT_LOST);
// Start
requestId2 = startService(clusterName, serviceName1, true, true);
requestId3 = startService(clusterName, serviceName2, true, true);
stages = actionDB.getAllStages(requestId2);
stages.addAll(actionDB.getAllStages(requestId3));
HostRoleCommand clientWithHostDown = null;
for (Stage stage : stages) {
for (HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().toString().equals("MAPREDUCE_CLIENT") && hrc
.getHostName().equals(host2))
clientWithHostDown = hrc;
}
}
Assert.assertNull(clientWithHostDown);
}
@Test
public void testClientServiceSmokeTests() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "PIG";
createService(clusterName, serviceName, null);
String componentName1 = "PIG";
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").persist();
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h2").setOsType("centos6");
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
// null service should work
createServiceComponentHost(clusterName, null, componentName1,
host1, null);
createServiceComponentHost(clusterName, null, componentName1,
host2, null);
ServiceRequest r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r);
RequestStatusResponse trackAction =
controller.updateServices(requests, mapRequestProps, true, false);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
Assert.assertEquals(State.INSTALLED, sc.getDesiredState());
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INSTALLED, sch.getDesiredState());
Assert.assertEquals(State.INIT, sch.getState());
}
}
List<ShortTaskStatus> taskStatuses = trackAction.getTasks();
Assert.assertEquals(2, taskStatuses.size());
List<Stage> stages = actionDB.getAllStages(trackAction.getRequestId());
Assert.assertEquals(1, stages.size());
Assert.assertEquals("Called from a test", stages.get(0).getRequestContext());
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
r = new ServiceRequest(clusterName, serviceName, null,
State.STARTED.toString());
requests.clear();
requests.add(r);
trackAction = controller.updateServices(requests, mapRequestProps, true, false);
Assert.assertNotNull(trackAction);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
Assert.assertEquals(State.INSTALLED, sc.getDesiredState());
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INSTALLED, sch.getDesiredState());
Assert.assertEquals(State.INSTALLED, sch.getState());
}
}
stages = actionDB.getAllStages(trackAction.getRequestId());
for (Stage s : stages) {
LOG.info("Stage dump : " + s.toString());
}
Assert.assertEquals(1, stages.size());
taskStatuses = trackAction.getTasks();
Assert.assertEquals(1, taskStatuses.size());
Assert.assertEquals(Role.PIG_SERVICE_CHECK.toString(),
taskStatuses.get(0).getRole());
}
@Test
public void testServiceCheckWhenHostIsUnhealthy() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
String host3 = "h3";
clusters.addHost(host3);
clusters.getHost("h3").setOsType("centos6");
clusters.getHost("h3").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
clusters.mapHostToCluster(host3, clusterName);
createServiceComponentHost(clusterName, serviceName, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host3, null);
// Install
installService(clusterName, serviceName, false, false);
clusters.getHost("h3").setState(HostState.UNHEALTHY);
clusters.getHost("h2").setState(HostState.HEALTHY);
// Start
long requestId = startService(clusterName, serviceName, true, false);
List<HostRoleCommand> commands = actionDB.getRequestTasks(requestId);
int commandCount = 0;
for(HostRoleCommand command : commands) {
if(command.getRoleCommand() == RoleCommand.EXECUTE &&
command.getRole() == Role.HDFS_SERVICE_CHECK) {
Assert.assertTrue(command.getHostName().equals("h2"));
commandCount++;
}
}
Assert.assertEquals("Expect only one service check.", 1, commandCount);
stopService(clusterName, serviceName, false, false);
clusters.getHost("h3").setState(HostState.HEALTHY);
clusters.getHost("h2").setState(HostState.HEARTBEAT_LOST);
requestId = startService(clusterName, serviceName, true, false);
commands = actionDB.getRequestTasks(requestId);
commandCount = 0;
for(HostRoleCommand command : commands) {
if(command.getRoleCommand() == RoleCommand.EXECUTE &&
command.getRole() == Role.HDFS_SERVICE_CHECK) {
Assert.assertTrue(command.getHostName().equals("h3"));
commandCount++;
}
}
Assert.assertEquals("Expect only one service check.", 1, commandCount);
Set<ActionRequest> actionRequests = new HashSet<ActionRequest>();
ActionRequest actionRequest = new ActionRequest("foo1", "HDFS", Role.HDFS_SERVICE_CHECK.name(), null);
actionRequests.add(actionRequest);
Map<String, String> requestProperties = new HashMap<String, String>();
RequestStatusResponse response = controller.createActions(actionRequests, requestProperties);
commands = actionDB.getRequestTasks(response.getRequestId());
commandCount = 0;
for(HostRoleCommand command : commands) {
if(command.getRoleCommand() == RoleCommand.EXECUTE &&
command.getRole() == Role.HDFS_SERVICE_CHECK) {
Assert.assertTrue(command.getHostName().equals("h3"));
commandCount++;
}
}
Assert.assertEquals("Expect only one service check.", 1, commandCount);
// When both are unhealthy then just pick one
clusters.getHost("h3").setState(HostState.WAITING_FOR_HOST_STATUS_UPDATES);
clusters.getHost("h2").setState(HostState.INIT);
response = controller.createActions(actionRequests, requestProperties);
commands = actionDB.getRequestTasks(response.getRequestId());
commandCount = 0;
for(HostRoleCommand command : commands) {
if(command.getRoleCommand() == RoleCommand.EXECUTE &&
command.getRole() == Role.HDFS_SERVICE_CHECK) {
Assert.assertTrue(command.getHostName().equals("h3") ||
command.getHostName().equals("h2"));
commandCount++;
}
}
Assert.assertEquals("Expect only one service check.", 1, commandCount);
}
@Test
public void testReInstallForInstallFailedClient() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
String host3 = "h3";
clusters.addHost(host3);
clusters.getHost("h3").setOsType("centos6");
clusters.getHost("h3").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
clusters.mapHostToCluster(host3, clusterName);
createServiceComponentHost(clusterName, serviceName, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host3, null);
// Install
installService(clusterName, serviceName, false, false);
// Mark client as install failed.
Cluster cluster = clusters.getCluster(clusterName);
Service s = cluster.getService(serviceName);
ServiceComponent sc3 = s.getServiceComponent(componentName3);
for(ServiceComponentHost sch : sc3.getServiceComponentHosts().values()) {
if (sch.getHostName().equals(host3)) {
sch.setState(State.INSTALL_FAILED);
}
}
// Start
long requestId = startService(clusterName, serviceName, false, true);
List<Stage> stages = actionDB.getAllStages(requestId);
HostRoleCommand clientReinstallCmd = null;
for (Stage stage : stages) {
for (HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getHostName().equals(host3) && hrc.getRole().toString()
.equals("HDFS_CLIENT")) {
clientReinstallCmd = hrc;
break;
}
}
}
Assert.assertNotNull(clientReinstallCmd);
}
@Test
public void testHivePasswordAbsentInConfigs() throws AmbariException {
String clusterName = "c1";
String serviceName = "HIVE";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-1.2.0"));
createService(clusterName, serviceName, null);
String componentName1 = "HIVE_METASTORE";
String componentName2 = "HIVE_SERVER";
String componentName3 = "HIVE_CLIENT";
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
String host2 = "h2";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos5");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
createServiceComponentHost(clusterName, serviceName, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
Map<String, String> configs = new HashMap<String, String>();
configs.put("a", "b");
configs.put(Configuration.HIVE_METASTORE_PASSWORD_PROPERTY, "aaa");
ConfigurationRequest cr1;
cr1 = new ConfigurationRequest(clusterName, "hive-site","version1",
configs);
ClusterRequest crReq = new ClusterRequest(null, clusterName, null, null);
crReq.setDesiredConfig(cr1);
controller.updateCluster(crReq, null);
// Install
installService(clusterName, serviceName, false, false);
// Start
long requestId = startService(clusterName, serviceName, false, false);
String passwordInConfig = null;
List<Stage> stages = actionDB.getAllStages(requestId);
for (Stage s : stages) {
for (HostRoleCommand hrc : s.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.HIVE_CLIENT.toString())) {
Map<String, String> hiveSite = hrc.getExecutionCommandWrapper()
.getExecutionCommand().getConfigurations().get("hive-site");
Assert.assertNotNull(hiveSite);
Assert.assertEquals("b", hiveSite.get("a"));
passwordInConfig = hiveSite.get(Configuration
.HIVE_METASTORE_PASSWORD_PROPERTY);
}
}
}
Assert.assertNull(passwordInConfig);
}
@Test
public void testDecommissonDatanodeAction() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
createServiceComponentHost(clusterName, serviceName, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
// Install
installService(clusterName, serviceName, false, false);
// Create and attach config
Map<String, String> configs = new HashMap<String, String>();
configs.put("a", "b");
ConfigurationRequest cr1,cr2;
cr1 = new ConfigurationRequest(clusterName, "hdfs-site","version1",
configs);
ClusterRequest crReq = new ClusterRequest(null, clusterName, null, null);
crReq.setDesiredConfig(cr1);
controller.updateCluster(crReq, null);
Map<String, String> props = new HashMap<String, String>();
props.put("datanodes", host2);
cr2 = new ConfigurationRequest(clusterName, "hdfs-exclude-file", "tag1",
props);
crReq = new ClusterRequest(null, clusterName, null, null);
crReq.setDesiredConfig(cr2);
controller.updateCluster(crReq, null);
// Start
startService(clusterName, serviceName, false, false);
Cluster cluster = clusters.getCluster(clusterName);
Service s = cluster.getService(serviceName);
Assert.assertEquals(State.STARTED, s.getDesiredState());
Set<ActionRequest> requests = new HashSet<ActionRequest>();
Map<String, String> params = new HashMap<String, String>(){{
put("test", "test");
}};
ActionRequest request = new ActionRequest(clusterName, "HDFS",
Role.DECOMMISSION_DATANODE.name(), params);
params.put("excludeFileTag", "tag1");
requests.add(request);
Map<String, String> requestProperties = new HashMap<String, String>();
requestProperties.put(REQUEST_CONTEXT_PROPERTY, "Called from a test");
RequestStatusResponse response = controller.createActions(requests,
requestProperties);
List<HostRoleCommand> storedTasks = actionDB.getRequestTasks(response.getRequestId());
ExecutionCommand execCmd = storedTasks.get(0).getExecutionCommandWrapper
().getExecutionCommand();
Assert.assertNotNull(storedTasks);
Assert.assertNotNull(execCmd.getConfigurationTags().get("hdfs-site"));
Assert.assertEquals(1, storedTasks.size());
Assert.assertEquals(host2, execCmd.getConfigurations().get
("hdfs-exclude-file").get("datanodes"));
}
@Test
public void testConfigsAttachedToServiceChecks() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
// null service should work
createServiceComponentHost(clusterName, null, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
// Create and attach config
Map<String, String> configs = new HashMap<String, String>();
configs.put("a", "b");
ConfigurationRequest cr1,cr2;
cr1 = new ConfigurationRequest(clusterName, "core-site","version1",
configs);
cr2 = new ConfigurationRequest(clusterName, "hdfs-site","version1",
configs);
ClusterRequest crReq = new ClusterRequest(null, clusterName, null, null);
crReq.setDesiredConfig(cr1);
controller.updateCluster(crReq, null);
crReq = new ClusterRequest(null, clusterName, null, null);
crReq.setDesiredConfig(cr2);
controller.updateCluster(crReq, null);
// Install
installService(clusterName, serviceName, false, false);
// Start
long requestId = startService(clusterName, serviceName, true, false);
List<Stage> stages = actionDB.getAllStages(requestId);
boolean serviceCheckFound = false;
for (Stage stage : stages) {
for (HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.HDFS_SERVICE_CHECK)) {
serviceCheckFound = true;
Assert.assertEquals(2, hrc.getExecutionCommandWrapper()
.getExecutionCommand().getConfigurationTags().size());
}
}
}
Assert.assertEquals(true, serviceCheckFound);
}
@Test
public void testConfigsAttachedToServiceNotCluster() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName).setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
// null service should work
createServiceComponentHost(clusterName, null, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
// Create and attach config
Map<String, String> configs = new HashMap<String, String>();
configs.put("a", "b");
ConfigurationRequest cr1,cr2;
cr1 = new ConfigurationRequest(clusterName, "core-site","version1",
configs);
cr2 = new ConfigurationRequest(clusterName, "hdfs-site","version1",
configs);
// create, but don't assign
controller.createConfiguration(cr1);
controller.createConfiguration(cr2);
Map<String,String> configVersions = new HashMap<String,String>() {{
put("core-site", "version1");
put("hdfs-site", "version1");
}};
ServiceRequest sr = new ServiceRequest(clusterName, serviceName, configVersions, null);
controller.updateServices(Collections.singleton(sr), new HashMap<String,String>(), false, false);
// Install
installService(clusterName, serviceName, false, false);
// Start
long requestId = startService(clusterName, serviceName, true, false);
Assert.assertEquals(0, clusters.getCluster(clusterName).getDesiredConfigs().size());
List<Stage> stages = actionDB.getAllStages(requestId);
boolean serviceCheckFound = false;
for (Stage stage : stages) {
for (HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.HDFS_SERVICE_CHECK)) {
serviceCheckFound = true;
Assert.assertEquals(2, hrc.getExecutionCommandWrapper()
.getExecutionCommand().getConfigurationTags().size());
}
}
}
Assert.assertEquals(true, serviceCheckFound);
}
@Test
public void testStackVersionAsHostLevelParams() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "PIG";
createService(clusterName, serviceName, null);
String componentName1 = "PIG";
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").persist();
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h2").setOsType("centos6");
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
// null service should work
createServiceComponentHost(clusterName, null, componentName1,
host1, null);
createServiceComponentHost(clusterName, null, componentName1,
host2, null);
ServiceRequest r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r);
RequestStatusResponse trackAction =
controller.updateServices(requests, mapRequestProps, true, false);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
List<Stage> stages = actionDB.getAllStages(trackAction.getRequestId());
Assert.assertEquals("0.1", stages.get(0).getOrderedHostRoleCommands().get
(0).getExecutionCommandWrapper().getExecutionCommand()
.getHostLevelParams().get("stack_version"));
}
@Test
public void testGetStacks() throws Exception {
StackRequest request = new StackRequest(null);
Set<StackResponse> responses = controller.getStacks(Collections.singleton(request));
Assert.assertEquals(STACKS_CNT, responses.size());
StackRequest requestWithParams = new StackRequest(STACK_NAME);
Set<StackResponse> responsesWithParams = controller.getStacks(Collections.singleton(requestWithParams));
Assert.assertEquals(1, responsesWithParams.size());
for (StackResponse responseWithParams: responsesWithParams) {
Assert.assertEquals(responseWithParams.getStackName(), STACK_NAME);
}
StackRequest invalidRequest = new StackRequest(NON_EXT_VALUE);
try {
controller.getStacks(Collections.singleton(invalidRequest));
} catch (StackAccessException e) {
Assert.assertTrue(e instanceof StackAccessException);
}
}
@Test
public void testGetStackVersions() throws Exception {
StackVersionRequest request = new StackVersionRequest(STACK_NAME, null);
Set<StackVersionResponse> responses = controller.getStackVersions(Collections.singleton(request));
Assert.assertEquals(STACK_VERSIONS_CNT, responses.size());
StackVersionRequest requestWithParams = new StackVersionRequest(STACK_NAME, STACK_VERSION);
Set<StackVersionResponse> responsesWithParams = controller.getStackVersions(Collections.singleton(requestWithParams));
Assert.assertEquals(1, responsesWithParams.size());
for (StackVersionResponse responseWithParams: responsesWithParams) {
Assert.assertEquals(responseWithParams.getStackVersion(), STACK_VERSION);
}
StackVersionRequest invalidRequest = new StackVersionRequest(STACK_NAME, NON_EXT_VALUE);
try {
controller.getStackVersions(Collections.singleton(invalidRequest));
} catch (StackAccessException e) {
Assert.assertTrue(e instanceof StackAccessException);
}
}
@Test
public void testGetRepositories() throws Exception {
RepositoryRequest request = new RepositoryRequest(STACK_NAME, STACK_VERSION, OS_TYPE, null);
Set<RepositoryResponse> responses = controller.getRepositories(Collections.singleton(request));
Assert.assertEquals(REPOS_CNT, responses.size());
RepositoryRequest requestWithParams = new RepositoryRequest(STACK_NAME, STACK_VERSION, OS_TYPE, REPO_ID);
Set<RepositoryResponse> responsesWithParams = controller.getRepositories(Collections.singleton(requestWithParams));
Assert.assertEquals(1, responsesWithParams.size());
for (RepositoryResponse responseWithParams: responsesWithParams) {
Assert.assertEquals(responseWithParams.getRepoId(), REPO_ID);
}
RepositoryRequest invalidRequest = new RepositoryRequest(STACK_NAME, STACK_VERSION, OS_TYPE, NON_EXT_VALUE);
try {
controller.getRepositories(Collections.singleton(invalidRequest));
} catch (StackAccessException e) {
Assert.assertTrue(e instanceof StackAccessException);
}
}
@Test
public void testGetStackServices() throws Exception {
StackServiceRequest request = new StackServiceRequest(STACK_NAME, STACK_VERSION, null);
Set<StackServiceResponse> responses = controller.getStackServices(Collections.singleton(request));
Assert.assertEquals(STACK_SERVICES_CNT, responses.size());
StackServiceRequest requestWithParams = new StackServiceRequest(STACK_NAME, STACK_VERSION, SERVICE_NAME);
Set<StackServiceResponse> responsesWithParams = controller.getStackServices(Collections.singleton(requestWithParams));
Assert.assertEquals(1, responsesWithParams.size());
for (StackServiceResponse responseWithParams: responsesWithParams) {
Assert.assertEquals(responseWithParams.getServiceName(), SERVICE_NAME);
}
StackServiceRequest invalidRequest = new StackServiceRequest(STACK_NAME, STACK_VERSION, NON_EXT_VALUE);
try {
controller.getStackServices(Collections.singleton(invalidRequest));
} catch (StackAccessException e) {
Assert.assertTrue(e instanceof StackAccessException);
}
}
@Test
public void testGetStackConfigurations() throws Exception {
StackConfigurationRequest request = new StackConfigurationRequest(STACK_NAME, STACK_VERSION, SERVICE_NAME, null);
Set<StackConfigurationResponse> responses = controller.getStackConfigurations(Collections.singleton(request));
Assert.assertEquals(STACK_PROPERTIES_CNT, responses.size());
StackConfigurationRequest requestWithParams = new StackConfigurationRequest(STACK_NAME, STACK_VERSION, SERVICE_NAME, PROPERTY_NAME);
Set<StackConfigurationResponse> responsesWithParams = controller.getStackConfigurations(Collections.singleton(requestWithParams));
Assert.assertEquals(1, responsesWithParams.size());
for (StackConfigurationResponse responseWithParams: responsesWithParams) {
Assert.assertEquals(responseWithParams.getPropertyName(), PROPERTY_NAME);
}
StackConfigurationRequest invalidRequest = new StackConfigurationRequest(STACK_NAME, STACK_VERSION, SERVICE_NAME, NON_EXT_VALUE);
try {
controller.getStackConfigurations(Collections.singleton(invalidRequest));
} catch (StackAccessException e) {
Assert.assertTrue(e instanceof StackAccessException);
}
}
@Test
public void testGetStackComponents() throws Exception {
StackServiceComponentRequest request = new StackServiceComponentRequest(STACK_NAME, STACK_VERSION, SERVICE_NAME, null);
Set<StackServiceComponentResponse> responses = controller.getStackComponents(Collections.singleton(request));
Assert.assertEquals(STACK_COMPONENTS_CNT, responses.size());
StackServiceComponentRequest requestWithParams = new StackServiceComponentRequest(STACK_NAME, STACK_VERSION, SERVICE_NAME, COMPONENT_NAME);
Set<StackServiceComponentResponse> responsesWithParams = controller.getStackComponents(Collections.singleton(requestWithParams));
Assert.assertEquals(1, responsesWithParams.size());
for (StackServiceComponentResponse responseWithParams: responsesWithParams) {
Assert.assertEquals(responseWithParams.getComponentName(), COMPONENT_NAME);
}
StackServiceComponentRequest invalidRequest = new StackServiceComponentRequest(STACK_NAME, STACK_VERSION, SERVICE_NAME, NON_EXT_VALUE);
try {
controller.getStackComponents(Collections.singleton(invalidRequest));
} catch (StackAccessException e) {
Assert.assertTrue(e instanceof StackAccessException);
}
}
@Test
public void testGetStackOperatingSystems() throws Exception {
OperatingSystemRequest request = new OperatingSystemRequest(STACK_NAME, STACK_VERSION, null);
Set<OperatingSystemResponse> responses = controller.getStackOperatingSystems(Collections.singleton(request));
Assert.assertEquals(OS_CNT, responses.size());
OperatingSystemRequest requestWithParams = new OperatingSystemRequest(STACK_NAME, STACK_VERSION, OS_TYPE);
Set<OperatingSystemResponse> responsesWithParams = controller.getStackOperatingSystems(Collections.singleton(requestWithParams));
Assert.assertEquals(1, responsesWithParams.size());
for (OperatingSystemResponse responseWithParams: responsesWithParams) {
Assert.assertEquals(responseWithParams.getOsType(), OS_TYPE);
}
OperatingSystemRequest invalidRequest = new OperatingSystemRequest(STACK_NAME, STACK_VERSION, NON_EXT_VALUE);
try {
controller.getStackOperatingSystems(Collections.singleton(invalidRequest));
} catch (StackAccessException e) {
Assert.assertTrue(e instanceof StackAccessException);
}
}
@Test
public void testServerActionForUpgradeFinalization() throws AmbariException {
String clusterName = "foo1";
StackId currentStackId = new StackId("HDP-0.1");
StackId newStackId = new StackId("HDP-0.2");
createCluster(clusterName);
Cluster c = clusters.getCluster(clusterName);
c.setDesiredStackVersion(currentStackId);
Assert.assertTrue(c.getCurrentStackVersion().equals(currentStackId));
ServerActionManager serverActionManager = new ServerActionManagerImpl(clusters);
Map<String, String> payload = new HashMap<String, String>();
payload.put(ServerAction.PayloadName.CLUSTER_NAME, clusterName);
payload.put(ServerAction.PayloadName.CURRENT_STACK_VERSION, newStackId.getStackId());
serverActionManager.executeAction(ServerAction.Command.FINALIZE_UPGRADE, payload);
Assert.assertTrue(c.getCurrentStackVersion().equals(newStackId));
}
@Test
public void testUpdateClusterVersionBasic() throws AmbariException {
String clusterName = "foo1";
String serviceName = "MAPREDUCE";
String host1 = "h1";
String host2 = "h2";
String componentName = "JOBTRACKER";
StackId currentStackId = new StackId("HDP-0.1");
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createCluster(clusterName);
Cluster c = clusters.getCluster(clusterName);
c.setDesiredStackVersion(currentStackId);
createService(clusterName, serviceName, State.INIT);
createServiceComponent(clusterName, serviceName, componentName, null);
clusters.addHost(host1);
clusters.getHost(host1).persist();
clusters.addHost(host2);
clusters.getHost(host2).persist();
clusters.getHost(host1).setOsType("centos5");
clusters.getHost(host2).setOsType("centos6");
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
createServiceComponentHost(clusterName, null, componentName,
host1, null);
createServiceComponentHost(clusterName, null, componentName,
host2, null);
c.getService(serviceName).setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1)
.setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2)
.setDesiredState(State.STARTED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1)
.setState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2)
.setState(State.STARTED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1)
.setStackVersion(currentStackId);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2)
.setStackVersion(currentStackId);
ClusterRequest r = new ClusterRequest(c.getClusterId(), clusterName, "HDP-0.0.1", null);
try {
controller.updateCluster(r, mapRequestProps);
fail("Update cluster should fail");
} catch (AmbariException e) {
Assert.assertTrue(e.getMessage().contains("must be greater than current version"));
}
r = new ClusterRequest(c.getClusterId(), clusterName, "HDPLocal-1.2.2", null);
try {
controller.updateCluster(r, mapRequestProps);
fail("Update cluster should fail");
} catch (AmbariException e) {
Assert.assertTrue(e.getMessage().contains("Upgrade not possible between different stacks"));
}
r = new ClusterRequest(c.getClusterId(), clusterName, "HDP-0.2", null);
try {
controller.updateCluster(r, mapRequestProps);
fail("Update cluster should fail");
} catch (AmbariException e) {
Assert.assertTrue(e.getMessage().contains("Upgrade needs all services to be stopped"));
Assert.assertTrue(e.getMessage().contains(serviceName));
}
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2)
.setDesiredState(State.INSTALLED);
r = new ClusterRequest(c.getClusterId(), clusterName, "HDP-0.2", null);
try {
controller.updateCluster(r, mapRequestProps);
fail("Update cluster should fail");
} catch (AmbariException e) {
Assert.assertTrue(e.getMessage().contains("Upgrade needs all services to be stopped"));
Assert.assertTrue(e.getMessage().contains(componentName));
}
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2)
.setState(State.INSTALLED);
controller.updateCluster(r, mapRequestProps);
StackId expectedStackId = new StackId("HDP-0.2");
Assert.assertTrue(expectedStackId.equals(c.getDesiredStackVersion()));
Assert.assertTrue(expectedStackId.equals(c.getService(serviceName).getDesiredStackVersion()));
Assert.assertTrue(expectedStackId.equals(c.getService(serviceName)
.getServiceComponent(componentName).getDesiredStackVersion()));
Assert.assertTrue(expectedStackId.equals(c.getService(serviceName)
.getServiceComponent(componentName).getServiceComponentHost(host1).getDesiredStackVersion()));
Assert.assertTrue(expectedStackId.equals(c.getService(serviceName)
.getServiceComponent(componentName).getServiceComponentHost(host2).getDesiredStackVersion()));
Assert.assertTrue(currentStackId.equals(c.getService(serviceName)
.getServiceComponent(componentName).getServiceComponentHost(host1).getStackVersion()));
Assert.assertTrue(currentStackId.equals(c.getService(serviceName)
.getServiceComponent(componentName).getServiceComponentHost(host2).getStackVersion()));
ServiceComponent sc = c.getService(serviceName).getServiceComponent(componentName);
Assert.assertEquals(State.UPGRADING, sc.getServiceComponentHost(host1).getState());
Assert.assertEquals(State.UPGRADING, sc.getServiceComponentHost(host2).getState());
// Fail as another request is active
try {
controller.updateCluster(r, mapRequestProps);
fail("Update cluster should fail");
} catch (AmbariException e) {
Assert.assertTrue(e.getMessage().contains("A prior upgrade request with id"));
}
// cases where there is no update required
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1)
.setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2)
.setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1)
.setState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2)
.setState(State.INSTALLED);
c.setCurrentStackVersion(expectedStackId);
r = new ClusterRequest(c.getClusterId(), clusterName, "", null);
controller.updateCluster(r, mapRequestProps);
Assert.assertEquals(State.INSTALLED, sc.getServiceComponentHost(host1).getState());
Assert.assertEquals(State.INSTALLED, sc.getServiceComponentHost(host2).getState());
r = new ClusterRequest(c.getClusterId(), clusterName, null, null);
controller.updateCluster(r, mapRequestProps);
Assert.assertEquals(State.INSTALLED, sc.getServiceComponentHost(host1).getState());
Assert.assertEquals(State.INSTALLED, sc.getServiceComponentHost(host2).getState());
r = new ClusterRequest(c.getClusterId(), clusterName, "HDP-0.2", null);
controller.updateCluster(r, mapRequestProps);
Assert.assertEquals(State.INSTALLED, sc.getServiceComponentHost(host1).getState());
Assert.assertEquals(State.INSTALLED, sc.getServiceComponentHost(host2).getState());
}
@Test
public void testUpdateClusterUpgradabilityCheck() throws AmbariException {
String clusterName = "foo1";
StackId currentStackId = new StackId("HDP-0.2");
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createCluster(clusterName);
Cluster c = clusters.getCluster(clusterName);
c.setDesiredStackVersion(currentStackId);
ClusterRequest r = new ClusterRequest(c.getClusterId(), clusterName, "HDP-0.3", null);
try {
controller.updateCluster(r, mapRequestProps);
} catch (AmbariException e) {
Assert.assertTrue(e.getMessage().contains("Illegal request to upgrade to"));
}
StackId unsupportedStackId = new StackId("HDP-0.0.1");
c.setDesiredStackVersion(unsupportedStackId);
c.setCurrentStackVersion(unsupportedStackId);
c.refresh();
r = new ClusterRequest(c.getClusterId(), clusterName, "HDP-0.2", null);
try {
controller.updateCluster(r, mapRequestProps);
} catch (AmbariException e) {
Assert.assertTrue(e.getMessage().contains("Upgrade is not allowed from"));
}
}
@Test
public void testUpdateClusterVersionCombinations() throws AmbariException {
String clusterName = "foo1";
String pigServiceName = "PIG";
String mrServiceName = "MAPREDUCE";
String host1 = "h1";
String host2 = "h2";
String pigComponentName = "PIG";
String mrJobTrackerComp = "JOBTRACKER";
String mrTaskTrackerComp = "TASKTRACKER";
String mrClientComp = "MAPREDUCE_CLIENT";
String hdfsService = "HDFS";
String hdfsNameNode = "NAMENODE";
String hdfsDataNode = "DATANODE";
String hdfsClient = "HDFS_CLIENT";
StackId currentStackId = new StackId("HDP-0.1");
StackId desiredStackId = new StackId("HDP-0.2");
List<String> hosts = new ArrayList<String>();
hosts.add(host1);
hosts.add(host2);
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
createCluster(clusterName);
Cluster c = clusters.getCluster(clusterName);
c.setDesiredStackVersion(currentStackId);
createService(clusterName, pigServiceName, State.INIT);
createServiceComponent(clusterName, pigServiceName, pigComponentName, null);
clusters.addHost(host1);
clusters.getHost(host1).persist();
clusters.addHost(host2);
clusters.getHost(host2).persist();
clusters.getHost(host1).setOsType("centos5");
clusters.getHost(host2).setOsType("centos6");
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
createServiceComponentHost(clusterName, null, pigComponentName,
host1, null);
createServiceComponentHost(clusterName, null, pigComponentName,
host2, null);
resetServiceState(pigServiceName, currentStackId, c);
ClusterRequest r = new ClusterRequest(c.getClusterId(), clusterName, "HDP-0.2", null);
RequestStatusResponse trackAction = controller.updateCluster(r, mapRequestProps);
List<Stage> stages = actionDB.getAllStages(trackAction.getRequestId());
// Upgrade a cluster with one service
ExpectedUpgradeTasks expectedTasks = new ExpectedUpgradeTasks(hosts);
expectedTasks.expectTask(Role.PIG, host1);
expectedTasks.expectTask(Role.PIG, host2);
expectedTasks.expectTask(Role.AMBARI_SERVER_ACTION);
validateGeneratedStages(stages, 2, expectedTasks);
resetCluster(c, currentStackId);
createService(clusterName, mrServiceName, State.INIT);
createServiceComponent(clusterName, mrServiceName, mrJobTrackerComp, null);
createServiceComponent(clusterName, mrServiceName, mrTaskTrackerComp, null);
createServiceComponent(clusterName, mrServiceName, mrClientComp, null);
createServiceComponentHost(clusterName, null, mrJobTrackerComp, host1, null);
createServiceComponentHost(clusterName, null, mrTaskTrackerComp, host2, null);
createServiceComponentHost(clusterName, null, mrClientComp, host2, null);
resetServiceState(mrServiceName, currentStackId, c);
// Upgrade a cluster with two service
actionDB.abortOperation(trackAction.getRequestId());
r = new ClusterRequest(c.getClusterId(), clusterName, "HDP-0.2", null);
trackAction = controller.updateCluster(r, mapRequestProps);
stages = actionDB.getAllStages(trackAction.getRequestId());
expectedTasks.expectTask(Role.JOBTRACKER, host1);
expectedTasks.expectTask(Role.TASKTRACKER, host2);
expectedTasks.expectTask(Role.MAPREDUCE_CLIENT, host2);
validateGeneratedStages(stages, 5, expectedTasks);
// Upgrade again
actionDB.abortOperation(trackAction.getRequestId());
trackAction = controller.updateCluster(r, mapRequestProps);
stages = actionDB.getAllStages(trackAction.getRequestId());
validateGeneratedStages(stages, 5, expectedTasks);
// some host components are upgraded
c.getService(pigServiceName).getServiceComponent(pigComponentName).getServiceComponentHost(host1)
.setState(State.INSTALLED);
c.getService(pigServiceName).getServiceComponent(pigComponentName).getServiceComponentHost(host2)
.setState(State.INSTALLED);
c.getService(pigServiceName).getServiceComponent(pigComponentName).getServiceComponentHost(host1)
.setStackVersion(desiredStackId);
c.getService(pigServiceName).getServiceComponent(pigComponentName).getServiceComponentHost(host2)
.setStackVersion(desiredStackId);
actionDB.abortOperation(trackAction.getRequestId());
trackAction = controller.updateCluster(r, mapRequestProps);
stages = actionDB.getAllStages(trackAction.getRequestId());
validateGeneratedStages(stages, 5, expectedTasks);
c.getService(mrServiceName).getServiceComponent(mrJobTrackerComp).getServiceComponentHost(host1)
.setState(State.UPGRADING);
c.getService(mrServiceName).getServiceComponent(mrTaskTrackerComp).getServiceComponentHost(host2)
.setState(State.UPGRADING);
actionDB.abortOperation(trackAction.getRequestId());
trackAction = controller.updateCluster(r, mapRequestProps);
stages = actionDB.getAllStages(trackAction.getRequestId());
validateGeneratedStages(stages, 5, expectedTasks);
// Add HDFS and upgrade
createService(clusterName, hdfsService, State.INIT);
createServiceComponent(clusterName, hdfsService, hdfsNameNode, null);
createServiceComponent(clusterName, hdfsService, hdfsDataNode, null);
createServiceComponent(clusterName, hdfsService, hdfsClient, null);
createServiceComponentHost(clusterName, null, hdfsNameNode, host1, null);
createServiceComponentHost(clusterName, null, hdfsDataNode, host1, null);
createServiceComponentHost(clusterName, null, hdfsDataNode, host2, null);
createServiceComponentHost(clusterName, null, hdfsClient, host2, null);
resetServiceState(hdfsService, currentStackId, c);
resetServiceState(mrServiceName, currentStackId, c);
resetServiceState(pigServiceName, currentStackId, c);
actionDB.abortOperation(trackAction.getRequestId());
trackAction = controller.updateCluster(r, mapRequestProps);
stages = actionDB.getAllStages(trackAction.getRequestId());
expectedTasks.resetAll();
expectedTasks.expectTask(Role.PIG, host1);
expectedTasks.expectTask(Role.PIG, host2);
expectedTasks.expectTask(Role.JOBTRACKER, host1);
expectedTasks.expectTask(Role.TASKTRACKER, host2);
expectedTasks.expectTask(Role.MAPREDUCE_CLIENT, host2);
expectedTasks.expectTask(Role.DATANODE, host1);
expectedTasks.expectTask(Role.DATANODE, host2);
expectedTasks.expectTask(Role.NAMENODE, host1);
expectedTasks.expectTask(Role.HDFS_CLIENT, host2);
expectedTasks.expectTask(Role.AMBARI_SERVER_ACTION);
validateGeneratedStages(stages, 8, expectedTasks);
}
private void resetServiceState(String service, StackId currentStackId, Cluster c) throws AmbariException {
c.getService(service).setDesiredState(State.INSTALLED);
for (ServiceComponent sc : c.getService(service).getServiceComponents().values()) {
sc.setDesiredState(State.INSTALLED);
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setDesiredState(State.INSTALLED);
sch.setState(State.INSTALLED);
sch.setStackVersion(currentStackId);
}
}
}
private void validateGeneratedStages(List<Stage> stages, int expectedStageCount, ExpectedUpgradeTasks expectedTasks) {
Assert.assertEquals(expectedStageCount, stages.size());
int prevRoleOrder = -1;
for (Stage stage : stages) {
int currRoleOrder = -1;
for (HostRoleCommand command : stage.getOrderedHostRoleCommands()) {
if(command.getRole() == Role.AMBARI_SERVER_ACTION) {
Assert.assertTrue(command.toString(), expectedTasks.isTaskExpected(command.getRole()));
currRoleOrder = expectedTasks.getRoleOrder(command.getRole());
ExecutionCommand execCommand = command.getExecutionCommandWrapper().getExecutionCommand();
Assert.assertTrue(
execCommand.getCommandParams().containsKey(ServerAction.PayloadName.CURRENT_STACK_VERSION));
Assert.assertTrue(
execCommand.getCommandParams().containsKey(ServerAction.PayloadName.CLUSTER_NAME));
Assert.assertEquals(RoleCommand.EXECUTE, execCommand.getRoleCommand());
} else {
Assert.assertTrue(command.toString(), expectedTasks.isTaskExpected(command.getRole(), command.getHostName()));
currRoleOrder = expectedTasks.getRoleOrder(command.getRole());
ExecutionCommand execCommand = command.getExecutionCommandWrapper().getExecutionCommand();
Assert.assertTrue(execCommand.getCommandParams().containsKey("source_stack_version"));
Assert.assertTrue(execCommand.getCommandParams().containsKey("target_stack_version"));
Assert.assertEquals(RoleCommand.UPGRADE, execCommand.getRoleCommand());
}
}
List<HostRoleCommand> commands = stage.getOrderedHostRoleCommands();
Assert.assertTrue(commands.size() > 0);
Role role = commands.get(0).getRole();
for (HostRoleCommand command : commands) {
Assert.assertTrue("All commands must be for the same role", role.equals(command.getRole()));
}
Assert.assertTrue("Roles must be in order", currRoleOrder > prevRoleOrder);
prevRoleOrder = currRoleOrder;
}
}
private void resetCluster(Cluster cluster, StackId currentStackId) {
cluster.setDesiredStackVersion(currentStackId);
for (Service service : cluster.getServices().values()) {
service.setDesiredStackVersion(currentStackId);
for (ServiceComponent component : service.getServiceComponents().values()) {
component.setDesiredStackVersion(currentStackId);
for (ServiceComponentHost componentHost : component.getServiceComponentHosts().values()) {
componentHost.setDesiredStackVersion(currentStackId);
componentHost.setState(State.INSTALLED);
}
}
}
}
class ExpectedUpgradeTasks {
private static final int ROLE_COUNT = 25;
private static final String DEFAULT_HOST = "default_host";
private ArrayList<Map<String, Boolean>> expectedList;
private Map<Role, Integer> roleToIndex;
public ExpectedUpgradeTasks(List<String> hosts) {
roleToIndex = new HashMap<Role, Integer>();
expectedList = new ArrayList<Map<String, Boolean>>(ROLE_COUNT);
fillRoleToIndex();
fillExpectedHosts(hosts);
}
public void expectTask(Role role, String host) {
expectedList.get(roleToIndex.get(role)).put(host, true);
}
public void expectTask(Role role) {
Assert.assertEquals(Role.AMBARI_SERVER_ACTION, role);
expectTask(role, DEFAULT_HOST);
}
public boolean isTaskExpected(Role role, String host) {
return expectedList.get(roleToIndex.get(role)).get(host);
}
public boolean isTaskExpected(Role role) {
Assert.assertEquals(Role.AMBARI_SERVER_ACTION, role);
return isTaskExpected(role, DEFAULT_HOST);
}
public int getRoleOrder(Role role) {
return roleToIndex.get(role);
}
public void resetAll() {
for (Role role : roleToIndex.keySet()) {
Map<String, Boolean> hostState = expectedList.get(roleToIndex.get(role));
for (String host : hostState.keySet()) {
hostState.put(host, false);
}
}
}
private void fillExpectedHosts(List<String> hosts) {
for (int index = 0; index < ROLE_COUNT; index++) {
Map<String, Boolean> hostState = new HashMap<String, Boolean>();
for (String host : hosts) {
hostState.put(host, false);
}
expectedList.add(hostState);
}
}
private void fillRoleToIndex() {
this.roleToIndex.put(Role.NAMENODE, 0);
this.roleToIndex.put(Role.SECONDARY_NAMENODE, 1);
this.roleToIndex.put(Role.DATANODE, 2);
this.roleToIndex.put(Role.HDFS_CLIENT, 3);
this.roleToIndex.put(Role.JOBTRACKER, 4);
this.roleToIndex.put(Role.TASKTRACKER, 5);
this.roleToIndex.put(Role.MAPREDUCE_CLIENT, 6);
this.roleToIndex.put(Role.ZOOKEEPER_SERVER, 7);
this.roleToIndex.put(Role.ZOOKEEPER_CLIENT, 8);
this.roleToIndex.put(Role.HBASE_MASTER, 9);
this.roleToIndex.put(Role.HBASE_REGIONSERVER, 10);
this.roleToIndex.put(Role.HBASE_CLIENT, 11);
this.roleToIndex.put(Role.HIVE_SERVER, 12);
this.roleToIndex.put(Role.HIVE_METASTORE, 13);
this.roleToIndex.put(Role.HIVE_CLIENT, 14);
this.roleToIndex.put(Role.HCAT, 15);
this.roleToIndex.put(Role.OOZIE_SERVER, 16);
this.roleToIndex.put(Role.OOZIE_CLIENT, 17);
this.roleToIndex.put(Role.WEBHCAT_SERVER, 18);
this.roleToIndex.put(Role.PIG, 19);
this.roleToIndex.put(Role.SQOOP, 20);
this.roleToIndex.put(Role.GANGLIA_SERVER, 21);
this.roleToIndex.put(Role.GANGLIA_MONITOR, 22);
this.roleToIndex.put(Role.NAGIOS_SERVER, 23);
this.roleToIndex.put(Role.AMBARI_SERVER_ACTION, 24);
}
}
@Test
public void testServiceStopWhileStopping() throws AmbariException {
String clusterName = "foo1";
createCluster(clusterName);
clusters.getCluster(clusterName)
.setDesiredStackVersion(new StackId("HDP-0.1"));
String serviceName = "HDFS";
createService(clusterName, serviceName, null);
String componentName1 = "NAMENODE";
String componentName2 = "DATANODE";
String componentName3 = "HDFS_CLIENT";
createServiceComponent(clusterName, serviceName, componentName1,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName2,
State.INIT);
createServiceComponent(clusterName, serviceName, componentName3,
State.INIT);
String host1 = "h1";
clusters.addHost(host1);
clusters.getHost("h1").setOsType("centos5");
clusters.getHost("h1").persist();
String host2 = "h2";
clusters.addHost(host2);
clusters.getHost("h2").setOsType("centos6");
clusters.getHost("h2").persist();
clusters.mapHostToCluster(host1, clusterName);
clusters.mapHostToCluster(host2, clusterName);
Map<String, String> mapRequestProps = new HashMap<String, String>();
mapRequestProps.put("context", "Called from a test");
// null service should work
createServiceComponentHost(clusterName, null, componentName1,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName2,
host2, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host1, null);
createServiceComponentHost(clusterName, serviceName, componentName3,
host2, null);
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName1)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName2)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName2)
.getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName3)
.getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName)
.getService(serviceName)
.getServiceComponent(componentName3)
.getServiceComponentHost(host2));
// Install
ServiceRequest r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
Set<ServiceRequest> requests = new HashSet<ServiceRequest>();
requests.add(r);
RequestStatusResponse trackAction =
controller.updateServices(requests, mapRequestProps, true, false);
Assert.assertEquals(State.INSTALLED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
// manually change live state to installed as no running action manager
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
// Start
r = new ServiceRequest(clusterName, serviceName, null,
State.STARTED.toString());
requests.clear();
requests.add(r);
trackAction = controller.updateServices(requests, mapRequestProps, true, false);
// manually change live state to started as no running action manager
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (!sch.getServiceComponentName().equals("HDFS_CLIENT"))
sch.setState(State.STARTED);
}
}
Assert.assertEquals(State.STARTED,
clusters.getCluster(clusterName).getService(serviceName)
.getDesiredState());
// Set Current state to stopping
clusters.getCluster(clusterName).getService(serviceName).setDesiredState
(State.STOPPING);
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (!sch.getServiceComponentName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.STARTED, sch.getDesiredState());
sch.setState(State.STOPPING);
} else if (sch.getServiceComponentName().equals("DATANODE")) {
ServiceComponentHostRequest r1 = new ServiceComponentHostRequest
(clusterName, serviceName, sch.getServiceComponentName(),
sch.getHostName(), null, State.INSTALLED.name());
Set<ServiceComponentHostRequest> reqs1 = new
HashSet<ServiceComponentHostRequest>();
reqs1.add(r1);
controller.updateHostComponents(reqs1, Collections.<String, String>emptyMap(), true);
Assert.assertEquals(State.INSTALLED, sch.getDesiredState());
}
}
}
// Stop all services
r = new ServiceRequest(clusterName, serviceName, null,
State.INSTALLED.toString());
requests.clear();
requests.add(r);
controller.updateServices(requests, mapRequestProps, true, false);
for (ServiceComponent sc :
clusters.getCluster(clusterName).getService(serviceName)
.getServiceComponents().values()) {
for (ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (!sch.getServiceComponentName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED, sch.getDesiredState());
}
}
}
}
}