| /** |
| * 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 java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Set; |
| |
| import org.apache.ambari.server.AmbariException; |
| import org.apache.ambari.server.StaticallyInject; |
| import org.apache.ambari.server.api.resources.OperatingSystemResourceDefinition; |
| import org.apache.ambari.server.api.services.AmbariMetaInfo; |
| import org.apache.ambari.server.controller.AmbariManagementController; |
| import org.apache.ambari.server.controller.predicate.AndPredicate; |
| import org.apache.ambari.server.controller.predicate.EqualsPredicate; |
| import org.apache.ambari.server.controller.predicate.OrPredicate; |
| import org.apache.ambari.server.controller.spi.NoSuchParentResourceException; |
| import org.apache.ambari.server.controller.spi.NoSuchResourceException; |
| 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.Resource.Type; |
| import org.apache.ambari.server.controller.spi.SystemException; |
| import org.apache.ambari.server.controller.spi.UnsupportedPropertyException; |
| import org.apache.ambari.server.controller.utilities.PredicateBuilder; |
| import org.apache.ambari.server.orm.dao.RepositoryVersionDAO; |
| import org.apache.ambari.server.orm.entities.RepositoryVersionEntity; |
| import org.apache.ambari.server.state.ServiceInfo; |
| import org.apache.ambari.server.state.StackId; |
| import org.apache.ambari.server.state.StackInfo; |
| 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 com.google.common.collect.Sets; |
| import com.google.inject.Inject; |
| import com.google.inject.Provider; |
| |
| |
| /** |
| * Resource provider for repository versions resources. |
| */ |
| @StaticallyInject |
| public class CompatibleRepositoryVersionResourceProvider extends ReadOnlyResourceProvider { |
| |
| // ----- Property ID constants --------------------------------------------- |
| |
| public static final String REPOSITORY_VERSION_ID_PROPERTY_ID = "CompatibleRepositoryVersions/id"; |
| public static final String REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID = "CompatibleRepositoryVersions/stack_name"; |
| public static final String REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID = "CompatibleRepositoryVersions/stack_version"; |
| public static final String REPOSITORY_VERSION_REPOSITORY_VERSION_PROPERTY_ID = "CompatibleRepositoryVersions/repository_version"; |
| public static final String REPOSITORY_VERSION_DISPLAY_NAME_PROPERTY_ID = "CompatibleRepositoryVersions/display_name"; |
| public static final String REPOSITORY_UPGRADES_SUPPORTED_TYPES_ID = "CompatibleRepositoryVersions/upgrade_types"; |
| public static final String REPOSITORY_VERSION_SERVICES = "CompatibleRepositoryVersions/services"; |
| public static final String REPOSITORY_VERSION_STACK_SERVICES = "CompatibleRepositoryVersions/stack_services"; |
| public static final String SUBRESOURCE_OPERATING_SYSTEMS_PROPERTY_ID = new OperatingSystemResourceDefinition().getPluralName(); |
| private static final String REPOSITORY_STACK_VALUE = "stack_value"; |
| |
| private static Set<String> pkPropertyIds = Collections.singleton(REPOSITORY_VERSION_ID_PROPERTY_ID); |
| |
| static Set<String> propertyIds = Sets.newHashSet( |
| REPOSITORY_STACK_VALUE, |
| REPOSITORY_VERSION_ID_PROPERTY_ID, |
| REPOSITORY_VERSION_REPOSITORY_VERSION_PROPERTY_ID, |
| REPOSITORY_VERSION_DISPLAY_NAME_PROPERTY_ID, |
| REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID, |
| REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID, |
| SUBRESOURCE_OPERATING_SYSTEMS_PROPERTY_ID, |
| REPOSITORY_UPGRADES_SUPPORTED_TYPES_ID, |
| REPOSITORY_VERSION_SERVICES, |
| REPOSITORY_VERSION_STACK_SERVICES); |
| |
| static Map<Type, String> keyPropertyIds = new HashMap<Type, String>() { |
| { |
| put(Type.Stack, REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID); |
| put(Type.StackVersion, REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID); |
| put(Type.Upgrade, REPOSITORY_UPGRADES_SUPPORTED_TYPES_ID); |
| put(Type.CompatibleRepositoryVersion, REPOSITORY_VERSION_ID_PROPERTY_ID); |
| } |
| }; |
| |
| @Inject |
| private static RepositoryVersionDAO s_repositoryVersionDAO; |
| |
| @Inject |
| private static Provider<AmbariMetaInfo> s_ambariMetaInfo; |
| |
| /** |
| * Create a new resource provider. |
| */ |
| public CompatibleRepositoryVersionResourceProvider(AmbariManagementController amc) { |
| super(propertyIds, keyPropertyIds, amc); |
| } |
| |
| @Override |
| public Set<Resource> getResources(Request request, Predicate predicate) |
| throws SystemException, UnsupportedPropertyException, NoSuchResourceException, NoSuchParentResourceException { |
| final Set<Resource> resources = new HashSet<>(); |
| final Set<String> requestedIds = getRequestPropertyIds(request, predicate); |
| final Set<Map<String, Object>> propertyMaps = getPropertyMaps(predicate); |
| |
| Long currentStackUniqueId = null; |
| Map<Long, CompatibleRepositoryVersion> compatibleRepositoryVersionsMap = new HashMap<>(); |
| |
| StackId stackId = null; |
| // !!! this is the case where the predicate was altered to include all stacks |
| for (Map<String, Object> propertyMap : propertyMaps) { |
| if (propertyMap.containsKey(REPOSITORY_STACK_VALUE)) { |
| stackId = new StackId(propertyMap.get(REPOSITORY_STACK_VALUE).toString()); |
| break; |
| } |
| } |
| |
| if (null == stackId) { |
| if (propertyMaps.size() == 1) { |
| Map<String, Object> propertyMap = propertyMaps.iterator().next(); |
| stackId = getStackInformationFromUrl(propertyMap); |
| } else { |
| LOG.error("Property Maps size is NOT equal to 1. Current 'propertyMaps' size = {}", propertyMaps.size()); |
| } |
| } |
| |
| if (null == stackId) { |
| LOG.error("Could not determine stack to process. Returning empty set."); |
| return resources; |
| } |
| |
| for (RepositoryVersionEntity repositoryVersionEntity : s_repositoryVersionDAO.findByStack(stackId)) { |
| currentStackUniqueId = repositoryVersionEntity.getId(); |
| compatibleRepositoryVersionsMap.put(repositoryVersionEntity.getId(), |
| new CompatibleRepositoryVersion(repositoryVersionEntity)); |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Added current stack id: {} to map", repositoryVersionEntity.getId()); |
| } |
| } |
| |
| Map<String, UpgradePack> packs = s_ambariMetaInfo.get().getUpgradePacks( |
| stackId.getStackName(), stackId.getStackVersion()); |
| |
| for (UpgradePack up : packs.values()) { |
| if (null != up.getTargetStack()) { |
| StackId targetStackId = new StackId(up.getTargetStack()); |
| List<RepositoryVersionEntity> repositoryVersionEntities = s_repositoryVersionDAO.findByStack(targetStackId); |
| |
| for (RepositoryVersionEntity repositoryVersionEntity : repositoryVersionEntities) { |
| if (compatibleRepositoryVersionsMap.containsKey(repositoryVersionEntity.getId())) { |
| compatibleRepositoryVersionsMap.get(repositoryVersionEntity.getId()).addUpgradePackType(up.getType()); |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Stack id: {} exists in map. Appended new upgrade type {}" + repositoryVersionEntity.getId(), up.getType()); |
| } |
| } else { |
| CompatibleRepositoryVersion compatibleRepositoryVersionEntity = new CompatibleRepositoryVersion(repositoryVersionEntity); |
| compatibleRepositoryVersionEntity.addUpgradePackType(up.getType()); |
| compatibleRepositoryVersionsMap.put(repositoryVersionEntity.getId(), compatibleRepositoryVersionEntity); |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Added Stack id: {} to map with upgrade type {}", repositoryVersionEntity.getId(), up.getType()); |
| } |
| } |
| } |
| } else { |
| if (currentStackUniqueId != null) { |
| compatibleRepositoryVersionsMap.get(currentStackUniqueId).addUpgradePackType(up.getType()); |
| if (LOG.isDebugEnabled()) { |
| LOG.debug("Current Stack id: {} retrieved from map. Added upgrade type {}", currentStackUniqueId, up.getType()); |
| } |
| } else { |
| LOG.error("Couldn't retrieve Current stack entry from Map."); |
| } |
| } |
| } |
| |
| for (CompatibleRepositoryVersion entity : compatibleRepositoryVersionsMap.values()) { |
| |
| RepositoryVersionEntity repositoryVersionEntity = entity.getRepositoryVersionEntity(); |
| final Resource resource = new ResourceImpl(Resource.Type.CompatibleRepositoryVersion); |
| setResourceProperty(resource, REPOSITORY_VERSION_ID_PROPERTY_ID, repositoryVersionEntity.getId(), requestedIds); |
| |
| setResourceProperty(resource, REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID, repositoryVersionEntity.getStackName(), requestedIds); |
| setResourceProperty(resource, REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID, repositoryVersionEntity.getStackVersion(), requestedIds); |
| |
| setResourceProperty(resource, REPOSITORY_VERSION_DISPLAY_NAME_PROPERTY_ID, repositoryVersionEntity.getDisplayName(), requestedIds); |
| setResourceProperty(resource, REPOSITORY_VERSION_REPOSITORY_VERSION_PROPERTY_ID, repositoryVersionEntity.getVersion(), requestedIds); |
| setResourceProperty(resource, REPOSITORY_UPGRADES_SUPPORTED_TYPES_ID, entity.getSupportedTypes(), requestedIds); |
| |
| final VersionDefinitionXml xml; |
| try { |
| xml = repositoryVersionEntity.getRepositoryXml(); |
| } catch (Exception e) { |
| throw new SystemException(String.format("Could not load xml for Repository %s", repositoryVersionEntity.getId()), e); |
| } |
| |
| final StackInfo stack; |
| try { |
| stack = s_ambariMetaInfo.get().getStack(repositoryVersionEntity.getStackName(), repositoryVersionEntity.getStackVersion()); |
| } catch (AmbariException e) { |
| throw new SystemException(String.format("Could not load stack %s for Repository %s", |
| repositoryVersionEntity.getStackId().toString(), repositoryVersionEntity.getId())); |
| } |
| |
| final List<ManifestServiceInfo> stackServices; |
| |
| if (null != xml) { |
| setResourceProperty(resource, REPOSITORY_VERSION_SERVICES, xml.getAvailableServices(stack), requestedIds); |
| stackServices = xml.getStackServices(stack); |
| } else { |
| stackServices = new ArrayList<>(); |
| |
| for (ServiceInfo si : stack.getServices()) { |
| stackServices.add(new ManifestServiceInfo(si.getName(), si.getDisplayName(), si.getComment(), |
| Collections.singleton(si.getVersion()))); |
| } |
| } |
| |
| setResourceProperty(resource, REPOSITORY_VERSION_STACK_SERVICES, stackServices, requestedIds); |
| |
| resources.add(resource); |
| } |
| return resources; |
| } |
| |
| @Override |
| protected Set<String> getPKPropertyIds() { |
| return pkPropertyIds; |
| } |
| |
| /** |
| * Gets the stack id from the request map |
| * |
| * @param propertyMap the request map |
| * @return the StackId, or {@code null} if not found. |
| */ |
| protected StackId getStackInformationFromUrl(Map<String, Object> propertyMap) { |
| if (propertyMap.containsKey(REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID) && propertyMap.containsKey(REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID)) { |
| return new StackId(propertyMap.get(REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID).toString(), propertyMap.get(REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID).toString()); |
| } |
| return null; |
| } |
| |
| /** |
| * Identify the case where this is a top-level request, containing ONLY the stack name |
| * and stack version. Determine all other compatible stacks and make a new Predicate |
| * out of them. |
| * |
| * Consider a stack STACK-2.2 that is compatible with 2.3 and 2.4. The result of this |
| * call will be a predicate like so (abbreviated): |
| * <pre> |
| * in -> AndPredicate([stack_name=STACK],[stack_version=2.2]) |
| * out-> OrPredicate( |
| * AndPredicate([stack_name=STACK],[stack_version=2.2]), |
| * AndPredicate([stack_name=STACK],[stack_version=2.3]), |
| * AndPredicate([stack_name=STACK],[stack_version=2.4]) ) |
| * </pre> |
| * |
| * Any input predicate that does not conform to ONLY stack_name/stack_version will |
| * revert to the that predicate (return {@code null}). |
| */ |
| @SuppressWarnings("rawtypes") |
| @Override |
| public Predicate amendPredicate(Predicate predicate) { |
| if (!AndPredicate.class.isInstance(predicate)) { |
| return null; |
| } |
| |
| AndPredicate ap = (AndPredicate) predicate; |
| if (2 != ap.getPropertyIds().size()) { |
| return null; |
| } |
| |
| if (!ap.getPropertyIds().contains(REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID) && |
| !ap.getPropertyIds().contains(REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID)) { |
| return null; |
| } |
| |
| Predicate[] predicates = ap.getPredicates(); |
| if (!EqualsPredicate.class.isInstance(predicates[0]) || !EqualsPredicate.class.isInstance(predicates[1])) { |
| return null; |
| } |
| |
| EqualsPredicate pred1 = (EqualsPredicate) predicates[0]; |
| EqualsPredicate pred2 = (EqualsPredicate) predicates[1]; |
| |
| StackId stackId = null; |
| if (pred1.getPropertyId().equals(REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID)) { |
| stackId = new StackId(pred1.getValue().toString(), pred2.getValue().toString()); |
| } else { |
| stackId = new StackId(pred2.getValue().toString(), pred1.getValue().toString()); |
| } |
| |
| Map<String, UpgradePack> packs = s_ambariMetaInfo.get().getUpgradePacks( |
| stackId.getStackName(), stackId.getStackVersion()); |
| |
| Set<String> stackIds = new HashSet<>(); |
| |
| for (Entry<String, UpgradePack> entry : packs.entrySet()) { |
| UpgradePack pack = entry.getValue(); |
| String packStack = pack.getTargetStack(); |
| if (null == packStack || !packStack.equals(stackId.toString())) { |
| stackIds.add(packStack); |
| } |
| } |
| |
| |
| // !!! use the one passed in, it already includes the one of interest |
| List<Predicate> usable = new ArrayList<>(); |
| usable.add(predicate); |
| |
| // !!! add predicate for each of the compatible stacks as found by the upgrade packs |
| for (String requiredStack : stackIds) { |
| StackId targetStack = new StackId(requiredStack); |
| Predicate p = new PredicateBuilder().property(REPOSITORY_VERSION_STACK_NAME_PROPERTY_ID).equals(targetStack.getStackName()) |
| .and().property(REPOSITORY_VERSION_STACK_VERSION_PROPERTY_ID).equals(targetStack.getStackVersion()).toPredicate(); |
| usable.add(p); |
| } |
| |
| // !!! add the stack that is used to find compatible versions for |
| Predicate p = new PredicateBuilder().property(REPOSITORY_STACK_VALUE).equals(stackId.toString()).toPredicate(); |
| usable.add(p); |
| |
| p = new OrPredicate(usable.toArray(new Predicate[usable.size()])); |
| |
| return p; |
| } |
| |
| } |
