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