Basic MAC Address allocation

quark/db/models.py

@@ -26,6 +26,7 @@ from quantum.openstack.common import log as logging
 
 LOG = logging.getLogger("quantum")
 
+
 class CreatedAt(object):
     created_at = sa.Column(sa.DateTime(), default=timeutils.utcnow)
 
@@ -143,19 +144,6 @@ class Subnet(BASEV2, CreatedAt, HasId, HasTenant):
     routes = orm.relationship(Route, backref='subnet', cascade='delete')
 
 
-class MacAddress(BASEV2, CreatedAt, HasTenant):
-    __tablename__ = "quark_mac_addresses"
-    address = sa.Column(sa.Integer(), primary_key=True)
-    mac_address_range_id = sa.Column(sa.Integer(),
-                                sa.ForeignKey("quark_mac_address_ranges.id"),
-                                nullable=False)
-
-
-class MacAddressRange(BASEV2, CreatedAt, HasId):
-    __tablename__ = "quark_mac_address_ranges"
-    cidr = sa.Column(sa.String(255), nullable=False)
-
-
 class Port(BASEV2, CreatedAt, HasId, HasTenant):
     __tablename__ = "quark_ports"
     network_id = sa.Column(sa.String(36), sa.ForeignKey("quark_networks.id"),
@@ -173,6 +161,23 @@ class Port(BASEV2, CreatedAt, HasId, HasTenant):
     device_id = sa.Column(sa.String(255), nullable=False)
 
 
+class MacAddress(BASEV2, CreatedAt, HasTenant):
+    __tablename__ = "quark_mac_addresses"
+    address = sa.Column(sa.BigInteger(), primary_key=True)
+    mac_address_range_id = sa.Column(sa.String(36),
+                                sa.ForeignKey("quark_mac_address_ranges.id"),
+                                nullable=False)
+    orm.relationship(Port, backref="mac_address")
+
+
+class MacAddressRange(BASEV2, CreatedAt, HasId):
+    __tablename__ = "quark_mac_address_ranges"
+    cidr = sa.Column(sa.String(255), nullable=False)
+    prefix = sa.Column(sa.Integer(), nullable=False)
+    first_address = sa.Column(sa.BigInteger(), nullable=False)
+    last_address = sa.Column(sa.BigInteger(), nullable=False)
+
+
 class Network(BASEV2, CreatedAt, HasTenant, HasId):
     __tablename__ = "quark_networks"
     name = sa.Column(sa.String(255))

quark/ipam.py

@@ -50,6 +50,42 @@ class QuarkIpam(object):
 
         raise exceptions.IpAddressGenerationFailure(net_id=net_id)
 
+    def allocate_mac_address(self, session, net_id, port_id, tenant_id):
+        ranges = session.query(models.MacAddressRange,
+                               sql_func.count(models.MacAddress).
+                               label("count")).\
+                        outerjoin(models.MacAddress).\
+                        group_by(models.MacAddressRange).\
+                        order_by("count DESC").\
+                        all()
+        if not ranges:
+            raise exceptions.MacAddressGenerationFailure(net_id=net_id)
+        LOG.critical(ranges)
+        for result in ranges:
+            rng, addr_count = result
+            if rng["last_address"] - rng["first_address"] <= addr_count:
+                continue
+            highest_mac = session.query(models.MacAddress).\
+                            filter(models.MacAddress.mac_address_range_id ==
+                                   rng["id"]).\
+                            order_by("address DESC").\
+                            first()
+            address = models.MacAddress()
+            LOG.critical(highest_mac)
+            if highest_mac:
+                next_mac = netaddr.EUI(highest_mac["address"]).value
+                address["address"] = netaddr.EUI(next_mac + 1)
+            else:
+                address["address"] = rng["first_address"]
+
+            address["mac_address_range_id"] = rng["id"]
+            address["tenant_id"] = tenant_id
+            LOG.critical(address)
+            session.add(address)
+            return address
+
+        raise exceptions.MacAddressGenerationFailure(net_id=net_id)
+
     def allocate_ip_address(self, session, net_id, port_id):
         address = session.query(models.IPAddress).\
                           filter(models.IPAddress.network_id == net_id).\

quark/plugin.py

@@ -89,7 +89,7 @@ class Plugin(quantum_plugin_base_v2.QuantumPluginBaseV2):
                'network_id': subnet.get('network_id'),
                'ip_version': subnet.get('ip_version'),
                'cidr': subnet.get('cidr'),
-               'enable_dhcp': subnet.get('enable_dhcp'),}
+               'enable_dhcp': subnet.get('enable_dhcp')}
                #'dns_nameservers': [dns.get('address')
                #                    for dns in subnet.get('dns_nameservers')],
                #'gateway_ip': subnet.get('gateway_ip'),
@@ -141,7 +141,7 @@ class Plugin(quantum_plugin_base_v2.QuantumPluginBaseV2):
         new_subnet = self._create_subnet(context, subnet, session)
         session.flush()
         subnet_dict = self._make_subnet_dict(new_subnet)
-        return self._make_subnet_dict(new_subnet)
+        return subnet_dict
 
     def update_subnet(self, context, id, subnet):
         """
@@ -409,6 +409,10 @@ class Plugin(quantum_plugin_base_v2.QuantumPluginBaseV2):
             addresses = self.ipam_driver.allocate_ip_address(session,
                                                              net_id,
                                                              port_id)
+            macs = self.ipam_driver.allocate_mac_address(session,
+                                                         net_id,
+                                                         port_id,
+                                                         context.tenant_id)
 
             #TODO(mdietz): aic doesn't support creating new switches past the
             #              first one. We need to implement spanning and tagging