workaround moto issue

Author: sanderegg

packages/aws-library/src/aws_library/ec2/_client.py

@@ -154,14 +154,41 @@ async def launch_instances(
                 max_total_number_of_instances=max_total_number_of_instances,
             )
 
+            subnet_descriptions = await self.client.describe_subnets(
+                SubnetIds=instance_config.subnet_ids
+            )
+            # check available IPs in subnets to give early feedback
+            subnet_id_to_available_ips: dict[str, int] = {}
+            for subnet in subnet_descriptions["Subnets"]:
+                if "SubnetId" in subnet and "AvailableIpAddressCount" in subnet:
+                    subnet_id_to_available_ips[subnet["SubnetId"]] = subnet[
+                        "AvailableIpAddressCount"
+                    ]
+            total_available_ips = sum(subnet_id_to_available_ips.values())
+            if total_available_ips < min_number_of_instances:
+                raise EC2InsufficientCapacityError(
+                    subnet_id=", ".join(instance_config.subnet_ids),
+                    instance_type=instance_config.type.name,
+                    details=(
+                        f"Not enough available IPs in subnets {subnet_id_to_available_ips}. "
+                        f"Total available IPs={total_available_ips} < min required instances={min_number_of_instances}"
+                    ),
+                )
+            # now let's not try to run instances in subnets that have not enough IPs
+            subnet_ids_with_capacity = [
+                subnet_id
+                for subnet_id, capacity in subnet_id_to_available_ips.items()
+                if capacity >= min_number_of_instances
+            ]
+
             resource_tags: list[TagTypeDef] = [
                 {"Key": tag_key, "Value": tag_value}
                 for tag_key, tag_value in instance_config.tags.items()
             ]
 
             # Try each subnet in order until one succeeds
             last_error = None
-            for subnet_id in instance_config.subnet_ids:
+            for subnet_id in subnet_ids_with_capacity:
                 try:
                     _logger.debug(
                         "Attempting to launch instances in subnet %s", subnet_id

packages/aws-library/tests/test_ec2_client.py

@@ -839,3 +839,66 @@ async def mock_run_instances(*args, **kwargs):
         expected_tags=ec2_instance_config.tags,
         expected_state="running",
     )
+
+
+@pytest.fixture
+async def with_small_subnet(
+    create_aws_subnet_id: Callable[..., Awaitable[str]],
+) -> tuple[str, int]:
+    """Creates a subnet with a single IP address to simulate InsufficientInstanceCapacity"""
+    single_ip_cidr = (
+        "10.0.11.0/29"  # /29 is the minimum allowed by AWS, gives 8 addresses
+    )
+    return (await create_aws_subnet_id(single_ip_cidr), 8 - 5)  # 5 are reserved by AWS
+
+
+async def test_launch_instances_with_small_subnet(
+    simcore_ec2_api: SimcoreEC2API,
+    ec2_client: EC2Client,
+    fake_ec2_instance_type: EC2InstanceType,
+    faker: Faker,
+    with_small_subnet: tuple[str, int],
+    aws_subnet_id: str,
+    aws_security_group_id: str,
+    aws_ami_id: str,
+    mocker: MockerFixture,
+):
+    await _assert_no_instances_in_ec2(ec2_client)
+    small_subnet_id, capacity = with_small_subnet
+    # Create a config with a single subnet (as requested)
+    ec2_instance_config = EC2InstanceConfig(
+        type=fake_ec2_instance_type,
+        tags=faker.pydict(allowed_types=(str,)),
+        startup_script=faker.pystr(),
+        ami_id=aws_ami_id,
+        key_name=faker.pystr(),
+        security_group_ids=[aws_security_group_id],
+        subnet_ids=[small_subnet_id, aws_subnet_id],
+        iam_instance_profile="",
+    )
+
+    # first call shall work in the first subnet
+    instances = await simcore_ec2_api.launch_instances(
+        ec2_instance_config,
+        min_number_of_instances=capacity,
+        number_of_instances=capacity,
+    )
+
+    # Verify we got 2 instances (partial capacity)
+    assert len(instances) == capacity
+
+    # Verify instances were created
+    await _assert_instances_in_ec2(
+        ec2_client,
+        expected_num_reservations=1,
+        expected_num_instances=capacity,
+        expected_instance_type=ec2_instance_config.type,
+        expected_tags=ec2_instance_config.tags,
+        expected_state="running",
+    )
+
+    instances = await simcore_ec2_api.launch_instances(
+        ec2_instance_config,
+        min_number_of_instances=1,
+        number_of_instances=1,
+    )

packages/pytest-simcore/src/pytest_simcore/aws_ec2_service.py

@@ -87,12 +87,12 @@ async def create_aws_subnet_id(
     aws_vpc_id: str,
     ec2_client: EC2Client,
     create_subnet_cidr_block: Callable[[], str],
-) -> AsyncIterator[Callable[[], Awaitable[str]]]:
+) -> AsyncIterator[Callable[..., Awaitable[str]]]:
     created_subnet_ids: set[str] = set()
 
-    async def _() -> str:
+    async def _(cidr_override: str | None = None) -> str:
         subnet = await ec2_client.create_subnet(
-            CidrBlock=create_subnet_cidr_block(), VpcId=aws_vpc_id
+            CidrBlock=cidr_override or create_subnet_cidr_block(), VpcId=aws_vpc_id
         )
         assert "Subnet" in subnet
         assert "SubnetId" in subnet["Subnet"]