def body_hostlink(self, lines):
pan_assign(lines, "target", self.dbobj.target)
if self.dbobj.owner_group:
owner_string = self.dbobj.owner_user + ':' + self.dbobj.owner_group
else:
owner_string = self.dbobj.owner_user
pan_assign(lines, "owner", owner_string)
def body_resourcegroup(self, lines):
pan_assign(lines, "name", self.dbobj.name)
if self.dbobj.resholder:
for resource in self.dbobj.resholder.resources:
pan_append(
lines, "resources/" + resource.resource_type,
StructureTemplate(resource.template_base + "/config"))
def body(self, lines):
path = PlenaryServiceInstanceToplevel.template_name(self.dbobj)
pan_assign(lines, "/system/services/%s" % self.dbobj.service,
StructureTemplate(path))
path = PlenaryServiceClientDefault.template_name(self.dbobj.service)
pan_include(lines, path)
def body_resourcegroup(self, lines):
pan_assign(lines, "name", self.dbobj.name)
if self.dbobj.resholder:
for resource in self.dbobj.resholder.resources:
pan_append(
lines, "resources/" + resource.resource_type, StructureTemplate(resource.template_base + "/config")
)
def body(self, lines):
pers = self.dbobj.personality
arch = pers.archetype
# FIXME: Enforce that one of the interfaces is marked boot?
for dbinterface in self.dbobj.machine.interfaces:
# Management interfaces are not configured at the host level
if dbinterface.interface_type == 'management':
continue
services = []
required_services = set(arch.services + pers.services)
for si in self.dbobj.services_used:
required_services.discard(si.service)
services.append(si.cfg_path + '/client/config')
if required_services:
missing = ", ".join(sorted([srv.name
for srv in required_services]))
raise IncompleteError(
"Host %s is missing the following required "
"services, please run 'aq reconfigure': %s." %
(self.name, missing))
provides = []
for si in self.dbobj.services_provided:
provides.append('%s/server/config' % si.cfg_path)
# Ensure used/provided services have a stable order
services.sort()
provides.sort()
# Okay, here's the real content
pan_include(lines, ["pan/units", "pan/functions"])
lines.append("")
pan_assign(
lines, "/",
StructureTemplate("hostdata/%s" % self.name,
{"metadata": PanValue("/metadata")}))
pan_include(lines, "archetype/base")
pan_include(lines, self.dbobj.operating_system.cfg_path + '/config')
pan_include(lines, services)
pan_include(lines, provides)
personality_template = "personality/%s/config" % \
self.dbobj.personality.name
pan_include(lines, personality_template)
if self.dbobj.cluster:
clplenary = PlenaryClusterClient(self.dbobj.cluster)
pan_include(lines, clplenary.plenary_template_name)
elif pers.cluster_required:
raise IncompleteError("Host %s personality %s requires cluster "
"membership, please run 'aq cluster'." %
(self.name, pers.name))
pan_include(lines, "archetype/final")
def helper_feature_template(featuretemplate, dbfeaturelink, lines):
params = get_parameters_by_feature(dbfeaturelink)
for path in params:
pan_assign(lines,
"/system/%s/%s" % (dbfeaturelink.cfg_path_escaped, path),
params[path])
lines.append(featuretemplate.format_raw(dbfeaturelink))
def body(self, lines):
pers = self.dbobj.personality
arch = pers.archetype
# FIXME: Enforce that one of the interfaces is marked boot?
for dbinterface in self.dbobj.hardware_entity.interfaces:
# Management interfaces are not configured at the host level
if dbinterface.interface_type == 'management':
continue
services = []
required_services = set(arch.services + pers.services)
for si in self.dbobj.services_used:
required_services.discard(si.service)
services.append(PlenaryServiceInstanceClientDefault.template_name(si))
if required_services:
missing = ", ".join(sorted([srv.name for srv in required_services]))
raise IncompleteError("{0} is missing the following required "
"services, please run 'aq reconfigure': "
"{1!s}.".format(self.dbobj, missing))
provides = []
for srv in self.dbobj.services_provided:
si = srv.service_instance
provides.append(PlenaryServiceInstanceServerDefault.template_name(si))
# Ensure used/provided services have a stable order
services.sort()
provides.sort()
# Okay, here's the real content
pan_include(lines, ["pan/units", "pan/functions"])
lines.append("")
path = PlenaryHostData.template_name(self.dbobj)
pan_assign(lines, "/",
StructureTemplate(path,
{"metadata": PanValue("/metadata")}))
pan_include(lines, "archetype/base")
opsys = self.dbobj.operating_system
pan_include(lines, "os/%s/%s/config" % (opsys.name, opsys.version))
pan_include(lines, services)
pan_include(lines, provides)
path = PlenaryPersonalityBase.template_name(pers)
pan_include(lines, path)
if self.dbobj.cluster:
pan_include(lines,
PlenaryClusterClient.template_name(self.dbobj.cluster))
elif pers.cluster_required:
raise IncompleteError("{0} requires cluster membership, please "
"run 'aq cluster'.".format(pers))
pan_include(lines, "archetype/final")
def body(self, lines):
pers = self.dbobj.personality
arch = pers.archetype
# FIXME: Enforce that one of the interfaces is marked boot?
for dbinterface in self.dbobj.machine.interfaces:
# Management interfaces are not configured at the host level
if dbinterface.interface_type == "management":
continue
services = []
required_services = set(arch.services + pers.services)
for si in self.dbobj.services_used:
required_services.discard(si.service)
services.append(si.cfg_path + "/client/config")
if required_services:
missing = ", ".join(sorted([srv.name for srv in required_services]))
raise IncompleteError(
"Host %s is missing the following required "
"services, please run 'aq reconfigure': %s." % (self.name, missing)
)
provides = []
for si in self.dbobj.services_provided:
provides.append("%s/server/config" % si.cfg_path)
# Ensure used/provided services have a stable order
services.sort()
provides.sort()
# Okay, here's the real content
pan_include(lines, ["pan/units", "pan/functions"])
lines.append("")
pan_assign(lines, "/", StructureTemplate("hostdata/%s" % self.name, {"metadata": PanValue("/metadata")}))
pan_include(lines, "archetype/base")
pan_include(lines, self.dbobj.operating_system.cfg_path + "/config")
pan_include(lines, services)
pan_include(lines, provides)
personality_template = "personality/%s/config" % self.dbobj.personality.name
pan_include(lines, personality_template)
if self.dbobj.cluster:
clplenary = PlenaryClusterClient(self.dbobj.cluster)
pan_include(lines, clplenary.plenary_template_name)
elif pers.cluster_required:
raise IncompleteError(
"Host %s personality %s requires cluster "
"membership, please run 'aq cluster'." % (self.name, pers.name)
)
pan_include(lines, "archetype/final")
def body(self, lines):
path = PlenaryServiceInstanceServer.template_name(self.dbobj)
# TODO: we should export the FQDN, IP address, and service address name
# that provides the service
# TODO: make it possible to provide multiple instances of the same
# service
pan_assign(lines, "/system/provides/%s" % self.dbobj.service,
StructureTemplate(path))
path = PlenaryServiceServerDefault.template_name(self.dbobj.service)
pan_include(lines, path)
def body_intervention(self, lines):
pan_assign(lines, "start", self.dbobj.start_date.isoformat())
pan_assign(lines, "expiry", self.dbobj.expiry_date.isoformat())
if self.dbobj.users:
pan_assign(lines, "users", sorted(self.dbobj.users.split(",")))
if self.dbobj.groups:
pan_assign(lines, "groups", sorted(self.dbobj.groups.split(",")))
if self.dbobj.disabled:
pan_assign(lines, "disabled", sorted(self.dbobj.disabled.split(",")))
def body(self, lines):
pan_assign(lines, "/system/cluster/name", self.name)
# We could just use a PAN external reference to pull in this value from
# the cluster template, but since we know that these templates are
# always in sync, we can duplicate the content here to avoid the
# possibility of circular external references.
if self.dbobj.resholder:
for resource in sorted(self.dbobj.resholder.resources):
pan_append(lines, "/system/cluster/resources/" +
resource.resource_type,
StructureTemplate(resource.template_base + '/config'))
lines.append("include { if_exists('features/' + value('/system/archetype/name') + '/%s/%s/config') };"
% (self.dbobj.personality.archetype.name,
self.dbobj.personality.name))
def body(self, lines):
pan_include(lines, ["pan/units", "pan/functions"])
pan_assign(lines, "/",
StructureTemplate("clusterdata/%s" % self.name,
{"metadata": PanValue("/metadata")}))
pan_include(lines, "archetype/base")
for servinst in sorted(self.dbobj.service_bindings):
pan_include(lines, "service/%s/%s/client/config" %
(servinst.service.name, servinst.name))
pan_include(lines, "personality/%s/config" %
self.dbobj.personality.name)
pan_include(lines, "archetype/final")
def body(self, lines):
pan_include(lines, ["pan/units", "pan/functions"])
pan_assign(lines, "/",
StructureTemplate("clusterdata/%s" % self.dbobj.name,
{"metadata": PanValue("/metadata")}))
pan_include(lines, "archetype/base")
#for esx_management_server
for servinst in sorted(self.dbobj.service_bindings):
path = PlenaryServiceInstanceClientDefault.template_name(servinst)
pan_include(lines, path)
path = PlenaryPersonalityBase.template_name(self.dbobj.personality)
pan_include(lines, path)
pan_include(lines, "archetype/final")
def body(self, lines):
pan_include(lines, ["pan/units", "pan/functions"])
pan_assign(
lines, "/",
StructureTemplate("clusterdata/%s" % self.name,
{"metadata": PanValue("/metadata")}))
pan_include(lines, "archetype/base")
for servinst in sorted(self.dbobj.service_bindings):
pan_include(
lines, "service/%s/%s/client/config" %
(servinst.service.name, servinst.name))
pan_include(lines,
"personality/%s/config" % self.dbobj.personality.name)
pan_include(lines, "archetype/final")
def body(self, lines):
pan_assign(lines, "/system/cluster/name", self.name)
# We could just use a PAN external reference to pull in this value from
# the cluster template, but since we know that these templates are
# always in sync, we can duplicate the content here to avoid the
# possibility of circular external references.
if self.dbobj.resholder:
for resource in sorted(self.dbobj.resholder.resources):
pan_append(
lines,
"/system/cluster/resources/" + resource.resource_type,
StructureTemplate(resource.template_base + '/config'))
lines.append(
"include { if_exists('features/' + value('/system/archetype/name') + '/%s/%s/config') };"
% (self.dbobj.personality.archetype.name,
self.dbobj.personality.name))
def body(self, lines):
pan_variable(lines, "PERSONALITY", self.dbobj.name)
## process grns
eon_id_map = defaultdict(set)
# own == pers level
for grn_rec in self.dbobj._grns:
eon_id_map[grn_rec.target].add(grn_rec.grn.eon_id)
for (target, eon_id_set) in eon_id_map.iteritems():
eon_id_list = list(eon_id_set)
eon_id_list.sort()
for eon_id in eon_id_list:
pan_append(lines, "/system/eon_id_maps/%s" % target, eon_id)
archetype = self.dbobj.archetype.name
# backward compat for esp reporting
if self.config.has_option("archetype_" + archetype,
"default_grn_target"):
default_grn_target = self.config.get("archetype_" + archetype,
"default_grn_target")
eon_id_set = eon_id_map[default_grn_target]
eon_id_list = list(eon_id_set)
eon_id_list.sort()
for eon_id in eon_id_list:
pan_append(lines, "/system/eon_ids", eon_id)
pan_assign(lines, "/system/personality/owner_eon_id",
self.dbobj.owner_eon_id)
## include pre features
path = PlenaryPersonalityPreFeature.template_name(self.dbobj)
pan_include_if_exists(lines, path)
## process parameter templates
pan_include_if_exists(lines, "personality/config")
pan_assign(lines, "/system/personality/name", self.dbobj.name)
if self.dbobj.host_environment.name != 'legacy':
pan_assign(lines, "/system/personality/host_environment",
self.dbobj.host_environment, True)
## TODO : This is just to satisfy quattor schema
## needs to be removed as soon as the schema allows this
pan_assign(lines, "/system/personality/systemgrn", [])
if self.dbobj.config_override:
pan_include(lines, "features/personality/config_override/config")
## include post features
path = PlenaryPersonalityPostFeature.template_name(self.dbobj)
pan_include_if_exists(lines, path)
def body_esx(self, lines):
if self.metacluster:
pan_assign(lines, "system/metacluster/name", self.metacluster)
pan_assign(lines, "system/cluster/ratio",
[self.dbobj.vm_count, self.dbobj.host_count])
pan_assign(lines, "system/cluster/max_hosts", self.dbobj.max_hosts)
lines.append("")
lines.append("")
if isinstance(self.dbobj, EsxCluster) and self.dbobj.switch:
pan_assign(lines, "system/cluster/switch",
self.dbobj.switch.primary_name)
def body_esx(self, lines):
if self.metacluster:
pan_assign(lines, "system/metacluster/name", self.metacluster)
pan_assign(lines, "system/cluster/ratio", [self.dbobj.vm_count,
self.dbobj.host_count])
pan_assign(lines, "system/cluster/max_hosts",
self.dbobj.max_hosts)
lines.append("")
lines.append("")
if isinstance(self.dbobj, EsxCluster) and self.dbobj.switch:
pan_assign(lines, "system/cluster/switch",
self.dbobj.switch.primary_name)
def body(self, lines):
pan_include(lines, "servicedata/%s/config" % self.service)
lines.append("")
pan_assign(lines, "instance", self.name)
pan_assign(lines, "servers", self.dbobj.server_fqdns)
if self.service == 'dns':
pan_assign(lines, "server_ips", self.dbobj.server_ips)
def _generate_content(self):
"""Not meant to be overridden or called directly."""
lines = []
type = self.template_type
if type is not None and type is not "":
type = type + " "
lines.append("%stemplate %s;" % (type, self.plenary_template_name))
lines.append("")
if self.template_type == "object":
if self.loadpath:
pan_variable(lines, "LOADPATH", [self.loadpath])
lines.append("")
pan_assign(lines, "/metadata/template/branch/name",
self.dbobj.branch.name)
pan_assign(lines, "/metadata/template/branch/type",
self.dbobj.branch.branch_type)
if self.dbobj.branch.branch_type == 'sandbox':
pan_assign(lines, "/metadata/template/branch/author",
self.dbobj.sandbox_author.name)
lines.append("")
self.body(lines)
return "\n".join(lines) + "\n"
def body(self, lines):
pan_variable(lines, "PERSONALITY", self.name)
## process grns
eon_id_map = defaultdict(set)
# own == pers level
for grn_rec in self.dbobj._grns:
eon_id_map[grn_rec.target].add(grn_rec.grn.eon_id)
for (target, eon_id_set) in eon_id_map.iteritems():
eon_id_list = list(eon_id_set)
eon_id_list.sort()
for eon_id in eon_id_list:
pan_append(lines, "/system/eon_id_maps/%s" % target, eon_id)
archetype = self.dbobj.archetype.name
# backward compat for esp reporting
if self.config.has_option("archetype_" + archetype,
"default_grn_target"):
default_grn_target = self.config.get("archetype_" + archetype,
"default_grn_target")
eon_id_set = eon_id_map[default_grn_target]
eon_id_list = list(eon_id_set)
eon_id_list.sort()
for eon_id in eon_id_list:
pan_append(lines, "/system/eon_ids", eon_id)
pan_assign(lines, "/system/personality/owner_eon_id",
self.dbobj.owner_eon_id)
## include pre features
pan_include_if_exists(lines, "%s/pre_feature" % self.plenary_core)
## process parameter templates
pan_include_if_exists(lines, "personality/config")
pan_assign(lines, "/system/personality/name", self.name)
pan_assign(lines, "/system/personality/host_environment",
self.dbobj.host_environment)
## TODO : This is just to satisfy quattor schema
## needs to be removed as soon as the schema allows this
pan_assign(lines, "/system/personality/systemgrn", [])
if self.dbobj.config_override:
pan_include(lines, "features/personality/config_override/config")
## include post features
pan_include_if_exists(lines, "%s/post_feature" % self.plenary_core)
def _generate_content(self):
"""Not meant to be overridden or called directly."""
lines = []
type = self.template_type
if type is not None and type is not "":
type = type + " "
lines.append("%stemplate %s;" % (type, self.plenary_template_name))
lines.append("")
if self.template_type == "object":
if self.loadpath:
pan_variable(lines, "LOADPATH", [self.loadpath])
lines.append("")
pan_assign(lines, "/metadata/template/branch/name",
self.dbobj.branch.name)
pan_assign(lines, "/metadata/template/branch/type",
self.dbobj.branch.branch_type)
if self.dbobj.branch.branch_type == 'sandbox':
pan_assign(lines, "/metadata/template/branch/author",
self.dbobj.sandbox_author.name)
lines.append("")
self.body(lines)
return "\n".join(lines) + "\n"
def body_virtual_machine(self, lines):
pan_assign(lines, "name", self.dbobj.name)
machine = self.dbobj.machine
pmac = Plenary.get_plenary(machine)
pan_assign(lines, "hardware",
StructureTemplate(pmac.plenary_template_name))
# One day we may get to the point where this will be required.
# FIXME: read the data from the host data template
if (machine.host):
# we fill this in manually instead of just assigning
# 'system' = value("hostname:/system")
# because the target host might not actually have a profile.
arch = machine.host.archetype
os = machine.host.operating_system
pn = machine.primary_name.fqdn
system = {
'archetype': {
'name': arch.name,
'os': os.name,
'osversion': os.version
},
'build': machine.host.status.name,
'network': {
'hostname': pn.name,
'domainname': pn.dns_domain
}
}
pan_assign(lines, "system", system)
def body(self, lines):
pan_include(lines, "servicedata/%s/config" % self.service)
lines.append("")
pan_assign(lines, "instance", self.name)
pan_assign(lines, "servers", self.dbobj.server_fqdns)
if self.service == 'dns':
pan_assign(lines, "server_ips", self.dbobj.server_ips)
def body(self, lines):
pan_include(lines, ["pan/units", "pan/functions"])
path = PlenaryClusterData.template_name(self.dbobj)
pan_assign(lines, "/",
StructureTemplate(path,
{"metadata": PanValue("/metadata")}))
pan_include(lines, "archetype/base")
for servinst in sorted(self.dbobj.service_bindings,
key=attrgetter('service.name', 'name')):
path = PlenaryServiceInstanceClientDefault.template_name(servinst)
pan_include(lines, path)
for srv in sorted(self.dbobj.services_provided,
key=attrgetter("service_instance.service.name",
"service_instance.name")):
path = PlenaryServiceInstanceServerDefault.template_name(srv.service_instance)
pan_include(lines, path)
path = PlenaryPersonalityBase.template_name(self.dbobj.personality)
pan_include(lines, path)
pan_include(lines, "archetype/final")
def body_virtual_machine(self, lines):
machine = self.dbobj.machine
path = PlenaryMachineInfo.template_name(machine)
pan_assign(lines, "hardware", StructureTemplate(path))
# One day we may get to the point where this will be required.
# FIXME: read the data from the host data template
if machine.host:
# we fill this in manually instead of just assigning
# 'system' = value("hostname:/system")
# because the target host might not actually have a profile.
arch = machine.host.archetype
os = machine.host.operating_system
pn = machine.primary_name.fqdn
system = {'archetype': {'name': arch.name,
'os': os.name,
'osversion': os.version},
'build': machine.host.status.name,
'network': {'hostname': pn.name,
'domainname': pn.dns_domain}}
pan_assign(lines, "system", system)
def body_hostlink(self, lines):
pan_assign(lines, "name", self.dbobj.name)
pan_assign(lines, "target", self.dbobj.target)
if self.dbobj.owner_group:
owner_string = self.dbobj.owner_user + ':' + self.dbobj.owner_group
else:
owner_string = self.dbobj.owner_user
pan_assign(lines, "owner", owner_string)
def body_esx(self, lines):
if self.dbobj.metacluster:
pan_assign(lines, "system/metacluster/name",
self.dbobj.metacluster.name)
pan_assign(lines, "system/cluster/ratio", [self.dbobj.vm_count,
self.dbobj.host_count])
# FIXME: This should move to the generic part because max_hosts makes
# sense for non-ESX clusters as well, but the current schema does not
# allow that
if self.dbobj.max_hosts is not None:
pan_assign(lines, "system/cluster/max_hosts",
self.dbobj.max_hosts)
if self.dbobj.network_device:
pan_assign(lines, "system/cluster/switch",
self.dbobj.network_device.primary_name)
def body(self, lines):
pan_include(lines,
PlenaryServiceToplevel.template_name(self.dbobj.service))
lines.append("")
pan_assign(lines, "instance", self.dbobj.name)
fqdns = [srv.fqdn for srv in self.dbobj.servers]
ips = [srv.ip for srv in self.dbobj.servers if srv.ip]
pan_assign(lines, "servers", fqdns)
pan_assign(lines, "server_ips", ips)
def _generate_content(self):
lines = []
lines.append("object template %s;" % self.template_name(self.dbobj))
lines.append("")
loadpath = self.loadpath(self.dbobj)
if loadpath:
pan_variable(lines, "LOADPATH", [loadpath])
lines.append("")
pan_assign(lines, "/metadata/template/branch/name",
self.dbobj.branch.name)
pan_assign(lines, "/metadata/template/branch/type",
self.dbobj.branch.branch_type)
if self.dbobj.branch.branch_type == 'sandbox':
pan_assign(lines, "/metadata/template/branch/author",
self.dbobj.sandbox_author.name)
lines.append("")
self.body(lines)
return "\n".join(lines) + "\n"
def body_virtual_machine(self, lines):
pan_assign(lines, "name", self.dbobj.name)
machine = self.dbobj.machine
pmac = Plenary.get_plenary(machine)
pan_assign(lines, "hardware", StructureTemplate(pmac.plenary_template_name))
# One day we may get to the point where this will be required.
# FIXME: read the data from the host data template
if machine.host:
# we fill this in manually instead of just assigning
# 'system' = value("hostname:/system")
# because the target host might not actually have a profile.
arch = machine.host.archetype
os = machine.host.operating_system
pn = machine.primary_name.fqdn
system = {
"archetype": {"name": arch.name, "os": os.name, "osversion": os.version},
"build": machine.host.status.name,
"network": {"hostname": pn.name, "domainname": pn.dns_domain},
}
pan_assign(lines, "system", system)
def body_reboot_schedule(self, lines):
pan_assign(lines, "time", self.dbobj.time)
pan_assign(lines, "week", self.dbobj.week)
pan_assign(lines, "day", self.dbobj.day)
def body_filesystem(self, lines):
pan_assign(lines, "type", self.dbobj.fstype)
pan_assign(lines, "mountpoint", self.dbobj.mountpoint)
pan_assign(lines, "mount", self.dbobj.mount)
pan_assign(lines, "block_device_path", self.dbobj.blockdev)
opts = ""
if self.dbobj.mountoptions:
opts = self.dbobj.mountoptions
pan_assign(lines, "mountopts", opts)
pan_assign(lines, "freq", self.dbobj.dumpfreq)
pan_assign(lines, "pass", self.dbobj.passno)
def body(self, lines):
ram = [StructureTemplate("hardware/ram/generic",
{"size": PanMetric(self.dbobj.memory, "MB")})]
cpus = []
for cpu_num in range(self.dbobj.cpu_quantity):
cpu = StructureTemplate("hardware/cpu/%s/%s" %
(self.dbobj.cpu.vendor.name,
self.dbobj.cpu.name))
cpus.append(cpu)
disks = {}
for disk in self.dbobj.disks:
devname = disk.device_name
params = {"capacity": PanMetric(disk.capacity, "GB"),
"interface": disk.controller_type}
if disk.bootable:
params["boot"] = True
if disk.disk_type == 'local':
tpl = StructureTemplate(
("hardware/harddisk/generic/%s" %
disk.controller_type),
params)
if disk.controller_type == 'cciss':
devname = "cciss/" + devname
elif disk.disk_type == 'virtual_disk':
share = disk.share
params["path"] = "%s/%s.vmdk" % (self.machine, disk.device_name)
params["address"] = disk.address
params["sharename"] = share.name
params["server"] = share.server
params["mountpoint"] = share.mount
tpl = params
disks[PanEscape(devname)] = tpl
managers = {}
interfaces = {}
for interface in self.dbobj.interfaces:
path = "hardware/nic/%s/%s" % (interface.model.vendor,
interface.model)
if interface.interface_type == 'public':
ifinfo = {}
if interface.mac:
ifinfo["hwaddr"] = interface.mac
if interface.port_group:
ifinfo["port_group"] = interface.port_group
if interface.bootable:
ifinfo["boot"] = interface.bootable
interfaces[interface.name] = StructureTemplate(path, ifinfo)
elif interface.interface_type == 'management':
has_addr = False
for addr in interface.assignments:
has_addr = True
manager = {"hwaddr": interface.mac}
if addr.fqdns:
manager["fqdn"] = addr.fqdns[0]
managers[addr.logical_name] = manager
if not has_addr:
managers[interface.name] = {"hwaddr": interface.mac}
elif interface.interface_type == 'bonding':
# Bonding interfaces need an entry under /hardware/cards/nic
# only if the MAC address has been explicitely set
if interface.mac:
ifinfo = {"hwaddr": interface.mac}
interfaces[interface.name] = StructureTemplate(path, ifinfo)
# Firstly, location
pan_assign(lines, "location", self.sysloc)
pan_assign(lines, "sysloc/building", self.building)
pan_assign(lines, "sysloc/city", self.city)
pan_assign(lines, "sysloc/continent", self.continent)
if self.rack:
pan_assign(lines, "rack/name", self.rack)
if self.rackrow:
pan_assign(lines, "rack/row", self.rackrow)
if self.rackcol:
pan_assign(lines, "rack/column", self.rackcol)
if self.room:
pan_assign(lines, "rack/room", self.room)
# And a chassis location?
if self.dbobj.chassis_slot:
slot = self.dbobj.chassis_slot[0]
pan_assign(lines, "chassis", slot.chassis.fqdn)
pan_assign(lines, "slot", slot.slot_number)
#if self.hub:
# pan_assign(lines, "sysloc/hub", self.hub)
if self.campus:
pan_assign(lines, "sysloc/campus", self.campus)
if self.bunker:
pan_assign(lines, "sysloc/bunker", self.bunker)
if self.dns_search_domains:
pan_assign(lines, "sysloc/dns_search_domains",
self.dns_search_domains)
# Now describe the hardware
lines.append("")
if self.dbobj.serial_no:
pan_assign(lines, "serialnumber", self.dbobj.serial_no)
pan_assign(lines, "nodename", self.machine)
pan_include(lines, "hardware/machine/%s/%s" %
(self.dbobj.model.vendor.name, self.dbobj.model.name))
lines.append("")
pan_assign(lines, "ram", ram)
pan_assign(lines, "cpu", cpus)
if disks:
pan_assign(lines, "harddisks", disks)
if interfaces:
pan_assign(lines, "cards/nic", interfaces)
# /hardware/console/preferred must be set, so we can't assign to
# "/console" directly
for manager in sorted(managers.keys()):
pan_assign(lines, "console/%s" % manager, managers[manager])
def body(self, lines):
pan_assign(
lines, "/system/provides/%s" % self.service,
StructureTemplate('servicedata/%s/%s/srvconfig' %
(self.service, self.name)))
pan_include(lines, "service/%s/server/config" % self.service)
def body(self, lines):
for path in self.parameters:
pan_assign(lines, path, self.parameters[path])
def body_reboot_schedule(self, lines):
pan_assign(lines, "name", self.dbobj.name)
pan_assign(lines, "time", self.dbobj.time)
pan_assign(lines, "week", self.dbobj.week)
pan_assign(lines, "day", self.dbobj.day)
def body(self, lines):
pan_assign(lines, "system/cluster/name", self.name)
pan_assign(lines, "system/cluster/type", self.dbobj.cluster_type)
dbloc = self.dbobj.location_constraint
pan_assign(lines, "system/cluster/sysloc/location", dbloc.sysloc())
if dbloc.continent:
pan_assign(lines, "system/cluster/sysloc/continent",
dbloc.continent.name)
if dbloc.city:
pan_assign(lines, "system/cluster/sysloc/city", dbloc.city.name)
if dbloc.campus:
pan_assign(lines, "system/cluster/sysloc/campus",
dbloc.campus.name)
## maintaining this so templates dont break
## during transtion period.. should be DEPRECATED
pan_assign(lines, "system/cluster/campus", dbloc.campus.name)
if dbloc.building:
pan_assign(lines, "system/cluster/sysloc/building",
dbloc.building.name)
if dbloc.bunker:
pan_assign(lines, "system/cluster/sysloc/bunker",
dbloc.bunker.name)
if dbloc.rack:
pan_assign(lines, "system/cluster/rack/row", dbloc.rack.rack_row)
pan_assign(lines, "system/cluster/rack/column",
dbloc.rack.rack_column)
pan_assign(lines, "system/cluster/rack/name", dbloc.rack.name)
if dbloc.room:
pan_assign(lines, "system/cluster/rack/room", dbloc.room)
pan_assign(lines, "system/cluster/down_hosts_threshold",
self.dbobj.dht_value)
if self.dbobj.dmt_value is not None:
pan_assign(lines, "system/cluster/down_maint_threshold",
self.dbobj.dmt_value)
if self.dbobj.down_hosts_percent:
pan_assign(lines, "system/cluster/down_hosts_percent",
self.dbobj.down_hosts_threshold)
pan_assign(lines, "system/cluster/down_hosts_as_percent",
self.dbobj.down_hosts_percent)
if self.dbobj.down_maint_percent:
pan_assign(lines, "system/cluster/down_maint_percent",
self.dbobj.down_maint_threshold)
pan_assign(lines, "system/cluster/down_maint_as_percent",
self.dbobj.down_maint_percent)
lines.append("")
# Only use system names here to avoid circular dependencies.
# Other templates that needs to look up the underlying values use:
# foreach(idx; host; value("system/cluster/members")) {
# v = value("/" + host + "/system/foo/bar/baz");
# );
pan_assign(lines, "system/cluster/members",
sorted([member.fqdn for member in self.dbobj.hosts]))
lines.append("")
if self.dbobj.resholder:
for resource in sorted(self.dbobj.resholder.resources):
pan_append(
lines, "system/resources/" + resource.resource_type,
StructureTemplate(resource.template_base + '/config'))
pan_assign(lines, "system/build", self.dbobj.status.name)
if self.dbobj.allowed_personalities:
pan_assign(
lines, "system/cluster/allowed_personalities",
sorted([
"%s/%s" % (p.archetype.name, p.name)
for p in self.dbobj.allowed_personalities
]))
fname = "body_%s" % self.dbobj.cluster_type
if hasattr(self, fname):
getattr(self, fname)(lines)
def body(self, lines):
pan_assign(lines, "instance", self.dbobj.name)
if self.dbobj.service.need_client_list:
pan_assign(lines, "clients", self.dbobj.client_fqdns)
def body(self, lines):
interfaces = dict()
routers = {}
default_gateway = None
pers = self.dbobj.personality
# FIXME: Enforce that one of the interfaces is marked boot?
for dbinterface in self.dbobj.machine.interfaces:
# Management interfaces are not configured at the host level
if dbinterface.interface_type == 'management':
continue
ifdesc = {}
if dbinterface.master:
ifdesc["bootproto"] = "none"
if isinstance(dbinterface.master, BondingInterface):
ifdesc["master"] = dbinterface.master.name
elif isinstance(dbinterface.master, BridgeInterface):
ifdesc["bridge"] = dbinterface.master.name
else:
raise InternalError("Unexpected master interface type: "
"{0}".format(dbinterface.master))
else:
if dbinterface.assignments:
# TODO: Let the templates select from "static"/"dhcp"
ifdesc["bootproto"] = "static"
else:
# Don't try to bring up the interface if there are no
# addresses assigned to it
ifdesc["bootproto"] = "none"
if isinstance(dbinterface, VlanInterface):
ifdesc["vlan"] = True
ifdesc["physdev"] = dbinterface.parent.name
static_routes = set()
for addr in dbinterface.assignments:
# Service addresses will be handled as resources
if addr.service_address:
continue
net = addr.network
if addr.label == "":
if net.routers:
local_rtrs = select_routers(self.dbobj.machine,
net.routers)
gateway = local_rtrs[0]
if is_default_route(dbinterface):
routers[dbinterface.name] = local_rtrs
else:
# No routers defided, fall back to the default
gateway = net.network[net.default_gateway_offset]
# TODO: generate appropriate routing policy if there are
# multiple interfaces marked as default_route
if not default_gateway and is_default_route(dbinterface):
default_gateway = gateway
ifdesc["ip"] = addr.ip
ifdesc["netmask"] = net.netmask
ifdesc["broadcast"] = net.broadcast
ifdesc["gateway"] = gateway
ifdesc["network_type"] = net.network_type
ifdesc[
"network_environment"] = net.network_environment.name
if addr.dns_records:
ifdesc["fqdn"] = addr.dns_records[0]
else:
aliasdesc = {
"ip": addr.ip,
"netmask": net.netmask,
"broadcast": net.broadcast
}
if addr.dns_records:
aliasdesc["fqdn"] = addr.dns_records[0]
if "aliases" in ifdesc:
ifdesc["aliases"][addr.label] = aliasdesc
else:
ifdesc["aliases"] = {addr.label: aliasdesc}
static_routes |= set(net.static_routes)
if static_routes:
if "route" not in ifdesc:
ifdesc["route"] = []
# Enforce a stable order to make it easier to verify changes in
# the plenaries
for route in sorted(list(static_routes),
key=attrgetter('destination',
'gateway_ip')):
ifdesc["route"].append({
"address": route.destination.ip,
"netmask": route.destination.netmask,
"gateway": route.gateway_ip
})
if not ifdesc["route"]:
del ifdesc["route"]
interfaces[dbinterface.name] = ifdesc
# Okay, here's the real content
pmachine = Plenary.get_plenary(self.dbobj.machine, logger=self.logger)
pan_assign(lines, "hardware",
StructureTemplate(pmachine.plenary_template_name))
lines.append("")
pan_assign(lines, "system/network/interfaces", interfaces)
pan_assign(lines, "system/network/primary_ip",
self.dbobj.machine.primary_ip)
if default_gateway:
pan_assign(lines, "system/network/default_gateway",
default_gateway)
if routers:
pan_assign(lines, "system/network/routers", routers)
lines.append("")
pan_assign(lines, "system/build", self.dbobj.status.name)
pan_assign(lines, "system/advertise_status",
self.dbobj.advertise_status)
## process grns
eon_id_map = defaultdict(set)
# own
for grn_rec in self.dbobj._grns:
eon_id_map[grn_rec.target].add(grn_rec.grn.eon_id)
# pers level
for grn_rec in pers._grns:
eon_id_map[grn_rec.target].add(grn_rec.grn.eon_id)
for (target, eon_id_set) in eon_id_map.iteritems():
eon_id_list = list(eon_id_set)
eon_id_list.sort()
pan_assign(lines, "system/eon_id_maps/%s" % target, eon_id_list)
# backward compat for esp reporting
archetype = self.dbobj.archetype.name
if self.config.has_option("archetype_" + archetype,
"default_grn_target"):
default_grn_target = self.config.get("archetype_" + archetype,
"default_grn_target")
eon_id_set = eon_id_map[default_grn_target]
eon_id_list = list(eon_id_set)
eon_id_list.sort()
if eon_id_list:
pan_assign(lines, "system/eon_ids", eon_id_list)
pan_assign(lines, "system/owner_eon_id", self.dbobj.owner_eon_id)
if self.dbobj.cluster:
pan_assign(lines, "system/cluster/name", self.dbobj.cluster.name)
pan_assign(lines, "system/cluster/node_index",
self.dbobj._cluster.node_index)
if self.dbobj.resholder:
lines.append("")
for resource in sorted(self.dbobj.resholder.resources):
pan_append(
lines, "system/resources/" + resource.resource_type,
StructureTemplate(resource.template_base + '/config'))
def body_service_address(self, lines):
pan_assign(lines, "name", self.dbobj.name)
pan_assign(lines, "ip", str(self.dbobj.dns_record.ip))
pan_assign(lines, "fqdn", str(self.dbobj.dns_record.fqdn))
pan_assign(lines, "interfaces", self.dbobj.interfaces)
def body_share(self, lines):
pan_assign(lines, "name", self.name)
pan_assign(lines, "server", self.dbobj.server)
pan_assign(lines, "mountpoint", self.dbobj.mount)
def body_filesystem(self, lines):
pan_assign(lines, "type", self.dbobj.fstype)
pan_assign(lines, "mountpoint", self.dbobj.mountpoint)
pan_assign(lines, "mount", self.dbobj.mount)
pan_assign(lines, "block_device_path", self.dbobj.blockdev)
opts = ""
if self.dbobj.mountoptions:
opts = self.dbobj.mountoptions
pan_assign(lines, "mountopts", opts)
pan_assign(lines, "freq", self.dbobj.dumpfreq)
pan_assign(lines, "pass", self.dbobj.passno)
def body_application(self, lines):
pan_assign(lines, "name", self.dbobj.name)
pan_assign(lines, "eonid", self.dbobj.eonid)
def body_intervention(self, lines):
pan_assign(lines, "name", self.dbobj.name)
pan_assign(lines, "start", self.dbobj.start_date.isoformat())
pan_assign(lines, "expiry", self.dbobj.expiry_date.isoformat())
if self.dbobj.users:
pan_assign(lines, "users", self.dbobj.users.split(","))
if self.dbobj.groups:
pan_assign(lines, "groups", self.dbobj.groups.split(","))
if self.dbobj.disabled:
pan_assign(lines, "disabled", self.dbobj.disabled.split(","))
def body(self, lines):
pan_assign(lines, "system/metacluster/name", self.name)
pan_assign(lines, "system/metacluster/type", self.dbobj.cluster_type)
dbloc = self.dbobj.location_constraint
pan_assign(lines, "system/metacluster/sysloc/location", dbloc.sysloc())
if dbloc.continent:
pan_assign(lines, "system/metacluster/sysloc/continent",
dbloc.continent.name)
if dbloc.city:
pan_assign(lines, "system/metacluster/sysloc/city",
dbloc.city.name)
if dbloc.campus:
pan_assign(lines, "system/metacluster/sysloc/campus",
dbloc.campus.name)
## maintaining this so templates dont break
## during transtion period.. should be DEPRECATED
pan_assign(lines, "system/metacluster/campus", dbloc.campus.name)
if dbloc.building:
pan_assign(lines, "system/metacluster/sysloc/building",
dbloc.building.name)
if dbloc.room:
pan_assign(lines, "system/cluster/rack/room", dbloc.room)
if dbloc.bunker:
pan_assign(lines, "system/cluster/sysloc/bunker",
dbloc.bunker.name)
if dbloc.rack:
pan_assign(lines, "system/metacluster/rack/row",
dbloc.rack.rack_row)
pan_assign(lines, "system/metacluster/rack/column",
dbloc.rack.rack_column)
pan_assign(lines, "system/metacluster/rack/name", dbloc.rack.name)
lines.append("")
pan_assign(lines, "system/metacluster/members",
[member.name for member in self.dbobj.members])
lines.append("")
pan_assign(lines, "system/build", self.dbobj.status.name)
lines.append("")
if self.dbobj.resholder:
for resource in sorted(self.dbobj.resholder.resources):
pan_append(
lines, "system/resources/" + resource.resource_type,
StructureTemplate(resource.template_base + '/config'))
def body_reboot_iv(self, lines):
pan_assign(lines, "justification", self.dbobj.justification)
self.body_intervention(lines)
def body(self, lines):
ram = [
StructureTemplate("hardware/ram/generic",
{"size": PanMetric(self.dbobj.memory, "MB")})
]
cpus = []
for cpu_num in range(self.dbobj.cpu_quantity):
cpu = StructureTemplate(
"hardware/cpu/%s/%s" %
(self.dbobj.cpu.vendor.name, self.dbobj.cpu.name))
cpus.append(cpu)
disks = {}
for disk in self.dbobj.disks:
devname = disk.device_name
params = {
"capacity": PanMetric(disk.capacity, "GB"),
"interface": disk.controller_type
}
if disk.bootable:
params["boot"] = True
if disk.disk_type == 'local':
tpl = StructureTemplate(
("hardware/harddisk/generic/%s" % disk.controller_type),
params)
if disk.controller_type == 'cciss':
devname = "cciss/" + devname
elif disk.disk_type == 'virtual_disk':
share = disk.share
params["path"] = "%s/%s.vmdk" % (self.machine,
disk.device_name)
params["address"] = disk.address
params["sharename"] = share.name
params["server"] = share.server
params["mountpoint"] = share.mount
tpl = params
disks[PanEscape(devname)] = tpl
managers = {}
interfaces = {}
for interface in self.dbobj.interfaces:
path = "hardware/nic/%s/%s" % (interface.model.vendor,
interface.model)
if interface.interface_type == 'public':
ifinfo = {}
if interface.mac:
ifinfo["hwaddr"] = interface.mac
if interface.port_group:
ifinfo["port_group"] = interface.port_group
if interface.bootable:
ifinfo["boot"] = interface.bootable
interfaces[interface.name] = StructureTemplate(path, ifinfo)
elif interface.interface_type == 'management':
has_addr = False
for addr in interface.assignments:
has_addr = True
manager = {"hwaddr": interface.mac}
if addr.fqdns:
manager["fqdn"] = addr.fqdns[0]
managers[addr.logical_name] = manager
if not has_addr:
managers[interface.name] = {"hwaddr": interface.mac}
elif interface.interface_type == 'bonding':
# Bonding interfaces need an entry under /hardware/cards/nic
# only if the MAC address has been explicitely set
if interface.mac:
ifinfo = {"hwaddr": interface.mac}
interfaces[interface.name] = StructureTemplate(
path, ifinfo)
# Firstly, location
pan_assign(lines, "location", self.sysloc)
pan_assign(lines, "sysloc/building", self.building)
pan_assign(lines, "sysloc/city", self.city)
pan_assign(lines, "sysloc/continent", self.continent)
if self.rack:
pan_assign(lines, "rack/name", self.rack)
if self.rackrow:
pan_assign(lines, "rack/row", self.rackrow)
if self.rackcol:
pan_assign(lines, "rack/column", self.rackcol)
if self.room:
pan_assign(lines, "rack/room", self.room)
# And a chassis location?
if self.dbobj.chassis_slot:
slot = self.dbobj.chassis_slot[0]
pan_assign(lines, "chassis", slot.chassis.fqdn)
pan_assign(lines, "slot", slot.slot_number)
#if self.hub:
# pan_assign(lines, "sysloc/hub", self.hub)
if self.campus:
pan_assign(lines, "sysloc/campus", self.campus)
if self.bunker:
pan_assign(lines, "sysloc/bunker", self.bunker)
if self.dns_search_domains:
pan_assign(lines, "sysloc/dns_search_domains",
self.dns_search_domains)
# Now describe the hardware
lines.append("")
if self.dbobj.serial_no:
pan_assign(lines, "serialnumber", self.dbobj.serial_no)
pan_assign(lines, "nodename", self.machine)
pan_include(
lines, "hardware/machine/%s/%s" %
(self.dbobj.model.vendor.name, self.dbobj.model.name))
lines.append("")
pan_assign(lines, "ram", ram)
pan_assign(lines, "cpu", cpus)
if disks:
pan_assign(lines, "harddisks", disks)
if interfaces:
pan_assign(lines, "cards/nic", interfaces)
# /hardware/console/preferred must be set, so we can't assign to
# "/console" directly
for manager in sorted(managers.keys()):
pan_assign(lines, "console/%s" % manager, managers[manager])
def body_service_address(self, lines):
pan_assign(lines, "ip", str(self.dbobj.dns_record.ip))
pan_assign(lines, "fqdn", str(self.dbobj.dns_record.fqdn))
pan_assign(lines, "interfaces", self.dbobj.interfaces)
def add_location_info(lines, dblocation, prefix=""):
if dblocation.continent:
pan_assign(lines, prefix + "sysloc/continent", dblocation.continent.name)
if dblocation.city:
pan_assign(lines, prefix + "sysloc/city", dblocation.city.name)
if dblocation.building:
pan_assign(lines, prefix + "sysloc/building", dblocation.building.name)
# FIXME: add hub?
if dblocation.campus:
pan_assign(lines, prefix + "sysloc/campus", dblocation.campus.name)
if dblocation.bunker:
pan_assign(lines, prefix + "sysloc/bunker", dblocation.bunker.name)
if dblocation.rack:
pan_assign(lines, prefix + "rack/name", dblocation.rack.name)
if dblocation.rack_row:
pan_assign(lines, prefix + "rack/row", dblocation.rack_row)
if dblocation.rack_column:
pan_assign(lines, prefix + "rack/column", dblocation.rack_column)
if dblocation.room:
pan_assign(lines, prefix + "rack/room", dblocation.room.name)
def body_reboot_iv(self, lines):
pan_assign(lines, "name", self.dbobj.name)
pan_assign(lines, "justification", self.dbobj.justification)
self.body_intervention(lines)
def body(self, lines):
pan_assign(lines, "instance", self.name)
pan_assign(lines, "clients", self.dbobj.client_fqdns)
def body(self, lines):
pan_assign(lines, "name", self.dbobj.name)
fname = "body_%s" % self.dbobj.resource_type
if hasattr(self, fname):
getattr(self, fname)(lines)
def body(self, lines):
pan_assign(lines, "system/metacluster/name", self.name)
pan_assign(lines, "system/metacluster/type", self.dbobj.cluster_type)
dbloc = self.dbobj.location_constraint
pan_assign(lines, "system/metacluster/sysloc/location", dbloc.sysloc())
if dbloc.continent:
pan_assign(lines, "system/metacluster/sysloc/continent",
dbloc.continent.name)
if dbloc.city:
pan_assign(lines, "system/metacluster/sysloc/city", dbloc.city.name)
if dbloc.campus:
pan_assign(lines, "system/metacluster/sysloc/campus",
dbloc.campus.name)
## maintaining this so templates dont break
## during transtion period.. should be DEPRECATED
pan_assign(lines, "system/metacluster/campus", dbloc.campus.name)
if dbloc.building:
pan_assign(lines, "system/metacluster/sysloc/building",
dbloc.building.name)
if dbloc.room:
pan_assign(lines, "system/cluster/rack/room", dbloc.room)
if dbloc.bunker:
pan_assign(lines, "system/cluster/sysloc/bunker", dbloc.bunker.name)
if dbloc.rack:
pan_assign(lines, "system/metacluster/rack/row",
dbloc.rack.rack_row)
pan_assign(lines, "system/metacluster/rack/column",
dbloc.rack.rack_column)
pan_assign(lines, "system/metacluster/rack/name",
dbloc.rack.name)
lines.append("")
pan_assign(lines, "system/metacluster/members",
[member.name for member in self.dbobj.members])
lines.append("")
pan_assign(lines, "system/build", self.dbobj.status.name)
lines.append("")
if self.dbobj.resholder:
for resource in sorted(self.dbobj.resholder.resources):
pan_append(lines, "system/resources/" + resource.resource_type,
StructureTemplate(resource.template_base +
'/config'))
def body_share(self, lines):
pan_assign(lines, "server", self.dbobj.server)
pan_assign(lines, "mountpoint", self.dbobj.mount)
if self.dbobj.latency_threshold:
pan_assign(lines, "latency_threshold", self.dbobj.latency_threshold)
