ConfigureAction extends AbstractServerAction { @Override public CommandReport execute( ConcurrentMap<String, Object> requestSharedDataContext) throws AmbariException, InterruptedException { Map<String,String> commandParameters = getCommandParameters(); if( null == commandParameters || commandParameters.isEmpty() ){ return createCommandReport(0, HostRoleStatus.FAILED, "{}", "", "Unable to change configuration values without command parameters"); } String clusterName = commandParameters.get("clusterName"); Cluster cluster = m_clusters.getCluster(clusterName); String configType = commandParameters.get(ConfigureTask.PARAMETER_CONFIG_TYPE); List<ConfigurationKeyValue> keyValuePairs = Collections.emptyList(); String keyValuePairJson = commandParameters.get(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS); if (null != keyValuePairJson) { keyValuePairs = m_gson.fromJson( keyValuePairJson, new TypeToken<List<ConfigurationKeyValue>>(){}.getType()); keyValuePairs = getAllowedSets(cluster, configType, keyValuePairs); } List<Transfer> transfers = Collections.emptyList(); String transferJson = commandParameters.get(ConfigureTask.PARAMETER_TRANSFERS); if (null != transferJson) { transfers = m_gson.fromJson( transferJson, new TypeToken<List<Transfer>>(){}.getType()); transfers = getAllowedTransfers(cluster, configType, transfers); } List<Replace> replacements = Collections.emptyList(); String replaceJson = commandParameters.get(ConfigureTask.PARAMETER_REPLACEMENTS); if (null != replaceJson) { replacements = m_gson.fromJson( replaceJson, new TypeToken<List<Replace>>(){}.getType()); replacements = getAllowedReplacements(cluster, configType, replacements); } List<Insert> insertions = Collections.emptyList(); String insertJson = commandParameters.get(ConfigureTask.PARAMETER_INSERTIONS); if (null != insertJson) { insertions = m_gson.fromJson( insertJson, new TypeToken<List<Insert>>(){}.getType()); } if (keyValuePairs.isEmpty() && transfers.isEmpty() && replacements.isEmpty() && insertions.isEmpty()) { String message = "cluster={0}, type={1}, transfers={2}, replacements={3}, insertions={4}, configurations={5}"; message = MessageFormat.format(message, clusterName, configType, transfers, replacements, insertions, keyValuePairs); StringBuilder buffer = new StringBuilder( "Skipping this configuration task since none of the conditions were met and there are no transfers, replacements, or insertions.").append("\n"); buffer.append(message); return createCommandReport(0, HostRoleStatus.COMPLETED, "{}", buffer.toString(), ""); } if (null == clusterName || null == configType || (keyValuePairs.isEmpty() && transfers.isEmpty() && replacements.isEmpty() && insertions.isEmpty())) { String message = "cluster={0}, type={1}, transfers={2}, replacements={3}, insertions={4}, configurations={5}"; message = MessageFormat.format(message, clusterName, configType, transfers, replacements, insertions, keyValuePairs); return createCommandReport(0, HostRoleStatus.FAILED, "{}", "", message); } Map<String, DesiredConfig> desiredConfigs = cluster.getDesiredConfigs(); DesiredConfig desiredConfig = desiredConfigs.get(configType); if (desiredConfig == null) { throw new AmbariException("Could not find desired config type with name " + configType); } Config config = cluster.getConfig(configType, desiredConfig.getTag()); if (config == null) { throw new AmbariException("Could not find config type with name " + configType); } StackId currentStack = cluster.getCurrentStackVersion(); StackId targetStack = cluster.getDesiredStackVersion(); StackId configStack = config.getStackId(); Map<String, String> base = config.getProperties(); Map<String, String> newValues = new HashMap<>(base); boolean changedValues = false; StringBuilder outputBuffer = new StringBuilder(250); for (Transfer transfer : transfers) { switch (transfer.operation) { case COPY: String valueToCopy = null; if( null == transfer.fromType ) { valueToCopy = base.get(transfer.fromKey); } else { Config other = cluster.getDesiredConfigByType(transfer.fromType); if (null != other){ Map<String, String> otherValues = other.getProperties(); if (otherValues.containsKey(transfer.fromKey)){ valueToCopy = otherValues.get(transfer.fromKey); } } } if (StringUtils.isBlank(valueToCopy) && !StringUtils.isBlank(transfer.defaultValue)) { valueToCopy = transfer.defaultValue; } if (StringUtils.isNotBlank(valueToCopy)) { if (transfer.coerceTo != null) { switch (transfer.coerceTo) { case YAML_ARRAY: { String[] splitValues = StringUtils.split(valueToCopy, ','); List<String> quotedValues = new ArrayList<>(splitValues.length); for (String splitValue : splitValues) { quotedValues.add("'" + StringUtils.trim(splitValue) + "'"); } valueToCopy = "[" + StringUtils.join(quotedValues, ',') + "]"; break; } default: break; } } changedValues = true; newValues.put(transfer.toKey, valueToCopy); updateBufferWithMessage(outputBuffer, MessageFormat.format("Created {0}/{1} = \"{2}\"", configType, transfer.toKey, mask(transfer, valueToCopy))); } break; case MOVE: if (newValues.containsKey(transfer.fromKey)) { newValues.put(transfer.toKey, newValues.remove(transfer.fromKey)); changedValues = true; updateBufferWithMessage(outputBuffer, MessageFormat.format("Renamed {0}/{1} to {2}/{3}", configType, transfer.fromKey, configType, transfer.toKey)); } else if (StringUtils.isNotBlank(transfer.defaultValue)) { newValues.put(transfer.toKey, transfer.defaultValue); changedValues = true; updateBufferWithMessage(outputBuffer, MessageFormat.format("Created {0}/{1} with default value \"{2}\"", configType, transfer.toKey, mask(transfer, transfer.defaultValue))); } break; case DELETE: if ("*".equals(transfer.deleteKey)) { newValues.clear(); updateBufferWithMessage(outputBuffer, MessageFormat.format("Deleted all keys from {0}", configType)); for (String keeper : transfer.keepKeys) { if (base.containsKey(keeper) && base.get(keeper) != null) { newValues.put(keeper, base.get(keeper)); updateBufferWithMessage(outputBuffer, MessageFormat.format("Preserved {0}/{1} after delete", configType, keeper)); } } if (transfer.preserveEdits) { List<String> edited = findValuesToPreserve(clusterName, config); for (String changed : edited) { newValues.put(changed, base.get(changed)); updateBufferWithMessage(outputBuffer, MessageFormat.format("Preserved {0}/{1} after delete", configType, changed)); } } changedValues = true; } else { newValues.remove(transfer.deleteKey); changedValues = true; updateBufferWithMessage(outputBuffer, MessageFormat.format("Deleted {0}/{1}", configType, transfer.deleteKey)); } break; } } if (null != keyValuePairs && !keyValuePairs.isEmpty()) { for (ConfigurationKeyValue keyValuePair : keyValuePairs) { String key = keyValuePair.key; String value = keyValuePair.value; if (null != key) { String oldValue = base.get(key); if (null != oldValue && value.equals(oldValue)) { if (currentStack.equals(targetStack) && !changedValues) { updateBufferWithMessage(outputBuffer, MessageFormat.format( "{0}/{1} for cluster {2} would not change, skipping setting", configType, key, clusterName)); continue; } } newValues.put(key, value); final String message; if (StringUtils.isEmpty(value)) { message = MessageFormat.format("{0}/{1} changed to an empty value", configType, key); } else { message = MessageFormat.format("{0}/{1} changed to \"{2}\"", configType, key, mask(keyValuePair, value)); } updateBufferWithMessage(outputBuffer, message); } } } for (Replace replacement : replacements) { String toReplace = newValues.get(replacement.key); if (StringUtils.isNotBlank(toReplace)) { if (!toReplace.contains(replacement.find)) { updateBufferWithMessage(outputBuffer, MessageFormat.format("String \"{0}\" was not found in {1}/{2}", replacement.find, configType, replacement.key)); } else { String replaced = StringUtils.replace(toReplace, replacement.find, replacement.replaceWith); newValues.put(replacement.key, replaced); updateBufferWithMessage(outputBuffer, MessageFormat.format("Replaced {0}/{1} containing \"{2}\" with \"{3}\"", configType, replacement.key, replacement.find, replacement.replaceWith)); } } else { updateBufferWithMessage(outputBuffer, MessageFormat.format( "Skipping replacement for {0}/{1} because it does not exist or is empty.", configType, replacement.key)); } } for (Insert insert : insertions) { String valueToInsertInto = newValues.get(insert.key); if (StringUtils.isNotBlank(valueToInsertInto)) { if (StringUtils.contains(valueToInsertInto, insert.value)) { updateBufferWithMessage(outputBuffer, MessageFormat.format("Skipping insertion for {0}/{1} because it already contains {2}", configType, insert.key, insert.value)); continue; } String valueToInsert = insert.value; if (insert.newlineBefore) { valueToInsert = System.lineSeparator() + valueToInsert; } if (insert.newlineAfter) { valueToInsert = valueToInsert + System.lineSeparator(); } switch (insert.insertType) { case APPEND: valueToInsertInto = valueToInsertInto + valueToInsert; break; case PREPEND: valueToInsertInto = valueToInsert + valueToInsertInto; break; default: LOG.error("Unable to insert {0}/{1} with unknown insertion type of {2}", configType, insert.key, insert.insertType); break; } newValues.put(insert.key, valueToInsertInto); updateBufferWithMessage(outputBuffer, MessageFormat.format( "Updated {0}/{1} by inserting {2}", configType, insert.key, insert.value)); } else { updateBufferWithMessage(outputBuffer, MessageFormat.format( "Skipping insertion for {0}/{1} because it does not exist or is empty.", configType, insert.key)); } } if (!targetStack.equals(currentStack) && targetStack.equals(configStack)) { config.setProperties(newValues); config.save(); return createCommandReport(0, HostRoleStatus.COMPLETED, "{}", outputBuffer.toString(), ""); } String serviceVersionNote = "Stack Upgrade"; String auditName = getExecutionCommand().getRoleParams().get(ServerAction.ACTION_USER_NAME); if (auditName == null) { auditName = m_configuration.getAnonymousAuditName(); } m_configHelper.createConfigType(cluster, m_controller, configType, newValues, auditName, serviceVersionNote); String message = "Finished updating configuration ''{0}''"; message = MessageFormat.format(message, configType); return createCommandReport(0, HostRoleStatus.COMPLETED, "{}", message, ""); }  @Override CommandReport execute(
      ConcurrentMap<String, Object> requestSharedDataContext);  }
@Test public void testConfigActionUpgradeAcrossStack() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setCurrentStackVersion(HDP_211_STACK); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() {{ put("initLimit", "10"); }}, new HashMap<String, Map<String,String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue keyValue = new ConfigurationKeyValue(); configurations.add(keyValue); keyValue.key = "initLimit"; keyValue.value = "11"; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper( executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertEquals("version2", config.getTag()); assertEquals("11", config.getProperties().get("initLimit")); }
@Test public void testDeletePreserveChanges() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("tickTime", "2000"); put("foo", "bar"); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); List<Transfer> transfers = new ArrayList<>(); Transfer transfer = new Transfer(); transfer.operation = TransferOperation.DELETE; transfer.deleteKey = "*"; transfer.preserveEdits = true; transfers.add(transfer); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); Map<String, String> map = config.getProperties(); assertEquals("bar", map.get("foo")); assertFalse(map.containsKey("tickTime")); }
@Test public void testConfigTransferCopy() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() {{ put("initLimit", "10"); put("copyIt", "10"); put("moveIt", "10"); put("deleteIt", "10"); }}, new HashMap<String, Map<String,String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue keyValue = new ConfigurationKeyValue(); configurations.add(keyValue); keyValue.key = "initLimit"; keyValue.value = "11"; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); List<Transfer> transfers = new ArrayList<>(); Transfer transfer = new Transfer(); transfer.operation = TransferOperation.COPY; transfer.fromKey = "copyIt"; transfer.toKey = "copyKey"; transfers.add(transfer); transfer = new Transfer(); transfer.operation = TransferOperation.COPY; transfer.fromKey = "copiedFromMissingKeyWithDefault"; transfer.toKey = "copiedToMissingKeyWithDefault"; transfer.defaultValue = "defaultValue"; transfers.add(transfer); transfer = new Transfer(); transfer.operation = TransferOperation.MOVE; transfer.fromKey = "moveIt"; transfer.toKey = "movedKey"; transfers.add(transfer); transfer = new Transfer(); transfer.operation = TransferOperation.MOVE; transfer.fromKey = "movedFromKeyMissingWithDefault"; transfer.toKey = "movedToMissingWithDefault"; transfer.defaultValue = "defaultValue2"; transfer.mask = true; transfers.add(transfer); transfer = new Transfer(); transfer.operation = TransferOperation.DELETE; transfer.deleteKey = "deleteIt"; transfers.add(transfer); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper( executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); Map<String, String> map = config.getProperties(); assertEquals("11", map.get("initLimit")); assertEquals("10", map.get("copyIt")); assertTrue(map.containsKey("copyKey")); assertEquals(map.get("copyIt"), map.get("copyKey")); assertFalse(map.containsKey("moveIt")); assertTrue(map.containsKey("movedKey")); assertFalse(map.containsKey("deletedKey")); assertTrue(map.containsKey("copiedToMissingKeyWithDefault")); assertEquals("defaultValue", map.get("copiedToMissingKeyWithDefault")); assertTrue(map.containsKey("movedToMissingWithDefault")); assertEquals("defaultValue2", map.get("movedToMissingWithDefault")); transfers.clear(); transfer = new Transfer(); transfer.operation = TransferOperation.DELETE; transfer.deleteKey = "*"; transfer.preserveEdits = true; transfer.keepKeys.add("copyKey"); transfer.keepKeys.add("keyNotExisting"); transfer.keepKeys.add(null); transfers.add(transfer); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); report = action.execute(null); assertNotNull(report); assertEquals(4, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); map = config.getProperties(); assertEquals(6, map.size()); assertTrue(map.containsKey("initLimit")); assertTrue(map.containsKey("copyKey")); assertFalse(map.containsKey("keyNotExisting")); assertFalse(map.containsKey(null)); }
@Test public void testCoerceValueOnCopy() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("zoo.server.csv", "c6401,c6402, c6403"); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); List<Transfer> transfers = new ArrayList<>(); Transfer transfer = new Transfer(); transfer.operation = TransferOperation.COPY; transfer.coerceTo = TransferCoercionType.YAML_ARRAY; transfer.fromKey = "zoo.server.csv"; transfer.toKey = "zoo.server.array"; transfer.defaultValue = "['foo','bar']"; transfers.add(transfer); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); Map<String, String> map = config.getProperties(); assertEquals("c6401,c6402, c6403", map.get("zoo.server.csv")); assertEquals("['c6401','c6402','c6403']", map.get("zoo.server.array")); }
@Test public void testValueReplacement() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("key_to_replace", "My New Cat"); put("key_with_no_match", "WxyAndZ"); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); List<Replace> replacements = new ArrayList<>(); Replace replace = new Replace(); replace.key = "key_to_replace"; replace.find = "New Cat"; replace.replaceWith = "Wet Dog"; replacements.add(replace); replace = new Replace(); replace.key = "key_with_no_match"; replace.find = "abc"; replace.replaceWith = "def"; replacements.add(replace); commandParams.put(ConfigureTask.PARAMETER_REPLACEMENTS, new Gson().toJson(replacements)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); assertEquals("My Wet Dog", config.getProperties().get("key_to_replace")); assertEquals("WxyAndZ", config.getProperties().get("key_with_no_match")); }
@Test public void testValueReplacementWithMissingConfigurations() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("existing", "This exists!"); put("missing", null); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); List<Replace> replacements = new ArrayList<>(); Replace replace = new Replace(); replace.key = "missing"; replace.find = "foo"; replace.replaceWith = "bar"; replacements.add(replace); commandParams.put(ConfigureTask.PARAMETER_REPLACEMENTS, new Gson().toJson(replacements)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertEquals(null, config.getProperties().get("missing")); }
@Test public void testMultipleKeyValuesPerTask() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setCurrentStackVersion(HDP_211_STACK); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("fooKey", "barValue"); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue fooKey2 = new ConfigurationKeyValue(); configurations.add(fooKey2); fooKey2.key = "fooKey2"; fooKey2.value = "barValue2"; ConfigurationKeyValue fooKey3 = new ConfigurationKeyValue(); configurations.add(fooKey3); fooKey3.key = "fooKey3"; fooKey3.value = "barValue3"; fooKey3.mask = true; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertEquals("barValue", config.getProperties().get("fooKey")); assertEquals("barValue2", config.getProperties().get("fooKey2")); assertEquals("barValue3", config.getProperties().get("fooKey3")); assertTrue(report.getStdOut().contains("******")); }
@Test public void testAllowedSet() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setCurrentStackVersion(HDP_211_STACK); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("set.key.1", "s1"); put("set.key.2", "s2"); put("set.key.3", "s3"); put("set.key.4", "s4"); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue fooKey1 = new ConfigurationKeyValue(); configurations.add(fooKey1); fooKey1.key = "fooKey1"; fooKey1.value = "barValue1"; ConfigurationKeyValue fooKey2 = new ConfigurationKeyValue(); configurations.add(fooKey2); fooKey2.key = "fooKey2"; fooKey2.value = "barValue2"; ConfigurationKeyValue fooKey3 = new ConfigurationKeyValue(); configurations.add(fooKey3); fooKey3.key = "fooKey3"; fooKey3.value = "barValue3"; fooKey3.ifKey = "set.key.1"; fooKey3.ifType = "zoo.cfg"; fooKey3.ifValue = "s1"; ConfigurationKeyValue fooKey4 = new ConfigurationKeyValue(); configurations.add(fooKey4); fooKey4.key = "fooKey4"; fooKey4.value = "barValue4"; fooKey4.ifKey = "set.key.2"; fooKey4.ifType = "zoo.cfg"; fooKey4.ifKeyState= PropertyKeyState.PRESENT; ConfigurationKeyValue fooKey5 = new ConfigurationKeyValue(); configurations.add(fooKey5); fooKey5.key = "fooKey5"; fooKey5.value = "barValue5"; fooKey5.ifKey = "abc"; fooKey5.ifType = "zoo.cfg"; fooKey5.ifKeyState= PropertyKeyState.ABSENT; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertEquals("barValue1", config.getProperties().get("fooKey1")); assertEquals("barValue2", config.getProperties().get("fooKey2")); assertEquals("barValue3", config.getProperties().get("fooKey3")); assertEquals("barValue4", config.getProperties().get("fooKey4")); assertEquals("barValue5", config.getProperties().get("fooKey5")); assertEquals("s1", config.getProperties().get("set.key.1")); assertEquals("s2", config.getProperties().get("set.key.2")); assertEquals("s3", config.getProperties().get("set.key.3")); assertEquals("s4", config.getProperties().get("set.key.4")); }
@Test public void testDisallowedSet() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setCurrentStackVersion(HDP_211_STACK); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("set.key.1", "s1"); put("set.key.2", "s2"); put("set.key.3", "s3"); put("set.key.4", "s4"); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue fooKey3 = new ConfigurationKeyValue(); configurations.add(fooKey3); fooKey3.key = "fooKey3"; fooKey3.value = "barValue3"; fooKey3.ifKey = "set.key.1"; fooKey3.ifType = "zoo.cfg"; fooKey3.ifValue = "no-such-value"; ConfigurationKeyValue fooKey4 = new ConfigurationKeyValue(); configurations.add(fooKey4); fooKey4.key = "fooKey4"; fooKey4.value = "barValue4"; fooKey4.ifKey = "set.key.2"; fooKey4.ifType = "zoo.cfg"; fooKey4.ifKeyState= PropertyKeyState.ABSENT; ConfigurationKeyValue fooKey5 = new ConfigurationKeyValue(); configurations.add(fooKey5); fooKey5.key = "fooKey5"; fooKey5.value = "barValue5"; fooKey5.ifKey = "abc"; fooKey5.ifType = "zoo.cfg"; fooKey5.ifKeyState= PropertyKeyState.PRESENT; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertEquals("s1", config.getProperties().get("set.key.1")); assertEquals("s2", config.getProperties().get("set.key.2")); assertEquals("s3", config.getProperties().get("set.key.3")); assertEquals("s4", config.getProperties().get("set.key.4")); assertFalse(config.getProperties().containsKey("fooKey3")); assertFalse(config.getProperties().containsKey("fooKey4")); assertFalse(config.getProperties().containsKey("fooKey5")); }
@Test public void testAllowedReplacment() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setCurrentStackVersion(HDP_211_STACK); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("replace.key.1", "r1"); put("replace.key.2", "r2"); put("replace.key.3", "r3a1"); put("replace.key.4", "r4"); put("replace.key.5", "r5"); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<Replace> replacements = new ArrayList<>(); Replace replace = new Replace(); replace.key = "replace.key.3"; replace.find = "a"; replace.replaceWith = "A"; replacements.add(replace); Replace replace2 = new Replace(); replacements.add(replace2); replace2.key = "replace.key.4"; replace2.find = "r"; replace2.replaceWith = "R"; replace2.ifKey = "replace.key.1"; replace2.ifType = "zoo.cfg"; replace2.ifValue = "r1"; replacements.add(replace2); Replace replace3 = new Replace(); replacements.add(replace3); replace3.key = "replace.key.2"; replace3.find = "r"; replace3.replaceWith = "R"; replace3.ifKey = "replace.key.1"; replace3.ifType = "zoo.cfg"; replace3.ifKeyState = PropertyKeyState.PRESENT; replacements.add(replace3); Replace replace4 = new Replace(); replacements.add(replace3); replace4.key = "replace.key.5"; replace4.find = "r"; replace4.replaceWith = "R"; replace4.ifKey = "no.such.key"; replace4.ifType = "zoo.cfg"; replace4.ifKeyState = PropertyKeyState.ABSENT; replacements.add(replace4); Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_REPLACEMENTS, new Gson().toJson(replacements)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertEquals("r1", config.getProperties().get("replace.key.1")); assertEquals("R2", config.getProperties().get("replace.key.2")); assertEquals("r3A1", config.getProperties().get("replace.key.3")); assertEquals("R4", config.getProperties().get("replace.key.4")); assertEquals("R5", config.getProperties().get("replace.key.5")); }
@Test public void testDisallowedReplacment() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setCurrentStackVersion(HDP_211_STACK); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("replace.key.1", "r1"); put("replace.key.2", "r2"); put("replace.key.3", "r3a1"); put("replace.key.4", "r4"); put("replace.key.5", "r5"); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<Replace> replacements = new ArrayList<>(); Replace replace2 = new Replace(); replacements.add(replace2); replace2.key = "replace.key.4"; replace2.find = "r"; replace2.replaceWith = "R"; replace2.ifKey = "replace.key.1"; replace2.ifType = "zoo.cfg"; replace2.ifValue = "not-this-value"; replacements.add(replace2); Replace replace3 = new Replace(); replacements.add(replace3); replace3.key = "replace.key.2"; replace3.find = "r"; replace3.replaceWith = "R"; replace3.ifKey = "replace.key.1"; replace3.ifType = "zoo.cfg"; replace3.ifKeyState = PropertyKeyState.ABSENT; replacements.add(replace3); Replace replace4 = new Replace(); replacements.add(replace3); replace4.key = "replace.key.5"; replace4.find = "r"; replace4.replaceWith = "R"; replace4.ifKey = "no.such.key"; replace4.ifType = "zoo.cfg"; replace4.ifKeyState = PropertyKeyState.PRESENT; replacements.add(replace4); Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_REPLACEMENTS, new Gson().toJson(replacements)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertEquals("r1", config.getProperties().get("replace.key.1")); assertEquals("r2", config.getProperties().get("replace.key.2")); assertEquals("r3a1", config.getProperties().get("replace.key.3")); assertEquals("r4", config.getProperties().get("replace.key.4")); assertEquals("r5", config.getProperties().get("replace.key.5")); }
@Test public void testAllowedTransferCopy() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() {{ put("initLimit", "10"); put("copy.key.1", "c1"); put("copy.key.2", "c2"); }}, new HashMap<String, Map<String,String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue keyValue = new ConfigurationKeyValue(); configurations.add(keyValue); keyValue.key = "initLimit"; keyValue.value = "11"; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); List<Transfer> transfers = new ArrayList<>(); Transfer transfer1 = new Transfer(); transfer1.operation = TransferOperation.COPY; transfer1.fromKey = "copy.key.1"; transfer1.toKey = "copy.to.key.1"; transfers.add(transfer1); Transfer transfer2 = new Transfer(); transfer2.operation = TransferOperation.COPY; transfer2.fromKey = "copy.key.no.need.to.exit.1"; transfer2.toKey = "copy.to.key.with.default.1"; transfer2.defaultValue = "defaultValue"; transfers.add(transfer2); Transfer transfer3 = new Transfer(); transfer3.operation = TransferOperation.COPY; transfer3.fromKey = "copy.key.2"; transfer3.toKey = "copy.to.key.2"; transfer3.ifKey = "initLimit"; transfer3.ifType = "zoo.cfg"; transfer3.ifValue = "10"; transfers.add(transfer3); Transfer transfer4 = new Transfer(); transfer4.operation = TransferOperation.COPY; transfer4.fromKey = "copy.key.2"; transfer4.toKey = "copy.to.key.3"; transfer4.ifKey = "initLimit"; transfer4.ifType = "zoo.cfg"; transfer4.ifKeyState = PropertyKeyState.PRESENT; transfers.add(transfer4); Transfer transfer5 = new Transfer(); transfer5.operation = TransferOperation.COPY; transfer5.fromKey = "copy.key.no.need.to.exist.2"; transfer5.toKey = "copy.to.key.with.default.2"; transfer5.defaultValue = "defaultValue2"; transfer5.ifKey = "no.such.key"; transfer5.ifType = "zoo.cfg"; transfer5.ifKeyState = PropertyKeyState.ABSENT; transfers.add(transfer5); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper( executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); Map<String, String> map = config.getProperties(); assertEquals(8, map.size()); assertEquals("11", map.get("initLimit")); assertEquals(map.get("copy.key.1"), map.get("copy.to.key.1")); assertTrue(!map.containsKey("copy.key.no.need.to.exit.1")); assertEquals("defaultValue", map.get("copy.to.key.with.default.1")); assertTrue(!map.containsKey("copy.key.no.need.to.exit.2")); assertEquals("defaultValue2", map.get("copy.to.key.with.default.2")); assertEquals(map.get("copy.key.2"), map.get("copy.to.key.2")); assertEquals(map.get("copy.key.2"), map.get("copy.to.key.3")); }
@Test public void testDisallowedTransferCopy() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() {{ put("initLimit", "10"); put("copy.key.1", "c1"); put("copy.key.2", "c2"); }}, new HashMap<String, Map<String,String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue keyValue = new ConfigurationKeyValue(); configurations.add(keyValue); keyValue.key = "initLimit"; keyValue.value = "11"; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); List<Transfer> transfers = new ArrayList<>(); Transfer transfer = new Transfer(); transfer.operation = TransferOperation.COPY; transfer.fromKey = "copy.key.2"; transfer.toKey = "copy.to.key.2"; transfer.ifKey = "initLimit"; transfer.ifType = "zoo.cfg"; transfer.ifValue = "not-the-real-value"; transfers.add(transfer); transfer = new Transfer(); transfer.operation = TransferOperation.COPY; transfer.fromKey = "copy.key.2"; transfer.toKey = "copy.to.key.3"; transfer.ifKey = "initLimit"; transfer.ifType = "zoo.cfg"; transfer.ifKeyState = PropertyKeyState.ABSENT; transfers.add(transfer); transfer = new Transfer(); transfer.operation = TransferOperation.COPY; transfer.fromKey = "copy.key.no.need.to.exist.2"; transfer.toKey = "copy.to.key.with.default.2"; transfer.defaultValue = "defaultValue2"; transfer.ifKey = "no.such.key"; transfer.ifType = "zoo.cfg"; transfer.ifKeyState = PropertyKeyState.PRESENT; transfers.add(transfer); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper( executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); Map<String, String> map = config.getProperties(); assertEquals(3, map.size()); assertEquals("11", map.get("initLimit")); assertEquals("c1", map.get("copy.key.1")); assertEquals("c2", map.get("copy.key.2")); }
@Test public void testAllowedTransferMove() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() {{ put("initLimit", "10"); put("move.key.1", "m1"); put("move.key.2", "m2"); put("move.key.3", "m3"); put("move.key.4", "m4"); }}, new HashMap<String, Map<String,String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue keyValue = new ConfigurationKeyValue(); configurations.add(keyValue); keyValue.key = "initLimit"; keyValue.value = "11"; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); List<Transfer> transfers = new ArrayList<>(); Transfer transfer1 = new Transfer(); transfer1.operation = TransferOperation.MOVE; transfer1.fromKey = "move.key.1"; transfer1.toKey = "move.to.key.1"; transfers.add(transfer1); Transfer transfer2 = new Transfer(); transfer2.operation = TransferOperation.MOVE; transfer2.fromKey = "move.key.2"; transfer2.toKey = "move.to.key.2"; transfer2.ifKey = "initLimit"; transfer2.ifType = "zoo.cfg"; transfer2.ifValue = "10"; transfers.add(transfer2); Transfer transfer3 = new Transfer(); transfer3.operation = TransferOperation.MOVE; transfer3.fromKey = "move.key.3"; transfer3.toKey = "move.to.key.3"; transfer3.ifKey = "initLimit"; transfer3.ifType = "zoo.cfg"; transfer3.ifKeyState = PropertyKeyState.PRESENT; transfers.add(transfer3); Transfer transfer4 = new Transfer(); transfer4.operation = TransferOperation.MOVE; transfer4.fromKey = "move.key.4"; transfer4.toKey = "move.to.key.4"; transfer4.ifKey = "no.such.key"; transfer4.ifType = "zoo.cfg"; transfer4.ifKeyState = PropertyKeyState.ABSENT; transfers.add(transfer4); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper( executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); Map<String, String> map = config.getProperties(); assertEquals(5, map.size()); String[] shouldNotExitKeys = new String[]{"move.key.1", "move.key.2", "move.key.3", "move.key.4"}; String[] shouldExitKeys = new String[]{"move.to.key.1", "move.to.key.2", "move.to.key.3", "move.to.key.4"}; for(String key: shouldNotExitKeys){ assertFalse(map.containsKey(key)); } for(String key: shouldExitKeys){ assertTrue(map.containsKey(key)); } }
@Test public void testDisallowedTransferMove() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() {{ put("initLimit", "10"); put("move.key.1", "m1"); put("move.key.2", "m2"); put("move.key.3", "m3"); put("move.key.4", "m4"); }}, new HashMap<String, Map<String,String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue keyValue = new ConfigurationKeyValue(); configurations.add(keyValue); keyValue.key = "initLimit"; keyValue.value = "11"; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); List<Transfer> transfers = new ArrayList<>(); Transfer transfer2 = new Transfer(); transfer2.operation = TransferOperation.MOVE; transfer2.fromKey = "move.key.2"; transfer2.toKey = "move.to.key.2"; transfer2.ifKey = "initLimit"; transfer2.ifType = "zoo.cfg"; transfer2.ifValue = "not-real-value"; transfers.add(transfer2); Transfer transfer3 = new Transfer(); transfer3.operation = TransferOperation.MOVE; transfer3.fromKey = "move.key.3"; transfer3.toKey = "move.to.key.3"; transfer3.ifKey = "initLimit"; transfer3.ifType = "zoo.cfg"; transfer3.ifKeyState = PropertyKeyState.ABSENT; transfers.add(transfer3); Transfer transfer4 = new Transfer(); transfer4.operation = TransferOperation.MOVE; transfer4.fromKey = "move.key.4"; transfer4.toKey = "move.to.key.4"; transfer4.ifKey = "no.such.key"; transfer4.ifType = "zoo.cfg"; transfer4.ifKeyState = PropertyKeyState.PRESENT; transfers.add(transfer3); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper( executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); Map<String, String> map = config.getProperties(); assertEquals(5, map.size()); String[] shouldExitKeys = new String[]{"move.key.1", "move.key.2", "move.key.3", "move.key.4"}; String[] shouldNotExitKeys = new String[]{"move.to.key.1", "move.to.key.2", "move.to.key.3", "move.to.key.4"}; for(String key: shouldNotExitKeys){ assertFalse(map.containsKey(key)); } for(String key: shouldExitKeys){ assertTrue(map.containsKey(key)); } }
@Test public void testAllowedTransferDelete() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() {{ put("initLimit", "10"); put("delete.key.1", "d1"); put("delete.key.2", "d2"); put("delete.key.3", "d3"); put("delete.key.4", "d4"); }}, new HashMap<String, Map<String,String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue keyValue = new ConfigurationKeyValue(); configurations.add(keyValue); keyValue.key = "initLimit"; keyValue.value = "11"; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); List<Transfer> transfers = new ArrayList<>(); Transfer transfer1 = new Transfer(); transfer1.operation = TransferOperation.DELETE; transfer1.deleteKey = "delete.key.1"; transfers.add(transfer1); Transfer transfer2 = new Transfer(); transfer2.operation = TransferOperation.DELETE; transfer2.deleteKey = "delete.key.2"; transfer2.ifKey = "initLimit"; transfer2.ifType = "zoo.cfg"; transfer2.ifValue = "10"; transfers.add(transfer2); Transfer transfer3 = new Transfer(); transfer3.operation = TransferOperation.DELETE; transfer3.deleteKey = "delete.key.3"; transfer3.ifKey = "initLimit"; transfer3.ifType = "zoo.cfg"; transfer3.ifKeyState = PropertyKeyState.PRESENT; transfers.add(transfer3); Transfer transfer4 = new Transfer(); transfer4.operation = TransferOperation.DELETE; transfer4.deleteKey = "delete.key.4"; transfer4.ifKey = "no.such.key"; transfer4.ifType = "zoo.cfg"; transfer4.ifKeyState = PropertyKeyState.ABSENT; transfers.add(transfer4); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper( executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); Map<String, String> map = config.getProperties(); assertEquals(1, map.size()); assertEquals("11", map.get("initLimit")); String[] shouldNotExitKeys = new String[]{"delete.key.1","delete.key.2","delete.key.3","delete.key.4"}; for(String key: shouldNotExitKeys){ assertFalse(map.containsKey(key)); } }
@Test public void testDisallowedTransferDelete() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() {{ put("initLimit", "10"); put("delete.key.1", "d1"); put("delete.key.2", "d2"); put("delete.key.3", "d3"); put("delete.key.4", "d4"); }}, new HashMap<String, Map<String,String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); List<ConfigurationKeyValue> configurations = new ArrayList<>(); ConfigurationKeyValue keyValue = new ConfigurationKeyValue(); configurations.add(keyValue); keyValue.key = "initLimit"; keyValue.value = "11"; Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS, new Gson().toJson(configurations)); List<Transfer> transfers = new ArrayList<>(); Transfer transfer2 = new Transfer(); transfer2.operation = TransferOperation.DELETE; transfer2.deleteKey = "delete.key.2"; transfer2.ifKey = "initLimit"; transfer2.ifType = "zoo.cfg"; transfer2.ifValue = "not.real.value"; transfers.add(transfer2); Transfer transfer3 = new Transfer(); transfer3.operation = TransferOperation.DELETE; transfer3.deleteKey = "delete.key.3"; transfer3.ifKey = "initLimit"; transfer3.ifType = "zoo.cfg"; transfer3.ifKeyState = PropertyKeyState.ABSENT; transfers.add(transfer3); Transfer transfer4 = new Transfer(); transfer4.operation = TransferOperation.DELETE; transfer4.deleteKey = "delete.key.4"; transfer4.ifKey = "no.such.key"; transfer4.ifType = "zoo.cfg"; transfer4.ifKeyState = PropertyKeyState.PRESENT; transfers.add(transfer4); commandParams.put(ConfigureTask.PARAMETER_TRANSFERS, new Gson().toJson(transfers)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper( executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); Map<String, String> map = config.getProperties(); assertEquals(5, map.size()); assertEquals("11", map.get("initLimit")); String[] shouldExitKeys = new String[]{"delete.key.1","delete.key.2","delete.key.3","delete.key.4"}; for(String key: shouldExitKeys){ assertTrue(map.containsKey(key)); } }
@Test public void testInsert() throws Exception { makeUpgradeCluster(); Cluster c = clusters.getCluster("c1"); assertEquals(1, c.getConfigsByType("zoo.cfg").size()); c.setDesiredStackVersion(HDP_220_STACK); Config config = cf.createNew(c, "zoo.cfg", "version2", new HashMap<String, String>() { { put("key_to_append", "append"); put("key_to_prepend", "prepend"); } }, new HashMap<String, Map<String, String>>()); c.addDesiredConfig("user", Collections.singleton(config)); assertEquals(2, c.getConfigsByType("zoo.cfg").size()); Map<String, String> commandParams = new HashMap<>(); commandParams.put("upgrade_direction", "upgrade"); commandParams.put("version", HDP_2_2_0_1); commandParams.put("clusterName", "c1"); commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE, "zoo.cfg"); final String prependValue = "This should be on a newline"; final String appendValue = " this will be after..."; List<Insert> insertions = new ArrayList<>(); Insert prepend = new Insert(); prepend.insertType = InsertType.PREPEND; prepend.key = "key_to_prepend"; prepend.value = prependValue; prepend.newlineBefore = false; prepend.newlineAfter = true; Insert append = new Insert(); append.insertType = InsertType.APPEND; append.key = "key_to_append"; append.value = appendValue; append.newlineBefore = false; append.newlineAfter = false; insertions.add(prepend); insertions.add(append); insertions.add(prepend); insertions.add(append); commandParams.put(ConfigureTask.PARAMETER_INSERTIONS, new Gson().toJson(insertions)); ExecutionCommand executionCommand = new ExecutionCommand(); executionCommand.setCommandParams(commandParams); executionCommand.setClusterName("c1"); executionCommand.setRoleParams(new HashMap<String, String>()); executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME, "username"); HostRoleCommand hostRoleCommand = hostRoleCommandFactory.create(null, null, null, null); hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand)); action.setExecutionCommand(executionCommand); action.setHostRoleCommand(hostRoleCommand); CommandReport report = action.execute(null); assertNotNull(report); assertEquals(3, c.getConfigsByType("zoo.cfg").size()); config = c.getDesiredConfigByType("zoo.cfg"); assertNotNull(config); assertFalse("version2".equals(config.getTag())); String expectedPrepend = prependValue + System.lineSeparator() + "prepend"; String expectedAppend = "append" + appendValue; assertEquals(expectedPrepend, config.getProperties().get("key_to_prepend")); assertEquals(expectedAppend, config.getProperties().get("key_to_append")); }