# vim: tabstop=4 shiftwidth=4 softtabstop=4
# 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.
import collections
import copy
import datetime
import logging
import random
import django.conf
import django.db.models
from django.utils.translation import ugettext_lazy as _ # noqa
import requests
from novaclient.v1_1.contrib import baremetal
from tuskarclient.v1 import client as tuskar_client
from openstack_dashboard.api import base
from openstack_dashboard.api import nova
LOG = logging.getLogger(__name__)
TUSKAR_ENDPOINT_URL = getattr(django.conf.settings, 'TUSKAR_ENDPOINT_URL')
REMOTE_NOVA_BAREMETAL_CREDS = getattr(django.conf.settings,
'REMOTE_NOVA_BAREMETAL_CREDS',
False)
OVERCLOUD_CREDS = getattr(django.conf.settings, 'OVERCLOUD_CREDS', False)
# FIXME: request isn't used right in the tuskar client right now, but looking
# at other clients, it seems like it will be in the future
def tuskarclient(request):
c = tuskar_client.Client(TUSKAR_ENDPOINT_URL)
return c
def baremetalclient(request):
def create_remote_nova_client_baremetal():
nc = nova.nova_client.Client(
REMOTE_NOVA_BAREMETAL_CREDS['user'],
REMOTE_NOVA_BAREMETAL_CREDS['password'],
REMOTE_NOVA_BAREMETAL_CREDS['tenant'],
auth_url=REMOTE_NOVA_BAREMETAL_CREDS['auth_url'],
bypass_url=REMOTE_NOVA_BAREMETAL_CREDS['bypass_url'],
)
return nc
def create_nova_client_baremetal():
insecure = getattr(django.conf.settings, 'OPENSTACK_SSL_NO_VERIFY',
False)
nc = nova.nova_client.Client(
request.user.username,
request.user.token.id,
project_id=request.user.tenant_id,
auth_url=base.url_for(request, 'compute'),
insecure=insecure,
http_log_debug=django.conf.settings.DEBUG)
nc.client.auth_token = request.user.token.id
nc.client.management_url = base.url_for(request, 'compute')
return nc
if REMOTE_NOVA_BAREMETAL_CREDS:
LOG.debug('remote nova baremetal client connection created')
nc = create_remote_nova_client_baremetal()
else:
LOG.debug('nova baremetal client connection created using token "%s" '
'and url "%s"' %
(request.user.token.id, base.url_for(request, 'compute')))
nc = create_nova_client_baremetal()
return baremetal.BareMetalNodeManager(nc)
def overcloudclient(request):
c = nova.nova_client.Client(OVERCLOUD_CREDS['user'],
OVERCLOUD_CREDS['password'],
OVERCLOUD_CREDS['tenant'],
auth_url=OVERCLOUD_CREDS['auth_url'])
return c
class StringIdAPIResourceWrapper(base.APIResourceWrapper):
# horizon DataTable class expects ids to be string,
# if it's not string, then comparison in
# horizon/tables/base.py:get_object_by_id fails.
# Because of this, ids returned from dummy api are converted to string
# (luckily django autoconverts strings to integers when passing string to
# django model id)
def __init__(self, apiresource, request=None):
self.request = request
self._apiresource = apiresource
# FIXME
# this is redefined from base.APIResourceWrapper,
# remove this when tuskarclient returns object instead of dict
def __getattr__(self, attr):
if attr in self._attrs:
if issubclass(self._apiresource.__class__, dict):
return self._apiresource.get(attr)
else:
try:
return self._apiresource.__getattribute__(attr)
except AttributeError:
return None
else:
raise AttributeError(attr)
@property
def id(self):
return str(self._apiresource.id)
# FIXME: self.request is required when calling some instance
# methods (e.g. list_flavors), once we really start using this request
# param (if ever), a proper request value should be set
@property
def request(self):
return getattr(self, '_request', None)
@request.setter
def request(self, value):
setattr(self, '_request', value)
class Alert(StringIdAPIResourceWrapper):
"""Wrapper for the Alert object returned by the
dummy model.
"""
_attrs = ['message', 'time']
class Capacity(StringIdAPIResourceWrapper):
"""Wrapper for the Capacity object returned by the
dummy model.
"""
_attrs = ['name', 'value', 'unit']
# defines a random usage of capacity - API should probably be able to
# determine usage of capacity based on capacity value and obejct_id
@property
def usage(self):
if not hasattr(self, '_usage'):
self._usage = random.randint(0, int(self.value))
return self._usage
# defines a random average of capacity - API should probably be able to
# determine average of capacity based on capacity value and obejct_id
@property
def average(self):
if not hasattr(self, '_average'):
self._average = random.randint(0, int(self.value))
return self._average
class BaremetalNode(StringIdAPIResourceWrapper):
_attrs = ['id', 'pm_address', 'cpus', 'memory_mb', 'service_host',
'local_gb', 'pm_user', 'instance_uuid']
@classmethod
def create(cls, request, **kwargs):
# The pm_address, pm_user and terminal_port need to be None when
# empty for the baremetal vm to work.
# terminal_port needs separate handling because 0 is a valid value.
terminal_port = kwargs['terminal_port']
if terminal_port == '':
terminal_port = None
node = baremetalclient(request).create(kwargs['service_host'],
kwargs['cpus'],
kwargs['memory_mb'],
kwargs['local_gb'],
kwargs['prov_mac_address'],
kwargs['pm_address'] or None,
kwargs['pm_user'] or None,
kwargs['pm_password'],
terminal_port)
return cls(node)
@classmethod
def get(cls, request, node_id):
node = cls(baremetalclient(request).get(node_id))
node.request = request
try:
# Nova instance info will be added to baremetal node attributes
nova_instance = nova.server_get(request,
node.instance_uuid)
except Exception:
nova_instance = None
LOG.debug("Couldn't obtain nova.server_get instance for "
"baremetal node %s" % node_id)
if nova_instance:
# If baremetal is provisioned, there is a nova instance.
addresses = nova_instance._apiresource.addresses.get('ctlplane')
if addresses:
node.ip_address_other = (", "
.join([addr['addr'] for addr in addresses]))
node.status = (nova_instance._apiresource.
_info['OS-EXT-STS:vm_state'])
node.power_management = ""
if node.pm_user:
node.power_management = node.pm_user + "/********"
else:
# If baremetal is unprovisioned, there is no nova instance.
node.status = 'unprovisioned'
# Returning baremetal node containing nova instance info
return node
@classmethod
def list(cls, request):
return [cls(n, request) for n in
baremetalclient(request).list()]
@classmethod
def list_unracked(cls, request):
try:
racked_node_ids = [node.nova_baremetal_node_id
for node in Node.list(request)]
return [bn for bn in BaremetalNode.list(request)
if bn.id not in racked_node_ids]
except requests.ConnectionError:
return []
@property
def mac_address(self):
try:
return self._apiresource.interfaces[0]['address']
except Exception:
return None
@property
# FIXME: just mock implementation, add proper one
def running_instances(self):
return 4
@property
# FIXME: just mock implementation, add proper one
def remaining_capacity(self):
return 100 - self.running_instances
@property
def running_virtual_machines(self):
if not hasattr(self, '_running_virtual_machines'):
if OVERCLOUD_CREDS:
search_opts = {}
search_opts['all_tenants'] = True
self._running_virtual_machines = [
s for s in overcloudclient(
self.request).servers.list(True, search_opts)
if s.hostId == self.id]
else:
LOG.debug('OVERCLOUD_CREDS is not set. '
'Can\'t connect to Overcloud')
self._running_virtual_machines = []
return self._running_virtual_machines
class Node(StringIdAPIResourceWrapper):
"""
Wrapper for the Node object returned by the
dummy model.
"""
_attrs = ['id', 'nova_baremetal_node_id']
@classmethod
def get(cls, request, node_id):
node = cls(tuskarclient(request).nodes.get(node_id))
node.request = request
return node
@classmethod
def list(cls, request):
return [cls(n, request) for n in (tuskarclient(request).nodes.list())]
@property
def rack(self):
if not hasattr(self, '_rack'):
if self.rack_id:
self._rack = Rack.get(self.request, self.rack_id)
else:
self._rack = None
return self._rack
@property
def rack_id(self):
try:
return unicode(self._apiresource.rack['id'])
except AttributeError:
return None
@property
def nova_baremetal_node(self):
if not hasattr(self, '_nova_baremetal_node'):
if self.nova_baremetal_node_id:
self._nova_baremetal_node = BaremetalNode.get(
self.request,
self.nova_baremetal_node_id)
else:
self._nova_baremetal_node = None
return self._nova_baremetal_node
def nova_baremetal_node_attribute(self, attr_name):
key = "_%s" % attr_name
if not hasattr(self, key):
if self.nova_baremetal_node:
value = getattr(self.nova_baremetal_node, attr_name, None)
else:
value = None
setattr(self, key, value)
return getattr(self, key)
@property
def service_host(self):
return self.nova_baremetal_node_attribute('service_host')
@property
def mac_address(self):
return self.nova_baremetal_node_attribute('mac_address')
@property
def ip_address_other(self):
return self.nova_baremetal_node_attribute('ip_address_other')
@property
def pm_address(self):
return self.nova_baremetal_node_attribute('pm_address')
@property
def status(self):
return self.nova_baremetal_node_attribute('status')
@property
def running_virtual_machines(self):
return self.nova_baremetal_node_attribute('running_virtual_machines')
@property
def list_flavors(self):
if not hasattr(self, '_flavors'):
# FIXME: just a mock of used instances, add real values
used_instances = 0
if not self.rack or not self.rack.resource_class:
return []
resource_class = self.rack.resource_class
added_flavors = tuskarclient(self.request).flavors\
.list(resource_class.id)
self._flavors = []
if added_flavors:
for f in added_flavors:
flavor_obj = Flavor(f)
#flavor_obj.max_vms = f.max_vms
# FIXME just a mock of used instances, add real values
used_instances += 5
flavor_obj.used_instances = used_instances
self._flavors.append(flavor_obj)
return self._flavors
@property
# FIXME: just mock implementation, add proper one
def is_provisioned(self):
return (self.status != "unprovisioned" and self.rack)
@property
def alerts(self):
if not hasattr(self, '_alerts'):
self._alerts = []
return self._alerts
class Rack(StringIdAPIResourceWrapper):
"""Wrapper for the Rack object returned by the
dummy model.
"""
_attrs = ['id', 'name', 'location', 'subnet', 'nodes', 'state',
'capacities']
@classmethod
def create(cls, request, **kwargs):
nodes = kwargs.get('nodes', [])
## FIXME: set nodes here
rack = tuskarclient(request).racks.create(
name=kwargs['name'],
location=kwargs['location'],
subnet=kwargs['subnet'],
nodes=nodes,
resource_class={'id': kwargs['resource_class_id']},
slots=0)
return cls(rack)
@classmethod
def update(cls, request, rack_id, rack_kwargs):
## FIXME: set nodes here
rack_args = copy.copy(rack_kwargs)
# remove rack_id from kwargs (othervise it is duplicated)
rack_args.pop('rack_id', None)
# correct data mapping for resource_class
if 'resource_class_id' in rack_args:
rack_args['resource_class'] = {
'id': rack_args.pop('resource_class_id', None)}
rack = tuskarclient(request).racks.update(rack_id, **rack_args)
return cls(rack)
@classmethod
def list(cls, request, only_free_racks=False):
if only_free_racks:
return [Rack(r, request) for r in
tuskarclient(request).racks.list() if (
getattr(r, 'resource_class', None) is None)]
else:
return [Rack(r, request) for r in
tuskarclient(request).racks.list()]
@classmethod
def get(cls, request, rack_id):
rack = cls(tuskarclient(request).racks.get(rack_id))
rack.request = request
return rack
@classmethod
def delete(cls, request, rack_id):
tuskarclient(request).racks.delete(rack_id)
@property
def node_ids(self):
""" List of unicode ids of nodes added to rack"""
return [
unicode(node['id']) for node in (
self.nodes)]
@property
def list_nodes(self):
if not hasattr(self, '_nodes'):
self._nodes = [Node.get(self.request, node['id']) for node in
self.nodes]
return self._nodes
@property
def list_baremetal_nodes(self):
if not hasattr(self, '_baremetal_nodes'):
self._baremetal_nodes = [node.nova_baremetal_node
for node in self.list_nodes]
return self._baremetal_nodes
@property
def nodes_count(self):
return len(self.nodes)
@property
def resource_class_id(self):
try:
return self._apiresource.resource_class['id']
except AttributeError:
return None
@property
def resource_class(self):
if not hasattr(self, '_resource_class'):
if self.resource_class_id:
self._resource_class = ResourceClass.get(
self.request,
self.resource_class_id)
else:
self._resource_class = None
return self._resource_class
@property
def list_capacities(self):
if not hasattr(self, '_capacities'):
self._capacities = [Capacity(c) for c in self.capacities]
return self._capacities
@property
def vm_capacity(self):
""" Rack VM Capacity is maximum value from its Resource Class's
Flavors max_vms (considering flavor sizes are multiples).
"""
if not hasattr(self, '_vm_capacity'):
try:
value = max([flavor.max_vms for flavor in
self.resource_class.list_flavors])
except Exception:
value = None
self._vm_capacity = Capacity({'name': "VM Capacity",
'value': value,
'unit': 'VMs'})
return self._vm_capacity
@property
def alerts(self):
if not hasattr(self, '_alerts'):
self._alerts = []
return self._alerts
@property
def aggregated_alerts(self):
# FIXME: for now return only list of nodes (particular alerts are not
# used)
return [node for node in self.list_nodes if node.alerts]
@property
def list_flavors(self):
if not hasattr(self, '_flavors'):
# FIXME just a mock of used instances, add real values
used_instances = 0
if not self.resource_class:
return []
added_flavors = (tuskarclient(self.request)
.flavors
.list(self.resource_class_id))
self._flavors = []
if added_flavors:
for f in added_flavors:
flavor_obj = Flavor(f)
#flavor_obj.max_vms = f.max_vms
# FIXME just a mock of used instances, add real values
used_instances += 2
flavor_obj.used_instances = used_instances
self._flavors.append(flavor_obj)
return self._flavors
@property
def all_used_instances(self):
return [flavor.used_instances for flavor in self.list_flavors]
@property
def total_instances(self):
# FIXME just mock implementation, add proper one
return sum(self.all_used_instances)
@property
def remaining_capacity(self):
# FIXME just mock implementation, add proper one
return 100 - self.total_instances
@property
def is_provisioned(self):
return (self.state == 'active') or (self.state == 'error')
@property
def is_provisioning(self):
return (self.state == 'provisioning')
@classmethod
def provision_all(cls, request):
tuskarclient(request).data_centers.provision_all()
class ResourceClass(StringIdAPIResourceWrapper):
"""Wrapper for the ResourceClass object returned by the
dummy model.
"""
_attrs = ['id', 'name', 'service_type', 'image_id', 'racks']
@classmethod
def get(cls, request, resource_class_id):
rc = cls(tuskarclient(request).resource_classes.get(resource_class_id))
rc.request = request
return rc
@classmethod
def create(self, request, name, service_type, image_id, flavors):
return ResourceClass(
tuskarclient(request).resource_classes.create(
name=name,
service_type=service_type,
image_id=image_id,
flavors=flavors))
@classmethod
def list(cls, request):
return [cls(rc, request) for rc in (
tuskarclient(request).resource_classes.list())]
@classmethod
def update(cls, request, resource_class_id, name, service_type, image_id,
flavors):
resource_class = cls(tuskarclient(request).resource_classes.update(
resource_class_id,
name=name,
service_type=service_type,
image_id=image_id,
flavors=flavors))
## FIXME: flavors have to be updated separately, seems less than ideal
for flavor_id in resource_class.flavors_ids:
Flavor.delete(request, resource_class_id=resource_class.id,
flavor_id=flavor_id)
for flavor in flavors:
Flavor.create(request,
resource_class_id=resource_class.id,
**flavor)
return resource_class
@property
def deletable(self):
return (len(self.racks) <= 0)
@classmethod
def delete(cls, request, resource_class_id):
tuskarclient(request).resource_classes.delete(resource_class_id)
@property
def racks_ids(self):
""" List of unicode ids of racks added to resource class """
return [
unicode(rack['id']) for rack in self.racks]
@property
def list_racks(self):
""" List of racks added to ResourceClass """
if not hasattr(self, '_racks'):
self._racks = [Rack.get(self.request, rid) for rid in (
self.racks_ids)]
return self._racks
def set_racks(self, request, racks_ids):
# FIXME: there is a bug now in tuskar, we have to remove all racks at
# first and then add new ones:
# https://github.com/tuskar/tuskar/issues/37
tuskarclient(request).resource_classes.update(self.id, racks=[])
racks = [{'id': rid} for rid in racks_ids]
tuskarclient(request).resource_classes.update(self.id, racks=racks)
@property
def racks_count(self):
return len(self.racks)
@property
def all_racks(self):
""" List of racks added to ResourceClass + list of free racks,
meaning racks that don't belong to any ResourceClass"""
if not hasattr(self, '_all_racks'):
self._all_racks =\
[r for r in (
Rack.list(self.request)) if (
r.resource_class_id is None or
str(r.resource_class_id) == self.id)]
return self._all_racks
@property
def nodes(self):
if not hasattr(self, '_nodes'):
self._nodes = [n for n in Node.list(self.request)
if n.rack_id in self.racks_ids]
return self._nodes
@property
def nodes_count(self):
return len(self.nodes)
@property
def flavors_ids(self):
""" List of unicode ids of flavors added to resource class """
return [unicode(flavor.id) for flavor in self.list_flavors]
@property
def list_flavors(self):
if not hasattr(self, '_flavors'):
# FIXME just a mock of used instances, add real values
used_instances = 0
added_flavors = tuskarclient(self.request).flavors.list(self.id)
self._flavors = []
for f in added_flavors:
flavor_obj = Flavor(f, self.request)
#flavor_obj.max_vms = f.max_vms
# FIXME just a mock of used instances, add real values
used_instances += 5
flavor_obj.used_instances = used_instances
self._flavors.append(flavor_obj)
return self._flavors
@property
def all_used_instances(self):
return [flavor.used_instances for flavor in self.list_flavors]
@property
def total_instances(self):
# FIXME just mock implementation, add proper one
return sum(self.all_used_instances)
@property
def remaining_capacity(self):
# FIXME just mock implementation, add proper one
return 100 - self.total_instances
@property
def capacities(self):
"""Aggregates Rack capacities values
"""
if not hasattr(self, '_capacities'):
capacities = [rack.list_capacities for rack in self.list_racks]
def add_capacities(c1, c2):
return [Capacity({'name': a.name,
'value': int(a.value) + int(b.value),
'unit': a.unit}) for a, b in zip(c1, c2)]
self._capacities = reduce(add_capacities, capacities)
return self._capacities
@property
def vm_capacity(self):
""" Resource Class VM Capacity is maximum value from It's Flavors
max_vms (considering flavor sizes are multiples), multipled by
number of Racks in Resource Class.
"""
if not hasattr(self, '_vm_capacity'):
try:
value = self.racks_count * max([flavor.max_vms for flavor in
self.list_flavors])
except Exception:
value = _("Unable to retrieve vm capacity")
self._vm_capacity = Capacity({'name': _("VM Capacity"),
'value': value,
'unit': _('VMs')})
return self._vm_capacity
@property
def aggregated_alerts(self):
# FIXME: for now return only list of racks (particular alerts are not
# used)
return [rack
for rack in self.list_racks
if rack.alerts + rack.aggregated_alerts]
@property
def has_provisioned_rack(self):
return any([rack.is_provisioned for rack in self.list_racks])
class Flavor(StringIdAPIResourceWrapper):
"""Wrapper for the Flavor object returned by Tuskar.
"""
_attrs = ['id', 'name', 'max_vms']
@classmethod
def get(cls, request, resource_class_id, flavor_id):
flavor = cls(tuskarclient(request).flavors.get(resource_class_id,
flavor_id))
flavor.request = request
return flavor
@classmethod
def create(cls, request, **kwargs):
return cls(tuskarclient(request).flavors.create(
kwargs['resource_class_id'],
name=kwargs['name'],
max_vms=kwargs['max_vms'],
capacities=kwargs['capacities']))
@classmethod
def delete(cls, request, **kwargs):
tuskarclient(request).flavors.delete(
kwargs['resource_class_id'],
kwargs['flavor_id'])
@property
def capacities(self):
if not hasattr(self, '_capacities'):
## FIXME: should we distinguish between tuskar
## capacities and our internal capacities?
CapacityStruct = collections.namedtuple('CapacityStruct',
'name value unit')
self._capacities = [Capacity(CapacityStruct(name=c['name'],
value=c['value'],
unit=c['unit']))
for c in self._apiresource.capacities]
return self._capacities
def capacity(self, capacity_name):
key = "_%s" % capacity_name
if not hasattr(self, key):
try:
capacity = [c for c in self.capacities if (
c.name == capacity_name)][0]
except Exception:
# FIXME: test this
capacity = Capacity(
name=capacity_name,
value=_('Unable to retrieve '
'(Is the flavor configured properly?)'),
unit='')
setattr(self, key, capacity)
return getattr(self, key)
@property
def cpu(self):
return self.capacity('cpu')
@property
def memory(self):
return self.capacity('memory')
@property
def storage(self):
return self.capacity('storage')
@property
def ephemeral_disk(self):
return self.capacity('ephemeral_disk')
@property
def swap_disk(self):
return self.capacity('swap_disk')
@property
def running_virtual_machines(self):
# FIXME: arbitrary number
return random.randint(0, int(self.cpu.value))
# defines a random average of capacity - API should probably be able to
# determine average of capacity based on capacity value and obejct_id
def vms_over_time(self, start_time, end_time):
values = []
current_time = start_time
while current_time <= end_time:
values.append(
{'date': current_time,
'value': random.randint(0, self.running_virtual_machines)})
current_time += datetime.timedelta(hours=1)
return values