def create_nodes()

in src/hpc/autoscale/ccbindings/legacy.py [0:0]

• 66 lines of code
• 12 McCabe index (conditional complexity)

    def create_nodes(self, nodes: List[Node], request_id: Optional[str] = None) -> NodeCreationResult:
        if self.read_only:
            ret = NodeCreationResult()
            ret.operation_id = str(uuid.uuid4())
            ret.sets = [NodeCreationResultSet(added=len(nodes))]
            for n in nodes:
                n.exists = True
                n.target_state = ht.NodeStatus("Started")
                n.delayed_node_id.node_id = ht.NodeId("dryrun-" + str(uuid.uuid4()))
            node_records = [_node_to_ccnode(n) for n in nodes]
            self._read_only_nodes[ht.OperationId(ret.operation_id)] = node_records
            return ret

        creation_request = NodeCreationRequest()
        creation_request.sets = []
        creation_request.request_id = request_id
        # the node attributes aren't hashable, so a string representation
        # is good enough to ensure they are all the same across the list.

        p_nodes_dict = partition(
            nodes,
            lambda n: (
                n.nodearray,
                n.vm_size,
                n.placement_group,
                str(n.node_attribute_overrides),
                n.keep_alive,
                n.name_format,
                n.name_offset,
            ),
        )

        request_tuples: List[Tuple[Node, NodeCreationRequestSet]] = []

        def _node_key(n: Node) -> Tuple[str, int]:
            try:
                index = int(n.name.split("-")[-1])
                return (n.nodearray, index)
            except ValueError:
                return (n.nodearray, -1)

        for key, p_nodes in p_nodes_dict.items():
            nodearray, vm_size, pg, _, keep_alive, name_format, name_offset = key
            request_set = NodeCreationRequestSet()

            if name_format:
                request_set.name_format = name_format
            request_set.nodearray = nodearray
            request_set.count = len(p_nodes)
            if name_offset is not None:
                request_set.name_offset = name_offset
            
            request_set.placement_group_id = pg
            request_set.definition = NodeCreationRequestSetDefinition()
            request_set.definition.machine_type = vm_size
            
            if p_nodes[0].node_attribute_overrides:
                request_set.node_attributes = deepcopy(
                    p_nodes[0].node_attribute_overrides
                )

            if keep_alive:
                if not request_set.node_attributes:
                    request_set.node_attributes = {}
                request_set.node_attributes["KeepAlive"] = keep_alive

            first_node = sorted(p_nodes, key=_node_key)[0]

            request_tuples.append((first_node, request_set))

        sorted_tuples = sorted(request_tuples, key=lambda t: _node_key(t[0]))
        for _, request_set in sorted_tuples:
            creation_request.sets.append(request_set)

        creation_request.validate()

        logging.fine(json.dumps(creation_request.to_dict()))

        http_response, result = self.clusters_module.create_nodes(
            self.session, self.cluster_name, creation_request
        )

        self._log_response(http_response, result)

        return result