service-capacity-modeling 0.3.74__py3-none-any.whl → 0.3.75__py3-none-any.whl

service_capacity_modeling/interface.py

@@ -264,14 +264,14 @@ class Drive(ExcludeUnsetModel):
         return max(self.block_size_kib, self.group_size_kib)
 
     @property
-    def max_size_gib(self):
+    def max_size_gib(self) -> int:
         if self.max_scale_size_gib != 0:
             return self.max_scale_size_gib
         else:
             return self.size_gib
 
     @property
-    def max_io_per_s(self):
+    def max_io_per_s(self) -> int:
         if self.max_scale_io_per_s != 0:
             return self.max_scale_io_per_s
         else:
@@ -779,23 +779,48 @@ class BufferComponent(str, Enum):
     compute = "compute"
     # [Data Shape]    a.k.a. "Dataset" related buffers, e.g. Disk and Memory
     storage = "storage"
-
     # Resource specific component
     cpu = "cpu"
     network = "network"
     disk = "disk"
     memory = "memory"
 
+    @staticmethod
+    def is_generic(component: str) -> bool:
+        return component in {BufferComponent.compute, BufferComponent.storage}
+
+    @staticmethod
+    def is_specific(component: str) -> bool:
+        return not BufferComponent.is_generic(component)
+
 
 class BufferIntent(str, Enum):
     # Most buffers show "desired" buffer, this is the default
     desired = "desired"
     # ratio on top of existing buffers to ensure exists. Generally combined
     # with a different desired buffer to ensure we don't just scale needlessly
+    # This means we can scale up or down as as long as we meet the desired buffer.
     scale = "scale"
-    # Ignore model preferences, just preserve existing buffers
+
+    # DEPRECATED: Use scale_up/scale_down instead
+    # Ignores model preferences, just preserve existing buffers
+    # We rarely actually want to do this since it can cause severe over provisioning
     preserve = "preserve"
 
+    # Scale up if necessary to meet the desired buffer.
+    # If the existing resource is over-provisioned, do not reduce the requirement.
+    # If under-provisioned, the requirement can be increased to meet the desired buffer.
+    # Example: need 20 cores but have 10 → scale up to 20 cores.
+    # Example 2: need 20 cores but have 40 → do not scale down and require at
+    # least 40 cores
+    scale_up = "scale_up"
+    # Scale down if necessary to meet the desired buffer.
+    # If the existing resource is under-provisioned, do not increase the requirement.
+    # If over-provisioned, the requirement can be decreased to meet the desired buffer.
+    # Example: need 20 cores but have 10 → maintain buffer and do not scale up.
+    # Example 2: need 20 cores but have 40 → scale down to 20 cores.
+    scale_down = "scale_down"
+
 
 class Buffer(ExcludeUnsetModel):
     # The value of the buffer expressed as a ratio over "normal" load e.g. 1.5x
@@ -819,7 +844,6 @@ class Buffers(ExcludeUnsetModel):
             "compute": Buffer(ratio: 1.5),
         }
     )
-
     And then models layer in their buffers, for example if a workload
     requires 10 CPU cores, but the operator of that workload  likes to build in
     2x buffer for background work (20 cores provisioned), they would express that

service_capacity_modeling/models/common.py

@@ -1,3 +1,4 @@
+# pylint: disable=too-many-lines
 import logging
 import math
 import random
@@ -6,8 +7,12 @@ from typing import Callable
 from typing import Dict
 from typing import List
 from typing import Optional
+from typing import Set
 from typing import Tuple
 
+from pydantic import BaseModel
+from pydantic import Field
+
 from service_capacity_modeling.hardware import shapes
 from service_capacity_modeling.interface import AVG_ITEM_SIZE_BYTES
 from service_capacity_modeling.interface import Buffer
@@ -63,6 +68,23 @@ def _QOS(tier: int) -> float:
         return 1
 
 
+def combine_buffer_ratios(left: Optional[float], right: Optional[float]) -> float:
+    """
+    Strategy for how two buffers for the same component are combined.
+    - Multiply two buffers by multiplying if both are not None
+    """
+
+    if left is None and right is None:
+        raise ValueError("Cannot combine buffer ratios when both values are None")
+    if left is None:
+        assert right is not None  # MyPy
+        return right
+    if right is None:
+        assert left is not None  # MyPy
+        return left
+    return left * right
+
+
 def _sqrt_staffed_cores(rps: float, latency_s: float, qos: float) -> int:
     # Square root staffing
     # s = a + Q*sqrt(a)
@@ -153,18 +175,31 @@ def normalize_cores(
     target_shape: Instance,
     reference_shape: Optional[Instance] = None,
 ) -> int:
-    """Calculates equivalent cores on a target shape relative to a reference
+    """Calculates equivalent CPU on a target shape relative to a reference
 
     Takes into account relative core frequency and IPC factor from the hardware
     description to give a rough estimate of how many equivalent cores you need
     in a target_shape to have the core_count number of cores on the reference_shape
     """
+    # Normalize the core count the same as CPUs
+    return _normalize_cpu(
+        cpu_count=core_count,
+        target_shape=target_shape,
+        reference_shape=reference_shape,
+    )
+
+
+def _normalize_cpu(
+    cpu_count: float,
+    target_shape: Instance,
+    reference_shape: Optional[Instance] = None,
+) -> int:
     if reference_shape is None:
         reference_shape = default_reference_shape
 
     target_speed = target_shape.cpu_ghz * target_shape.cpu_ipc_scale
     reference_speed = reference_shape.cpu_ghz * reference_shape.cpu_ipc_scale
-    return max(1, math.ceil(core_count / (target_speed / reference_speed)))
+    return max(1, math.ceil(cpu_count / (target_speed / reference_speed)))
 
 
 def _reserved_headroom(
@@ -218,8 +253,6 @@ def cpu_headroom_target(instance: Instance, buffers: Optional[Buffers] = None) -
 # When someone asks for the key, return any buffers that
 # influence the component in the value
 _default_buffer_fallbacks: Dict[str, List[str]] = {
-    BufferComponent.compute: [BufferComponent.cpu],
-    BufferComponent.storage: [BufferComponent.disk],
     BufferComponent.cpu: [BufferComponent.compute],
     BufferComponent.network: [BufferComponent.compute],
     BufferComponent.memory: [BufferComponent.storage],
@@ -227,6 +260,44 @@ _default_buffer_fallbacks: Dict[str, List[str]] = {
 }
 
 
+def _expand_components(
+    components: List[str],
+    component_fallbacks: Optional[Dict[str, List[str]]] = None,
+) -> Set[str]:
+    """Expand and dedupe components to include their fallbacks
+
+    Args:
+        components: List of component names to expand
+        component_fallbacks: Optional fallback mapping (uses default if None)
+
+    Returns:
+        Set of expanded component names including fallbacks
+    """
+
+    # Semantically it does not make sense to fetch buffers for the generic category
+    generic_components = [c for c in components if BufferComponent.is_generic(c)]
+    if generic_components:
+        all_specific_components = [
+            c for c in BufferComponent if BufferComponent.is_specific(c)
+        ]
+        raise ValueError(
+            f"Only specific components allowed. Generic components found: "
+            f"{', '.join(str(c) for c in generic_components)}. "
+            f"Use specific components instead: "
+            f"{', '.join(str(c) for c in all_specific_components)}"
+        )
+
+    if component_fallbacks is None:
+        component_fallbacks = _default_buffer_fallbacks
+
+    expanded_components = set(components)
+    for component in components:
+        expanded_components = expanded_components | set(
+            component_fallbacks.get(component, [])
+        )
+    return expanded_components
+
+
 def buffer_for_components(
     buffers: Buffers,
     components: List[str],
@@ -245,14 +316,7 @@ def buffer_for_components(
         components: the components that ultimately matched after applying
         source: All the component buffers that made up the composite ratio
     """
-    if component_fallbacks is None:
-        component_fallbacks = _default_buffer_fallbacks
-
-    unique_components = set(components)
-    for component in components:
-        unique_components = unique_components | set(
-            component_fallbacks.get(component, [])
-        )
+    expanded_components = _expand_components(components, component_fallbacks)
 
     desired = {k: v.model_copy() for k, v in buffers.desired.items()}
     if current_capacity:
@@ -266,14 +330,14 @@ def buffer_for_components(
     ratio = 1.0
     sources = {}
     for name, buffer in desired.items():
-        if any(i in unique_components for i in buffer.components):
+        if expanded_components.intersection(buffer.components):
             sources[name] = buffer
-            ratio *= buffer.ratio
+            ratio = combine_buffer_ratios(ratio, buffer.ratio)
     if not sources:
         ratio = buffers.default.ratio
 
     return Buffer(
-        ratio=ratio, components=sorted(list(unique_components)), sources=sources
+        ratio=ratio, components=sorted(list(expanded_components)), sources=sources
     )
 
 
@@ -483,7 +547,7 @@ def compute_stateful_zone(  # pylint: disable=too-many-positional-arguments
         # When initially provisioniong we don't want to attach more than
         # 1/3 the maximum volume size in one node (preferring more nodes
         # with smaller volumes)
-        max_size = drive.max_size_gib / 3
+        max_size = math.ceil(drive.max_size_gib / 3)
         if ebs_gib > max_size > 0:
             ratio = ebs_gib / max_size
             count = max(cluster_size(math.ceil(count * ratio)), min_count)
@@ -717,180 +781,188 @@ def merge_plan(
     )
 
 
-def derived_buffer_for_component(buffer: Dict[str, Buffer], components: List[str]):
-    scale = 0.0
-    preserve = False
-
-    if not buffer:
-        return scale, preserve
-
-    for bfr in buffer.values():
-        if any(component in components for component in bfr.components):
-            if bfr.intent == BufferIntent.scale:
-                scale = max(scale, bfr.ratio)
+class DerivedBuffers(BaseModel):
+    scale: float = Field(default=1, gt=0)
+    preserve: bool = False
+    # When present, this is the maximum ratio of the current usage
+    ceiling: Optional[float] = Field(
+        default=None,
+        gt=0,
+    )
+    # When present, this is the minimum ratio of the current usage
+    floor: Optional[float] = Field(default=None, gt=0)
+
+    @staticmethod
+    def for_components(
+        buffer: Dict[str, Buffer],
+        components: List[str],
+        component_fallbacks: Optional[Dict[str, List[str]]] = None,
+    ):
+        expanded_components = _expand_components(components, component_fallbacks)
+
+        scale = 1.0
+        preserve = False
+        ceiling = None
+        floor = None
+
+        for bfr in buffer.values():
+            if not expanded_components.intersection(bfr.components):
+                continue
+
+            if bfr.intent in [
+                BufferIntent.scale,
+                BufferIntent.scale_up,
+                BufferIntent.scale_down,
+            ]:
+                scale = combine_buffer_ratios(scale, bfr.ratio)
+            if bfr.intent == BufferIntent.scale_up:
+                floor = 1  # Create a floor of 1.0x the current usage
+            if bfr.intent == BufferIntent.scale_down:
+                ceiling = 1  # Create a ceiling of 1.0x the current usage
             if bfr.intent == BufferIntent.preserve:
                 preserve = True
 
-    return scale, preserve
-
-
-def get_cores_from_current_capacity(
-    current_capacity: CurrentClusterCapacity, buffers: Buffers, instance: Instance
-):
-    # compute cores required per zone
-    cpu_success_buffer = (1 - cpu_headroom_target(instance, buffers)) * 100
-    current_cpu_utilization = current_capacity.cpu_utilization.mid
-
-    if current_capacity.cluster_instance is None:
-        cluster_instance = shapes.instance(current_capacity.cluster_instance_name)
-    else:
-        cluster_instance = current_capacity.cluster_instance
-
-    current_cores = cluster_instance.cpu * current_capacity.cluster_instance_count.mid
-
-    scale, preserve = derived_buffer_for_component(buffers.derived, ["compute", "cpu"])
-    # Scale and preserve for the same component should not be passed together.
-    # If user passes it, then scale will be preferred over preserve.
-    if scale > 0:
-        # if the new cpu core is less than the current,
-        # then take no action and return the current cpu cores
-        new_cpu_utilization = current_cpu_utilization * scale
-        core_scale_up_factor = max(1.0, new_cpu_utilization / cpu_success_buffer)
-        return math.ceil(current_cores * core_scale_up_factor)
-
-    if preserve:
-        return current_cores
-
-    return int(current_cores * (current_cpu_utilization / cpu_success_buffer))
-
-
-def get_memory_from_current_capacity(
-    current_capacity: CurrentClusterCapacity, buffers: Buffers
-):
-    # compute memory required per zone
-    current_memory_utilization = (
-        current_capacity.memory_utilization_gib.mid
-        * current_capacity.cluster_instance_count.mid
-    )
-
-    if current_capacity.cluster_instance is None:
-        cluster_instance = shapes.instance(current_capacity.cluster_instance_name)
-    else:
-        cluster_instance = current_capacity.cluster_instance
-
-    zonal_ram_allocated = (
-        cluster_instance.ram_gib * current_capacity.cluster_instance_count.mid
-    )
-
-    # These are the desired buffers
-    memory_buffer = buffer_for_components(
-        buffers=buffers, components=[BufferComponent.memory]
-    )
-
-    scale, preserve = derived_buffer_for_component(
-        buffers.derived, ["memory", "storage"]
-    )
-    # Scale and preserve for the same component should not be passed together.
-    # If user passes it, then scale will be preferred over preserve.
-    if scale > 0:
-        # if the new required memory is less than the current,
-        # then take no action and return the current ram
-        return max(
-            current_memory_utilization * scale * memory_buffer.ratio,
-            zonal_ram_allocated,
+        return DerivedBuffers(
+            scale=scale, preserve=preserve, ceiling=ceiling, floor=floor
         )
 
-    if preserve:
-        return zonal_ram_allocated
-
-    return current_memory_utilization * memory_buffer.ratio
-
-
-def get_network_from_current_capacity(
-    current_capacity: CurrentClusterCapacity, buffers: Buffers
-):
-    # compute network required per zone
-    current_network_utilization = (
-        current_capacity.network_utilization_mbps.mid
-        * current_capacity.cluster_instance_count.mid
-    )
-
-    if current_capacity.cluster_instance is None:
-        cluster_instance = shapes.instance(current_capacity.cluster_instance_name)
-    else:
-        cluster_instance = current_capacity.cluster_instance
-
-    zonal_network_allocated = (
-        cluster_instance.net_mbps * current_capacity.cluster_instance_count.mid
-    )
-
-    # These are the desired buffers
-    network_buffer = buffer_for_components(
-        buffers=buffers, components=[BufferComponent.network]
-    )
+    def calculate_requirement(
+        self,
+        current_usage: float,
+        existing_capacity: float,
+        desired_buffer_ratio: float = 1.0,
+    ) -> float:
+        if self.preserve:
+            return existing_capacity
+
+        requirement = self.scale * current_usage * desired_buffer_ratio
+        if self.ceiling is not None:
+            requirement = min(requirement, self.ceiling * existing_capacity)
+        if self.floor is not None:
+            requirement = max(requirement, self.floor * existing_capacity)
+
+        return requirement
+
+
+class RequirementFromCurrentCapacity(BaseModel):
+    current_capacity: CurrentClusterCapacity
+    buffers: Buffers
+
+    @property
+    def current_instance(self) -> Instance:
+        if self.current_capacity.cluster_instance is not None:
+            return self.current_capacity.cluster_instance
+        return shapes.instance(self.current_capacity.cluster_instance_name)
+
+    def cpu(self, instance_candidate: Instance) -> int:
+        current_cpu_util = self.current_capacity.cpu_utilization.mid / 100
+        current_total_cpu = (
+            self.current_instance.cpu * self.current_capacity.cluster_instance_count.mid
+        )
 
-    scale, preserve = derived_buffer_for_component(
-        buffers.derived, ["compute", "network"]
-    )
-    # Scale and preserve for the same component should not be passed together.
-    # If user passes it, then scale will be preferred over preserve.
-    if scale > 0:
-        # if the new required network is less than the current,
-        # then take no action and return the current bandwidth
-        return max(
-            current_network_utilization * scale * network_buffer.ratio,
-            zonal_network_allocated,
+        derived_buffers = DerivedBuffers.for_components(
+            self.buffers.derived, [BufferComponent.cpu]
         )
 
-    if preserve:
-        return zonal_network_allocated
+        # The ideal CPU% that accomodates the headroom + desired buffer, sometimes
+        # referred to as the "success buffer"
+        target_cpu_util = 1 - cpu_headroom_target(instance_candidate, self.buffers)
+        # current_util / target_util ratio indicates CPU scaling direction:
+        # > 1: scale up, < 1: scale down, = 1: no change needed
+        used_cpu = (current_cpu_util / target_cpu_util) * current_total_cpu
+        return math.ceil(
+            # Desired buffer is omitted because the cpu_headroom already
+            # includes it
+            derived_buffers.calculate_requirement(
+                current_usage=used_cpu,
+                existing_capacity=current_total_cpu,
+            )
+        )
 
-    return current_network_utilization * network_buffer.ratio
+    @property
+    def mem_gib(self) -> float:
+        current_memory_utilization = (
+            self.current_capacity.memory_utilization_gib.mid
+            * self.current_capacity.cluster_instance_count.mid
+        )
+        zonal_ram_allocated = (
+            self.current_instance.ram_gib
+            * self.current_capacity.cluster_instance_count.mid
+        )
 
+        desired_buffer = buffer_for_components(
+            buffers=self.buffers, components=[BufferComponent.memory]
+        )
+        derived_buffer = DerivedBuffers.for_components(
+            self.buffers.derived, [BufferComponent.memory]
+        )
 
-def get_disk_from_current_capacity(
-    current_capacity: CurrentClusterCapacity, buffers: Buffers
-):
-    # compute disk required per zone
-    current_disk_utilization = (
-        current_capacity.disk_utilization_gib.mid
-        * current_capacity.cluster_instance_count.mid
-    )
+        return derived_buffer.calculate_requirement(
+            current_usage=current_memory_utilization,
+            existing_capacity=zonal_ram_allocated,
+            desired_buffer_ratio=desired_buffer.ratio,
+        )
 
-    if current_capacity.cluster_instance is None:
-        cluster_instance = shapes.instance(current_capacity.cluster_instance_name)
-    else:
-        cluster_instance = current_capacity.cluster_instance
+    @property
+    def disk_gib(self) -> int:
+        current_cluster_disk_util_gib = (
+            self.current_capacity.disk_utilization_gib.mid
+            * self.current_capacity.cluster_instance_count.mid
+        )
+        current_node_disk_gib = (
+            self.current_instance.drive.max_size_gib
+            if self.current_instance.drive is not None
+            else (
+                self.current_capacity.cluster_drive.size_gib
+                if self.current_capacity.cluster_drive is not None
+                else 0
+            )
+        )
 
-    if cluster_instance.drive is not None:
-        instance_disk_allocated = cluster_instance.drive.max_size_gib
-    else:
-        assert current_capacity.cluster_drive is not None, "Drive should not be None"
-        instance_disk_allocated = current_capacity.cluster_drive.size_gib
+        zonal_disk_allocated = (
+            current_node_disk_gib * self.current_capacity.cluster_instance_count.mid
+        )
+        # These are the desired buffers
+        disk_buffer = buffer_for_components(
+            buffers=self.buffers, components=[BufferComponent.disk]
+        )
 
-    zonal_disk_allocated = (
-        instance_disk_allocated * current_capacity.cluster_instance_count.mid
-    )
+        derived_buffer = DerivedBuffers.for_components(
+            self.buffers.derived, [BufferComponent.disk]
+        )
+        required_disk = derived_buffer.calculate_requirement(
+            current_usage=current_cluster_disk_util_gib,
+            existing_capacity=zonal_disk_allocated,
+            desired_buffer_ratio=disk_buffer.ratio,
+        )
+        return math.ceil(required_disk)
 
-    # These are the desired buffers
-    disk_buffer = buffer_for_components(
-        buffers=buffers, components=[BufferComponent.disk]
-    )
+    @property
+    def network_mbps(self) -> int:
+        current_network_utilization = (
+            self.current_capacity.network_utilization_mbps.mid
+            * self.current_capacity.cluster_instance_count.mid
+        )
+        zonal_network_allocated = (
+            self.current_instance.net_mbps
+            * self.current_capacity.cluster_instance_count.mid
+        )
 
-    scale, preserve = derived_buffer_for_component(buffers.derived, ["storage", "disk"])
-    # Scale and preserve for the same component should not be passed together.
-    # If user passes it, then scale will be preferred over preserve.
-    if scale > 0:
-        # if the new required disk is less than the current,
-        # then take no action and return the current disk
-        return max(
-            current_disk_utilization * scale * disk_buffer.ratio, zonal_disk_allocated
+        # These are the desired buffers
+        network_buffer = buffer_for_components(
+            buffers=self.buffers, components=[BufferComponent.network]
+        )
+        derived_buffer = DerivedBuffers.for_components(
+            self.buffers.derived, [BufferComponent.network]
         )
-    if preserve:
-        # preserve the current disk size for the zone
-        return zonal_disk_allocated
 
-    return current_disk_utilization * disk_buffer.ratio
+        return math.ceil(
+            derived_buffer.calculate_requirement(
+                current_usage=current_network_utilization,
+                existing_capacity=zonal_network_allocated,
+                desired_buffer_ratio=network_buffer.ratio,
+            )
+        )
 
 
 def zonal_requirements_from_current(
@@ -901,20 +973,25 @@ def zonal_requirements_from_current(
 ) -> CapacityRequirement:
     if current_cluster is not None and current_cluster.zonal[0] is not None:
         current_capacity: CurrentClusterCapacity = current_cluster.zonal[0]
-        needed_cores = normalize_cores(
-            get_cores_from_current_capacity(current_capacity, buffers, instance),
+
+        # Adjust the CPUs (vCPU + cores) based on generation / instance type
+        requirement = RequirementFromCurrentCapacity(
+            current_capacity=current_capacity,
+            buffers=buffers,
+        )
+        normalized_cpu = _normalize_cpu(
+            requirement.cpu(instance),
             instance,
             reference_shape,
         )
-        needed_network_mbps = get_network_from_current_capacity(
-            current_capacity, buffers
-        )
-        needed_memory_gib = get_memory_from_current_capacity(current_capacity, buffers)
-        needed_disk_gib = get_disk_from_current_capacity(current_capacity, buffers)
+
+        needed_network_mbps = requirement.network_mbps
+        needed_disk_gib = requirement.disk_gib
+        needed_memory_gib = requirement.mem_gib
 
         return CapacityRequirement(
             requirement_type="zonal-capacity",
-            cpu_cores=certain_int(needed_cores),
+            cpu_cores=certain_int(normalized_cpu),
             mem_gib=certain_float(needed_memory_gib),
             disk_gib=certain_float(needed_disk_gib),
             network_mbps=certain_float(needed_network_mbps),

service_capacity_modeling/models/org/netflix/cassandra.py

@@ -35,7 +35,7 @@ from service_capacity_modeling.interface import ServiceCapacity
 from service_capacity_modeling.models import CapacityModel
 from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
-from service_capacity_modeling.models.common import derived_buffer_for_component
+from service_capacity_modeling.models.common import DerivedBuffers
 from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
 from service_capacity_modeling.models.common import network_services
 from service_capacity_modeling.models.common import normalize_cores
@@ -181,7 +181,9 @@ def _zonal_requirement_for_new_cluster(
     )
 
 
-def _estimate_cassandra_requirement(  # pylint: disable=too-many-positional-arguments
+# pylint: disable=too-many-locals
+# pylint: disable=too-many-positional-arguments
+def _estimate_cassandra_requirement(
     instance: Instance,
     desires: CapacityDesires,
     working_set: float,
@@ -205,19 +207,22 @@ def _estimate_cassandra_requirement(  # pylint: disable=too-many-positional-argu
     # If the cluster is already provisioned
     if current_capacity and desires.current_clusters is not None:
         capacity_requirement = zonal_requirements_from_current(
-            desires.current_clusters, desires.buffers, instance, reference_shape
+            desires.current_clusters,
+            desires.buffers,
+            instance,
+            reference_shape,
         )
-        disk_scale, _ = derived_buffer_for_component(
-            desires.buffers.derived, ["storage", "disk"]
+        disk_derived_buffer = DerivedBuffers.for_components(
+            desires.buffers.derived, [BufferComponent.disk]
         )
         disk_used_gib = (
             current_capacity.disk_utilization_gib.mid
             * current_capacity.cluster_instance_count.mid
-            * (disk_scale or 1)
-        )
-        _, memory_preserve = derived_buffer_for_component(
-            desires.buffers.derived, ["storage", "memory"]
+            * disk_derived_buffer.scale
         )
+        memory_preserve = DerivedBuffers.for_components(
+            desires.buffers.derived, [BufferComponent.memory]
+        ).preserve
     else:
         # If the cluster is not yet provisioned
         capacity_requirement = _zonal_requirement_for_new_cluster(

service_capacity_modeling/models/org/netflix/evcache.py

@@ -33,13 +33,10 @@ from service_capacity_modeling.interface import Requirements
 from service_capacity_modeling.models import CapacityModel
 from service_capacity_modeling.models.common import buffer_for_components
 from service_capacity_modeling.models.common import compute_stateful_zone
-from service_capacity_modeling.models.common import get_cores_from_current_capacity
-from service_capacity_modeling.models.common import get_disk_from_current_capacity
 from service_capacity_modeling.models.common import get_effective_disk_per_node_gib
-from service_capacity_modeling.models.common import get_memory_from_current_capacity
-from service_capacity_modeling.models.common import get_network_from_current_capacity
 from service_capacity_modeling.models.common import network_services
 from service_capacity_modeling.models.common import normalize_cores
+from service_capacity_modeling.models.common import RequirementFromCurrentCapacity
 from service_capacity_modeling.models.common import simple_network_mbps
 from service_capacity_modeling.models.common import sqrt_staffed_cores
 from service_capacity_modeling.models.common import working_set_from_drive_and_slo
@@ -104,25 +101,20 @@ def calculate_vitals_for_capacity_planner(
     )
     if not current_capacity:
         return needed_cores, needed_network_mbps, needed_memory_gib, needed_disk_gib
+    requirements = RequirementFromCurrentCapacity(
+        current_capacity=current_capacity,
+        buffers=desires.buffers,
+    )
     needed_cores = normalize_cores(
-        core_count=get_cores_from_current_capacity(
-            current_capacity, desires.buffers, instance
-        ),
+        core_count=requirements.cpu(instance_candidate=instance),
         target_shape=instance,
         reference_shape=current_capacity.cluster_instance,
     )
-    needed_network_mbps = get_network_from_current_capacity(
-        current_capacity, desires.buffers
-    )
-    needed_memory_gib = get_memory_from_current_capacity(
-        current_capacity, desires.buffers
+    needed_network_mbps = requirements.network_mbps
+    needed_disk_gib = (
+        requirements.disk_gib if current_capacity.cluster_drive is not None else 0.0
     )
-    if current_capacity.cluster_drive is None:
-        needed_disk_gib = 0.0
-    else:
-        needed_disk_gib = get_disk_from_current_capacity(
-            current_capacity, desires.buffers
-        )
+    needed_memory_gib = requirements.mem_gib
     return needed_cores, needed_network_mbps, needed_memory_gib, needed_disk_gib
 
 

{service_capacity_modeling-0.3.74.dist-info → service_capacity_modeling-0.3.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: service-capacity-modeling
-Version: 0.3.74
+Version: 0.3.75
 Summary: Contains utilities for modeling capacity for pluggable workloads
 Author: Joseph Lynch
 Author-email: josephl@netflix.com

{service_capacity_modeling-0.3.74.dist-info → service_capacity_modeling-0.3.75.dist-info}/RECORD

@@ -1,6 +1,6 @@
 service_capacity_modeling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 service_capacity_modeling/capacity_planner.py,sha256=B6e0esOAvV6qMkEeLIO9rEveTftRG_Ut_d9gYgSIM0w,31914
-service_capacity_modeling/interface.py,sha256=-nwCW67LBoxR9I_FZxkMmB0n4VS21gqrdfDCskZ0w7E,37493
+service_capacity_modeling/interface.py,sha256=WLCVqrRgH4Vz3YhzZAct0QMXrBOow7v5ipZLoJ7AfSc,38826
 service_capacity_modeling/stats.py,sha256=8HIPwVnmvbauBwXhn6vbNYO7-CzWPuymnq0eX7ZA1_w,5849
 service_capacity_modeling/hardware/__init__.py,sha256=kzIHnIymwnf4qQYDpfIChIAxTF8b87XtnBg1TwF_J9E,8974
 service_capacity_modeling/hardware/profiles/__init__.py,sha256=7-y3JbCBkgzaAjFla2RIymREcImdZ51HTl3yn3vzoGw,1602
@@ -46,19 +46,19 @@ service_capacity_modeling/hardware/profiles/shapes/aws/manual_drives.json,sha256
 service_capacity_modeling/hardware/profiles/shapes/aws/manual_instances.json,sha256=-_jxyQgmwKe5JnbfhMD9xDCq0sy7z2fdZn7Fu76IUkk,12457
 service_capacity_modeling/hardware/profiles/shapes/aws/manual_services.json,sha256=h63675KKmu5IrI3BORDN8fiAqLjAyYHArErKbC7-T30,776
 service_capacity_modeling/models/__init__.py,sha256=XK7rTBW8ZXQY5L9Uy2FwjuFN_KBW3hKw7IrhG1piajs,13567
-service_capacity_modeling/models/common.py,sha256=oF1WVhd6kXFvKNs7zzkms25U1Si_iqCn48TptyxWd0E,34128
+service_capacity_modeling/models/common.py,sha256=ntBx5Rku4UfJiKwZ0tkv75gXBzUlGT6hOUTLvENlElA,36534
 service_capacity_modeling/models/headroom_strategy.py,sha256=QIkP_K_tK2EGAjloaGfXeAPH5M0UDCN8FlAtwV9xxTA,651
 service_capacity_modeling/models/utils.py,sha256=WosEEg4o1_WSbTb5mL-M1v8JuWJgvS2oWvnDS3qNz3k,2662
 service_capacity_modeling/models/org/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 service_capacity_modeling/models/org/netflix/__init__.py,sha256=m7IaQbo85NEbDvfoPJREIznpzg0YHTCrKP5C1GvnOYM,2378
 service_capacity_modeling/models/org/netflix/aurora.py,sha256=Mi9zd48k64GkKIjAs3J1S2qThguNvyWIy2dUmhwrVhc,12883
-service_capacity_modeling/models/org/netflix/cassandra.py,sha256=QdSurxiv9XiCK7z6Omn6hjZf0rHleDfMvn3-JSpr5rA,38548
+service_capacity_modeling/models/org/netflix/cassandra.py,sha256=MnTD7X3-mm05LtM_CjWatIVyeMCfPqVsxszTDb8s7ao,38632
 service_capacity_modeling/models/org/netflix/counter.py,sha256=hOVRRCgCPU-A5TdLKQXc_mWTQpkKOWRNjOeECdDP7kA,9205
 service_capacity_modeling/models/org/netflix/crdb.py,sha256=ELIbxwfNsJcEkNGW7qtz0SEzt3Vj6wj8QL5QQeebIlo,20635
 service_capacity_modeling/models/org/netflix/ddb.py,sha256=GDoXVIpDDY6xDB0dsiaz7RAPPj-qffTrM9N6w5-5ndg,26311
 service_capacity_modeling/models/org/netflix/elasticsearch.py,sha256=AfyqfC4Y_QDyvYLBbeq8_ReM9q54RUNrZkOsSBjBgIc,25085
 service_capacity_modeling/models/org/netflix/entity.py,sha256=M0vzwhf8UAbVxnXspAkN4GEbq3rix6yoky6W2oDG6a0,8648
-service_capacity_modeling/models/org/netflix/evcache.py,sha256=70lgaRgNwJH84o6JVoUDplkCi4v-WzEX3nxVagoJjDc,25775
+service_capacity_modeling/models/org/netflix/evcache.py,sha256=mLSoecrXwwfrt9ZRu1LZ2po8lD50orQAFnpvW0YTmI8,25396
 service_capacity_modeling/models/org/netflix/graphkv.py,sha256=iS5QDDv9_hNY6nIgdL-umB439qP7-jN-n6_Tl6d-ZSo,8557
 service_capacity_modeling/models/org/netflix/iso_date_math.py,sha256=CPGHLmbGeNqkcYcmCkLKhPZcAU-yTJ2HjvuXdnNyCYc,996
 service_capacity_modeling/models/org/netflix/kafka.py,sha256=MDHaht5cWsOJ113uMl6nQ7nllSATrlBCQ-TXLkqMWEk,25466
@@ -75,9 +75,9 @@ service_capacity_modeling/tools/auto_shape.py,sha256=Pe9a7vbFxqIy8eL8ssENTu9FNnF
 service_capacity_modeling/tools/fetch_pricing.py,sha256=JkgJPTE0SVj8sdGQvo0HN-Hdv3nfA2tu7C_Arad5aX8,3762
 service_capacity_modeling/tools/generate_missing.py,sha256=XqUs54CPfli4XtK0rEiFKqDvpwCiMAD8wrl7fAxpYHs,3062
 service_capacity_modeling/tools/instance_families.py,sha256=5Y4_aJ5ML-JPzwaWcS_caUeZ28CmUVoqjYYLaRl01vg,9148
-service_capacity_modeling-0.3.74.dist-info/licenses/LICENSE,sha256=nl_Lt5v9VvJ-5lWJDT4ddKAG-VZ-2IaLmbzpgYDz2hU,11343
-service_capacity_modeling-0.3.74.dist-info/METADATA,sha256=Q32PjFEqL_3-U-JUgIMQeW8hz4CtAIqw3m2H39gndYU,10214
-service_capacity_modeling-0.3.74.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-service_capacity_modeling-0.3.74.dist-info/entry_points.txt,sha256=ZsjzpG5SomWpT1zCE19n1uSXKH2gTI_yc33sdl0vmJg,146
-service_capacity_modeling-0.3.74.dist-info/top_level.txt,sha256=H8XjTCLgR3enHq5t3bIbxt9SeUkUT8HT_SDv2dgIT_A,26
-service_capacity_modeling-0.3.74.dist-info/RECORD,,
+service_capacity_modeling-0.3.75.dist-info/licenses/LICENSE,sha256=nl_Lt5v9VvJ-5lWJDT4ddKAG-VZ-2IaLmbzpgYDz2hU,11343
+service_capacity_modeling-0.3.75.dist-info/METADATA,sha256=r_DDZjFo54y1QWSRY7HfJ4wWwypgxT31-oKXeCBLoMA,10214
+service_capacity_modeling-0.3.75.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+service_capacity_modeling-0.3.75.dist-info/entry_points.txt,sha256=ZsjzpG5SomWpT1zCE19n1uSXKH2gTI_yc33sdl0vmJg,146
+service_capacity_modeling-0.3.75.dist-info/top_level.txt,sha256=H8XjTCLgR3enHq5t3bIbxt9SeUkUT8HT_SDv2dgIT_A,26
+service_capacity_modeling-0.3.75.dist-info/RECORD,,