# Copyright 2017 AT&T Intellectual Property. All other 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.
"""Object models for a Region and the combined site design."""
import uuid
import datetime
import oslo_versionedobjects.fields as ovo_fields
import drydock_provisioner.error as errors
import drydock_provisioner.objects as objects
import drydock_provisioner.objects.base as base
import drydock_provisioner.objects.fields as hd_fields
@base.DrydockObjectRegistry.register
class Site(base.DrydockPersistentObject, base.DrydockObject):
VERSION = '1.0'
fields = {
'name':
ovo_fields.StringField(),
'status':
hd_fields.SiteStatusField(default=hd_fields.SiteStatus.Unknown),
'source':
hd_fields.ModelSourceField(),
'tag_definitions':
ovo_fields.ObjectField('NodeTagDefinitionList', nullable=True),
'repositories':
ovo_fields.ObjectField('RepositoryList', nullable=True),
'authorized_keys':
ovo_fields.ListOfStringsField(nullable=True),
}
def __init__(self, **kwargs):
super(Site, self).__init__(**kwargs)
def get_id(self):
return self.name
def get_name(self):
return self.name
def add_tag_definition(self, tag_definition):
self.tag_definitions.append(tag_definition)
def add_key(self, key_string):
self.authorized_keys.append(key_string)
@base.DrydockObjectRegistry.register
class NodeTagDefinition(base.DrydockObject):
VERSION = '1.0'
fields = {
'tag': ovo_fields.StringField(),
'type': ovo_fields.StringField(),
'definition': ovo_fields.StringField(),
'source': hd_fields.ModelSourceField(),
}
def __init__(self, **kwargs):
super(NodeTagDefinition, self).__init__(**kwargs)
# TagDefinition keyed by tag
def get_id(self):
return self.tag
@base.DrydockObjectRegistry.register
class NodeTagDefinitionList(base.DrydockObjectListBase, base.DrydockObject):
VERSION = '1.0'
fields = {
'objects': ovo_fields.ListOfObjectsField('NodeTagDefinition'),
}
@base.DrydockObjectRegistry.register
class Repository(base.DrydockObject):
VERSION = '1.0'
fields = {
'name': ovo_fields.StringField(),
'url': ovo_fields.StringField(),
'repo_type': ovo_fields.StringField(),
'gpgkey': ovo_fields.StringField(nullable=True),
'distributions': ovo_fields.ListOfStringsField(nullable=True),
'subrepos': ovo_fields.ListOfStringsField(nullable=True),
'components': ovo_fields.ListOfStringsField(nullable=True),
'arches': ovo_fields.ListOfStringsField(default=['amd64']),
'options': ovo_fields.DictOfStringsField(nullable=True)
}
STANDARD_COMPONENTS = {
'apt': {'main', 'restricted', 'universe', 'multiverse'},
}
STANDARD_SUBREPOS = {
'apt': {'security', 'updates', 'backports'},
}
def __init__(self, **kwargs):
super(Repository, self).__init__(**kwargs)
# Repository keyed by tag
def get_id(self):
return self.name
def get_disabled_components(self):
enabled = set(self.components or [])
std = self.STANDARD_COMPONENTS.get(self.repo_type, ())
return std - enabled
def get_disabled_subrepos(self):
enabled = set(self.subrepos or [])
std = self.STANDARD_SUBREPOS.get(self.repo_type, ())
return std - enabled
@base.DrydockObjectRegistry.register
class RepositoryList(base.DrydockObjectListBase, base.DrydockObject):
VERSION = '1.0'
fields = {
'objects': ovo_fields.ListOfObjectsField('Repository'),
'remove_unlisted': ovo_fields.BooleanField(default=False),
}
@base.DrydockObjectRegistry.register
class SiteDesign(base.DrydockPersistentObject, base.DrydockObject):
VERSION = '1.0'
fields = {
'id':
ovo_fields.UUIDField(),
# if null, indicates this is the site base design
'base_design_id':
ovo_fields.UUIDField(nullable=True),
'source':
hd_fields.ModelSourceField(),
'site':
ovo_fields.ObjectField('Site', nullable=True),
'networks':
ovo_fields.ObjectField('NetworkList', nullable=True),
'network_links':
ovo_fields.ObjectField('NetworkLinkList', nullable=True),
'host_profiles':
ovo_fields.ObjectField('HostProfileList', nullable=True),
'hardware_profiles':
ovo_fields.ObjectField('HardwareProfileList', nullable=True),
'baremetal_nodes':
ovo_fields.ObjectField('BaremetalNodeList', nullable=True),
'racks':
ovo_fields.ObjectField('RackList', nullable=True),
'bootactions':
ovo_fields.ObjectField('BootActionList', nullable=True),
}
def __init__(self, **kwargs):
super(SiteDesign, self).__init__(**kwargs)
# Assign UUID id
def assign_id(self):
self.id = uuid.uuid4()
return self.id
# SiteDesign Keyed by id
def get_id(self):
return self.id
def get_site(self):
return self.site
def set_site(self, site):
self.site = site
def add_network(self, new_network):
if new_network is None:
raise errors.DesignError("Invalid Network model")
if self.networks is None:
self.networks = objects.NetworkList()
self.networks.append(new_network)
def get_network(self, network_key):
if self.networks:
for n in self.networks:
if n.get_id() == network_key:
return n
raise errors.DesignError(
"Network %s not found in design state" % network_key)
def add_network_link(self, new_network_link):
if new_network_link is None:
raise errors.DesignError("Invalid NetworkLink model")
if self.network_links is None:
self.network_links = objects.NetworkLinkList()
self.network_links.append(new_network_link)
def get_network_link(self, link_key):
if self.network_links:
for network_link in self.network_links:
if network_link.get_id() == link_key:
return network_link
raise errors.DesignError(
"NetworkLink %s not found in design state" % link_key)
def add_rack(self, new_rack):
if new_rack is None:
raise errors.DesignError("Invalid Rack model")
if self.racks is None:
self.racks = objects.RackList()
self.racks.append(new_rack)
def get_rack(self, rack_key):
if self.racks:
for r in self.racks:
if r.get_id() == rack_key:
return r
raise errors.DesignError(
"Rack %s not found in design state" % rack_key)
def add_bootaction(self, new_ba):
"""Add a bootaction definition to this site design.
:param new_ba: instance of BootAction to add to the design
"""
if self.bootactions is None:
self.bootactions = objects.BootActionList()
self.bootactions.append(new_ba)
def get_bootaction(self, ba_key):
"""Select a boot action from this site design with the matchkey key.
:param ba_key: Value should match the ``get_id()`` value of the BootAction returned
"""
if self.bootactions:
for ba in self.bootactions:
if ba.get_id() == ba_key:
return ba
raise errors.DesignError(
"BootAction %s not found in design state" % ba_key)
def add_host_profile(self, new_host_profile):
if new_host_profile is None:
raise errors.DesignError("Invalid HostProfile model")
if self.host_profiles is None:
self.host_profiles = objects.HostProfileList()
self.host_profiles.append(new_host_profile)
def get_host_profile(self, profile_key):
if self.host_profiles:
for p in self.host_profiles:
if p.get_id() == profile_key:
return p
raise errors.DesignError(
"HostProfile %s not found in design state" % profile_key)
def add_hardware_profile(self, new_hardware_profile):
if new_hardware_profile is None:
raise errors.DesignError("Invalid HardwareProfile model")
if self.hardware_profiles is None:
self.hardware_profiles = objects.HardwareProfileList()
self.hardware_profiles.append(new_hardware_profile)
def get_hardware_profile(self, profile_key):
if self.hardware_profiles:
for p in self.hardware_profiles:
if p.get_id() == profile_key:
return p
raise errors.DesignError(
"HardwareProfile %s not found in design state" % profile_key)
def add_baremetal_node(self, new_baremetal_node):
if new_baremetal_node is None:
raise errors.DesignError("Invalid BaremetalNode model")
if self.baremetal_nodes is None:
self.baremetal_nodes = objects.BaremetalNodeList()
self.baremetal_nodes.append(new_baremetal_node)
def get_baremetal_node(self, node_key):
if self.baremetal_nodes:
for n in self.baremetal_nodes:
if n.get_id() == node_key:
return n
raise errors.DesignError(
"BaremetalNode %s not found in design state" % node_key)
def add_promenade_config(self, prom_conf):
if self.prom_configs is None:
self.prom_configs = objects.PromenadeConfigList()
self.prom_configs.append(prom_conf)
def get_promenade_configs(self):
return self.prom_configs
def get_promenade_config(self, target_list):
targeted_docs = []
if target_list is None or not isinstance(target_list, list):
return targeted_docs
for t in target_list:
targeted_docs.extend(self.prom_configs.select_for_target(t))
return targeted_docs
def create(self, ctx, state_manager):
self.created_at = datetime.datetime.now()
self.created_by = ctx.user
state_manager.post_design(self)
def save(self, ctx, state_manager):
self.updated_at = datetime.datetime.now()
self.updated_by = ctx.user
state_manager.put_design(self)
"""
Support filtering on rack name, node name or node tag
for now. Each filter can be a comma-delimited list of
values. The final result is an intersection of all the
filters
"""
def get_filtered_nodes(self, node_filter):
effective_nodes = self.baremetal_nodes
# filter by rack
rack_filter = node_filter.get('rackname', None)
if rack_filter is not None:
rack_list = rack_filter.split(',')
effective_nodes = [
x for x in effective_nodes if x.get_rack() in rack_list
]
# filter by name
name_filter = node_filter.get('nodename', None)
if name_filter is not None:
name_list = name_filter.split(',')
effective_nodes = [
x for x in effective_nodes if x.get_name() in name_list
]
# filter by tag
tag_filter = node_filter.get('tags', None)
if tag_filter is not None:
tag_list = tag_filter.split(',')
effective_nodes = [
x for x in effective_nodes for t in tag_list if x.has_tag(t)
]
return effective_nodes
