def _allocate_allocatable_address(ip_block, interface,
requested_address=None):
"""Slowly migrate off the AllocatableIps Table."""
model = ipam.models.IpAddress
db_session = session.get_session()
db_session.begin()
allocatable_qry = _query_by(ipam.models.AllocatableIp,
db_session=db_session,
ip_block_id=ip_block.id)
if requested_address is not None:
filter_kwargs = {'address': requested_address}
allocatable_qry = allocatable_qry.filter(**filter_kwargs)
allocatable_address = allocatable_qry.first()
if not allocatable_address:
db_session.commit()
return
ip = allocatable_address.address
address = model(id=utils.generate_uuid(),
created_at=utils.utcnow(),
updated_at=utils.utcnow(),
address=str(ip),
ip_block_id=ip_block.id,
interface_id=interface.id,
used_by_tenant_id=interface.tenant_id,
allocated=True)
db_session.merge(address)
try:
db_session.flush()
except sqlalchemy.exc.IntegrityError:
db_session.rollback()
db_session.begin()
db_session.delete(allocatable_address)
db_session.commit()
LOG.debug("Allocatable ip %s in block %s was a dupe. Deleted" %
(ip, ip_block.id))
return _allocate_allocatable_address(ip_block, interface,
requested_address)
db_session.delete(allocatable_address)
db_session.commit()
return address
db_session.delete(allocatable_qry.address)
def delete_interface(interface):
db_session = session.get_session()
with db_session.begin():
mac_qry = _query_by(ipam.models.MacAddress, db_session=db_session,
interface_id=interface.id)
mac = mac_qry.with_lockmode('update').first()
if mac:
db_session.delete(mac)
ips_qry = _query_by(ipam.models.IpAddress, db_session=db_session,
interface_id=interface.id)
ips = ips_qry.with_lockmode('update').all()
for ip in ips:
LOG.debug("Marking IP address for deallocation: %r" % ip)
ip.allocated = False
ip.marked_for_deallocation = True
ip.deallocated_at = utils.utcnow()
ip.interface_id = None
db_session.merge(ip)
db_session.delete(interface)
return mac, ips
# NOTE(jkoelker) Failsafe return:
return None, []
def create(cls, **values):
if 'id' not in values or values['id'] is None:
values['id'] = utils.generate_uuid()
values['created_at'] = utils.utcnow()
instance = cls(**values).save()
instance._notify_fields("create")
return instance
def save(self):
if not self.is_valid():
raise InvalidModelError(self.errors)
self._convert_columns_to_proper_type()
self._before_save()
self['updated_at'] = utils.utcnow()
return db.db_api.save(self)
def save(self):
if not self.is_valid():
raise InvalidModelError(self.errors)
self._convert_columns_to_proper_type()
self._before_save()
self['updated_at'] = utils.utcnow()
LOG.debug("Saving %s: %s" % (self.__class__.__name__, self.__dict__))
return db.db_api.save(self)
def deallocated_by_date():
days = config.Config.get('keep_deallocated_ips_for_days')
if days is None:
seconds = config.Config.get('keep_deallocated_ips_for_seconds', 172800)
else:
seconds = int(days) * 86400
LOG.debug("Delete delay = ", seconds)
return utils.utcnow() - datetime.timedelta(seconds=int(seconds))
def save(self):
if not self.is_valid():
raise InvalidModelError(self.errors)
self._convert_columns_to_proper_type()
self._before_save()
self['updated_at'] = utils.utcnow()
LOG.debug("Saving %s: %s" % (self.__class__.__name__, self.__dict__))
return db.db_api.save(self)
def _generate_message(self, event_type, priority, payload):
return {
"message_id": str(utils.generate_uuid()),
"publisher_id": socket.gethostname(),
"event_type": event_type,
"priority": priority,
"payload": payload,
"timestamp": str(utils.utcnow()),
}
def _generate_message(self, event_type, priority, payload):
return {
"message_id": str(utils.generate_uuid()),
"publisher_id": socket.gethostname(),
"event_type": event_type,
"priority": priority,
"payload": payload,
"timestamp": str(utils.utcnow()),
}
def _setup_expected_message(self, priority, event,
message):
self.setup_uuid_with("test_uuid")
return {'event_type': event,
'timestamp': str(utils.utcnow()),
'priority': priority,
'message_id': "test_uuid",
'payload': message,
'publisher_id': socket.gethostname(),
}
def _setup_expected_message(self, priority, event, message):
self.setup_uuid_with("test_uuid")
return {
'event_type': event,
'timestamp': str(utils.utcnow()),
'priority': priority,
'message_id': "test_uuid",
'payload': message,
'publisher_id': socket.gethostname(),
}
def deallocate(self):
LOG.debug("Marking IP address for deallocation: %r" % self)
self.update(marked_for_deallocation=True,
deallocated_at=utils.utcnow(),
interface_id=None)
def deallocate(self):
LOG.debug("Marking IP address for deallocation: %r" % self)
self.update(marked_for_deallocation=True,
deallocated_at=utils.utcnow(),
interface_id=None)
def create(cls, **values):
values['id'] = utils.generate_uuid()
values['created_at'] = utils.utcnow()
instance = cls(**values).save()
instance._notify_fields("create")
return instance
def deallocated_by_date():
days = config.Config.get('keep_deallocated_ips_for_days', 2)
return utils.utcnow() - datetime.timedelta(days=int(days))
def deallocate(self):
self.update(marked_for_deallocation=True,
deallocated_at=utils.utcnow(),
interface_id=None)
def allocate_ipv4_address(ip_block, interface, requested_address=None):
model = ipam.models.IpAddress
address = _allocate_allocatable_address(ip_block, interface,
requested_address)
if address:
return address
db_session = session.get_session()
with db_session.begin():
address_qry = _query_by(model, db_session=db_session,
allocated=False,
marked_for_deallocation=False,
ip_block_id=ip_block.id)
if requested_address is not None:
address_qry = address_qry.filter(address=requested_address)
address = address_qry.with_lockmode('update').first()
if address:
address.allocated = True
address.interface_id = interface.id
address.used_by_tenant_id = interface.tenant_id
address.updated_at = utils.utcnow()
db_session.merge(address)
return address
else:
ips = netaddr.IPNetwork(ip_block.cidr)
counter = (ip_block.allocatable_ip_counter or ips[0].value)
if counter >= ips[-1].value:
ip_block.is_full = True
# NOTE(jkoelker) explicit save() to flush the session prior
# to raising
save(ip_block, db_session=db_session)
raise exception.NoMoreAddressesError(_("IpBlock is full"))
ip = netaddr.IPAddress(counter)
# NOTE(jkoelker) HRM, this may need to be rethought order wise
counter = counter + 1
if counter >= ips[-1].value:
ip_block.is_full = True
ip_block.allocatable_ip_counter = counter
db_session.merge(ip_block)
# NOTE(jkoelker) SQLAlchemy models, how do you work? ;)
address = model(id=utils.generate_uuid(),
created_at=utils.utcnow(),
updated_at=utils.utcnow(),
address=str(ip),
ip_block_id=ip_block.id,
interface_id=interface.id,
used_by_tenant_id=interface.tenant_id,
allocated=True)
db_session.merge(address)
return address
