class EndpointGroupContractMasters(model_base.Base):
"""DB model for contract-masters configured for an EPG."""
__tablename__ = 'aim_endpoint_group_contract_masters'
epg_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_endpoint_groups.aim_id'),
primary_key=True)
app_profile_name = model_base.name_column(primary_key=True)
name = model_base.name_column(primary_key=True)
class Endpoint(model_base.Base, model_base.HasDisplayName,
model_base.AttributeMixin):
"""DB model for Endpoint."""
__tablename__ = 'aim_endpoints'
__table_args__ = (model_base.to_tuple(model_base.Base.__table_args__))
uuid = sa.Column(sa.String(36), primary_key=True)
epg_tenant_name = model_base.name_column()
epg_app_profile_name = model_base.name_column()
epg_name = model_base.name_column()
class ServiceGraphLinearChainNode(model_base.Base):
"""DB model for linear-chain nodes used by ServiceGraph."""
__tablename__ = 'aim_service_graph_linear_chain_nodes'
sg_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_service_graphs.aim_id'),
primary_key=True)
name = model_base.name_column(primary_key=True)
device_cluster_name = model_base.name_column()
device_cluster_tenant_name = model_base.name_column()
class ContractSubject(model_base.Base, model_base.HasAimId, model_base.HasName,
model_base.HasDisplayName, model_base.HasTenantName,
model_base.AttributeMixin, model_base.IsMonitored):
"""DB model for Contract Subject."""
__tablename__ = 'aim_contract_subjects'
__table_args__ = (model_base.uniq_column(__tablename__, 'tenant_name',
'contract_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
contract_name = model_base.name_column(nullable=False)
service_graph_name = model_base.name_column()
in_service_graph_name = model_base.name_column()
out_service_graph_name = model_base.name_column()
filters = orm.relationship(ContractSubjectFilter,
backref='contract',
cascade='all, delete-orphan',
lazy='joined')
def from_attr(self, session, res_attr):
ins = [f for f in self.filters if f.direction == 'in']
outs = [f for f in self.filters if f.direction == 'out']
bis = [f for f in self.filters if f.direction == 'bi']
if 'in_filters' in res_attr:
ins = []
for f in (res_attr.pop('in_filters', []) or []):
ins.append(ContractSubjectFilter(name=f, direction='in'))
if 'out_filters' in res_attr:
outs = []
for f in (res_attr.pop('out_filters', []) or []):
outs.append(ContractSubjectFilter(name=f, direction='out'))
if 'bi_filters' in res_attr:
bis = []
for f in (res_attr.pop('bi_filters', []) or []):
bis.append(ContractSubjectFilter(name=f, direction='bi'))
self.filters = ins + outs + bis
# map remaining attributes to model
super(ContractSubject, self).from_attr(session, res_attr)
def to_attr(self, session):
res_attr = super(ContractSubject, self).to_attr(session)
for f in res_attr.pop('filters', []):
if f.direction == 'in':
attr = 'in_filters'
elif f.direction == 'out':
attr = 'out_filters'
else:
attr = 'bi_filters'
res_attr.setdefault(attr, []).append(f.name)
return res_attr
class SecurityGroupRule(model_base.Base, model_base.HasAimId,
model_base.HasName, model_base.HasDisplayName,
model_base.HasTenantName, model_base.AttributeMixin,
model_base.IsMonitored):
"""DB model SecurityGroup Subject."""
__tablename__ = 'aim_security_group_rules'
__table_args__ = (model_base.uniq_column(
__tablename__, 'tenant_name', 'security_group_name',
'security_group_subject_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
security_group_name = model_base.name_column(nullable=False)
security_group_subject_name = model_base.name_column(nullable=False)
remote_ips = orm.relationship(SecurityGroupRuleRemoteIp,
backref='security_group_rule',
cascade='all, delete-orphan',
lazy='joined')
direction = sa.Column(sa.String(16))
ethertype = sa.Column(sa.String(16))
ip_protocol = sa.Column(sa.String(16))
from_port = sa.Column(sa.String(16))
to_port = sa.Column(sa.String(16))
conn_track = sa.Column(sa.String(25))
icmp_code = sa.Column(sa.String(16))
icmp_type = sa.Column(sa.String(16))
remote_group_id = sa.Column(sa.String(64), nullable=False)
def from_attr(self, session, res_attr):
if 'remote_ips' in res_attr:
# list of IPs has same order as DB objects
old_ip_list = [x.cidr for x in self.remote_ips]
# Use sets to calculate additions and deletions
old_set = set(old_ip_list)
new_set = set(res_attr['remote_ips'])
# For deletions, start from the end of the list to preserve order
deletion_indexes = [
old_ip_list.index(ip) for ip in (old_set - new_set)
]
deletion_indexes.sort()
if deletion_indexes:
for index in deletion_indexes[::-1]:
self.remote_ips.pop(index)
for ip in (new_set - old_set):
self.remote_ips.append(SecurityGroupRuleRemoteIp(cidr=ip))
res_attr.pop('remote_ips')
# map remaining attributes to model
super(SecurityGroupRule, self).from_attr(session, res_attr)
def to_attr(self, session):
res_attr = super(SecurityGroupRule, self).to_attr(session)
res_attr['remote_ips'] = [x.cidr for x in res_attr['remote_ips']]
return res_attr
class VmmInjectedNamespace(model_base.Base, model_base.HasAimId,
model_base.HasName, model_base.HasDisplayName,
model_base.AttributeMixin):
"""DB model VmmInjectedNamespace."""
__tablename__ = 'aim_vmm_inj_namespaces'
__table_args__ = (
model_base.uniq_column(__tablename__, 'domain_type', 'domain_name',
'controller_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
domain_type = model_base.name_column(nullable=False)
domain_name = model_base.name_column(nullable=False)
controller_name = model_base.name_column(nullable=False)
class ServiceGraphLinearChainNode(model_base.Base):
"""DB model for linear-chain nodes used by ServiceGraph."""
__tablename__ = 'aim_service_graph_linear_chain_nodes'
__table_args__ = (model_base.uniq_column(__tablename__, 'sg_aim_id',
'name', 'sequence_number') +
model_base.to_tuple(model_base.Base.__table_args__))
sg_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_service_graphs.aim_id'),
primary_key=True)
name = model_base.name_column(primary_key=True)
device_cluster_name = model_base.name_column()
device_cluster_tenant_name = model_base.name_column()
sequence_number = sa.Column(sa.Integer)
class L3OutInterfaceProfile(model_base.Base, model_base.HasAimId,
model_base.HasName, model_base.HasDisplayName,
model_base.HasTenantName,
model_base.AttributeMixin, model_base.IsMonitored):
"""DB model for L3OutInterfaceProfile."""
__tablename__ = 'aim_l3out_interface_profiles'
__table_args__ = (
model_base.uniq_column(__tablename__, 'tenant_name', 'l3out_name',
'node_profile_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
l3out_name = model_base.name_column(nullable=False)
node_profile_name = model_base.name_column(nullable=False)
class ExternalSubnet(model_base.Base, model_base.HasAimId,
model_base.HasDisplayName, model_base.HasTenantName,
model_base.AttributeMixin, model_base.IsMonitored):
"""DB model for ExternalSubnet."""
__tablename__ = 'aim_external_subnets'
__table_args__ = (
model_base.uniq_column(__tablename__, 'tenant_name', 'l3out_name',
'external_network_name', 'cidr') +
model_base.to_tuple(model_base.Base.__table_args__))
l3out_name = model_base.name_column(nullable=False)
external_network_name = model_base.name_column(nullable=False)
cidr = sa.Column(sa.String(64), nullable=False)
class L3OutNode(model_base.Base, model_base.HasAimId, model_base.HasTenantName,
model_base.AttributeMixin, model_base.IsMonitored):
"""DB model for L3OutNode."""
__tablename__ = 'aim_l3out_nodes'
__table_args__ = (
model_base.uniq_column(__tablename__, 'tenant_name', 'l3out_name',
'node_profile_name', 'node_path') +
model_base.to_tuple(model_base.Base.__table_args__))
l3out_name = model_base.name_column(nullable=False)
node_profile_name = model_base.name_column(nullable=False)
# Use VARCHAR with ASCII encoding to work-around MySQL limitations
# on the length of primary keys
node_path = sa.Column(VARCHAR(512, charset='latin1'), nullable=False)
router_id = sa.Column(sa.String(64), nullable=False)
class VmmInjectedHost(model_base.Base, model_base.HasAimId, model_base.HasName,
model_base.HasDisplayName, model_base.AttributeMixin):
"""DB model VmmInjectedHost."""
__tablename__ = 'aim_vmm_inj_hosts'
__table_args__ = (
model_base.uniq_column(__tablename__, 'domain_type', 'domain_name',
'controller_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
domain_type = model_base.name_column(nullable=False)
domain_name = model_base.name_column(nullable=False)
controller_name = model_base.name_column(nullable=False)
host_name = sa.Column(sa.String(128))
kernel_version = sa.Column(sa.String(32))
os = sa.Column(sa.String(64))
class VmmInjectedDeployment(model_base.Base, model_base.HasAimId,
model_base.HasName, model_base.HasDisplayName,
model_base.AttributeMixin):
"""DB model VmmInjectedDeployment."""
__tablename__ = 'aim_vmm_inj_deployments'
__table_args__ = (
model_base.uniq_column(__tablename__, 'domain_type', 'domain_name',
'controller_name', 'namespace_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
domain_type = model_base.name_column(nullable=False)
domain_name = model_base.name_column(nullable=False)
controller_name = model_base.name_column(nullable=False)
namespace_name = model_base.name_column(nullable=False)
replicas = sa.Column(sa.Integer)
class DeviceClusterInterface(model_base.Base, model_base.HasAimId,
model_base.HasName, model_base.HasDisplayName,
model_base.HasTenantName,
model_base.AttributeMixin,
model_base.IsMonitored):
"""DB model for DeviceClusterInterface."""
__tablename__ = 'aim_device_cluster_ifs'
__table_args__ = (model_base.uniq_column(__tablename__, 'tenant_name',
'device_cluster_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
device_cluster_name = model_base.name_column(nullable=False)
encap = sa.Column(sa.String(24))
concrete_ifs = orm.relationship(DeviceClusterInterfaceConcreteIfs,
backref='cluster_interface',
cascade='all, delete-orphan',
lazy='joined')
def from_attr(self, session, res_attr):
if 'concrete_interfaces' in res_attr:
ifs = []
for i in (res_attr.pop('concrete_interfaces', []) or []):
ifs.append(DeviceClusterInterfaceConcreteIfs(interface=i))
self.concrete_ifs = ifs
# map remaining attributes to model
super(DeviceClusterInterface, self).from_attr(session, res_attr)
def to_attr(self, session):
res_attr = super(DeviceClusterInterface, self).to_attr(session)
for f in res_attr.pop('concrete_ifs', []):
res_attr.setdefault('concrete_interfaces', []).append(f.interface)
return res_attr
class ServiceRedirectPolicy(model_base.Base, model_base.HasAimId,
model_base.HasName, model_base.HasDisplayName,
model_base.HasTenantName,
model_base.AttributeMixin, model_base.IsMonitored):
"""DB model for ServiceRedirectPolicy."""
__tablename__ = 'aim_service_redirect_policies'
__table_args__ = (
model_base.uniq_column(__tablename__, 'tenant_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
monitoring_policy_tenant_name = model_base.name_column()
monitoring_policy_name = model_base.name_column()
dest = orm.relationship(ServiceRedirectPolicyDestination,
backref='redirect_policy',
cascade='all, delete-orphan',
lazy='joined')
def from_attr(self, session, res_attr):
if 'destinations' in res_attr:
dests = []
for d in (res_attr.pop('destinations', []) or []):
if not d.get('ip'):
continue
dests.append(
ServiceRedirectPolicyDestination(
ip=d['ip'],
mac=d.get('mac'),
redirect_health_group_dn=d.get(
'redirect_health_group_dn'),
name=d.get('name')))
self.dest = dests
# map remaining attributes to model
super(ServiceRedirectPolicy, self).from_attr(session, res_attr)
def to_attr(self, session):
res_attr = super(ServiceRedirectPolicy, self).to_attr(session)
for d in res_attr.pop('dest', []):
dst = {'ip': d.ip}
if d.mac is not None:
dst['mac'] = d.mac
if d.redirect_health_group_dn is not None:
dst['redirect_health_group_dn'] = (d.redirect_health_group_dn)
if d.name is not None:
dst['name'] = d.name
res_attr.setdefault('destinations', []).append(dst)
return res_attr
class VMMDomain(model_base.Base, model_base.HasDisplayName,
model_base.HasAimId, model_base.AttributeMixin,
model_base.IsMonitored, model_base.HasName):
"""DB model for VMM Domain."""
__tablename__ = 'aim_vmm_domains'
__table_args__ = (model_base.uniq_column(__tablename__, 'type', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
type = sa.Column(sa.String(64))
enforcement_pref = sa.Column(sa.Enum('sw', 'hw', 'unknown'))
mode = sa.Column(sa.Enum('default', 'n1kv', 'unknown', 'ovs', 'k8s'))
mcast_address = sa.Column(sa.String(64))
encap_mode = sa.Column(sa.Enum('unknown', 'vlan', 'vxlan'))
pref_encap_mode = sa.Column(sa.Enum('unspecified', 'vlan', 'vxlan'))
vlan_pool_name = model_base.name_column()
vlan_pool_type = sa.Column(sa.Enum('static', 'dynamic'))
mcast_addr_pool_name = model_base.name_column()
class L3OutStaticRoute(model_base.Base, model_base.HasAimId,
model_base.HasDisplayName, model_base.HasTenantName,
model_base.AttributeMixin, model_base.IsMonitored):
"""DB model for L3OutStaticRoute."""
__tablename__ = 'aim_l3out_static_routes'
__table_args__ = (
model_base.uniq_column(__tablename__, 'tenant_name', 'l3out_name',
'node_profile_name', 'node_path', 'cidr') +
model_base.to_tuple(model_base.Base.__table_args__))
l3out_name = model_base.name_column(nullable=False)
node_profile_name = model_base.name_column(nullable=False)
# Use VARCHAR with ASCII encoding to work-around MySQL limitations
# on the length of primary keys
node_path = sa.Column(VARCHAR(512, charset='latin1'), nullable=False)
cidr = sa.Column(sa.String(64), nullable=False)
preference = sa.Column(sa.String(16), nullable=False)
next_hop_list = orm.relationship(L3OutNextHop,
backref='static_route',
cascade='all, delete-orphan',
lazy='joined')
def from_attr(self, session, res_attr):
if 'next_hop_list' in res_attr:
next_hop_list = []
for p in (res_attr.pop('next_hop_list', []) or []):
if p.get('addr') and p.get('preference'):
next_hop_list.append(
L3OutNextHop(addr=p['addr'],
preference=p['preference']))
self.next_hop_list = next_hop_list
# map remaining attributes to model
super(L3OutStaticRoute, self).from_attr(session, res_attr)
def to_attr(self, session):
res_attr = super(L3OutStaticRoute, self).to_attr(session)
for p in res_attr.pop('next_hop_list', []):
res_attr.setdefault('next_hop_list', []).append({
'addr':
p.addr,
'preference':
p.preference
})
return res_attr
class ConcreteDeviceInterface(model_base.Base, model_base.HasAimId,
model_base.HasName, model_base.HasDisplayName,
model_base.HasTenantName,
model_base.AttributeMixin,
model_base.IsMonitored):
"""DB model for ConcreteDeviceInterface."""
__tablename__ = 'aim_concrete_device_ifs'
__table_args__ = (
model_base.uniq_column(__tablename__, 'tenant_name',
'device_cluster_name', 'device_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
device_cluster_name = model_base.name_column(nullable=False)
device_name = model_base.name_column(nullable=False)
path = sa.Column(sa.String(512))
host = sa.Column(sa.String(512), nullable=True, index=True)
class EndpointGroupPhysicalDomain(model_base.Base):
"""DB model for Contracts used by EndpointGroup."""
__tablename__ = 'aim_endpoint_group_physical_domains'
epg_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_endpoint_groups.aim_id'),
primary_key=True)
physdom_name = model_base.name_column(primary_key=True)
class DeviceCluster(model_base.Base, model_base.HasAimId, model_base.HasName,
model_base.HasDisplayName, model_base.HasTenantName,
model_base.AttributeMixin, model_base.IsMonitored):
"""DB model for DeviceCluster."""
__tablename__ = 'aim_device_clusters'
__table_args__ = (
model_base.uniq_column(__tablename__, 'tenant_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
device_type = sa.Column(sa.Enum("PHYSICAL", "VIRTUAL"))
service_type = sa.Column(sa.Enum("ADC", "FW", "OTHERS", "IDSIPS", "COPY"))
context_aware = sa.Column(sa.Enum("single-Context", "multi-Context"))
managed = sa.Column(sa.Boolean)
physical_domain_name = model_base.name_column()
vmm_domain_type = model_base.name_column()
vmm_domain_name = model_base.name_column()
encap = sa.Column(sa.String(24))
devices = orm.relationship(DeviceClusterDevice,
backref='cluster',
cascade='all, delete-orphan',
lazy='joined')
def from_attr(self, session, res_attr):
if 'devices' in res_attr:
devs = []
for d in (res_attr.pop('devices', []) or []):
devs.append(
DeviceClusterDevice(name=d['name'],
path=d.get('path', None),
host=d.get('host', None)))
self.devices = devs
# map remaining attributes to model
super(DeviceCluster, self).from_attr(session, res_attr)
def to_attr(self, session):
res_attr = super(DeviceCluster, self).to_attr(session)
for f in res_attr.pop('devices', []):
d = {'name': f.name}
if f.path is not None:
d['path'] = f.path
if f.host is not None:
d['host'] = f.host
res_attr.setdefault('devices', []).append(d)
return res_attr
class ContractSubjectFilter(model_base.Base):
"""DB model for filters used by Contract Subject."""
__tablename__ = 'aim_contract_subject_filters'
subject_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_contract_subjects.aim_id'),
primary_key=True)
name = model_base.name_column(primary_key=True)
direction = sa.Column(sa.Enum('bi', 'in', 'out'), primary_key=True)
class EndpointGroupVMMDomain(model_base.Base):
"""DB model for Contracts used by EndpointGroup."""
__tablename__ = 'aim_endpoint_group_vmm_domains'
epg_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_endpoint_groups.aim_id'),
primary_key=True)
vmm_type = sa.Column(sa.String(64), primary_key=True)
vmm_name = model_base.name_column(primary_key=True)
class ExternalNetworkContract(model_base.Base):
"""DB model for Contracts used by ExternalNetwork."""
__tablename__ = 'aim_external_network_contracts'
ext_net_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_external_networks.aim_id'),
primary_key=True)
name = model_base.name_column(primary_key=True)
provides = sa.Column(sa.Boolean, primary_key=True)
class EndpointGroupContract(model_base.Base):
"""DB model for Contracts used by EndpointGroup."""
__tablename__ = 'aim_endpoint_group_contracts'
epg_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_endpoint_groups.aim_id'),
primary_key=True)
name = model_base.name_column(primary_key=True)
provides = sa.Column(sa.Boolean, primary_key=True)
class VmmInjectedServiceEndpoint(model_base.Base):
"""DB model endpoints used by VmmInjectedService."""
__tablename__ = 'aim_vmm_inj_service_endpoints'
svc_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_vmm_inj_services.aim_id'),
primary_key=True)
ip = sa.Column(sa.String(64), primary_key=True)
pod_name = model_base.name_column(primary_key=True)
class BridgeDomainL3Out(model_base.Base):
"""DB model for L3Outs used by a BridgeDomain."""
__tablename__ = 'aim_bridge_domain_l3outs'
bd_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_bridge_domains.aim_id'),
primary_key=True)
name = model_base.name_column(primary_key=True)
class VMMController(model_base.Base, model_base.HasDisplayName,
model_base.HasAimId, model_base.AttributeMixin,
model_base.IsMonitored, model_base.HasName):
"""DB model for VMM Controller."""
__tablename__ = 'aim_vmm_controllers'
__table_args__ = (model_base.uniq_column(__tablename__, 'domain_type',
'domain_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
domain_name = model_base.name_column(nullable=False)
domain_type = model_base.name_column(nullable=False)
scope = sa.Column(
sa.Enum('unmanaged', 'vm', 'iaas', 'network', 'MicrosoftSCVMM',
'openstack', 'kubernetes'))
root_cont_name = sa.Column(sa.String(64))
host_or_ip = sa.Column(sa.String(128))
mode = sa.Column(sa.Enum('default', 'n1kv', 'unknown', 'ovs', 'k8s'))
class DeviceClusterDevice(model_base.Base):
"""DB model for Devices used by DeviceCluster."""
__tablename__ = 'aim_device_cluster_devices'
dc_aim_id = sa.Column(sa.Integer,
sa.ForeignKey('aim_device_clusters.aim_id'),
primary_key=True)
name = model_base.name_column(primary_key=True)
path = sa.Column(sa.String(512))
class ConcreteDevice(model_base.Base, model_base.HasAimId, model_base.HasName,
model_base.HasDisplayName, model_base.HasTenantName,
model_base.AttributeMixin, model_base.IsMonitored):
"""DB model for ConcreteDevice."""
__tablename__ = 'aim_concrete_devices'
__table_args__ = (model_base.uniq_column(__tablename__, 'tenant_name',
'device_cluster_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
device_cluster_name = model_base.name_column(nullable=False)
class SecurityGroupSubject(model_base.Base, model_base.HasAimId,
model_base.HasName, model_base.HasDisplayName,
model_base.HasTenantName, model_base.AttributeMixin,
model_base.IsMonitored):
"""DB model SecurityGroup Subject."""
__tablename__ = 'aim_security_group_subjects'
__table_args__ = (model_base.uniq_column(__tablename__, 'tenant_name',
'security_group_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
security_group_name = model_base.name_column(nullable=False)
class L3Outside(model_base.Base, model_base.HasAimId, model_base.HasName,
model_base.HasDisplayName, model_base.HasTenantName,
model_base.AttributeMixin, model_base.IsMonitored):
"""DB model for L3Outside."""
__tablename__ = 'aim_l3outsides'
__table_args__ = (
model_base.uniq_column(__tablename__, 'tenant_name', 'name') +
model_base.to_tuple(model_base.Base.__table_args__))
vrf_name = model_base.name_column()
l3_domain_dn = sa.Column(sa.String(1024))
