3cc0700d7f
Added new updatable attribute to NodeUpdate action: `fuel2 node update 1 --name NewName` Also test added. Change-Id: If1174ede30b849ab1fc357823e9624b98ca7ec7e Partial-Bug: #1498523
207 lines
6.9 KiB
Python
207 lines
6.9 KiB
Python
# Copyright 2015 Mirantis, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from collections import namedtuple
|
|
import copy
|
|
|
|
from fuelclient.cli import error
|
|
from fuelclient import objects
|
|
from fuelclient.v1 import base_v1
|
|
|
|
|
|
SplittedLabel = namedtuple('SplittedLabel', ['key', 'value', 'has_separator'])
|
|
|
|
|
|
class NodeClient(base_v1.BaseV1Client):
|
|
|
|
_entity_wrapper = objects.Node
|
|
_updatable_attributes = ('hostname', 'labels', 'name')
|
|
|
|
def get_all(self, environment_id=None, labels=None):
|
|
"""Get nodes by specific environment or labels
|
|
|
|
:param environment_id: Id of specific environment(cluster)
|
|
:type environment_id: int
|
|
:param labels: List of string labels for filtering nodes
|
|
:type labels: list
|
|
:returns: list -- filtered list of nodes
|
|
"""
|
|
result = self._entity_wrapper.get_all_data()
|
|
|
|
if environment_id is not None:
|
|
result = [item for item in result
|
|
if item['cluster'] == environment_id]
|
|
|
|
if labels:
|
|
result = [item for item in result
|
|
if self._check_label(labels, item)]
|
|
|
|
return result
|
|
|
|
def get_node_vms_conf(self, node_id):
|
|
node = self._entity_wrapper(node_id)
|
|
return node.get_node_vms_conf()
|
|
|
|
def node_vms_create(self, node_id, config):
|
|
node = self._entity_wrapper(node_id)
|
|
return node.node_vms_create(config)
|
|
|
|
def update(self, node_id, **updated_attributes):
|
|
node = self._entity_wrapper(obj_id=node_id)
|
|
|
|
for attr in updated_attributes:
|
|
if attr not in self._updatable_attributes:
|
|
msg = 'Only {0} are updatable'.format(
|
|
self._updatable_attributes)
|
|
raise error.BadDataException(msg)
|
|
|
|
return node.set(updated_attributes)
|
|
|
|
def get_all_labels_for_nodes(self, node_ids=None):
|
|
"""Get list of labels for specific nodes. If no node_ids then all
|
|
labels should be returned
|
|
|
|
:param node_ids: List of node ids for filtering labels
|
|
:type node_ids: list
|
|
:returns: list -- filtered list of labels
|
|
"""
|
|
labels = []
|
|
|
|
result = self._entity_wrapper.get_all_data()
|
|
|
|
if node_ids:
|
|
result = filter(lambda node: str(node['id']) in node_ids, result)
|
|
|
|
for node in result:
|
|
for key, value in node.get('labels', []).items():
|
|
labels.append({
|
|
'node_id': node.get('id'),
|
|
'label_name': key,
|
|
'label_value': value
|
|
})
|
|
|
|
labels = sorted(labels, key=lambda label: label.get('node_id'))
|
|
|
|
return labels
|
|
|
|
def set_labels_for_nodes(self, labels=None, node_ids=None):
|
|
"""Update nodes labels attribute with new data. If node_ids
|
|
are empty list then labels will be updated on all nodes
|
|
|
|
:param labels: List of string pairs `key=val` for labels
|
|
:type labels: list
|
|
:param node_ids: List of node ids where labels should be updated
|
|
:type node_ids: list
|
|
:return: list -- ids of nodes where labels were updated
|
|
"""
|
|
data_to_return = []
|
|
labels_to_update = {}
|
|
|
|
for label in labels:
|
|
key, val, _ = self._split_label(label)
|
|
if not key:
|
|
msg = 'Wrong label "{0}" was provided. Label key couldn\'t ' \
|
|
'be an empty string.'.format(label)
|
|
raise error.LabelEmptyKeyError(msg)
|
|
labels_to_update[key] = val
|
|
|
|
if node_ids:
|
|
for node_id in node_ids:
|
|
node = self._entity_wrapper(obj_id=node_id)
|
|
db_labels = copy.deepcopy(node.labels)
|
|
db_labels.update(labels_to_update)
|
|
|
|
result = self.update(node_id, **{'labels': db_labels})
|
|
data_to_return.append(str(result.get('id')))
|
|
else:
|
|
nodes = self._entity_wrapper.get_all_data()
|
|
for node in nodes:
|
|
db_labels = copy.deepcopy(node['labels'])
|
|
db_labels.update(labels_to_update)
|
|
|
|
result = self.update(node['id'], **{'labels': db_labels})
|
|
data_to_return.append(str(result.get('id')))
|
|
|
|
return data_to_return
|
|
|
|
def delete_labels_for_nodes(self, labels=None, node_ids=None):
|
|
"""Delete labels data from nodes labels. If node_ids are
|
|
empty list then labels will be deleted on all nodes
|
|
|
|
:param labels: List of string label keys
|
|
:type labels: list
|
|
:param node_ids: List of node ids where labels should be deleted
|
|
:type node_ids: list
|
|
:returns: list -- ids of nodes where labels were deleted
|
|
"""
|
|
data_to_return = []
|
|
|
|
if node_ids:
|
|
nodes = (self._entity_wrapper(obj_id=n_id).data
|
|
for n_id in node_ids)
|
|
else:
|
|
nodes = self._entity_wrapper.get_all_data()
|
|
|
|
for node in nodes:
|
|
updated_labels = self._labels_after_delete(
|
|
node['labels'], labels)
|
|
|
|
result = self.update(node['id'], **{'labels': updated_labels})
|
|
data_to_return.append(str(result.get('id')))
|
|
|
|
return data_to_return
|
|
|
|
def _check_label(self, labels, item):
|
|
checking_list = []
|
|
|
|
for label in labels:
|
|
key, val, has_separator = self._split_label(label)
|
|
if key in item.get('labels'):
|
|
if not has_separator:
|
|
checking_val = True
|
|
else:
|
|
checking_val = item['labels'][key] == val
|
|
checking_list.append(checking_val)
|
|
|
|
return any(checking_list)
|
|
|
|
@classmethod
|
|
def _labels_after_delete(cls, labels, labels_to_delete):
|
|
if not labels_to_delete:
|
|
return {}
|
|
|
|
db_labels = copy.deepcopy(labels)
|
|
for label in labels_to_delete:
|
|
label = label.strip()
|
|
sl = cls._split_label(label)
|
|
if sl.has_separator:
|
|
if sl.key in db_labels and db_labels[sl.key] == sl.value:
|
|
db_labels.pop(sl.key)
|
|
else:
|
|
db_labels.pop(sl.key, None)
|
|
|
|
return db_labels
|
|
|
|
@staticmethod
|
|
def _split_label(label):
|
|
name, separator, value = label.partition('=')
|
|
name = name.strip()
|
|
value = value.strip()
|
|
value = None if value == '' else value
|
|
return SplittedLabel(name, value, bool(separator))
|
|
|
|
|
|
def get_client():
|
|
return NodeClient()
|