def test_fail_upd_bootable_iface_to_null_mac():
machine = sess.query(Machine).first()
iface = Interface(hardware_entity=machine, name='eth1', mac=random_mac(),
bootable=True, interface_type='public')
create(sess, iface)
assert isinstance(iface, Interface), 'no iface created @ %s' % func_name()
iface.mac = None
commit(sess)
assert iface.mac is not None, 'able to set a bootable interface to null'
def test_fail_upd_mgmt_iface_to_null_mac():
machine = sess.query(Machine).first()
iface = Interface(hardware_entity=machine, name='ipmi', mac=random_mac(),
bootable=True, interface_type='management')
create(sess, iface)
assert isinstance(iface, Interface), 'no iface created @ %s' % func_name()
iface.mac = None
commit(sess)
assert iface.mac is not None, 'set a management iface to null mac_addr'
def test_fail_upd_bootable_iface_to_null_mac():
machine = sess.query(Machine).first()
iface = Interface(hardware_entity=machine,
name='eth1',
mac=random_mac(),
bootable=True,
interface_type='public')
create(sess, iface)
assert isinstance(iface, Interface), 'no iface created @ %s' % func_name()
iface.mac = None
commit(sess)
assert iface.mac is not None, 'able to set a bootable interface to null'
def test_fail_upd_mgmt_iface_to_null_mac():
machine = sess.query(Machine).first()
iface = Interface(hardware_entity=machine,
name='ipmi',
mac=random_mac(),
bootable=True,
interface_type='management')
create(sess, iface)
assert isinstance(iface, Interface), 'no iface created @ %s' % func_name()
iface.mac = None
commit(sess)
assert iface.mac is not None, 'set a management iface to null mac_addr'
def render(self, session, logger, interface, chassis, mac, comments,
rename_to, **arguments):
for arg in self.invalid_parameters:
if arguments.get(arg) is not None:
raise UnimplementedError("update_interface --chassis cannot use "
"the --%s option." % arg)
dbchassis = Chassis.get_unique(session, chassis, compel=True)
dbinterface = Interface.get_unique(session, hardware_entity=dbchassis,
name=interface, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbchassis)
if comments:
dbinterface.comments = comments
if mac:
dbinterface.mac = mac
if rename_to:
rename_interface(session, dbinterface, rename_to)
session.flush()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbchassis, oldinfo)
dsdb_runner.commit_or_rollback("Could not update chassis in DSDB")
return
def add_interfaces(session):
""" Add a default interface for all HW that has an IP """
q = session.query(HardwareEntity)
q = q.filter(~exists().where(Interface.hardware_entity_id == HardwareEntity.id))
q = q.outerjoin(PrimaryNameAssociation, System, DnsDomain)
q = q.options(contains_eager('_primary_name_asc'))
q = q.options(contains_eager('_primary_name_asc.dns_record'))
q = q.options(contains_eager('_primary_name_asc.dns_record.dns_domain'))
q = q.filter(System.ip != None)
hws = q.all()
count = 0
for hw in hws:
if hw.hardware_type == "machine":
interface = "eth0"
itype = "public"
elif hw.hardware_type == "switch":
interface = "xge"
itype = "oa"
else:
interface = "oa"
itype = "oa"
#print "Adding default interface for {0:l}".format(hw)
dbinterface = Interface(hardware_entity=hw, name=interface,
interface_type="oa",
comments="Created automatically by upgrade script")
session.add(dbinterface)
count += 1
session.flush()
print "Added %d interfaces" % count
def test_create_iface():
machine = sess.query(Machine).first()
iface = Interface(hardware_entity=machine,
name='eth0',
mac=random_mac(),
bootable=True,
interface_type='public')
create(sess, iface)
assert isinstance(iface, Interface), 'no iface created @ %s' % func_name()
def render(self, session, logger, interface, machine, mac, model, vendor,
boot, pg, autopg, comments, master, clear_master, default_route,
rename_to, **arguments):
"""This command expects to locate an interface based only on name
and machine - all other fields, if specified, are meant as updates.
If the machine has a host, dsdb may need to be updated.
The boot flag can *only* be set to true. This is mostly technical,
as at this point in the interface it is difficult to tell if the
flag was unset or set to false. However, it also vastly simplifies
the dsdb logic - we never have to worry about a user trying to
remove the boot flag from a host in dsdb.
"""
audit_results = []
dbhw_ent = Machine.get_unique(session, machine, compel=True)
dbinterface = Interface.get_unique(session, hardware_entity=dbhw_ent,
name=interface, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
if arguments.get('hostname', None):
# Hack to set an intial interface for an aurora host...
dbhost = dbhw_ent.host
if dbhost.archetype.name == 'aurora' and \
dbhw_ent.primary_ip and not dbinterface.addresses:
assign_address(dbinterface, dbhw_ent.primary_ip,
dbhw_ent.primary_name.network, logger=logger)
# We may need extra IP verification (or an autoip option)...
# This may also throw spurious errors if attempting to set the
# port_group to a value it already has.
if pg is not None and dbinterface.port_group != pg.lower().strip():
dbinterface.port_group = verify_port_group(
dbinterface.hardware_entity, pg)
elif autopg:
dbinterface.port_group = choose_port_group(
session, logger, dbinterface.hardware_entity)
audit_results.append(('pg', dbinterface.port_group))
if master:
if dbinterface.addresses:
# FIXME: as a special case, if the only address is the
# primary IP, then we could just move it to the master
# interface. However this can be worked around by bonding
# the interface before calling "add host", so don't bother
# for now.
raise ArgumentError("Can not enslave {0:l} because it has "
"addresses.".format(dbinterface))
dbmaster = Interface.get_unique(session, hardware_entity=dbhw_ent,
name=master, compel=True)
if dbmaster in dbinterface.all_slaves():
raise ArgumentError("Enslaving {0:l} would create a circle, "
"which is not allowed.".format(dbinterface))
dbinterface.master = dbmaster
if clear_master:
if not dbinterface.master:
raise ArgumentError("{0} is not a slave.".format(dbinterface))
dbinterface.master = None
if comments:
dbinterface.comments = comments
if boot:
# Figure out if the current bootble interface also has the
# default route set; the new bootable interface probably
# wants to have the same settings. Note that if
# old_default_route is None there was no bootable interface.
old_default_route = None
for i in dbhw_ent.interfaces:
if i.bootable == True:
old_default_route = i.default_route
break
# Apply the bootable flag to the supplied interface, clearing
# it on all other interfaces.
for i in dbhw_ent.interfaces:
if i == dbinterface:
i.bootable = True
else:
i.bootable = False
# If the user was not explicit about the default route flag
# (default_route is None); there was an existing bootable
# interface (old_default_route is not None); the new default
# route setting differs from the old - then produce a warning.
if (default_route is None and
old_default_route is not None and
dbinterface.default_route != old_default_route):
if old_default_route:
logger.client_info("Warning: New boot interface {0} is no "
"longer provides the default route; it "
"did before!".format(dbinterface))
else:
logger.client_info("Warning: New boot interface {0} now "
"provides the default route; it didn't "
"before!".format(dbinterface))
# Should we also transfer the primary IP to the new boot interface?
# That could get tricky if the new interface already has an IP
# address...
if default_route is not None:
dbinterface.default_route = default_route
if not first_of(dbhw_ent.interfaces, lambda x: x.default_route):
logger.client_info("Warning: {0:l} has no default route, hope "
"that's ok.".format(dbhw_ent))
#Set this mac address last so that you can update to a bootable
#interface *before* adding a mac address. This is so the validation
#that takes place in the interface class doesn't have to be worried
#about the order of update to bootable=True and mac address
if mac:
q = session.query(Interface).filter_by(mac=mac)
other = q.first()
if other and other != dbinterface:
raise ArgumentError("MAC address {0} is already in use by "
"{1:l}.".format(mac, other))
dbinterface.mac = mac
if model or vendor:
if not dbinterface.model_allowed:
raise ArgumentError("Model/vendor can not be set for a {0:lc}."
.format(dbinterface))
dbmodel = Model.get_unique(session, name=model, vendor=vendor,
model_type=NicType.Nic, compel=True)
dbinterface.model = dbmodel
if rename_to:
rename_interface(session, dbinterface, rename_to)
session.flush()
plenaries = PlenaryCollection(logger=logger)
plenaries.append(Plenary.get_plenary(dbhw_ent))
# Interface renaming affects the host and service addresses
if dbhw_ent.host:
plenaries.append(Plenary.get_plenary(dbhw_ent.host))
for addr in dbinterface.assignments:
if addr.service_address:
plenaries.append(Plenary.get_plenary(addr.service_address))
with plenaries.get_key():
try:
plenaries.write(locked=True)
if dbhw_ent.host and dbhw_ent.host.archetype.name != "aurora":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback()
except AquilonError, err:
plenaries.restore_stash()
raise ArgumentError(err)
except:
def render(
self,
session,
logger,
machine,
chassis,
switch,
interface,
fqdn,
ip,
label,
keep_dns,
network_environment,
**kwargs
):
if machine:
hwtype = "machine"
hwname = machine
elif chassis:
hwtype = "chassis"
hwname = chassis
elif switch:
hwtype = "switch"
hwname = switch
dbhw_ent = HardwareEntity.get_unique(session, hwname, hardware_type=hwtype, compel=True)
dbinterface = Interface.get_unique(session, hardware_entity=dbhw_ent, name=interface, compel=True)
dbnet_env = NetworkEnvironment.get_unique_or_default(session, network_environment)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
if fqdn:
dbdns_rec = ARecord.get_unique(session, fqdn=fqdn, dns_environment=dbnet_env.dns_environment, compel=True)
ip = dbdns_rec.ip
addr = None
if ip:
addr = first_of(dbinterface.assignments, lambda x: x.ip == ip)
if not addr:
raise ArgumentError("{0} does not have IP address {1} assigned to " "it.".format(dbinterface, ip))
elif label is not None:
addr = first_of(dbinterface.assignments, lambda x: x.label == label)
if not addr:
raise ArgumentError("{0} does not have an address with label " "{1}.".format(dbinterface, label))
if not addr:
raise ArgumentError("Please specify the address to be removed " "using either --ip, --label, or --fqdn.")
dbnetwork = addr.network
ip = addr.ip
if dbnetwork.network_environment != dbnet_env:
raise ArgumentError(
"The specified address lives in {0:l}, not in "
"{1:l}. Use the --network_environment option "
"to select the correct environment.".format(dbnetwork.network_environment, dbnet_env)
)
# Forbid removing the primary name
if ip == dbhw_ent.primary_ip:
raise ArgumentError("The primary IP address of a hardware entity " "cannot be removed.")
dbinterface.assignments.remove(addr)
# Check if the address was assigned to multiple interfaces, and remove
# the DNS entries if this was the last use
q = session.query(AddressAssignment)
q = q.filter_by(network=dbnetwork)
q = q.filter_by(ip=ip)
other_uses = q.all()
if not other_uses and not keep_dns:
q = session.query(ARecord)
q = q.filter_by(network=dbnetwork)
q = q.filter_by(ip=ip)
q = q.join(ARecord.fqdn)
q = q.filter_by(dns_environment=dbnet_env.dns_environment)
map(delete_dns_record, q.all())
session.flush()
dbhost = getattr(dbhw_ent, "host", None)
if dbhost:
plenary_info = PlenaryHost(dbhost, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
try:
plenary_info.write(locked=True)
except IncompleteError:
# FIXME: if this command is used after "add host" but before
# "make", then writing out the template will fail due to
# required services not being assigned. Ignore this error
# for now.
plenary_info.restore_stash()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbhw_ent, oldinfo)
if not other_uses and keep_dns:
q = session.query(ARecord)
q = q.filter_by(network=dbnetwork)
q = q.filter_by(ip=ip)
dbdns_rec = q.first()
dsdb_runner.add_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
except:
plenary_info.restore_stash()
raise
finally:
lock_queue.release(key)
else:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
return
def render(self, session, logger, machine, chassis, switch, interface,
fqdn, ip, label, keep_dns, network_environment, **kwargs):
if machine:
hwtype = 'machine'
hwname = machine
elif chassis:
hwtype = 'chassis'
hwname = chassis
elif switch:
hwtype = 'switch'
hwname = switch
dbhw_ent = HardwareEntity.get_unique(session,
hwname,
hardware_type=hwtype,
compel=True)
dbinterface = Interface.get_unique(session,
hardware_entity=dbhw_ent,
name=interface,
compel=True)
dbnet_env = NetworkEnvironment.get_unique_or_default(
session, network_environment)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
if fqdn:
dbdns_rec = ARecord.get_unique(
session,
fqdn=fqdn,
dns_environment=dbnet_env.dns_environment,
compel=True)
ip = dbdns_rec.ip
addr = None
if ip:
addr = first_of(dbinterface.assignments, lambda x: x.ip == ip)
if not addr:
raise ArgumentError(
"{0} does not have IP address {1} assigned to "
"it.".format(dbinterface, ip))
elif label is not None:
addr = first_of(dbinterface.assignments,
lambda x: x.label == label)
if not addr:
raise ArgumentError("{0} does not have an address with label "
"{1}.".format(dbinterface, label))
if not addr:
raise ArgumentError("Please specify the address to be removed "
"using either --ip, --label, or --fqdn.")
dbnetwork = addr.network
ip = addr.ip
if dbnetwork.network_environment != dbnet_env:
raise ArgumentError("The specified address lives in {0:l}, not in "
"{1:l}. Use the --network_environment option "
"to select the correct environment.".format(
dbnetwork.network_environment, dbnet_env))
# Forbid removing the primary name
if ip == dbhw_ent.primary_ip:
raise ArgumentError("The primary IP address of a hardware entity "
"cannot be removed.")
dbinterface.assignments.remove(addr)
# Check if the address was assigned to multiple interfaces, and remove
# the DNS entries if this was the last use
q = session.query(AddressAssignment)
q = q.filter_by(network=dbnetwork)
q = q.filter_by(ip=ip)
other_uses = q.all()
if not other_uses and not keep_dns:
q = session.query(ARecord)
q = q.filter_by(network=dbnetwork)
q = q.filter_by(ip=ip)
q = q.join(ARecord.fqdn)
q = q.filter_by(dns_environment=dbnet_env.dns_environment)
map(delete_dns_record, q.all())
session.flush()
dbhost = getattr(dbhw_ent, "host", None)
if dbhost:
plenary_info = PlenaryHost(dbhost, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
try:
plenary_info.write(locked=True)
except IncompleteError:
# FIXME: if this command is used after "add host" but before
# "make", then writing out the template will fail due to
# required services not being assigned. Ignore this error
# for now.
plenary_info.restore_stash()
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbhw_ent, oldinfo)
if not other_uses and keep_dns:
q = session.query(ARecord)
q = q.filter_by(network=dbnetwork)
q = q.filter_by(ip=ip)
dbdns_rec = q.first()
dsdb_runner.add_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
except:
plenary_info.restore_stash()
raise
finally:
lock_queue.release(key)
else:
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
return
def get_or_create_interface(session, dbhw_ent, name=None, mac=None,
model=None, vendor=None,
interface_type='public', bootable=None,
preclude=False, port_group=None, comments=None):
"""
Look up an existing interface or create a new one.
If either the name or the MAC address is given and a matching interface
exists, then that interface is returned and the other parameters are not
checked.
If neither the name nor the MAC address is given, but there is just one
existing interface matching the specified interface_type/bootable/port_group
combination, then that interface is returned. If there are multiple matches,
an exception is raised.
If no interfaces were found, and enough parameters are provided, then a new
interface is created. For this purpose, at least the name and in some cases
the MAC address must be specified.
Setting preclude to True enforces the creation of a new interface. An error
is raised if a conflicting interface already exists.
"""
dbinterface = None
if mac:
# Look for the MAC globally. If it is present, check that it belongs to
# the right hardware, and that it does not conflict with the name (if
# any).
q = session.query(Interface)
q = q.filter_by(mac=mac)
dbinterface = q.first()
if dbinterface and (dbinterface.hardware_entity != dbhw_ent or
(name and dbinterface.name != name)):
raise ArgumentError("MAC address %s is already in use: %s." %
(mac, describe_interface(session,
dbinterface)))
if name and not dbinterface:
# Special logic to allow "add_interface" to succeed if there is an
# auto-created interface already
if preclude and len(dbhw_ent.interfaces) == 1:
dbinterface = dbhw_ent.interfaces[0]
if dbinterface.mac is None and \
dbinterface.interface_type == interface_type and \
dbinterface.comments is not None and \
dbinterface.comments.startswith("Created automatically"):
dbinterface.name = name
dbinterface.mac = mac
if hasattr(dbinterface, "bootable") and bootable is not None:
dbinterface.bootable = bootable
dbinterface.comments = comments
if hasattr(dbinterface, "port_group"):
dbinterface.port_group = port_group
session.flush()
return dbinterface
dbinterface = None
for iface in dbhw_ent.interfaces:
if iface.name == name:
dbinterface = iface
break
if not name and not mac:
# Time for guessing. If neither the name nor the MAC was given, then
# there is no guarantee of uniqueness, but we can still return something
# useful if e.g. there is just one management interface.
interfaces = []
for iface in dbhw_ent.interfaces:
if iface.interface_type != interface_type:
continue
if bootable is not None and (not hasattr(iface, "bootable") or
iface.bootable != bootable):
continue
if port_group is not None and (not hasattr(iface, "port_group") or
iface.port_group != port_group):
continue
interfaces.append(iface)
if len(interfaces) > 1:
type_msg = _type_msg(interface_type, bootable)
raise ArgumentError("{0} has multiple {1} interfaces, please "
"specify which one to "
"use.".format(dbhw_ent, type_msg))
elif interfaces:
dbinterface = interfaces[0]
else:
dbinterface = None
if dbinterface:
if preclude:
raise ArgumentError("{0} already exists.".format(dbinterface))
return dbinterface
# No suitable interface was found, try to create a new one
if not name:
# Not enough information to create it
type_msg = _type_msg(interface_type, bootable)
raise ArgumentError("{0} has no {1} interfaces.".format(dbhw_ent,
type_msg))
cls = Interface.polymorphic_subclass(interface_type,
"Invalid interface type")
extra_args = {}
default_route = False
if bootable is not None:
extra_args["bootable"] = bootable
default_route = bootable
if port_group is not None:
extra_args["port_group"] = port_group
if not model and not vendor:
dbmodel = dbhw_ent.model.nic_model
elif not cls.model_allowed:
raise ArgumentError("Model/vendor can not be set for a %s." %
cls._get_class_label(tolower=True))
else:
dbmodel = Model.get_unique(session, name=model, vendor=vendor,
machine_type="nic", compel=True)
# VLAN interfaces need some special handling
if interface_type == 'vlan':
result = _vlan_re.match(name)
if not result:
raise ArgumentError("Invalid VLAN interface name '%s'." % name)
parent_name = result.groups()[0]
vlan_id = int(result.groups()[1])
dbparent = None
for iface in dbhw_ent.interfaces:
if iface.name == parent_name:
dbparent = iface
break
if not dbparent:
raise ArgumentError("Parent interface %s for VLAN interface %s "
"does not exist, please create it first." %
(parent_name, name))
extra_args["parent"] = dbparent
extra_args["vlan_id"] = vlan_id
for key in extra_args.keys():
if key not in cls.extra_fields:
raise InternalError("Parameter %s is not valid for %s "
"interfaces." % (key, interface_type))
try:
dbinterface = cls(name=name, mac=mac, comments=comments, model=dbmodel,
default_route=default_route, **extra_args)
except ValueError, err:
raise ArgumentError(err)
def render(self, session, logger, interface, machine, switch, chassis, mac,
user, **arguments):
if not (machine or switch or chassis or mac):
raise ArgumentError("Please specify at least one of --chassis, "
"--machine, --switch or --mac.")
if machine:
dbhw_ent = Machine.get_unique(session, machine, compel=True)
elif switch:
dbhw_ent = Switch.get_unique(session, switch, compel=True)
elif chassis:
dbhw_ent = Chassis.get_unique(session, chassis, compel=True)
else:
dbhw_ent = None
dbinterface = Interface.get_unique(session, hardware_entity=dbhw_ent,
name=interface, mac=mac, compel=True)
if not dbhw_ent:
dbhw_ent = dbinterface.hardware_entity
if dbinterface.vlans:
vlans = ", ".join([iface.name for iface in
dbinterface.vlans.values()])
raise ArgumentError("{0} is the parent of the following VLAN "
"interfaces, delete them first: "
"{1}.".format(dbinterface, vlans))
if dbinterface.slaves:
slaves = ", ".join([iface.name for iface in dbinterface.slaves])
raise ArgumentError("{0} is the master of the following slave "
"interfaces, delete them first: "
"{1}.".format(dbinterface, slaves))
try:
for addr in dbinterface.assignments:
if addr.ip != dbhw_ent.primary_ip:
continue
# Special handling: if this interface was created automatically,
# and there is exactly one other interface with no IP address,
# then re-assign the primary address to that interface
if not dbinterface.mac and dbinterface.comments is not None and \
dbinterface.comments.startswith("Created automatically") and \
len(dbhw_ent.interfaces) == 2:
if dbinterface == dbhw_ent.interfaces[0]:
other = dbhw_ent.interfaces[1]
else:
other = dbhw_ent.interfaces[0]
if len(other.assignments) == 0:
assign_address(other, dbhw_ent.primary_ip,
dbhw_ent.primary_name.network)
dbinterface.addresses.remove(dbhw_ent.primary_ip)
raise _Goto
# If this is a machine, it is possible to delete the host to get rid
# of the primary name
if dbhw_ent.hardware_type == "machine":
msg = " You should delete the host first."
else:
msg = ""
raise ArgumentError("{0} holds the primary address of the {1:cl}, "
"therefore it cannot be deleted."
"{2}".format(dbinterface, dbhw_ent, msg))
except _Goto:
pass
addrs = ", ".join(["%s: %s" % (addr.logical_name, addr.ip) for addr in
dbinterface.assignments])
if addrs:
raise ArgumentError("{0} still has the following addresses "
"configured, delete them first: "
"{1}.".format(dbinterface, addrs))
dbhw_ent.interfaces.remove(dbinterface)
session.flush()
if dbhw_ent.hardware_type == 'machine':
plenary_info = PlenaryMachineInfo(dbhw_ent, logger=logger)
plenary_info.write()
return
def render(
self,
session,
logger,
interface,
machine,
mac,
model,
vendor,
boot,
pg,
autopg,
comments,
master,
clear_master,
default_route,
rename_to,
**arguments
):
"""This command expects to locate an interface based only on name
and machine - all other fields, if specified, are meant as updates.
If the machine has a host, dsdb may need to be updated.
The boot flag can *only* be set to true. This is mostly technical,
as at this point in the interface it is difficult to tell if the
flag was unset or set to false. However, it also vastly simplifies
the dsdb logic - we never have to worry about a user trying to
remove the boot flag from a host in dsdb.
"""
audit_results = []
dbhw_ent = Machine.get_unique(session, machine, compel=True)
dbinterface = Interface.get_unique(session, hardware_entity=dbhw_ent, name=interface, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
if arguments.get("hostname", None):
# Hack to set an intial interface for an aurora host...
dbhost = dbhw_ent.host
if dbhost.archetype.name == "aurora" and dbhw_ent.primary_ip and not dbinterface.addresses:
assign_address(dbinterface, dbhw_ent.primary_ip, dbhw_ent.primary_name.network)
# We may need extra IP verification (or an autoip option)...
# This may also throw spurious errors if attempting to set the
# port_group to a value it already has.
if pg is not None and dbinterface.port_group != pg.lower().strip():
dbinterface.port_group = verify_port_group(dbinterface.hardware_entity, pg)
elif autopg:
dbinterface.port_group = choose_port_group(session, logger, dbinterface.hardware_entity)
audit_results.append(("pg", dbinterface.port_group))
if master:
if dbinterface.addresses:
# FIXME: as a special case, if the only address is the
# primary IP, then we could just move it to the master
# interface. However this can be worked around by bonding
# the interface before calling "add host", so don't bother
# for now.
raise ArgumentError("Can not enslave {0:l} because it has " "addresses.".format(dbinterface))
dbmaster = Interface.get_unique(session, hardware_entity=dbhw_ent, name=master, compel=True)
if dbmaster in dbinterface.all_slaves():
raise ArgumentError(
"Enslaving {0:l} would create a circle, " "which is not allowed.".format(dbinterface)
)
dbinterface.master = dbmaster
if clear_master:
if not dbinterface.master:
raise ArgumentError("{0} is not a slave.".format(dbinterface))
dbinterface.master = None
if comments:
dbinterface.comments = comments
if boot:
# Should we also transfer the primary IP to the new boot interface?
# That could get tricky if the new interface already has an IP
# address...
for i in dbhw_ent.interfaces:
if i == dbinterface:
i.bootable = True
i.default_route = True
else:
i.bootable = False
i.default_route = False
if default_route is not None:
dbinterface.default_route = default_route
if not first_of(dbhw_ent.interfaces, lambda x: x.default_route):
logger.client_info("Warning: {0:l} has no default route, hope " "that's ok.".format(dbhw_ent))
# Set this mac address last so that you can update to a bootable
# interface *before* adding a mac address. This is so the validation
# that takes place in the interface class doesn't have to be worried
# about the order of update to bootable=True and mac address
if mac:
q = session.query(Interface).filter_by(mac=mac)
other = q.first()
if other and other != dbinterface:
raise ArgumentError("MAC address {0} is already in use by " "{1:l}.".format(mac, other))
dbinterface.mac = mac
if model or vendor:
if not dbinterface.model_allowed:
raise ArgumentError("Model/vendor can not be set for a {0:lc}.".format(dbinterface))
dbmodel = Model.get_unique(session, name=model, vendor=vendor, machine_type="nic", compel=True)
dbinterface.model = dbmodel
if rename_to:
rename_interface(session, dbinterface, rename_to)
session.flush()
session.refresh(dbhw_ent)
plenary_info = PlenaryMachineInfo(dbhw_ent, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
plenary_info.write(locked=True)
if dbhw_ent.host and dbhw_ent.host.archetype.name != "aurora":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback()
except AquilonError, err:
plenary_info.restore_stash()
raise ArgumentError(err)
def render(self, session, logger, interface, machine, network_device,
switch, chassis, mac, user, **arguments):
if switch:
self.deprecated_option("switch", "Please use --network_device "
"instead.", logger=logger, user=user,
**arguments)
if not network_device:
network_device = switch
self.require_one_of(machine=machine, network_device=network_device,
chassis=chassis, mac=mac)
if machine:
dbhw_ent = Machine.get_unique(session, machine, compel=True)
elif network_device:
dbhw_ent = NetworkDevice.get_unique(session, network_device, compel=True)
elif chassis:
dbhw_ent = Chassis.get_unique(session, chassis, compel=True)
else:
dbhw_ent = None
dbinterface = Interface.get_unique(session, hardware_entity=dbhw_ent,
name=interface, mac=mac, compel=True)
if not dbhw_ent:
dbhw_ent = dbinterface.hardware_entity
if dbinterface.vlans:
vlans = ", ".join([iface.name for iface in
dbinterface.vlans.values()])
raise ArgumentError("{0} is the parent of the following VLAN "
"interfaces, delete them first: "
"{1}.".format(dbinterface, vlans))
if dbinterface.slaves:
slaves = ", ".join([iface.name for iface in dbinterface.slaves])
raise ArgumentError("{0} is the master of the following slave "
"interfaces, delete them first: "
"{1}.".format(dbinterface, slaves))
for addr in dbinterface.assignments:
if addr.ip != dbhw_ent.primary_ip:
continue
# If this is a machine, it is possible to delete the host to get rid
# of the primary name
if dbhw_ent.hardware_type == "machine":
msg = " You should delete the host first."
else:
msg = ""
raise ArgumentError("{0} holds the primary address of the {1:cl}, "
"therefore it cannot be deleted."
"{2}".format(dbinterface, dbhw_ent, msg))
addrs = ", ".join(["%s: %s" % (addr.logical_name, addr.ip) for addr in
dbinterface.assignments])
if addrs:
raise ArgumentError("{0} still has the following addresses "
"configured, delete them first: "
"{1}.".format(dbinterface, addrs))
dbhw_ent.interfaces.remove(dbinterface)
session.flush()
if dbhw_ent.hardware_type == 'machine':
plenary_info = Plenary.get_plenary(dbhw_ent, logger=logger)
plenary_info.write()
return
def render(self, session, logger, interface, machine, mac, model, vendor,
boot, pg, autopg, comments, master, clear_master, default_route,
rename_to, **arguments):
"""This command expects to locate an interface based only on name
and machine - all other fields, if specified, are meant as updates.
If the machine has a host, dsdb may need to be updated.
The boot flag can *only* be set to true. This is mostly technical,
as at this point in the interface it is difficult to tell if the
flag was unset or set to false. However, it also vastly simplifies
the dsdb logic - we never have to worry about a user trying to
remove the boot flag from a host in dsdb.
"""
audit_results = []
dbhw_ent = Machine.get_unique(session, machine, compel=True)
dbinterface = Interface.get_unique(session,
hardware_entity=dbhw_ent,
name=interface,
compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
if arguments.get('hostname', None):
# Hack to set an intial interface for an aurora host...
dbhost = dbhw_ent.host
if dbhost.archetype.name == 'aurora' and \
dbhw_ent.primary_ip and not dbinterface.addresses:
assign_address(dbinterface, dbhw_ent.primary_ip,
dbhw_ent.primary_name.network)
# We may need extra IP verification (or an autoip option)...
# This may also throw spurious errors if attempting to set the
# port_group to a value it already has.
if pg is not None and dbinterface.port_group != pg.lower().strip():
dbinterface.port_group = verify_port_group(
dbinterface.hardware_entity, pg)
elif autopg:
dbinterface.port_group = choose_port_group(
session, logger, dbinterface.hardware_entity)
audit_results.append(('pg', dbinterface.port_group))
if master:
if dbinterface.addresses:
# FIXME: as a special case, if the only address is the
# primary IP, then we could just move it to the master
# interface. However this can be worked around by bonding
# the interface before calling "add host", so don't bother
# for now.
raise ArgumentError("Can not enslave {0:l} because it has "
"addresses.".format(dbinterface))
dbmaster = Interface.get_unique(session,
hardware_entity=dbhw_ent,
name=master,
compel=True)
if dbmaster in dbinterface.all_slaves():
raise ArgumentError(
"Enslaving {0:l} would create a circle, "
"which is not allowed.".format(dbinterface))
dbinterface.master = dbmaster
if clear_master:
if not dbinterface.master:
raise ArgumentError("{0} is not a slave.".format(dbinterface))
dbinterface.master = None
if comments:
dbinterface.comments = comments
if boot:
# Should we also transfer the primary IP to the new boot interface?
# That could get tricky if the new interface already has an IP
# address...
for i in dbhw_ent.interfaces:
if i == dbinterface:
i.bootable = True
i.default_route = True
else:
i.bootable = False
i.default_route = False
if default_route is not None:
dbinterface.default_route = default_route
if not first_of(dbhw_ent.interfaces, lambda x: x.default_route):
logger.client_info("Warning: {0:l} has no default route, hope "
"that's ok.".format(dbhw_ent))
#Set this mac address last so that you can update to a bootable
#interface *before* adding a mac address. This is so the validation
#that takes place in the interface class doesn't have to be worried
#about the order of update to bootable=True and mac address
if mac:
q = session.query(Interface).filter_by(mac=mac)
other = q.first()
if other and other != dbinterface:
raise ArgumentError("MAC address {0} is already in use by "
"{1:l}.".format(mac, other))
dbinterface.mac = mac
if model or vendor:
if not dbinterface.model_allowed:
raise ArgumentError(
"Model/vendor can not be set for a {0:lc}.".format(
dbinterface))
dbmodel = Model.get_unique(session,
name=model,
vendor=vendor,
machine_type='nic',
compel=True)
dbinterface.model = dbmodel
if rename_to:
rename_interface(session, dbinterface, rename_to)
session.flush()
session.refresh(dbhw_ent)
plenary_info = PlenaryMachineInfo(dbhw_ent, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
plenary_info.write(locked=True)
if dbhw_ent.host and dbhw_ent.host.archetype.name != "aurora":
dsdb_runner = DSDBRunner(logger=logger)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback()
except AquilonError, err:
plenary_info.restore_stash()
raise ArgumentError(err)
def get_or_create_interface(session,
dbhw_ent,
name=None,
mac=None,
model=None,
vendor=None,
interface_type='public',
bootable=None,
preclude=False,
port_group=None,
comments=None):
"""
Look up an existing interface or create a new one.
If either the name or the MAC address is given and a matching interface
exists, then that interface is returned and the other parameters are not
checked.
If neither the name nor the MAC address is given, but there is just one
existing interface matching the specified interface_type/bootable/port_group
combination, then that interface is returned. If there are multiple matches,
an exception is raised.
If no interfaces were found, and enough parameters are provided, then a new
interface is created. For this purpose, at least the name and in some cases
the MAC address must be specified.
Setting preclude to True enforces the creation of a new interface. An error
is raised if a conflicting interface already exists.
"""
dbinterface = None
if mac:
# Look for the MAC globally. If it is present, check that it belongs to
# the right hardware, and that it does not conflict with the name (if
# any).
q = session.query(Interface)
q = q.filter_by(mac=mac)
dbinterface = q.first()
if dbinterface and (dbinterface.hardware_entity != dbhw_ent or
(name and dbinterface.name != name)):
raise ArgumentError(
"MAC address %s is already in use: %s." %
(mac, describe_interface(session, dbinterface)))
if name and not dbinterface:
# Special logic to allow "add_interface" to succeed if there is an
# auto-created interface already
if preclude and len(dbhw_ent.interfaces) == 1:
dbinterface = dbhw_ent.interfaces[0]
if dbinterface.mac is None and \
dbinterface.interface_type == interface_type and \
dbinterface.comments is not None and \
dbinterface.comments.startswith("Created automatically"):
dbinterface.name = name
dbinterface.mac = mac
if hasattr(dbinterface, "bootable") and bootable is not None:
dbinterface.bootable = bootable
dbinterface.comments = comments
if hasattr(dbinterface, "port_group"):
dbinterface.port_group = port_group
session.flush()
return dbinterface
dbinterface = None
for iface in dbhw_ent.interfaces:
if iface.name == name:
dbinterface = iface
break
if not name and not mac:
# Time for guessing. If neither the name nor the MAC was given, then
# there is no guarantee of uniqueness, but we can still return something
# useful if e.g. there is just one management interface.
interfaces = []
for iface in dbhw_ent.interfaces:
if iface.interface_type != interface_type:
continue
if bootable is not None and (not hasattr(iface, "bootable")
or iface.bootable != bootable):
continue
if port_group is not None and (not hasattr(iface, "port_group")
or iface.port_group != port_group):
continue
interfaces.append(iface)
if len(interfaces) > 1:
type_msg = _type_msg(interface_type, bootable)
raise ArgumentError("{0} has multiple {1} interfaces, please "
"specify which one to "
"use.".format(dbhw_ent, type_msg))
elif interfaces:
dbinterface = interfaces[0]
else:
dbinterface = None
if dbinterface:
if preclude:
raise ArgumentError("{0} already exists.".format(dbinterface))
return dbinterface
# No suitable interface was found, try to create a new one
if not name:
# Not enough information to create it
type_msg = _type_msg(interface_type, bootable)
raise ArgumentError("{0} has no {1} interfaces.".format(
dbhw_ent, type_msg))
cls = Interface.polymorphic_subclass(interface_type,
"Invalid interface type")
extra_args = {}
default_route = False
if bootable is not None:
extra_args["bootable"] = bootable
default_route = bootable
if port_group is not None:
extra_args["port_group"] = port_group
if not model and not vendor:
dbmodel = dbhw_ent.model.nic_model
elif not cls.model_allowed:
raise ArgumentError("Model/vendor can not be set for a %s." %
cls._get_class_label(tolower=True))
else:
dbmodel = Model.get_unique(session,
name=model,
vendor=vendor,
machine_type="nic",
compel=True)
# VLAN interfaces need some special handling
if interface_type == 'vlan':
result = _vlan_re.match(name)
if not result:
raise ArgumentError("Invalid VLAN interface name '%s'." % name)
parent_name = result.groups()[0]
vlan_id = int(result.groups()[1])
dbparent = None
for iface in dbhw_ent.interfaces:
if iface.name == parent_name:
dbparent = iface
break
if not dbparent:
raise ArgumentError("Parent interface %s for VLAN interface %s "
"does not exist, please create it first." %
(parent_name, name))
extra_args["parent"] = dbparent
extra_args["vlan_id"] = vlan_id
for key in extra_args.keys():
if key not in cls.extra_fields:
raise InternalError("Parameter %s is not valid for %s "
"interfaces." % (key, interface_type))
try:
dbinterface = cls(name=name,
mac=mac,
comments=comments,
model=dbmodel,
default_route=default_route,
**extra_args)
except ValueError, err:
raise ArgumentError(err)
def test_fail_management_iface_with_no_mac_addr():
machine = sess.query(Machine).first()
iface = Interface(machine=machine,
name='eth2',
interface_type='management')
def test_fail_bootable_iface_with_no_mac_addr():
machine = sess.query(Machine).first()
iface = Interface(machine=machine,
name='eth3',
interface_type='public',
bootable=True)
def render(self, session, logger, machine, chassis, switch, fqdn,
interface, label, network_environment, map_to_primary,
**kwargs):
if machine:
hwtype = 'machine'
hwname = machine
elif chassis:
hwtype = 'chassis'
hwname = chassis
elif switch:
hwtype = 'switch'
hwname = switch
dbnet_env = NetworkEnvironment.get_unique_or_default(
session, network_environment)
dbhw_ent = HardwareEntity.get_unique(session,
hwname,
hardware_type=hwtype,
compel=True)
dbinterface = Interface.get_unique(session,
hardware_entity=dbhw_ent,
name=interface,
compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
audit_results = []
ip = generate_ip(session,
logger,
dbinterface,
network_environment=dbnet_env,
audit_results=audit_results,
**kwargs)
if dbinterface.interface_type == "loopback":
# Switch loopback interfaces may use e.g. the network address as an
# IP address
relaxed = True
else:
relaxed = False
if not fqdn:
if not dbhw_ent.primary_name:
raise ArgumentError("{0} has no primary name, can not "
"auto-generate the DNS record. "
"Please specify --fqdn.".format(dbhw_ent))
if label:
name = "%s-%s-%s" % (dbhw_ent.primary_name.fqdn.name,
interface, label)
else:
name = "%s-%s" % (dbhw_ent.primary_name.fqdn.name, interface)
fqdn = "%s.%s" % (name, dbhw_ent.primary_name.fqdn.dns_domain)
if label is None:
label = ""
elif label == "hostname":
# When add_host sets up Zebra, it always uses the label 'hostname'.
# Due to the primary IP being special, add_interface_address cannot
# really emulate what add_host does, so tell the user where to look.
raise ArgumentError("The 'hostname' label can only be managed "
"by add_host/del_host.")
# The label will be used as an nlist key
if label:
validate_basic("label", label)
# TODO: add allow_multi=True
dbdns_rec, newly_created = grab_address(session,
fqdn,
ip,
dbnet_env,
relaxed=relaxed)
ip = dbdns_rec.ip
dbnetwork = dbdns_rec.network
delete_old_dsdb_entry = not newly_created and not dbdns_rec.assignments
# Reverse PTR control. Auxiliary addresses should point to the primary
# name by default, with some exceptions.
if (map_to_primary is None and dbhw_ent.primary_name
and dbinterface.interface_type != "management"
and dbdns_rec.fqdn.dns_environment
== dbhw_ent.primary_name.fqdn.dns_environment):
map_to_primary = True
if map_to_primary:
if not dbhw_ent.primary_name:
raise ArgumentError(
"{0} does not have a primary name, cannot "
"set the reverse DNS mapping.".format(dbhw_ent))
if (dbhw_ent.primary_name.fqdn.dns_environment !=
dbdns_rec.fqdn.dns_environment):
raise ArgumentError("{0} lives in {1:l}, not {2:l}.".format(
dbhw_ent, dbhw_ent.primary_name.fqdn.dns_environment,
dbdns_rec.fqdn.dns_environment))
if dbinterface.interface_type == "management":
raise ArgumentError("The reverse PTR for management addresses "
"should not point to the primary name.")
dbdns_rec.reverse_ptr = dbhw_ent.primary_name.fqdn
# Check that the network ranges assigned to different interfaces
# do not overlap even if the network environments are different, because
# that would confuse routing on the host. E.g. if eth0 is an internal
# and eth1 is an external interface, then using 192.168.1.10/24 on eth0
# and using 192.168.1.20/26 on eth1 won't work.
for addr in dbhw_ent.all_addresses():
if addr.network != dbnetwork and \
addr.network.network.overlaps(dbnetwork.network):
raise ArgumentError("{0} in {1:l} used on {2:l} overlaps "
"requested {3:l} in "
"{4:l}.".format(
addr.network,
addr.network.network_environment,
addr.interface, dbnetwork,
dbnetwork.network_environment))
assign_address(dbinterface, ip, dbnetwork, label=label)
session.flush()
dbhost = getattr(dbhw_ent, "host", None)
if dbhost:
plenary_info = PlenaryHost(dbhost, logger=logger)
key = plenary_info.get_write_key()
try:
lock_queue.acquire(key)
try:
plenary_info.write(locked=True)
except IncompleteError:
# FIXME: if this command is used after "add host" but before
# "make", then writing out the template will fail due to
# required services not being assigned. Ignore this error
# for now.
plenary_info.restore_stash()
dsdb_runner = DSDBRunner(logger=logger)
if delete_old_dsdb_entry:
dsdb_runner.delete_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
except:
plenary_info.restore_stash()
raise
finally:
lock_queue.release(key)
else:
dsdb_runner = DSDBRunner(logger=logger)
if delete_old_dsdb_entry:
dsdb_runner.delete_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
for name, value in audit_results:
self.audit_result(session, name, value, **kwargs)
return
def render(self, session, logger, machine, chassis, network_device, fqdn,
interface, label, network_environment, map_to_primary, **kwargs):
if machine:
hwtype = 'machine'
hwname = machine
elif chassis:
hwtype = 'chassis'
hwname = chassis
elif network_device:
hwtype = 'network_device'
hwname = network_device
dbnet_env = NetworkEnvironment.get_unique_or_default(session,
network_environment)
dbhw_ent = HardwareEntity.get_unique(session, hwname,
hardware_type=hwtype, compel=True)
dbinterface = Interface.get_unique(session, hardware_entity=dbhw_ent,
name=interface, compel=True)
oldinfo = DSDBRunner.snapshot_hw(dbhw_ent)
audit_results = []
ip = generate_ip(session, logger, dbinterface,
network_environment=dbnet_env,
audit_results=audit_results, **kwargs)
if dbinterface.interface_type == "loopback":
# Switch loopback interfaces may use e.g. the network address as an
# IP address
relaxed = True
else:
relaxed = False
if not fqdn:
if not dbhw_ent.primary_name:
raise ArgumentError("{0} has no primary name, can not "
"auto-generate the DNS record. "
"Please specify --fqdn.".format(dbhw_ent))
if label:
name = "%s-%s-%s" % (dbhw_ent.primary_name.fqdn.name, interface,
label)
else:
name = "%s-%s" % (dbhw_ent.primary_name.fqdn.name, interface)
fqdn = "%s.%s" % (name, dbhw_ent.primary_name.fqdn.dns_domain)
if label is None:
label = ""
elif label == "hostname":
# When add_host sets up Zebra, it always uses the label 'hostname'.
# Due to the primary IP being special, add_interface_address cannot
# really emulate what add_host does, so tell the user where to look.
raise ArgumentError("The 'hostname' label can only be managed "
"by add_host/del_host.")
# The label will be used as an nlist key
if label:
validate_nlist_key("label", label)
# TODO: add allow_multi=True
dbdns_rec, newly_created = grab_address(session, fqdn, ip, dbnet_env,
relaxed=relaxed)
ip = dbdns_rec.ip
dbnetwork = dbdns_rec.network
delete_old_dsdb_entry = not newly_created and not dbdns_rec.assignments
# Reverse PTR control. Auxiliary addresses should point to the primary
# name by default, with some exceptions.
if (map_to_primary is None and dbhw_ent.primary_name and
dbinterface.interface_type != "management" and
dbdns_rec.fqdn.dns_environment == dbhw_ent.primary_name.fqdn.dns_environment):
map_to_primary = True
if map_to_primary:
if not dbhw_ent.primary_name:
raise ArgumentError("{0} does not have a primary name, cannot "
"set the reverse DNS mapping."
.format(dbhw_ent))
if (dbhw_ent.primary_name.fqdn.dns_environment !=
dbdns_rec.fqdn.dns_environment):
raise ArgumentError("{0} lives in {1:l}, not {2:l}."
.format(dbhw_ent,
dbhw_ent.primary_name.fqdn.dns_environment,
dbdns_rec.fqdn.dns_environment))
if dbinterface.interface_type == "management":
raise ArgumentError("The reverse PTR for management addresses "
"should not point to the primary name.")
dbdns_rec.reverse_ptr = dbhw_ent.primary_name.fqdn
# Check that the network ranges assigned to different interfaces
# do not overlap even if the network environments are different, because
# that would confuse routing on the host. E.g. if eth0 is an internal
# and eth1 is an external interface, then using 192.168.1.10/24 on eth0
# and using 192.168.1.20/26 on eth1 won't work.
for addr in dbhw_ent.all_addresses():
if addr.network != dbnetwork and \
addr.network.network.overlaps(dbnetwork.network):
raise ArgumentError("{0} in {1:l} used on {2:l} overlaps "
"requested {3:l} in "
"{4:l}.".format(addr.network,
addr.network.network_environment,
addr.interface,
dbnetwork,
dbnetwork.network_environment))
assign_address(dbinterface, ip, dbnetwork, label=label, logger=logger)
session.flush()
dbhost = getattr(dbhw_ent, "host", None)
if dbhost:
plenary_info = Plenary.get_plenary(dbhost, logger=logger)
with plenary_info.get_key():
try:
try:
plenary_info.write(locked=True)
except IncompleteError:
# FIXME: if this command is used after "add host" but
# before "make", then writing out the template will fail
# due to required services not being assigned. Ignore
# this error for now.
plenary_info.restore_stash()
dsdb_runner = DSDBRunner(logger=logger)
if delete_old_dsdb_entry:
dsdb_runner.delete_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
except:
plenary_info.restore_stash()
raise
else:
dsdb_runner = DSDBRunner(logger=logger)
if delete_old_dsdb_entry:
dsdb_runner.delete_host_details(dbdns_rec.fqdn, ip)
dsdb_runner.update_host(dbhw_ent, oldinfo)
dsdb_runner.commit_or_rollback("Could not add host to DSDB")
for name, value in audit_results:
self.audit_result(session, name, value, **kwargs)
return
