| /* |
| * 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.ignite.internal.processors.cache; |
| |
| import org.apache.ignite.IgniteCheckedException; |
| import org.apache.ignite.configuration.IgniteConfiguration; |
| import org.apache.ignite.configuration.MemoryConfiguration; |
| import org.apache.ignite.configuration.MemoryPolicyConfiguration; |
| import org.apache.ignite.testframework.junits.common.GridCommonAbstractTest; |
| import org.junit.Test; |
| |
| /** |
| * |
| */ |
| public class MemoryPolicyConfigValidationTest extends GridCommonAbstractTest { |
| /** */ |
| private static final String VALID_DEFAULT_MEM_PLC_NAME = "valid_dlft_mem_plc"; |
| |
| /** */ |
| private static final String VALID_USER_MEM_PLC_NAME = "valid_user_mem_plc"; |
| |
| /** */ |
| private static final String MISSING_DEFAULT_MEM_PLC_NAME = "missing_mem_plc"; |
| |
| /** Configuration violation type to check. */ |
| private ValidationViolationType violationType; |
| |
| /** {@inheritDoc} */ |
| @Override protected IgniteConfiguration getConfiguration(String gridName) throws Exception { |
| IgniteConfiguration cfg = super.getConfiguration(gridName); |
| |
| MemoryConfiguration memCfg = new MemoryConfiguration(); |
| |
| MemoryPolicyConfiguration[] plcs = null; |
| |
| switch (violationType) { |
| case NAMES_CONFLICT: |
| plcs = createPlcsWithNamesConflictCfg(); |
| |
| break; |
| |
| case SYSTEM_MEMORY_POLICY_NAME_MISUSE: |
| plcs = createPlcWithReservedNameMisuseCfg(); |
| |
| break; |
| |
| case TOO_SMALL_MEMORY_SIZE: |
| plcs = createTooSmallMemoryCfg(); |
| |
| break; |
| |
| case NULL_NAME_ON_USER_DEFINED_POLICY: |
| plcs = createPlcWithNullName(); |
| |
| break; |
| |
| case MISSING_USER_DEFINED_DEFAULT: |
| plcs = createMissingUserDefinedDefault(); |
| |
| memCfg.setDefaultMemoryPolicyName(MISSING_DEFAULT_MEM_PLC_NAME); |
| |
| break; |
| |
| case TOO_SMALL_USER_DEFINED_DFLT_MEM_PLC_SIZE: |
| memCfg.setDefaultMemoryPolicySize(1); |
| |
| break; |
| |
| case DEFAULT_SIZE_IS_DEFINED_TWICE: |
| plcs = createValidUserDefault(); |
| |
| memCfg.setDefaultMemoryPolicyName(VALID_DEFAULT_MEM_PLC_NAME); |
| memCfg.setDefaultMemoryPolicySize(10L * 1014 * 1024); |
| |
| break; |
| |
| case MAX_SIZE_IS_SMALLER_THAN_INITIAL_SIZE: |
| plcs = createMaxSizeSmallerThanInitialSize(); |
| |
| break; |
| |
| case LTE_ZERO_RATE_TIME_INTERVAL: |
| plcs = createRateTimeIntervalIsNegative(); |
| |
| break; |
| |
| case LTE_ZERO_SUB_INTERVALS: |
| plcs = createSubIntervalsIsNegative(); |
| |
| break; |
| |
| default: |
| fail("Violation type was not configured: " + violationType); |
| } |
| |
| memCfg.setMemoryPolicies(plcs); |
| |
| cfg.setMemoryConfiguration(memCfg); |
| |
| return cfg; |
| } |
| |
| /** |
| * |
| */ |
| private MemoryPolicyConfiguration[] createSubIntervalsIsNegative() { |
| MemoryPolicyConfiguration[] res = new MemoryPolicyConfiguration[1]; |
| |
| res[0] = createMemoryPolicy(VALID_DEFAULT_MEM_PLC_NAME, 100L * 1024 * 1024, 100L * 1024 * 1024); |
| res[0].setSubIntervals(-10); |
| |
| return res; |
| } |
| |
| /** |
| * |
| */ |
| private MemoryPolicyConfiguration[] createRateTimeIntervalIsNegative() { |
| MemoryPolicyConfiguration[] res = new MemoryPolicyConfiguration[1]; |
| |
| res[0] = createMemoryPolicy(VALID_DEFAULT_MEM_PLC_NAME, 100L * 1024 * 1024, 100L * 1024 * 1024); |
| res[0].setRateTimeInterval(-10); |
| |
| return res; |
| } |
| |
| /** |
| * |
| */ |
| private MemoryPolicyConfiguration[] createValidUserDefault() { |
| MemoryPolicyConfiguration[] res = new MemoryPolicyConfiguration[1]; |
| |
| res[0] = createMemoryPolicy(VALID_DEFAULT_MEM_PLC_NAME, 100L * 1024 * 1024, 100L * 1024 * 1024); |
| |
| return res; |
| } |
| |
| /** |
| * |
| */ |
| private MemoryPolicyConfiguration[] createMissingUserDefinedDefault() { |
| MemoryPolicyConfiguration[] res = new MemoryPolicyConfiguration[1]; |
| |
| res[0] = createMemoryPolicy(VALID_USER_MEM_PLC_NAME, 10L * 1024 * 1024, 10L * 1024 * 1024); |
| |
| return res; |
| } |
| |
| /** |
| * |
| */ |
| private MemoryPolicyConfiguration[] createPlcWithNullName() { |
| MemoryPolicyConfiguration[] res = new MemoryPolicyConfiguration[1]; |
| |
| res[0] = createMemoryPolicy(null, 10L * 1024 * 1024, 10L * 1024 * 1024); |
| |
| return res; |
| } |
| |
| /** |
| * |
| */ |
| private MemoryPolicyConfiguration[] createTooSmallMemoryCfg() { |
| MemoryPolicyConfiguration[] res = new MemoryPolicyConfiguration[1]; |
| |
| res[0] = createMemoryPolicy(VALID_DEFAULT_MEM_PLC_NAME, 10, 10); |
| |
| return res; |
| } |
| |
| /** |
| * |
| */ |
| private MemoryPolicyConfiguration[] createPlcWithReservedNameMisuseCfg() { |
| MemoryPolicyConfiguration[] res = new MemoryPolicyConfiguration[1]; |
| |
| res[0] = createMemoryPolicy("sysMemPlc", 10L * 1024 * 1024, 10L * 1024 * 1024); |
| |
| return res; |
| } |
| |
| /** |
| * |
| */ |
| private MemoryPolicyConfiguration[] createPlcsWithNamesConflictCfg() { |
| MemoryPolicyConfiguration[] res = new MemoryPolicyConfiguration[2]; |
| |
| res[0] = createMemoryPolicy("cflt0", 10L * 1024 * 1024, 10L * 1024 * 1024); |
| res[1] = createMemoryPolicy("cflt0", 10L * 1024 * 1024, 10L * 1024 * 1024); |
| |
| return res; |
| } |
| |
| /** |
| * |
| */ |
| private MemoryPolicyConfiguration[] createMaxSizeSmallerThanInitialSize() { |
| MemoryPolicyConfiguration[] res = new MemoryPolicyConfiguration[1]; |
| |
| res[0] = createMemoryPolicy("invalidSize", 100L * 1024 * 1024, 10L * 1024 * 1024); |
| |
| return res; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override protected void afterTest() throws Exception { |
| super.afterTest(); |
| |
| stopAllGrids(); |
| } |
| |
| /** |
| * @param name Name of MemoryPolicyConfiguration. |
| * @param initialSize Initial size of MemoryPolicyConfiguration in bytes. |
| * @param maxSize Max size of MemoryPolicyConfiguration in bytes. |
| */ |
| private MemoryPolicyConfiguration createMemoryPolicy(String name, long initialSize, long maxSize) { |
| MemoryPolicyConfiguration plc = new MemoryPolicyConfiguration(); |
| |
| plc.setName(name); |
| plc.setInitialSize(initialSize); |
| plc.setMaxSize(maxSize); |
| |
| return plc; |
| } |
| |
| /** |
| * 'sysMemPlc' name is reserved for MemoryPolicyConfiguration for system caches. |
| */ |
| @Test |
| public void testReservedMemoryPolicyMisuse() throws Exception { |
| violationType = ValidationViolationType.SYSTEM_MEMORY_POLICY_NAME_MISUSE; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * If user defines default is must be presented among configured memory policies. |
| */ |
| @Test |
| public void testMissingUserDefinedDefault() throws Exception { |
| violationType = ValidationViolationType.MISSING_USER_DEFINED_DEFAULT; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * Names of all MemoryPolicies must be distinct. |
| */ |
| @Test |
| public void testNamesConflict() throws Exception { |
| violationType = ValidationViolationType.NAMES_CONFLICT; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * User-defined policy must have a non-null non-empty name. |
| */ |
| @Test |
| public void testNullNameOnUserDefinedPolicy() throws Exception { |
| violationType = ValidationViolationType.NULL_NAME_ON_USER_DEFINED_POLICY; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * MemoryPolicy must be configured with size of at least 1MB. |
| */ |
| @Test |
| public void testMemoryTooSmall() throws Exception { |
| violationType = ValidationViolationType.TOO_SMALL_MEMORY_SIZE; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * MemoryPolicy must be configured with size of at least 1MB. |
| */ |
| @Test |
| public void testMaxSizeSmallerThanInitialSize() throws Exception { |
| violationType = ValidationViolationType.MAX_SIZE_IS_SMALLER_THAN_INITIAL_SIZE; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * User-defined size of default MemoryPolicy must be at least 1MB. |
| */ |
| @Test |
| public void testUserDefinedDefaultMemoryTooSmall() throws Exception { |
| violationType = ValidationViolationType.TOO_SMALL_USER_DEFINED_DFLT_MEM_PLC_SIZE; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * Defining size of default MemoryPolicy twice with and through <b>defaultMemoryPolicySize</b> property |
| * and using <b>MemoryPolicyConfiguration</b> description is prohibited. |
| */ |
| @Test |
| public void testDefaultMemoryPolicySizeDefinedTwice() throws Exception { |
| violationType = ValidationViolationType.DEFAULT_SIZE_IS_DEFINED_TWICE; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * |
| */ |
| @Test |
| public void testRateTimeIntervalPropertyIsNegative() throws Exception { |
| violationType = ValidationViolationType.LTE_ZERO_RATE_TIME_INTERVAL; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * |
| */ |
| @Test |
| public void testSubIntervalsPropertyIsNegative() throws Exception { |
| violationType = ValidationViolationType.LTE_ZERO_SUB_INTERVALS; |
| |
| doTest(violationType); |
| } |
| |
| /** |
| * Tries to start ignite node with invalid configuration and checks that corresponding exception is thrown. |
| * |
| * @param violationType Configuration violation type. |
| */ |
| private void doTest(ValidationViolationType violationType) throws Exception { |
| try { |
| startGrid(0); |
| } |
| catch (IgniteCheckedException e) { |
| Throwable c = e.getCause(); |
| |
| assertTrue(c != null); |
| assertTrue(c.getMessage().contains(violationType.violationMsg)); |
| |
| return; |
| } |
| |
| fail("Expected exception hasn't been thrown"); |
| } |
| |
| /** |
| * |
| */ |
| private enum ValidationViolationType { |
| /** */ |
| NAMES_CONFLICT("have the same name"), |
| |
| /** */ |
| SYSTEM_MEMORY_POLICY_NAME_MISUSE("name is reserved for internal use"), |
| |
| /** */ |
| TOO_SMALL_MEMORY_SIZE("must have size more than 10MB"), |
| |
| /** */ |
| NULL_NAME_ON_USER_DEFINED_POLICY("must have non-null and non-empty name"), |
| |
| /** */ |
| MISSING_USER_DEFINED_DEFAULT("name must be presented among configured"), |
| |
| /** */ |
| DEFAULT_SIZE_IS_DEFINED_TWICE("properties are set at the same time."), |
| |
| /** */ |
| TOO_SMALL_USER_DEFINED_DFLT_MEM_PLC_SIZE("must have size more than 10MB"), |
| |
| /** */ |
| MAX_SIZE_IS_SMALLER_THAN_INITIAL_SIZE("must not be smaller than initialSize"), |
| |
| /** Case when rateTimeInterval property of MemoryPolicyConfiguration is less than or equals zero. */ |
| LTE_ZERO_RATE_TIME_INTERVAL("Rate time interval must be greater than zero"), |
| |
| /** Case when subIntervals property of MemoryPolicyConfiguration is less than or equals zero. */ |
| LTE_ZERO_SUB_INTERVALS("Sub intervals must be greater than zero"); |
| |
| /** |
| * @param violationMsg Violation message. |
| */ |
| ValidationViolationType(String violationMsg) { |
| this.violationMsg = violationMsg; |
| } |
| |
| /** */ |
| String violationMsg; |
| } |
| } |