Source code for cobbler.items.system

from cobbler import autoinstall_manager
from cobbler.items import item
from cobbler import power_manager
from cobbler import utils
from cobbler import validate
from cobbler.cexceptions import CX
from cobbler.utils import _


# this data structure is described in item.py
FIELDS = [
    # non-editable in UI (internal)
    ["ctime", 0, 0, "", False, "", 0, "float"],
    ["depth", 2, 0, "", False, "", 0, "int"],
    ["ipv6_autoconfiguration", False, 0, "IPv6 Autoconfiguration", True, "", 0, "bool"],
    ["mtime", 0, 0, "", False, "", 0, "float"],
    ["repos_enabled", False, 0, "Repos Enabled", True, "(re)configure local repos on this machine at next config update?", 0, "bool"],
    ["uid", "", 0, "", False, "", 0, "str"],

    # editable in UI
    ["autoinstall", "<<inherit>>", 0, "Automatic Installation Template", True, "Path to automatic installation template", 0, "str"],
    ["autoinstall_meta", {}, 0, "Automatic Installation Template Metadata", True, "Ex: dog=fang agent=86", 0, "dict"],
    ["boot_files", {}, '<<inherit>>', "TFTP Boot Files", True, "Files copied into tftpboot beyond the kernel/initrd", 0, "list"],
    ["boot_loader", "<<inherit>>", 0, "Boot loader", True, "Linux installation boot loader", utils.get_supported_system_boot_loaders(), "str"],
    ["comment", "", 0, "Comment", True, "Free form text description", 0, "str"],
    ["enable_gpxe", "<<inherit>>", 0, "Enable gPXE?", True, "Use gPXE instead of PXELINUX for advanced booting options", 0, "bool"],
    ["fetchable_files", {}, '<<inherit>>', "Fetchable Files", True, "Templates for tftp or wget/curl", 0, "dict"],
    ["gateway", "", 0, "Gateway", True, "", 0, "str"],
    ["hostname", "", 0, "Hostname", True, "", 0, "str"],
    ["image", None, 0, "Image", True, "Parent image (if not a profile)", 0, "str"],
    ["ipv6_default_device", "", 0, "IPv6 Default Device", True, "", 0, "str"],
    ["kernel_options", {}, 0, "Kernel Options", True, "Ex: selinux=permissive", 0, "dict"],
    ["kernel_options_post", {}, 0, "Kernel Options (Post Install)", True, "Ex: clocksource=pit noapic", 0, "dict"],
    ["mgmt_classes", "<<inherit>>", 0, "Management Classes", True, "For external config management", 0, "list"],
    ["mgmt_parameters", "<<inherit>>", 0, "Management Parameters", True, "Parameters which will be handed to your management application (Must be valid YAML dictionary)", 0, "str"],
    ["name", "", 0, "Name", True, "Ex: vanhalen.example.org", 0, "str"],
    ["name_servers", [], 0, "Name Servers", True, "space delimited", 0, "list"],
    ["name_servers_search", [], 0, "Name Servers Search Path", True, "space delimited", 0, "list"],
    ["netboot_enabled", True, 0, "Netboot Enabled", True, "PXE (re)install this machine at next boot?", 0, "bool"],
    ["next_server", "<<inherit>>", 0, "Next Server Override", True, "See manpage or leave blank", 0, "str"],
    ["owners", "<<inherit>>", 0, "Owners", True, "Owners list for authz_ownership (space delimited)", 0, "list"],
    ["power_address", "", 0, "Power Management Address", True, "Ex: power-device.example.org", 0, "str"],
    ["power_id", "", 0, "Power Management ID", True, "Usually a plug number or blade name, if power type requires it", 0, "str"],
    ["power_pass", "", 0, "Power Management Password", True, "", 0, "str"],
    ["power_type", "SETTINGS:power_management_default_type", 0, "Power Management Type", True, "Power management script to use", power_manager.get_power_types(), "str"],
    ["power_user", "", 0, "Power Management Username", True, "", 0, "str"],
    ["power_options", "", 0, "Power Management Options", True, "Additional options, to be passed to the fencing agent", 0, "str"],
    ["power_identity_file", "", 0, "Power Identity File", True, "Identity file to be passed to the fencing agent (ssh key)", 0, "str"],
    ["profile", None, 0, "Profile", True, "Parent profile", [], "str"],
    ["proxy", "<<inherit>>", 0, "Internal Proxy", True, "Internal proxy URL", 0, "str"],
    ["redhat_management_key", "<<inherit>>", 0, "Redhat Management Key", True, "Registration key for RHN, Spacewalk, or Satellite", 0, "str"],
    ["server", "<<inherit>>", 0, "Server Override", True, "See manpage or leave blank", 0, "str"],
    ["status", "production", 0, "Status", True, "System status", ["", "development", "testing", "acceptance", "production"], "str"],
    ["template_files", {}, 0, "Template Files", True, "File mappings for built-in configuration management", 0, "dict"],
    ["virt_auto_boot", "<<inherit>>", 0, "Virt Auto Boot", True, "Auto boot this VM?", 0, "bool"],
    ["virt_cpus", "<<inherit>>", 0, "Virt CPUs", True, "", 0, "int"],
    ["virt_disk_driver", "<<inherit>>", 0, "Virt Disk Driver Type", True, "The on-disk format for the virtualization disk", validate.VIRT_DISK_DRIVERS, "str"],
    ["virt_file_size", "<<inherit>>", 0, "Virt File Size(GB)", True, "", 0, "float"],
    ["virt_path", "<<inherit>>", 0, "Virt Path", True, "Ex: /directory or VolGroup00", 0, "str"],
    ["virt_pxe_boot", 0, 0, "Virt PXE Boot", True, "Use PXE to build this VM?", 0, "bool"],
    ["virt_ram", "<<inherit>>", 0, "Virt RAM (MB)", True, "", 0, "int"],
    ["virt_type", "<<inherit>>", 0, "Virt Type", True, "Virtualization technology to use", validate.VIRT_TYPES, "str"],
    ["serial_device", "", 0, "Serial Device #", True, "Serial Device Number", 0, "int"],
    ["serial_baud_rate", "", 0, "Serial Baud Rate", True, "Serial Baud Rate", ["", "2400", "4800", "9600", "19200", "38400", "57600", "115200"], "int"],
]

# network interface fields are in a separate list because a system may contain
# several network interfaces and thus several values for each one of those fields
# (1-N cardinality), while it may contain only one value for other fields
# (1-1 cardinality). This difference requires special handling.
NETWORK_INTERFACE_FIELDS = [
    ["bonding_opts", "", 0, "Bonding Opts", True, "Should be used with --interface", 0, "str"],
    ["bridge_opts", "", 0, "Bridge Opts", True, "Should be used with --interface", 0, "str"],
    ["cnames", [], 0, "CNAMES", True, "Cannonical Name Records, should be used with --interface, In quotes, space delimited", 0, "list"],
    ["connected_mode", False, 0, "InfiniBand Connected Mode", True, "Should be used with --interface", 0, "bool"],
    ["dhcp_tag", "", 0, "DHCP Tag", True, "Should be used with --interface", 0, "str"],
    ["dns_name", "", 0, "DNS Name", True, "Should be used with --interface", 0, "str"],
    ["if_gateway", "", 0, "Per-Interface Gateway", True, "Should be used with --interface", 0, "str"],
    ["interface_master", "", 0, "Master Interface", True, "Should be used with --interface", 0, "str"],
    ["interface_type", "na", 0, "Interface Type", True, "Should be used with --interface", ["na", "bond", "bond_slave", "bridge", "bridge_slave", "bonded_bridge_slave", "bmc", "infiniband"], "str"],
    ["ip_address", "", 0, "IP Address", True, "Should be used with --interface", 0, "str"],
    ["ipv6_address", "", 0, "IPv6 Address", True, "Should be used with --interface", 0, "str"],
    ["ipv6_default_gateway", "", 0, "IPv6 Default Gateway", True, "Should be used with --interface", 0, "str"],
    ["ipv6_mtu", "", 0, "IPv6 MTU", True, "Should be used with --interface", 0, "str"],
    ["ipv6_prefix", "", 0, "IPv6 Prefix", True, "Should be used with --interface", 0, "str"],
    ["ipv6_secondaries", [], 0, "IPv6 Secondaries", True, "Space delimited. Should be used with --interface", 0, "list"],
    ["ipv6_static_routes", [], 0, "IPv6 Static Routes", True, "Should be used with --interface", 0, "list"],
    ["mac_address", "", 0, "MAC Address", True, "(Place \"random\" in this field for a random MAC Address.)", 0, "str"],
    ["management", False, 0, "Management Interface", True, "Is this the management interface? Should be used with --interface", 0, "bool"],
    ["mtu", "", 0, "MTU", True, "", 0, "str"],
    ["netmask", "", 0, "Subnet Mask", True, "Should be used with --interface", 0, "str"],
    ["static", False, 0, "Static", True, "Is this interface static? Should be used with --interface", 0, "bool"],
    ["static_routes", [], 0, "Static Routes", True, "Should be used with --interface", 0, "list"],
    ["virt_bridge", "", 0, "Virt Bridge", True, "Should be used with --interface", 0, "str"],
]


[docs]class System(item.Item): """ A Cobbler system object. """ TYPE_NAME = _("system") COLLECTION_TYPE = "system" def __init__(self, *args, **kwargs): super(System, self).__init__(*args, **kwargs) self.interfaces = dict() self.kernel_options = {} self.kernel_options_post = {} self.autoinstall_meta = {} self.fetchable_files = {} self.boot_files = {} self.template_files = {} # # override some base class methods first (item.Item) #
[docs] def get_fields(self): return FIELDS
[docs] def make_clone(self): _dict = self.to_dict() cloned = System(self.collection_mgr) cloned.from_dict(_dict) return cloned
[docs] def from_dict(self, seed_data): # FIXME: most definitely doesn't grok interfaces yet. return utils.from_dict_from_fields(self, seed_data, FIELDS)
[docs] def get_parent(self): """ Return object next highest up the tree. """ if (self.parent is None or self.parent == '') and self.profile: return self.collection_mgr.profiles().find(name=self.profile) elif (self.parent is None or self.parent == '') and self.image: return self.collection_mgr.images().find(name=self.image) else: return self.collection_mgr.systems().find(name=self.parent)
[docs] def check_if_valid(self): if self.name is None or self.name == "": raise CX("name is required") if self.profile is None or self.profile == "": if self.image is None or self.image == "": raise CX("Error with system %s - profile or image is required" % (self.name))
# # specific methods for item.System # def __create_interface(self, interface): self.interfaces[interface] = {} for field in NETWORK_INTERFACE_FIELDS: self.interfaces[interface][field[0]] = field[1] def __get_interface(self, name): if not name: name = "default" if name not in self.interfaces: self.__create_interface(name) return self.interfaces[name]
[docs] def delete_interface(self, name): """ Used to remove an interface. """ if name in self.interfaces and len(self.interfaces) > 1: del self.interfaces[name] else: if name not in self.interfaces: # no interface here to delete pass else: raise CX(_("At least one interface needs to be defined."))
[docs] def rename_interface(self, names): """ Used to rename an interface. """ (name, newname) = names if name not in self.interfaces: raise CX(_("Interface %s does not exist" % name)) if newname in self.interfaces: raise CX(_("Interface %s already exists" % newname)) else: self.interfaces[newname] = self.interfaces[name] del self.interfaces[name]
[docs] def set_boot_loader(self, name): if name not in utils.get_supported_system_boot_loaders(): raise CX(_("Invalid boot loader name: %s" % name)) self.boot_loader = name
[docs] def set_server(self, server): """ If a system can't reach the boot server at the value configured in settings because it doesn't have the same name on it's subnet this is there for an override. """ if server is None or server == "": server = "<<inherit>>" self.server = server
[docs] def set_next_server(self, server): if server is None or server == "" or server == "<<inherit>>": self.next_server = "<<inherit>>" else: server = server.strip() self.next_server = validate.ipv4_address(server)
[docs] def set_proxy(self, proxy): if proxy is None or proxy == "": proxy = "<<inherit>>" self.proxy = proxy
[docs] def set_redhat_management_key(self, management_key): if management_key is None or management_key == "": self.redhat_management_key = "<<inherit>>" self.redhat_management_key = management_key
[docs] def get_redhat_management_key(self): return self.redhat_management_key
[docs] def get_mac_address(self, interface): """ Get the mac address, which may be implicit in the object name or explicit with --mac-address. Use the explicit location first. """ intf = self.__get_interface(interface) if intf["mac_address"] != "": return intf["mac_address"].strip() else: return None
[docs] def get_ip_address(self, interface): """ Get the IP address for the given interface. """ intf = self.__get_interface(interface) if intf["ip_address"] != "": return intf["ip_address"].strip() else: return ""
[docs] def is_management_supported(self, cidr_ok=True): """ Can only add system PXE records if a MAC or IP address is available, else it's a koan only record. """ if self.name == "default": return True for (name, x) in list(self.interfaces.items()): mac = x.get("mac_address", None) ip = x.get("ip_address", None) if ip is not None and not cidr_ok and ip.find("/") != -1: # ip is in CIDR notation return False if mac is not None or ip is not None: # has ip and/or mac return True return False
[docs] def set_dhcp_tag(self, dhcp_tag, interface): intf = self.__get_interface(interface) intf["dhcp_tag"] = dhcp_tag
[docs] def set_cnames(self, cnames, interface): intf = self.__get_interface(interface) data = utils.input_string_or_list(cnames) intf["cnames"] = data
[docs] def set_static_routes(self, routes, interface): intf = self.__get_interface(interface) data = utils.input_string_or_list(routes) intf["static_routes"] = data
[docs] def set_status(self, status): self.status = status
[docs] def set_static(self, truthiness, interface): intf = self.__get_interface(interface) intf["static"] = utils.input_boolean(truthiness)
[docs] def set_management(self, truthiness, interface): intf = self.__get_interface(interface) intf["management"] = utils.input_boolean(truthiness)
# ---
[docs] def set_dns_name(self, dns_name, interface): """ Set DNS name for interface. @param: str dns_name (dns name) @param: str interface (interface name) @returns: True or CX """ dns_name = validate.hostname(dns_name) if dns_name != "" and utils.input_boolean(self.collection_mgr._settings.allow_duplicate_hostnames) is False: matched = self.collection_mgr.api.find_items("system", {"dns_name": dns_name}) for x in matched: if x.name != self.name: raise CX("DNS name duplicated: %s" % dns_name) intf = self.__get_interface(interface) intf["dns_name"] = dns_name
[docs] def set_hostname(self, hostname): """ Set hostname. @param: str hostname (hostname for system) @returns: True or CX """ self.hostname = validate.hostname(hostname)
[docs] def set_ip_address(self, address, interface): """ Set IPv4 address on interface. @param: str address (ip address) @param: str interface (interface name) @returns: True or CX """ address = validate.ipv4_address(address) if address != "" and utils.input_boolean(self.collection_mgr._settings.allow_duplicate_ips) is False: matched = self.collection_mgr.api.find_items("system", {"ip_address": address}) for x in matched: if x.name != self.name: raise CX("IP address duplicated: %s" % address) intf = self.__get_interface(interface) intf["ip_address"] = address
[docs] def set_mac_address(self, address, interface): """ Set mac address on interface. @param: str address (mac address) @param: str interface (interface name) @returns: True or CX """ address = validate.mac_address(address) if address == "random": address = utils.get_random_mac(self.collection_mgr.api) if address != "" and utils.input_boolean(self.collection_mgr._settings.allow_duplicate_macs) is False: matched = self.collection_mgr.api.find_items("system", {"mac_address": address}) for x in matched: if x.name != self.name: raise CX("MAC address duplicated: %s" % address) intf = self.__get_interface(interface) intf["mac_address"] = address
[docs] def set_gateway(self, gateway): """ Set a gateway IPv4 address. @param: str gateway (ip address) @returns: True or CX """ self.gateway = validate.ipv4_address(gateway)
[docs] def set_name_servers(self, data): """ Set the DNS servers. @param: str/list data (string or list of nameservers) @returns: True or CX """ self.name_servers = validate.name_servers(data)
[docs] def set_netmask(self, netmask, interface): """ Set the netmask for given interface. @param: str netmask (netmask) @param: str interface (interface name) @returns: True or CX """ intf = self.__get_interface(interface) intf["netmask"] = validate.ipv4_netmask(netmask)
[docs] def set_if_gateway(self, gateway, interface): """ Set the per-interface gateway. @param: str gateway (ipv4 address for the gateway) @param: str interface (interface name) @returns: True or CX """ intf = self.__get_interface(interface) intf["if_gateway"] = validate.ipv4_address(gateway)
# --
[docs] def set_virt_bridge(self, bridge, interface): if bridge == "": bridge = self.settings.default_virt_bridge intf = self.__get_interface(interface) intf["virt_bridge"] = bridge
[docs] def set_interface_type(self, type, interface): interface_types = ["bridge", "bridge_slave", "bond", "bond_slave", "bonded_bridge_slave", "bmc", "na", "infiniband", ""] if type not in interface_types: raise CX(_("interface type value must be one of: %s or blank" % ",".join(interface_types))) if type == "na": type = "" intf = self.__get_interface(interface) intf["interface_type"] = type
[docs] def set_interface_master(self, interface_master, interface): intf = self.__get_interface(interface) intf["interface_master"] = interface_master
[docs] def set_bonding_opts(self, bonding_opts, interface): intf = self.__get_interface(interface) intf["bonding_opts"] = bonding_opts
[docs] def set_bridge_opts(self, bridge_opts, interface): intf = self.__get_interface(interface) intf["bridge_opts"] = bridge_opts
[docs] def set_ipv6_autoconfiguration(self, truthiness): self.ipv6_autoconfiguration = utils.input_boolean(truthiness)
[docs] def set_ipv6_default_device(self, interface_name): if interface_name is None: interface_name = "" self.ipv6_default_device = interface_name
[docs] def set_ipv6_address(self, address, interface): """ Set IPv6 address on interface. @param: str address (ip address) @param: str interface (interface name) @returns: True or CX """ address = validate.ipv6_address(address) if address != "" and utils.input_boolean(self.collection_mgr._settings.allow_duplicate_ips) is False: matched = self.collection_mgr.api.find_items("system", {"ipv6_address": address}) for x in matched: if x.name != self.name: raise CX("IP address duplicated: %s" % address) intf = self.__get_interface(interface) intf["ipv6_address"] = address
[docs] def set_ipv6_prefix(self, prefix, interface): """ Assign a IPv6 prefix """ intf = self.__get_interface(interface) intf["ipv6_prefix"] = prefix.strip()
[docs] def set_ipv6_secondaries(self, addresses, interface): intf = self.__get_interface(interface) data = utils.input_string_or_list(addresses) secondaries = [] for address in data: if address == "" or utils.is_ip(address): secondaries.append(address) else: raise CX(_("invalid format for IPv6 IP address (%s)") % address) intf["ipv6_secondaries"] = secondaries
[docs] def set_ipv6_default_gateway(self, address, interface): intf = self.__get_interface(interface) if address == "" or utils.is_ip(address): intf["ipv6_default_gateway"] = address.strip() return raise CX(_("invalid format for IPv6 IP address (%s)") % address)
[docs] def set_ipv6_static_routes(self, routes, interface): intf = self.__get_interface(interface) data = utils.input_string_or_list(routes) intf["ipv6_static_routes"] = data
[docs] def set_ipv6_mtu(self, mtu, interface): intf = self.__get_interface(interface) intf["ipv6_mtu"] = mtu
[docs] def set_mtu(self, mtu, interface): intf = self.__get_interface(interface) intf["mtu"] = mtu
[docs] def set_connected_mode(self, truthiness, interface): intf = self.__get_interface(interface) intf["connected_mode"] = utils.input_boolean(truthiness)
[docs] def set_enable_gpxe(self, enable_gpxe): """ Sets whether or not the system will use gPXE for booting. """ self.enable_gpxe = utils.input_boolean(enable_gpxe)
[docs] def set_profile(self, profile_name): """ Set the system to use a certain named profile. The profile must have already been loaded into the Profiles collection. """ old_parent = self.get_parent() if profile_name in ["delete", "None", "~", ""] or profile_name is None: self.profile = "" if isinstance(old_parent, item.Item): old_parent.children.pop(self.name, 'pass') return self.image = "" # mutual exclusion rule p = self.collection_mgr.profiles().find(name=profile_name) if p is not None: self.profile = profile_name self.depth = p.depth + 1 # subprofiles have varying depths. if isinstance(old_parent, item.Item): old_parent.children.pop(self.name, 'pass') new_parent = self.get_parent() if isinstance(new_parent, item.Item): new_parent.children[self.name] = self return raise CX(_("invalid profile name: %s") % profile_name)
[docs] def set_image(self, image_name): """ Set the system to use a certain named image. Works like set_profile but cannot be used at the same time. It's one or the other. """ old_parent = self.get_parent() if image_name in ["delete", "None", "~", ""] or image_name is None: self.image = "" if isinstance(old_parent, item.Item): old_parent.children.pop(self.name, 'pass') return self.profile = "" # mutual exclusion rule img = self.collection_mgr.images().find(name=image_name) if img is not None: self.image = image_name self.depth = img.depth + 1 if isinstance(old_parent, item.Item): old_parent.children.pop(self.name, 'pass') new_parent = self.get_parent() if isinstance(new_parent, item.Item): new_parent.children[self.name] = self return raise CX(_("invalid image name (%s)") % image_name)
[docs] def set_virt_cpus(self, num): return utils.set_virt_cpus(self, num)
[docs] def set_virt_file_size(self, num): return utils.set_virt_file_size(self, num)
[docs] def set_virt_disk_driver(self, driver): return utils.set_virt_disk_driver(self, driver)
[docs] def set_virt_auto_boot(self, num): return utils.set_virt_auto_boot(self, num)
[docs] def set_virt_pxe_boot(self, num): return utils.set_virt_pxe_boot(self, num)
[docs] def set_virt_ram(self, num): return utils.set_virt_ram(self, num)
[docs] def set_virt_type(self, vtype): return utils.set_virt_type(self, vtype)
[docs] def set_virt_path(self, path): return utils.set_virt_path(self, path, for_system=True)
[docs] def set_netboot_enabled(self, netboot_enabled): """ If true, allows per-system PXE files to be generated on sync (or add). If false, these files are not generated, thus eliminating the potential for an infinite install loop when systems are set to PXE boot first in the boot order. In general, users who are PXE booting first in the boot order won't create system definitions, so this feature primarily comes into play for programmatic users of the API, who want to initially create a system with netboot enabled and then disable it after the system installs, as triggered by some action in automatic installation file's %post section. For this reason, this option is not urfaced in the CLI, output, or documentation (yet). Use of this option does not affect the ability to use PXE menus. If an admin has machines set up to PXE only after local boot fails, this option isn't even relevant. """ self.netboot_enabled = utils.input_boolean(netboot_enabled)
[docs] def set_autoinstall(self, autoinstall): """ Set the automatic installation template filepath, this must be a local file. @param str local automatic installation template file path """ autoinstall_mgr = autoinstall_manager.AutoInstallationManager(self.collection_mgr) self.autoinstall = autoinstall_mgr.validate_autoinstall_template_file_path(autoinstall)
[docs] def set_power_type(self, power_type): if power_type is None: power_type = "" power_manager.validate_power_type(power_type) self.power_type = power_type
[docs] def set_power_identity_file(self, power_identity_file): if power_identity_file is None: power_identity_file = "" utils.safe_filter(power_identity_file) self.power_identity_file = power_identity_file
[docs] def set_power_options(self, power_options): if power_options is None: power_options = "" utils.safe_filter(power_options) self.power_options = power_options
[docs] def set_power_user(self, power_user): if power_user is None: power_user = "" utils.safe_filter(power_user) self.power_user = power_user
[docs] def set_power_pass(self, power_pass): if power_pass is None: power_pass = "" utils.safe_filter(power_pass) self.power_pass = power_pass
[docs] def set_power_address(self, power_address): if power_address is None: power_address = "" utils.safe_filter(power_address) self.power_address = power_address
[docs] def set_power_id(self, power_id): if power_id is None: power_id = "" utils.safe_filter(power_id) self.power_id = power_id
[docs] def modify_interface(self, _dict): """ Used by the WUI to modify an interface more-efficiently """ for (key, value) in list(_dict.items()): (field, interface) = key.split("-", 1) field = field.replace("_", "").replace("-", "") if field == "bondingopts": self.set_bonding_opts(value, interface) if field == "bridgeopts": self.set_bridge_opts(value, interface) if field == "connected_mode": self.set_connected_mode(value, interface) if field == "cnames": self.set_cnames(value, interface) if field == "dhcptag": self.set_dhcp_tag(value, interface) if field == "dnsname": self.set_dns_name(value, interface) if field == "ifgateway": self.set_if_gateway(value, interface) if field == "interfacetype": self.set_interface_type(value, interface) if field == "interfacemaster": self.set_interface_master(value, interface) if field == "ipaddress": self.set_ip_address(value, interface) if field == "ipv6address": self.set_ipv6_address(value, interface) if field == "ipv6defaultgateway": self.set_ipv6_default_gateway(value, interface) if field == "ipv6mtu": self.set_ipv6_mtu(value, interface) if field == "ipv6prefix": self.set_ipv6_prefix(value, interface) if field == "ipv6secondaries": self.set_ipv6_secondaries(value, interface) if field == "ipv6staticroutes": self.set_ipv6_static_routes(value, interface) if field == "macaddress": self.set_mac_address(value, interface) if field == "management": self.set_management(value, interface) if field == "mtu": self.set_mtu(value, interface) if field == "netmask": self.set_netmask(value, interface) if field == "static": self.set_static(value, interface) if field == "staticroutes": self.set_static_routes(value, interface) if field == "virtbridge": self.set_virt_bridge(value, interface)
[docs] def set_repos_enabled(self, repos_enabled): self.repos_enabled = utils.input_boolean(repos_enabled)
[docs] def set_serial_device(self, device_number): return utils.set_serial_device(self, device_number)
[docs] def set_serial_baud_rate(self, baud_rate): return utils.set_serial_baud_rate(self, baud_rate)
[docs] def get_config_filename(self, interface, loader=None): """ The configuration file for each system pxe uses is either a form of the MAC address of the hex version of the IP. If none of that is available, just use the given name, though the name given will be unsuitable for PXE configuration (For this, check system.is_management_supported()). This same file is used to store system config information in the Apache tree, so it's still relevant. :param loader: Bootloader type. :type loader: str :param interface: Name of the interface. :type interface: str """ if loader is None: loader = self.boot_loader if interface not in self.interfaces: return None if self.name == "default": if loader == "grub": return None return "default" mac = self.get_mac_address(interface) ip = self.get_ip_address(interface) if mac is not None and mac != "": if loader == "grub": return mac.lower() else: return "01-" + "-".join(mac.split(":")).lower() elif ip is not None and ip != "": return utils.get_host_ip(ip) else: return self.name
# EOF