| /** |
| * 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.internal; |
| |
| import static junit.framework.Assert.assertEquals; |
| import static junit.framework.Assert.assertNotNull; |
| import static junit.framework.Assert.assertNull; |
| import static junit.framework.Assert.assertTrue; |
| import static org.easymock.EasyMock.expect; |
| import static org.easymock.EasyMock.replay; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.apache.ambari.server.api.services.AmbariMetaInfo; |
| import org.apache.ambari.server.controller.ResourceProviderFactory; |
| import org.apache.ambari.server.controller.predicate.AndPredicate; |
| import org.apache.ambari.server.controller.predicate.OrPredicate; |
| import org.apache.ambari.server.controller.spi.Predicate; |
| import org.apache.ambari.server.controller.spi.Request; |
| import org.apache.ambari.server.controller.spi.Resource; |
| import org.apache.ambari.server.controller.spi.ResourceProvider; |
| import org.apache.ambari.server.controller.utilities.PredicateBuilder; |
| import org.apache.ambari.server.controller.utilities.PropertyHelper; |
| import org.apache.ambari.server.orm.GuiceJpaInitializer; |
| import org.apache.ambari.server.orm.InMemoryDefaultTestModule; |
| import org.apache.ambari.server.orm.dao.ClusterVersionDAO; |
| import org.apache.ambari.server.orm.dao.RepositoryVersionDAO; |
| import org.apache.ambari.server.orm.entities.RepositoryVersionEntity; |
| import org.apache.ambari.server.orm.entities.StackEntity; |
| import org.apache.ambari.server.security.TestAuthenticationFactory; |
| import org.apache.ambari.server.state.StackId; |
| import org.apache.ambari.server.state.StackInfo; |
| import org.apache.ambari.server.state.repository.AvailableService; |
| import org.apache.ambari.server.state.repository.ManifestServiceInfo; |
| import org.apache.ambari.server.state.repository.VersionDefinitionXml; |
| import org.apache.ambari.server.state.stack.UpgradePack; |
| import org.apache.ambari.server.state.stack.upgrade.UpgradeType; |
| import org.easymock.EasyMock; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| import org.springframework.security.core.context.SecurityContextHolder; |
| |
| import com.google.inject.Guice; |
| import com.google.inject.Injector; |
| import com.google.inject.persist.PersistService; |
| |
| /** |
| * CompatibleRepositoryVersionResourceProvider tests. |
| */ |
| public class CompatibleRepositoryVersionResourceProviderTest { |
| |
| private static Injector injector; |
| |
| private static String jsonStringRedhat6 = "[{\"OperatingSystems\":{\"os_type\":\"redhat6\"},\"repositories\":[]}]"; |
| private static StackId stackId11 = new StackId("HDP", "1.1"); |
| private static StackId stackId22 = new StackId("HDP", "2.2"); |
| |
| @Before |
| public void before() throws Exception { |
| final AmbariMetaInfo ambariMetaInfo = EasyMock.createMock(AmbariMetaInfo.class); |
| final ClusterVersionDAO clusterVersionDAO = EasyMock.createMock(ClusterVersionDAO.class); |
| |
| StackEntity hdp11Stack = new StackEntity(); |
| hdp11Stack.setStackName("HDP"); |
| hdp11Stack.setStackVersion("1.1"); |
| |
| RepositoryVersionEntity entity1 = new RepositoryVersionEntity(); |
| entity1.setDisplayName("name1"); |
| entity1.setOperatingSystems(jsonStringRedhat6); |
| entity1.setStack(hdp11Stack); |
| entity1.setVersion("1.1.1.1"); |
| entity1.setId(1L); |
| |
| StackEntity hdp22Stack = new StackEntity(); |
| hdp22Stack.setStackName("HDP"); |
| hdp22Stack.setStackVersion("2.2"); |
| |
| RepositoryVersionEntity entity2 = new ExtendedRepositoryVersionEntity(); |
| entity2.setDisplayName("name2"); |
| entity2.setOperatingSystems(jsonStringRedhat6); |
| entity2.setStack(hdp22Stack); |
| entity2.setVersion("2.2.2.2"); |
| entity2.setId(2L); |
| |
| final RepositoryVersionDAO repoVersionDAO = EasyMock.createMock(RepositoryVersionDAO.class); |
| |
| expect(repoVersionDAO.findByStack(stackId11)).andReturn(Collections.singletonList(entity1)).atLeastOnce(); |
| expect(repoVersionDAO.findByStack(stackId22)).andReturn(Collections.singletonList(entity2)).atLeastOnce(); |
| replay(repoVersionDAO); |
| |
| final StackInfo stack1 = new StackInfo() { |
| @Override |
| public Map<String, UpgradePack> getUpgradePacks() { |
| Map<String, UpgradePack> map = new HashMap<String, UpgradePack>(); |
| |
| UpgradePack pack1 = new UpgradePack() { |
| |
| @Override |
| public String getName() { |
| return "pack1"; |
| } |
| |
| @Override |
| public String getTarget() { |
| return "1.1.*.*"; |
| } |
| |
| @Override |
| public UpgradeType getType() { |
| return UpgradeType.ROLLING; |
| } |
| }; |
| |
| UpgradePack pack2 = new UpgradePack() { |
| @Override |
| public String getName() { |
| return "pack2"; |
| } |
| |
| @Override |
| public String getTarget() { |
| return "2.2.*.*"; |
| } |
| |
| @Override |
| public String getTargetStack() { |
| return "HDP-2.2"; |
| } |
| |
| @Override |
| public UpgradeType getType() { |
| return UpgradeType.NON_ROLLING; |
| } |
| }; |
| |
| UpgradePack pack3 = new UpgradePack() { |
| @Override |
| public String getName() { |
| return "pack2"; |
| } |
| |
| @Override |
| public String getTarget() { |
| return "2.2.*.*"; |
| } |
| |
| @Override |
| public String getTargetStack() { |
| return "HDP-2.2"; |
| } |
| |
| @Override |
| public UpgradeType getType() { |
| return UpgradeType.ROLLING; |
| } |
| }; |
| |
| map.put("pack1", pack1); |
| map.put("pack2", pack2); |
| map.put("pack3", pack3); |
| return map; |
| } |
| }; |
| |
| final StackInfo stack2 = new StackInfo() { |
| @Override |
| public Map<String, UpgradePack> getUpgradePacks() { |
| Map<String, UpgradePack> map = new HashMap<String, UpgradePack>(); |
| |
| UpgradePack pack = new UpgradePack() { |
| @Override |
| public String getName() { |
| return "pack2"; |
| } |
| |
| @Override |
| public String getTarget() { |
| return "2.2.*.*"; |
| } |
| |
| @Override |
| public UpgradeType getType() { |
| return UpgradeType.NON_ROLLING; |
| } |
| }; |
| |
| map.put("pack2", pack); |
| return map; |
| } |
| }; |
| |
| |
| InMemoryDefaultTestModule injectorModule = new InMemoryDefaultTestModule() { |
| @Override |
| protected void configure() { |
| super.configure(); |
| bind(AmbariMetaInfo.class).toInstance(ambariMetaInfo); |
| bind(ClusterVersionDAO.class).toInstance(clusterVersionDAO); |
| bind(RepositoryVersionDAO.class).toInstance(repoVersionDAO); |
| requestStaticInjection(CompatibleRepositoryVersionResourceProvider.class); |
| } |
| |
| ; |
| }; |
| injector = Guice.createInjector(injectorModule); |
| |
| expect(ambariMetaInfo.getStack("HDP", "1.1")).andReturn(stack1).atLeastOnce(); |
| expect(ambariMetaInfo.getStack("HDP", "2.2")).andReturn(stack2).atLeastOnce(); |
| expect(ambariMetaInfo.getUpgradePacks("HDP", "1.1")).andReturn(stack1.getUpgradePacks()).atLeastOnce(); |
| expect(ambariMetaInfo.getUpgradePacks("HDP", "2.2")).andReturn(stack2.getUpgradePacks()).atLeastOnce(); |
| |
| replay(ambariMetaInfo); |
| |
| injector.getInstance(GuiceJpaInitializer.class); |
| } |
| |
| @After |
| public void after() { |
| injector.getInstance(PersistService.class).stop(); |
| injector = null; |
| |
| SecurityContextHolder.getContext().setAuthentication(null); |
| } |
| |
| @Test |
| public void testVersionInStack() { |
| assertTrue(RepositoryVersionEntity.isVersionInStack(new StackId("HDP", "2.3"), "2.3.0.0")); |
| assertTrue(RepositoryVersionEntity.isVersionInStack(new StackId("HDPWIN", "2.3"), "2.3.0.0")); |
| |
| assertTrue(RepositoryVersionEntity.isVersionInStack(new StackId("HDP", "2.3"), "HDP-2.3.0.0")); |
| assertTrue(RepositoryVersionEntity.isVersionInStack(new StackId("HDPWIN", "2.3"), "HDPWIN-2.3.0.0")); |
| } |
| |
| @Test |
| public void testGetResources() throws Exception { |
| SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createClusterAdministrator("admin", 2L)); |
| |
| final ResourceProvider provider = injector.getInstance(ResourceProviderFactory.class).getRepositoryVersionResourceProvider(); |
| |
| Request getRequest = PropertyHelper.getReadRequest( |
| RepositoryVersionResourceProvider.REPOSITORY_VERSION_ID_PROPERTY_ID, |
| RepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID, |
| RepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_UPGRADES_SUPPORTED_TYPES_ID); |
| Predicate predicateStackName = new PredicateBuilder().property(RepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID).equals("HDP").toPredicate(); |
| Predicate predicateStackVersion = new PredicateBuilder().property(RepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID).equals("1.1").toPredicate(); |
| |
| // !!! non-compatible, within stack |
| assertEquals(1, provider.getResources(getRequest, new AndPredicate(predicateStackName, predicateStackVersion)).size()); |
| |
| CompatibleRepositoryVersionResourceProvider compatibleProvider = new CompatibleRepositoryVersionResourceProvider(null); |
| |
| getRequest = PropertyHelper.getReadRequest( |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_ID_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_UPGRADES_SUPPORTED_TYPES_ID); |
| predicateStackName = new PredicateBuilder().property(CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID).equals("HDP").toPredicate(); |
| predicateStackVersion = new PredicateBuilder().property(CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID).equals("1.1").toPredicate(); |
| |
| // !!! compatible, across stack |
| Set<Resource> resources = compatibleProvider.getResources(getRequest, new AndPredicate(predicateStackName, predicateStackVersion)); |
| assertEquals(2, resources.size()); |
| |
| // Test For Upgrade Types |
| Map<String, List<UpgradeType>> versionToUpgradeTypesMap = new HashMap<>(); |
| versionToUpgradeTypesMap.put("1.1", Arrays.asList(UpgradeType.ROLLING)); |
| versionToUpgradeTypesMap.put("2.2", Arrays.asList(UpgradeType.NON_ROLLING, UpgradeType.ROLLING)); |
| assertEquals(versionToUpgradeTypesMap.size(), checkUpgradeTypes(resources, versionToUpgradeTypesMap)); |
| |
| // !!! verify we can get services |
| RepositoryVersionDAO dao = injector.getInstance(RepositoryVersionDAO.class); |
| List<RepositoryVersionEntity> entities = dao.findByStack(stackId22); |
| assertEquals(1, entities.size()); |
| RepositoryVersionEntity entity = entities.get(0); |
| assertTrue(ExtendedRepositoryVersionEntity.class.isInstance(entity)); |
| |
| VersionDefinitionXml mockXml = EasyMock.createMock(VersionDefinitionXml.class); |
| AvailableService mockAvailable = EasyMock.createMock(AvailableService.class); |
| ManifestServiceInfo mockStackService = EasyMock.createMock(ManifestServiceInfo.class); |
| |
| expect(mockXml.getAvailableServices((StackInfo)EasyMock.anyObject())).andReturn(Collections.singletonList(mockAvailable)).atLeastOnce(); |
| expect(mockXml.getStackServices((StackInfo)EasyMock.anyObject())).andReturn(Collections.singletonList(mockStackService)).atLeastOnce(); |
| |
| replay(mockXml); |
| |
| ((ExtendedRepositoryVersionEntity) entity).m_xml = mockXml; |
| |
| getRequest = PropertyHelper.getReadRequest( |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_ID_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_UPGRADES_SUPPORTED_TYPES_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_SERVICES); |
| predicateStackName = new PredicateBuilder().property(CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID).equals("HDP").toPredicate(); |
| predicateStackVersion = new PredicateBuilder().property(CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID).equals("1.1").toPredicate(); |
| |
| resources = compatibleProvider.getResources(getRequest, new AndPredicate(predicateStackName, predicateStackVersion)); |
| assertEquals(2, resources.size()); |
| |
| for (Resource r : resources) { |
| Object stackId = r.getPropertyValue(CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID); |
| assertNotNull(stackId); |
| if (stackId.toString().equals("2.2")) { |
| assertNotNull(r.getPropertyValue(CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_SERVICES)); |
| } else { |
| assertNull(r.getPropertyValue(CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_SERVICES)); |
| } |
| } |
| } |
| |
| @Test |
| public void testGetResourcesWithAmendedPredicate() throws Exception { |
| SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createClusterAdministrator("admin", 2L)); |
| |
| final ResourceProvider provider = injector.getInstance(ResourceProviderFactory.class).getRepositoryVersionResourceProvider(); |
| |
| Request getRequest = PropertyHelper.getReadRequest( |
| RepositoryVersionResourceProvider.REPOSITORY_VERSION_ID_PROPERTY_ID, |
| RepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID, |
| RepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_UPGRADES_SUPPORTED_TYPES_ID); |
| Predicate predicateStackName = new PredicateBuilder().property(RepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID).equals("HDP").toPredicate(); |
| Predicate predicateStackVersion = new PredicateBuilder().property(RepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID).equals("1.1").toPredicate(); |
| |
| // !!! non-compatible, within stack |
| assertEquals(1, provider.getResources(getRequest, new AndPredicate(predicateStackName, predicateStackVersion)).size()); |
| |
| CompatibleRepositoryVersionResourceProvider compatibleProvider = new CompatibleRepositoryVersionResourceProvider(null); |
| |
| getRequest = PropertyHelper.getReadRequest( |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_ID_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID, |
| CompatibleRepositoryVersionResourceProvider.REPOSITORY_UPGRADES_SUPPORTED_TYPES_ID); |
| predicateStackName = new PredicateBuilder().property(CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID).equals("HDP").toPredicate(); |
| predicateStackVersion = new PredicateBuilder().property(CompatibleRepositoryVersionResourceProvider.REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID).equals("1.1").toPredicate(); |
| |
| // !!! compatible, across stack |
| Predicate newPredicate = compatibleProvider.amendPredicate(new AndPredicate(predicateStackName, predicateStackVersion)); |
| |
| assertEquals(OrPredicate.class, newPredicate.getClass()); |
| |
| Set<Resource> resources = compatibleProvider.getResources(getRequest, newPredicate); |
| assertEquals(2, resources.size()); |
| |
| // Test For Upgrade Types |
| Map<String, List<UpgradeType>> versionToUpgradeTypesMap = new HashMap<>(); |
| versionToUpgradeTypesMap.put("1.1", Arrays.asList(UpgradeType.ROLLING)); |
| versionToUpgradeTypesMap.put("2.2", Arrays.asList(UpgradeType.NON_ROLLING, UpgradeType.ROLLING)); |
| assertEquals(versionToUpgradeTypesMap.size(), checkUpgradeTypes(resources, versionToUpgradeTypesMap)); |
| } |
| |
| /** |
| * Checks for UpgradeTypes for the specified Target stack versions. |
| * |
| * @param resources The resource Set to iterate over |
| * @param versionToUpgradeTypesMap Contains 'Stack version' to 'Upgrade Type' Map. |
| * @return count, 0 or number of Stack version's Upgrade Type(s) correctly compared. |
| */ |
| public int checkUpgradeTypes(Set<Resource> resources, Map<String, List<UpgradeType>> versionToUpgradeTypesMap) { |
| int count = 0; |
| Iterator<Resource> itr = resources.iterator(); |
| while (itr.hasNext()) { |
| Resource res = itr.next(); |
| Map<String, Map<String, Object>> resPropMap = res.getPropertiesMap(); |
| for (String resource : resPropMap.keySet()) { |
| Map<String, Object> propMap = resPropMap.get(resource); |
| String stackVersion = propMap.get("stack_version").toString(); |
| if (versionToUpgradeTypesMap.containsKey(stackVersion)) { |
| List<UpgradeType> upgradeTypes = new ArrayList<>((Set<UpgradeType>)propMap.get("upgrade_types")); |
| List<UpgradeType> expectedTypes = versionToUpgradeTypesMap.get(stackVersion); |
| Collections.sort(upgradeTypes); |
| Collections.sort(expectedTypes); |
| |
| assertEquals(expectedTypes, upgradeTypes); |
| count++; |
| } |
| } |
| } |
| return count; |
| } |
| |
| private static class ExtendedRepositoryVersionEntity extends RepositoryVersionEntity { |
| private VersionDefinitionXml m_xml = null; |
| |
| @Override |
| public VersionDefinitionXml getRepositoryXml() throws Exception { |
| return m_xml; |
| } |
| |
| } |
| |
| } |