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(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 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, ["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_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)