| /* | |
| * Copyright (C) 2012 The Android Open Source Project | |
| * | |
| * Licensed 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 com.motorolamobility.preflighting.core.internal.checker; | |
| import static com.motorolamobility.preflighting.core.logging.PreflightingLogger.error; | |
| import static com.motorolamobility.preflighting.core.logging.PreflightingLogger.warn; | |
| import java.util.ArrayList; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.TreeMap; | |
| import org.eclipse.core.runtime.CoreException; | |
| import org.eclipse.core.runtime.IConfigurationElement; | |
| import org.eclipse.core.runtime.IExtension; | |
| import org.eclipse.core.runtime.IExtensionPoint; | |
| import org.eclipse.core.runtime.IExtensionRegistry; | |
| import org.eclipse.core.runtime.InvalidRegistryObjectException; | |
| import org.eclipse.core.runtime.Platform; | |
| import com.motorolamobility.preflighting.core.PreflightingCorePlugin; | |
| import com.motorolamobility.preflighting.core.checker.Checker; | |
| import com.motorolamobility.preflighting.core.checker.CheckerExtension; | |
| import com.motorolamobility.preflighting.core.checker.IChecker; | |
| import com.motorolamobility.preflighting.core.checker.condition.ICondition; | |
| import com.motorolamobility.preflighting.core.checker.parameter.CheckerParameter; | |
| import com.motorolamobility.preflighting.core.checker.parameter.ICheckerParameter; | |
| import com.motorolamobility.preflighting.core.exception.PreflightingExtensionPointException; | |
| import com.motorolamobility.preflighting.core.i18n.PreflightingCoreNLS; | |
| import com.motorolamobility.preflighting.core.internal.checkerparameter.CheckerParameterElement; | |
| import com.motorolamobility.preflighting.core.internal.conditions.ConditionElement; | |
| import com.motorolamobility.preflighting.core.validation.ParameterType; | |
| import com.motorolamobility.preflighting.core.validation.ValidationResultData.SEVERITY; | |
| public abstract class CheckerExtensionReader | |
| { | |
| /** | |
| * Load existing checkers, mapped by checker id (value used to call the checker | |
| * on command line). | |
| * The map is sorted alphabetically by checker id. | |
| * | |
| * @param checkersMap The map of checkers to be populated | |
| * | |
| * @throws PreflightingExtensionPointException If an error with this extension point is found, | |
| * the exception is thrown to warn the framework that this functionality is broken | |
| */ | |
| public static void loadCheckers(TreeMap<String, CheckerExtension> checkersMap) | |
| throws PreflightingExtensionPointException | |
| { | |
| checkersMap.clear(); | |
| IExtensionRegistry extReg = Platform.getExtensionRegistry(); | |
| IExtensionPoint extPoint = | |
| extReg.getExtensionPoint(CheckerExtension.CHECKER_EXTENSION_POINT_ID); | |
| // it should not be null, but check to prevent errors | |
| if (extPoint != null) | |
| { | |
| try | |
| { | |
| IExtension[] extensions = extPoint.getExtensions(); | |
| for (IExtension aExtension : extensions) | |
| { | |
| IConfigurationElement[] configElements = aExtension.getConfigurationElements(); | |
| for (IConfigurationElement aConfig : configElements) | |
| { | |
| if (aConfig.getName().equals( | |
| CheckerExtension.CHECKER_EXTENSION_POINT_ELEMENT_CHECKER)) | |
| { | |
| try | |
| { | |
| String id = | |
| aConfig.getAttribute(CheckerExtension.CHECKER_EXTENSION_POINT_ATTRIBUTE_ID); | |
| String name = | |
| aConfig.getAttribute(CheckerExtension.CHECKER_EXTENSION_POINT_ATTRIBUTE_NAME); | |
| String description = | |
| aConfig.getAttribute(CheckerExtension.CHECKER_EXTENSION_POINT_ATTRIBUTE_DESCRIPTION); | |
| String checkerClassName = | |
| aConfig.getAttribute(CheckerExtension.CHECKER_EXTENSION_POINT_ATTRIBUTE_CLASS); | |
| IChecker checker = null; | |
| if (checkerClassName != null) | |
| { | |
| checker = | |
| (IChecker) aConfig | |
| .createExecutableExtension(CheckerExtension.CHECKER_EXTENSION_POINT_ATTRIBUTE_CLASS); | |
| } | |
| else | |
| { | |
| checker = new Checker(); | |
| } | |
| checker.setId(id); | |
| checker.setEnabled(true); | |
| CheckerExtension checkerExtension = | |
| new CheckerExtension(id, name, description, checker); | |
| loadConditions(checkerExtension, aConfig); | |
| loadParameters(checkerExtension, aConfig); | |
| checkersMap.put(id, checkerExtension); | |
| } | |
| catch (CoreException ce) | |
| { | |
| warn(CheckerExtensionReader.class, | |
| "Error reading checker extension of id " //$NON-NLS-1$ | |
| + aExtension.getUniqueIdentifier() | |
| + ": invalid checker or condition class", ce); | |
| } | |
| catch (Exception e) | |
| { | |
| warn(CheckerExtensionReader.class, | |
| "Error reading checker extension of id " //$NON-NLS-1$ | |
| + aExtension.getUniqueIdentifier(), e); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| catch (InvalidRegistryObjectException e) | |
| { | |
| error(CheckerExtensionReader.class, | |
| "Unexpected error with the checker extension point", e); //$NON-NLS-1$ | |
| throw new PreflightingExtensionPointException( | |
| PreflightingCoreNLS.CheckerExtensionReader_UnexpectedErrorCheckerExtensionPoint, | |
| e); | |
| } | |
| } | |
| else | |
| { | |
| error(CheckerExtensionReader.class, "Checker extension point not found"); //$NON-NLS-1$ | |
| throw new PreflightingExtensionPointException( | |
| PreflightingCoreNLS.CheckerExtensionReader_CheckerExtensionPointNotFound); | |
| } | |
| } | |
| /* | |
| * Load all children elements from a given checker element. | |
| * Currently only conditions are supported. | |
| */ | |
| private static void loadConditions(CheckerExtension checkerExtension, | |
| IConfigurationElement checkerElement) throws CoreException | |
| { | |
| IConfigurationElement[] childrenElements = checkerElement.getChildren(); | |
| if (childrenElements.length > 0) | |
| { | |
| List<ConditionElement> conditionsList = | |
| new ArrayList<ConditionElement>(childrenElements.length); | |
| HashMap<String, ICondition> checkerConditions = | |
| new HashMap<String, ICondition>(childrenElements.length); | |
| for (IConfigurationElement childElement : childrenElements) | |
| { | |
| if (childElement.getName().equals(ConditionElement.CHECKER_CONDITION_ELEMENT_NAME)) //Condition found, load it! | |
| { | |
| String conditionId = | |
| childElement | |
| .getAttribute(ConditionElement.CHECKER_CONDITION_ATTRIBUTE_ID); | |
| String conditionName = | |
| childElement | |
| .getAttribute(ConditionElement.CHECKER_CONDITION_ATTRIBUTE_NAME); | |
| String conditionDesc = | |
| childElement | |
| .getAttribute(ConditionElement.CHECKER_CONDITION_ATTRIBUTE_DESCRIPTION); | |
| String defaultSeverityLevel = | |
| childElement | |
| .getAttribute(ConditionElement.CHECKER_CONDITION_ATTRIBUTE_DEFAULT_SEVERITY); | |
| String markerType = | |
| childElement | |
| .getAttribute(ConditionElement.CHECKER_CONDITION_ATTRIBUTE_MARKER_TYPE); | |
| ICondition condition = | |
| (ICondition) childElement | |
| .createExecutableExtension(ConditionElement.CHECKER_CONDITION_ATTRIBUTE_CLASS); | |
| condition.setId(conditionId); | |
| condition.setName(conditionName); | |
| condition.setDescription(conditionDesc); | |
| condition.setSeverityLevel(SEVERITY.valueOf(defaultSeverityLevel)); | |
| condition.setChecker(checkerExtension.getChecker()); | |
| condition.setMarkerType(markerType); | |
| PreflightingCorePlugin.addAvailableMarker(markerType); | |
| ConditionElement conditionElement = | |
| new ConditionElement(conditionId, conditionName, conditionDesc, | |
| defaultSeverityLevel, condition); | |
| conditionsList.add(conditionElement); | |
| checkerConditions.put(conditionId, condition); | |
| } | |
| } | |
| checkerExtension.getChecker().setConditions(checkerConditions); | |
| checkerExtension.setConditions(conditionsList | |
| .toArray(new ConditionElement[conditionsList.size()])); | |
| } | |
| } | |
| /** | |
| * Load the list of {@link CheckerParameterElement} objects into the {@link ConditionElement} parameter, | |
| * This list comes from the defined extension-points. | |
| * | |
| * @param checkerExtension {@link CheckerExtension} where the {@link CheckerParameterElement} objects | |
| * will be added. | |
| * @param conditionConfigurationElement Configuration element. This element is responsible to fetch the | |
| * data from the defined extension-points. | |
| */ | |
| private static void loadParameters(CheckerExtension checkerExtension, | |
| IConfigurationElement conditionConfigurationElement) | |
| { | |
| IConfigurationElement[] childrenElements = conditionConfigurationElement.getChildren(); | |
| if (childrenElements.length > 0) | |
| { | |
| List<CheckerParameterElement> parameterElementList = | |
| new ArrayList<CheckerParameterElement>(childrenElements.length); | |
| Map<String, ICheckerParameter> parameters = new HashMap<String, ICheckerParameter>(); | |
| for (IConfigurationElement childElement : childrenElements) | |
| { | |
| if (childElement.getName().equals( | |
| CheckerParameterElement.CHECKER_PARAMETER_ELEMENT_NAME)) //Condition found, load it! | |
| { | |
| String parameterId = | |
| childElement | |
| .getAttribute(CheckerParameterElement.CHECKER_PARAMETER_ATTRIBUTE_ID); | |
| String parameterName = | |
| childElement | |
| .getAttribute(CheckerParameterElement.CHECKER_PARAMETER_ATTRIBUTE_NAME); | |
| String parameterDescription = | |
| childElement | |
| .getAttribute(CheckerParameterElement.CHECKER_PARAMETER_ATTRIBUTE_DESCRIPTION); | |
| String parameterValueDescription = | |
| childElement | |
| .getAttribute(CheckerParameterElement.CHECKER_PARAMETER_ATTRIBUTE_VALUE_DESCRIPTION); | |
| String parameterTypeString = | |
| childElement | |
| .getAttribute(CheckerParameterElement.CHECKER_PARAMETER_ATTRIBUTE_TYPE); | |
| boolean parameterIsMandatory = | |
| Boolean.parseBoolean(childElement | |
| .getAttribute(CheckerParameterElement.CHECKER_PARAMETER_ATTRIBUTE_IS_MANDATORY)); | |
| ParameterType parameterType = null; | |
| if (parameterTypeString.equals("BOOLEAN")) | |
| { | |
| parameterType = ParameterType.BOOLEAN; | |
| } | |
| else if (parameterTypeString.equals("INTEGER")) | |
| { | |
| parameterType = ParameterType.INTEGER; | |
| } | |
| else | |
| { | |
| parameterType = ParameterType.STRING; | |
| } | |
| ICheckerParameter parameter = | |
| new CheckerParameter(parameterId, parameterName, parameterDescription, | |
| parameterValueDescription, parameterType, parameterIsMandatory); | |
| CheckerParameterElement parameterElement = | |
| new CheckerParameterElement(parameterId, parameterName, | |
| parameterDescription, parameterValueDescription, | |
| parameterTypeString, parameterIsMandatory); | |
| parameters.put(parameterId, parameter); | |
| parameterElementList.add(parameterElement); | |
| } | |
| } | |
| checkerExtension.getChecker().setParameters(parameters); | |
| checkerExtension.setConditionParameters(parameterElementList | |
| .toArray(new CheckerParameterElement[parameterElementList.size()])); | |
| } | |
| } | |
| } |