added stack-id in resource name generation

src/main/java/software/amazon/cloudformation/resource/IdentifierUtils.java

@@ -14,13 +14,22 @@
 */
 package software.amazon.cloudformation.resource;
 
+import com.google.common.base.Splitter;
+import com.google.common.collect.Iterables;
+import java.util.Arrays;
 import java.util.Random;
+import java.util.regex.Pattern;
 import org.apache.commons.lang3.RandomStringUtils;
 
 public class IdentifierUtils {
 
  private static final int GENERATED_PHYSICALID_MAXLEN = 40;
  private static final int GUID_LENGTH = 12;
+ private static final int MIN_PHYSICAL_RESOURCE_ID_LENGTH = 15;
+ private static final int MIN_PREFERRED_LENGTH = 17;
+ private static final Splitter STACKID_SPLITTER = Splitter.on('/');
+ private static final Pattern STACK_ARN_PATTERN = Pattern.compile("^[a-z0-9-:]*stack/[-a-z0-9A-Z/]*");
+ private static final Pattern STACK_NAME_PATTERN = Pattern.compile("^[-a-z0-9A-Z]*");
 
  private IdentifierUtils() {
  }
@@ -56,7 +65,7 @@ public static String generateResourceIdentifier(final String logicalResourceId,
  generateResourceIdentifier(final String logicalResourceId, final String clientRequestToken, final int maxLength) {
  int maxLogicalIdLength = maxLength - (GUID_LENGTH + 1);
 
- int endIndex = logicalResourceId.length() > maxLogicalIdLength ? maxLogicalIdLength : logicalResourceId.length();
+ int endIndex = Math.min(logicalResourceId.length(), maxLogicalIdLength);
 
  StringBuilder sb = new StringBuilder();
  if (endIndex > 0) {
@@ -66,4 +75,92 @@ public static String generateResourceIdentifier(final String logicalResourceId,
  return sb.append(RandomStringUtils.random(GUID_LENGTH, 0, 0, true, true, null, new Random(clientRequestToken.hashCode())))
  .toString();
  }
+
+ public static String generateResourceIdentifier(final String stackId,
+ final String logicalResourceId,
+ final String clientRequestToken,
+ final int maxLength) {
+
+ if (maxLength < MIN_PHYSICAL_RESOURCE_ID_LENGTH) {
+ throw new IllegalArgumentException("Cannot generate resource IDs shorter than " + MIN_PHYSICAL_RESOURCE_ID_LENGTH
+ + " characters.");
+ }
+
+ String stackName = stackId;
+
+ if (isStackArn(stackId)) {
+ stackName = STACKID_SPLITTER.splitToList(stackId).get(1);
+ }
+
+ if (!isValidStackName(stackName)) {
+ throw new IllegalArgumentException(String.format("%s is not a valid Stack name", stackName));
+ }
+
+ // some services don't allow leading dashes. Since stack name is first, clean
+ // off any + no consecutive dashes
+
+ final String cleanStackName = stackName.replaceFirst("^-+", "").replaceAll("-{2,}", "-");
+
+ final boolean separate = maxLength > MIN_PREFERRED_LENGTH;
+ // 13 char length is reserved for the hashed value and one
+ // for each dash separator (if needed). the rest if the characters
+ // will get allocated evenly between the stack and resource names
+
+ final int freeCharacters = maxLength - 13 - (separate ? 1 : 0);
+ final int[] requestedLengths = new int[2];
+
+ requestedLengths[0] = cleanStackName.length();
+ requestedLengths[1] = logicalResourceId.length();
+
+ final int[] availableLengths = fairSplit(freeCharacters, requestedLengths);
+ final int charsForStackName = availableLengths[0];
+ final int charsForResrcName = availableLengths[1];
+
+ final StringBuilder prefix = new StringBuilder();
+
+ prefix.append(cleanStackName, 0, charsForStackName);
+ if (separate) {
+ prefix.append("-");
+ }
+ prefix.append(logicalResourceId, 0, charsForResrcName);
+
+ return IdentifierUtils.generateResourceIdentifier(prefix.toString(), clientRequestToken, maxLength);
+ }
+
+ private static boolean isStackArn(String stackId) {
+ return STACK_ARN_PATTERN.matcher(stackId).matches() && Iterables.size(STACKID_SPLITTER.split(stackId)) == 3;
+ }
+
+ private static boolean isValidStackName(String stackName) {
+ return STACK_NAME_PATTERN.matcher(stackName).matches();
+ }
+
+ private static int[] fairSplit(final int cap, final int[] buckets) {
+ int remaining = cap;
+
+ int[] allocated = new int[buckets.length];
+ Arrays.fill(allocated, 0);
+
+ while (remaining > 0) {
+ // at least one capacity unit
+ int maxAllocation = remaining < buckets.length ? 1 : remaining / buckets.length;
+
+ int bucketSatisfied = 0; // reset on each cap
+
+ for (int i = -1; ++i < buckets.length;) {
+ if (allocated[i] < buckets[i]) {
+ final int incrementalAllocation = Math.min(maxAllocation, buckets[i] - allocated[i]);
+ allocated[i] += incrementalAllocation;
+ remaining -= incrementalAllocation;
+ } else {
+ bucketSatisfied++;
+ }
+
+ if (remaining <= 0 || bucketSatisfied == buckets.length) {
+ return allocated;
+ }
+ }
+ }
+ return allocated;
+ }
 }

src/test/java/software/amazon/cloudformation/resource/IdentifierUtilsTest.java

@@ -48,4 +48,92 @@ public void generateResourceIdentifier_withShortLength_prefixTruncated() {
  // string that is left to fix the max length.
  assertThat(result).startsWith("my-re-");
  }
+
+ @Test
+ public void generateResourceIdentifier_withStackNameStackId() {
+ String result = IdentifierUtils.generateResourceIdentifier("my-stack-name", "my-resource", "123456", 18);
+ assertThat(result.length()).isLessThanOrEqualTo(18);
+
+ // to ensure randomness in the identity, the result will always be a random
+ // string PREFIXED by the size of
+ // string that is left to fix the max length.
+ assertThat(result).startsWith("my-my-");
+ }
+
+ @Test
+ public void generateResourceIdentifier_withStackName() {
+ String result = IdentifierUtils.generateResourceIdentifier("my-stack-name", "my-resource", "123456", 50);
+ assertThat(result.length()).isLessThanOrEqualTo(49);
+
+ // to ensure randomness in the identity, the result will always be a random
+ // string PREFIXED by the size of
+ // string that is left to fix the max length.
+ assertThat(result).startsWith("my-stack-name-my-resource-");
+ }
+
+ @Test
+ public void generateResourceIdentifier_withStackNameLessThanPreferredLen() {
+ String result = IdentifierUtils.generateResourceIdentifier("my-stack-name", "my-resource", "123456", 16);
+ assertThat(result.length()).isLessThanOrEqualTo(16);
+
+ // to ensure randomness in the identity, the result will always be a random
+ // string PREFIXED by the size of
+ // string that is left to fix the max length.
+ assertThat(result).startsWith("mym-");
+ }
+
+ @Test
+ public void generateResourceIdentifier_withStackNameBothFitMaxLen() {
+ String result = IdentifierUtils.generateResourceIdentifier(
+ "arn:aws:cloudformation:us-east-1:123456789012:stack/my-stack-name/084c0bd1-082b-11eb-afdc-0a2fadfa68a5",
+ "my-resource", "123456", 255);
+ assertThat(result.length()).isLessThanOrEqualTo(44);
+ assertThat(result).isEqualTo("my-stack-name-my-resource-hDoP0dahAFjd");
+ }
+
+ @Test
+ public void generateResourceIdentifier_withLongStackNameAndShotLogicalId() {
+ String result = IdentifierUtils.generateResourceIdentifier(
+ "arn:aws:cloudformation:us-east-1:123456789012:stack/my-very-very-very-very-very-very-long-custom-stack-name/084c0bd1-082b-11eb-afdc-0a2fadfa68a5",
+ "abc", "123456", 36);
+ assertThat(result.length()).isLessThanOrEqualTo(36);
+ assertThat(result).isEqualTo("my-very-very-very-v-abc-hDoP0dahAFjd");
+ }
+
+ @Test
+ public void generateResourceIdentifier_withShortStackNameAndLongLogicalId() {
+ String result = IdentifierUtils.generateResourceIdentifier("abc",
+ "my-very-very-very-very-very-very-long-custom-logical-id", "123456", 36);
+ assertThat(result.length()).isLessThanOrEqualTo(36);
+ assertThat(result).isEqualTo("abc-my-very-very-very-v-hDoP0dahAFjd");
+ }
+
+ @Test
+ public void generateResourceIdentifier_withLongStackNameAndLongLogicalId() {
+ String result = IdentifierUtils.generateResourceIdentifier(
+ "arn:aws:cloudformation:us-east-1:123456789012:stack/my-very-very-very-very-very-very-long-custom-stack-name/084c0bd1-082b-11eb-afdc-0a2fadfa68a5",
+ "my-very-very-very-very-very-very-long-custom-logical-id", "123456", 36);
+ assertThat(result.length()).isEqualTo(36);
+ assertThat(result).isEqualTo("my-very-ver-my-very-ver-hDoP0dahAFjd");
+ }
+
+ @Test
+ public void generateResourceIdentifier_withStackInValidInput() {
+ try {
+ IdentifierUtils.generateResourceIdentifier("stack/my-stack-name", "my-resource", "123456", 255);
+ } catch (IllegalArgumentException e) {
+ assertThat(e.getMessage()).isEqualTo("stack/my-stack-name is not a valid Stack name");
+ }
+ }
+
+ @Test
+ public void generateResourceIdentifier_withStackValidStackId() {
+ try {
+ IdentifierUtils.generateResourceIdentifier(
+ "arn:aws:cloudformation:us-east-1:123456789012:stack/my-stack-name/084c0bd1-082b-11eb-afdc-0a2fadfa68a5",
+ "my-resource", "123456", 14);
+ } catch (IllegalArgumentException e) {
+ assertThat(e.getMessage()).isEqualTo("Cannot generate resource IDs shorter than 15 characters.");
+ }
+ }
 }