def __str__(self) -> ht.NodeId: return ht.NodeId( "NodeId(name={}, node_id={}, operation_id={}, operation_offset={}, transient_id={})" .format( self.name, self.node_id, self.operation_id, self.operation_offset, self.transient_id, ))
def __init__( self, name: ht.NodeName, node_id: ht.NodeId = None, operation_id: Optional[ht.OperationId] = None, operation_offset: Optional[int] = None, ) -> None: self.name = name self.transient_id = ht.NodeId(str(uuid4())) self.operation_id = operation_id self.operation_offset = operation_offset self.node_id = node_id
def create_nodes(self, nodes: List[Node]) -> 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 = [] # 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, ), ) 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 = key request_set = NodeCreationRequestSet() request_set.nodearray = nodearray request_set.count = len(p_nodes) 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
def start_nodes( self, nodes: Optional[List[Node]] = None, names: Optional[List[ht.NodeName]] = None, node_ids: Optional[List[ht.NodeId]] = None, hostnames: Optional[List[ht.Hostname]] = None, ip_addresses: Optional[List[ht.IpAddress]] = None, custom_filter: str = None, request_id: Optional[str] = None, ) -> NodeManagementResult: if self.read_only: ret = NodeCreationResult() ret.operation_id = str(uuid.uuid4()) node_records: List[Dict] if not nodes: all_nodes: List[Dict] = [] for rnodes in self._read_only_nodes.values(): all_nodes.extend(rnodes) if names: node_records = [n for n in all_nodes if n["Name"] in names] elif node_ids: node_records = [n for n in all_nodes if n["NodeId"] in node_ids] elif hostnames: node_records = [n for n in all_nodes if n["Hostname"] in hostnames] elif ip_addresses: node_records = [ n for n in all_nodes if n["PrivateIp"] in ip_addresses ] elif custom_filter: raise RuntimeError( "custom_filter is not supported with run_only mode (--dry-run)" ) elif request_id: node_records = [ n for n in all_nodes if n["RequestId"] == request_id ] else: raise RuntimeError( "Please specify at least one of nodes, names, node_ids, hostnames, ip_addresses, custom_filter or request_id" ) else: node_records = [_node_to_ccnode(n) for n in nodes] ret.sets = [NodeCreationResultSet(added=len(node_records))] for n in nodes or []: n.exists = True n.target_state = ht.NodeStatus("Started") if not n.delayed_node_id.node_id: n.delayed_node_id.node_id = ht.NodeId("dryrun-" + str(uuid.uuid4())) self._read_only_nodes[ht.OperationId(ret.operation_id)] = node_records return ret request = self._node_management_request( nodes, names, node_ids, hostnames, ip_addresses, custom_filter, request_id ) logging.fine(json.dumps(request.to_dict())) http_response, result = self.clusters_module.start_nodes( self.session, self.cluster_name, request ) self._log_response(http_response, result) return result