# Copyright (c) 2018 European Organization for Nuclear Research.
# All Rights Reserved.
#
# 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 magnumclient.common import utils as magnum_utils
from magnumclient.i18n import _
from osc_lib.command import command
from osc_lib import utils
NODEGROUP_ATTRIBUTES = [
'uuid',
'name',
'cluster_id',
'project_id',
'docker_volume_size',
'labels',
'labels_overridden',
'labels_skipped',
'labels_added',
'flavor_id',
'image_id',
'node_addresses',
'node_count',
'role',
'max_node_count',
'min_node_count',
'is_default',
'stack_id',
'status',
'status_reason',
]
class CreateNodeGroup(command.Command):
_description = _("Create a nodegroup")
def get_parser(self, prog_name):
parser = super(CreateNodeGroup, self).get_parser(prog_name)
# NOTE: All arguments are positional and, if not provided
# with a default, required.
parser.add_argument('--docker-volume-size',
dest='docker_volume_size',
type=int,
metavar='<docker-volume-size>',
help=('The size in GB for the docker volume to '
'use.'))
parser.add_argument('--labels',
metavar='<KEY1=VALUE1,KEY2=VALUE2;KEY3=VALUE3...>',
action='append',
help=_('Arbitrary labels in the form of key=value'
'pairs to associate with a nodegroup. '
'May be used multiple times.'))
parser.add_argument('cluster',
metavar='<cluster>',
help='Name of the nodegroup to create.')
parser.add_argument('name',
metavar='<name>',
help='Name of the nodegroup to create.')
parser.add_argument('--node-count',
dest='node_count',
type=int,
default=1,
metavar='<node-count>',
help='The nodegroup node count.')
parser.add_argument('--min-nodes',
dest='min_node_count',
type=int,
default=0,
metavar='<min-nodes>',
help='The nodegroup minimum node count.')
parser.add_argument('--max-nodes',
dest='max_node_count',
type=int,
default=None,
metavar='<max-nodes>',
help='The nodegroup maximum node count.')
parser.add_argument('--role',
dest='role',
type=str,
default='worker',
metavar='<role>',
help=('The role of the nodegroup'))
parser.add_argument(
'--image',
metavar='<image>',
help=_('The name or UUID of the base image to customize for the '
'NodeGroup.'))
parser.add_argument(
'--flavor',
metavar='<flavor>',
help=_('The nova flavor name or UUID to use when launching the '
'nodes in this NodeGroup.'))
parser.add_argument(
'--merge-labels',
dest='merge_labels',
action='store_true',
default=False,
help=_('The labels provided will be merged with the labels '
'configured in the specified cluster.'))
return parser
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
mag_client = self.app.client_manager.container_infra
args = {
'name': parsed_args.name,
'node_count': parsed_args.node_count,
'max_node_count': parsed_args.max_node_count,
'min_node_count': parsed_args.min_node_count,
'role': parsed_args.role,
}
if parsed_args.labels is not None:
args['labels'] = magnum_utils.handle_labels(parsed_args.labels)
if parsed_args.docker_volume_size is not None:
args['docker_volume_size'] = parsed_args.docker_volume_size
if parsed_args.flavor is not None:
args['flavor_id'] = parsed_args.flavor
if parsed_args.image is not None:
args['image_id'] = parsed_args.image
if parsed_args.merge_labels:
# We are only sending this if it's True. This
# way we avoid breaking older APIs.
args["merge_labels"] = parsed_args.merge_labels
cluster_id = parsed_args.cluster
nodegroup = mag_client.nodegroups.create(cluster_id, **args)
print("Request to create nodegroup %s accepted"
% nodegroup.uuid)
class DeleteNodeGroup(command.Command):
_description = _("Delete a nodegroup")
def get_parser(self, prog_name):
parser = super(DeleteNodeGroup, self).get_parser(prog_name)
parser.add_argument(
'cluster',
metavar='<cluster>',
help=_('ID or name of the cluster where the nodegroup(s) '
'belong(s).'))
parser.add_argument(
'nodegroup',
nargs='+',
metavar='<nodegroup>',
help='ID or name of the nodegroup(s) to delete.')
return parser
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
mag_client = self.app.client_manager.container_infra
cluster_id = parsed_args.cluster
for ng in parsed_args.nodegroup:
mag_client.nodegroups.delete(cluster_id, ng)
print("Request to delete nodegroup %s has been accepted." % ng)
class ListNodeGroup(command.Lister):
_description = _("List nodegroups")
def get_parser(self, prog_name):
parser = super(ListNodeGroup, self).get_parser(prog_name)
parser.add_argument(
'cluster',
metavar='<cluster>',
help=_('ID or name of the cluster where the nodegroup belongs.'))
parser.add_argument(
'--limit',
metavar='<limit>',
type=int,
help=_('Maximum number of nodegroups to return'))
parser.add_argument(
'--sort-key',
metavar='<sort-key>',
help=_('Column to sort results by'))
parser.add_argument(
'--sort-dir',
metavar='<sort-dir>',
choices=['desc', 'asc'],
help=_('Direction to sort. "asc" or "desc".'))
parser.add_argument(
'--role',
metavar='<role>',
help=_('List the nodegroups in the cluster with this role'))
return parser
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
mag_client = self.app.client_manager.container_infra
columns = ['uuid', 'name', 'flavor_id', 'image_id', 'node_count',
'status', 'role']
cluster_id = parsed_args.cluster
nodegroups = mag_client.nodegroups.list(cluster_id,
limit=parsed_args.limit,
sort_key=parsed_args.sort_key,
sort_dir=parsed_args.sort_dir,
role=parsed_args.role)
return (
columns,
(utils.get_item_properties(n, columns) for n in nodegroups)
)
class ShowNodeGroup(command.ShowOne):
_description = _("Show a nodegroup")
def get_parser(self, prog_name):
parser = super(ShowNodeGroup, self).get_parser(prog_name)
parser.add_argument(
'cluster',
metavar='<cluster>',
help=_('ID or name of the cluster where the nodegroup belongs.'))
parser.add_argument(
'nodegroup',
metavar='<nodegroup>',
help=_('ID or name of the nodegroup to show.')
)
return parser
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
columns = NODEGROUP_ATTRIBUTES
mag_client = self.app.client_manager.container_infra
cluster_id = parsed_args.cluster
nodegroup = mag_client.nodegroups.get(cluster_id,
parsed_args.nodegroup)
return (columns, utils.get_item_properties(nodegroup, columns))
class UpdateNodeGroup(command.Command):
_description = _("Update a Nodegroup")
def get_parser(self, prog_name):
parser = super(UpdateNodeGroup, self).get_parser(prog_name)
parser.add_argument(
'cluster',
metavar='<cluster>',
help=_('ID or name of the cluster where the nodegroup belongs.'))
parser.add_argument(
'nodegroup',
metavar='<nodegroup>',
help=_('The name or UUID of cluster to update'))
parser.add_argument(
'op',
metavar='<op>',
choices=['add', 'replace', 'remove'],
help=_("Operations: one of 'add', 'replace' or 'remove'"))
parser.add_argument(
'attributes',
metavar='<path=value>',
nargs='+',
action='append',
default=[],
help=_(
"Attributes to add/replace or remove (only PATH is necessary "
"on remove)"))
return parser
def take_action(self, parsed_args):
self.log.debug("take_action(%s)", parsed_args)
mag_client = self.app.client_manager.container_infra
patch = magnum_utils.args_array_to_patch(parsed_args.op,
parsed_args.attributes[0])
cluster_id = parsed_args.cluster
mag_client.nodegroups.update(cluster_id, parsed_args.nodegroup,
patch)
print("Request to update nodegroup %s has been accepted." %
parsed_args.nodegroup)