class Subnet(mf.ModelBase, mixins.Name, mixins.Topic):
enable_dhcp = fields.BoolField()
dhcp_ip = df_fields.IpAddressField()
cidr = df_fields.IpNetworkField()
gateway_ip = df_fields.IpAddressField()
dns_nameservers = df_fields.ListOfField(df_fields.IpAddressField())
host_routes = fields.ListField(host_route.HostRoute)
class Chassis(mf.ModelBase, mixins.BasicEvents):
table_name = 'chassis'
ip = df_fields.IpAddressField(required=True)
external_host_ip = df_fields.IpAddressField()
tunnel_types = df_fields.EnumListField(conf.CONF.df.tunnel_types,
required=True)
class FloatingIp(mf.ModelBase, mixins.Version, mixins.Topic,
mixins.BasicEvents):
table_name = 'floatingip'
floating_ip_address = df_fields.IpAddressField()
fixed_ip_address = df_fields.IpAddressField()
lport = df_fields.ReferenceField(l2.LogicalPort)
floating_lport = df_fields.ReferenceField(l2.LogicalPort)
lrouter = df_fields.ReferenceField(LogicalRouter)
class FieldTestModel(mf.ModelBase):
enum = df_fields.EnumField(('a', 'b', 'c'))
enum_list = df_fields.EnumListField(('a', 'b', 'c'))
ipaddr = df_fields.IpAddressField()
ipnetwork = df_fields.IpNetworkField()
ref = df_fields.ReferenceField(ReffedTestModel)
ref_list = df_fields.ReferenceListField(ReffedTestModel)
ip_list = df_fields.ListOfField(df_fields.IpAddressField())
def __init__(self, **kwargs):
super(FieldTestModel, self).__init__(id='id1', **kwargs)
class Subnet(mf.ModelBase, mixins.Name, mixins.Topic, mixins.Version,
mixins.BasicEvents):
table_name = "lsubnet"
enable_dhcp = fields.BoolField()
dhcp_ip = df_fields.IpAddressField()
cidr = df_fields.IpNetworkField()
gateway_ip = df_fields.IpAddressField()
dns_nameservers = df_fields.ListOfField(df_fields.IpAddressField())
host_routes = fields.ListField(host_route.HostRoute)
lswitch = df_fields.ReferenceField(LogicalSwitch, required=True)
class FieldTestModel(mf.ModelBase):
enum = df_fields.EnumField(('a', 'b', 'c'))
enum_list = df_fields.EnumListField(('a', 'b', 'c'))
ipaddr = df_fields.IpAddressField()
ipnetwork = df_fields.IpNetworkField()
ref = df_fields.ReferenceField(ReffedTestModel)
ref_list = df_fields.ReferenceListField(ReffedTestModel)
ip_list = df_fields.ListOfField(df_fields.IpAddressField())
port_range = df_fields.PortRangeField()
dhcp_opts = df_fields.DhcpOptsDictField()
def __init__(self, **kwargs):
id = kwargs.pop("id", 'id1')
super(FieldTestModel, self).__init__(id=id, **kwargs)
class RemoteLabeledRoute(mf.ModelBase, mixins.BasicEvents):
table_name = 'rlroutes'
destination = df_fields.IpNetworkField(required=True)
nexthop = df_fields.IpAddressField(required=True)
label = fields.IntField(required=True)
helper_port = fields.StringField(required=True)
class FloatingIp(mf.ModelBase, mixins.Version, mixins.Topic, mixins.UniqueKey,
mixins.Name, mixins.BasicEvents):
table_name = 'floatingip'
status = df_fields.EnumField(
(constants.FLOATINGIP_STATUS_ACTIVE, constants.FLOATINGIP_STATUS_DOWN,
constants.FLOATINGIP_STATUS_ERROR))
floating_ip_address = df_fields.IpAddressField()
fixed_ip_address = df_fields.IpAddressField()
lport = df_fields.ReferenceField(l2.LogicalPort)
floating_lport = df_fields.ReferenceField(l2.LogicalPort)
lrouter = df_fields.ReferenceField(LogicalRouter)
@property
def is_local(self):
return self.lport is not None and self.lport.is_local
class AllowedAddressPairsActivePort(mf.ModelBase, mixins.Topic,
mixins.BasicEvents):
table_name = "activeport"
ip = df_fields.IpAddressField()
network = df_fields.ReferenceField(l2.LogicalSwitch)
detected_mac = df_fields.MacAddressField()
detected_lport = df_fields.ReferenceField(l2.LogicalPort)
class PortBinding(models.Base):
type = df_fields.EnumField((BINDING_CHASSIS, BINDING_VTEP), required=True)
chassis = df_fields.ReferenceField(core.Chassis)
vtep_address = df_fields.IpAddressField()
@property
def ip(self):
if self.type == BINDING_CHASSIS:
return self.chassis.ip
elif self.type == BINDING_VTEP:
return self.vtep_address
return None
@property
def is_local(self):
if self.type == BINDING_CHASSIS:
return self.chassis.id == cfg.CONF.host
return False
def __deepcopy__(self, memo):
return PortBinding(
type=self.type,
chassis=copy.deepcopy(self.chassis, memo),
vtep_address=self.vtep_address,
)
class BGPPeer(mf.ModelBase, mixins.Topic, mixins.Name):
table_name = "bgp_peer"
peer_ip = df_fields.IpAddressField(required=True)
remote_as = fields.IntField(required=True)
auth_type = fields.StringField()
password = fields.StringField()
class FloatingIp(mf.ModelBase, mixins.Version, mixins.Topic, mixins.Name,
mixins.BasicEvents):
table_name = 'floatingip'
floating_ip_address = df_fields.IpAddressField()
fixed_ip_address = df_fields.IpAddressField()
lport = df_fields.ReferenceField(l2.LogicalPort)
floating_lport = df_fields.ReferenceField(l2.LogicalPort)
lrouter = df_fields.ReferenceField(LogicalRouter)
@property
def is_local(self):
if self.lport is None:
return False
lport = self.lport.get_object()
return lport is not None and lport.is_local
class LogicalPort(mf.ModelBase, mixins.Name, mixins.Version, mixins.Topic,
mixins.UniqueKey, mixins.BasicEvents):
table_name = "lport"
ips = df_fields.ListOfField(df_fields.IpAddressField())
subnets = df_fields.ReferenceListField(Subnet)
macs = df_fields.ListOfField(df_fields.MacAddressField())
enabled = fields.BoolField()
binding = fields.EmbeddedField(PortBinding)
lswitch = df_fields.ReferenceField(LogicalSwitch)
security_groups = df_fields.ReferenceListField(secgroups.SecurityGroup)
allowed_address_pairs = fields.ListField(AddressPair)
port_security_enabled = fields.BoolField()
device_owner = fields.StringField()
device_id = fields.StringField()
qos_policy = df_fields.ReferenceField(qos.QosPolicy)
dhcp_params = fields.EmbeddedField(DhcpParams)
binding_vnic_type = df_fields.EnumField(portbindings.VNIC_TYPES)
@property
def ip(self):
try:
return self.ips[0]
except IndexError:
return None
@property
def mac(self):
try:
return self.macs[0]
except IndexError:
return None
@property
def is_local(self):
return port_locator.is_port_local(self)
@property
def is_remote(self):
return port_locator.is_port_remote(self)
@property
def all_ips(self):
ips = set(self.ips)
ips.update(pair.ip_address for pair in self.allowed_address_pairs)
return ips
def __str__(self):
data = {}
for name in dir(self):
if name.startswith('_'):
continue
cls_definition = getattr(self.__class__, name, None)
if isinstance(cls_definition, fields.BaseField):
if name in self._set_fields:
data[name] = getattr(self, name)
elif not cls_definition: # Display only instnaces, not classes
data[name] = getattr(self, name)
return str(data)
class LogicalSimplePort(mf.ModelBase, mixins.Name, mixins.BasicEvents):
table_name = "lport"
port_num = fields.IntField(False)
ips = df_fields.ListOfField(df_fields.IpAddressField())
subnets = df_fields.ReferenceListField(Subnet)
macs = df_fields.ListOfField(df_fields.MacAddressField())
enabled = fields.BoolField()
lswitch = df_fields.ReferenceField(LogicalSwitch)
qos_policy = df_fields.ReferenceField(qos.QosPolicy)
@property
def ip(self):
try:
return self.ips[0]
except IndexError:
return None
@property
def mac(self):
try:
return self.macs[0]
except IndexError:
return None
def __str__(self):
data = {}
for name in dir(self):
if name.startswith('_'):
continue
cls_definition = getattr(self.__class__, name, None)
if isinstance(cls_definition, fields.BaseField):
if name in self._set_fields:
data[name] = getattr(self, name)
elif not cls_definition: # Display only instnaces, not classes
data[name] = getattr(self, name)
return str(data)
class AddressPair(models.Base):
ip_address = df_fields.IpAddressField(required=True)
mac_address = df_fields.MacAddressField(required=True)
class LogicalPort(mf.ModelBase, mixins.Name, mixins.Version, mixins.Topic,
mixins.UniqueKey):
table_name = "lport"
ips = df_fields.ListOfField(df_fields.IpAddressField())
subnets = df_fields.ReferenceListField(Subnet)
macs = df_fields.ListOfField(df_fields.MacAddressField())
enabled = fields.BoolField()
chassis = df_fields.ReferenceField(core.Chassis)
lswitch = df_fields.ReferenceField(LogicalSwitch)
security_groups = df_fields.ReferenceListField(secgroups.SecurityGroup)
allowed_address_pairs = fields.ListField(AddressPair)
port_security_enabled = fields.BoolField()
device_owner = fields.StringField()
device_id = fields.StringField()
qos_policy = df_fields.ReferenceField(qos.QosPolicy)
remote_vtep = fields.BoolField()
extra_dhcp_options = df_fields.IntStringDictField()
binding_vnic_type = df_fields.EnumField(portbindings.VNIC_TYPES)
def __init__(self,
ofport=None,
is_local=None,
peer_vtep_address=None,
**kwargs):
super(LogicalPort, self).__init__(**kwargs)
self.ofport = ofport
self.is_local = is_local
self.peer_vtep_address = peer_vtep_address
@property
def ip(self):
try:
return self.ips[0]
except IndexError:
return None
@property
def mac(self):
try:
return self.macs[0]
except IndexError:
return None
def is_vm_port(self):
"""
Return True if the device owner starts with 'compute:' (or is None)
"""
owner = self.device_owner
if not owner or owner.startswith(n_const.DEVICE_OWNER_COMPUTE_PREFIX):
return True
return False
def __str__(self):
data = {}
for name in dir(self):
if name.startswith('_'):
continue
cls_definition = getattr(self.__class__, name, None)
if isinstance(cls_definition, fields.BaseField):
if name in self._set_fields:
data[name] = getattr(self, name)
elif not cls_definition: # Display only instnaces, not classes
data[name] = getattr(self, name)
return str(data)
def emit_created(self):
ofport = getattr(self, 'ofport', None)
if not ofport:
return
is_local = getattr(self, 'is_local', None)
LOG.info("Adding new logical port = %s", self)
if is_local:
self.emit_local_created()
else:
self.emit_remote_created()
def emit_updated(self, original_lport):
ofport = getattr(self, 'ofport', None)
if not ofport:
return
is_local = getattr(self, 'is_local', None)
LOG.info(
"Updating %(location)s logical port = %(port)s, "
"original port = %(original_port)s", {
'port': self,
'original_port': original_lport,
'location': 'local' if is_local else 'remote'
})
if is_local:
self.emit_local_updated(original_lport)
else:
self.emit_remote_updated(original_lport)
def emit_deleted(self):
is_local = getattr(self, 'is_local', None)
ofport = getattr(self, 'ofport', None)
if not ofport:
return
if is_local:
self.emit_local_deleted()
else:
self.emit_remote_deleted()
class HostRoute(models.Base):
destination = df_fields.IpNetworkField(required=True)
nexthop = df_fields.IpAddressField(required=True)
class DhcpParams(models.Base):
opts = df_fields.DhcpOptsDictField()
siaddr = df_fields.IpAddressField()
class LogicalRouterPort(mf.ModelBase, mixins.Topic, mixins.UniqueKey):
mac = fields.StringField()
port_no = fields.StringField()
gateway_ip = df_fields.IpAddressField()
lswitch = df_fields.ReferenceField(l2.LogicalSwitch)
network = df_fields.IpNetworkField()
