def update_pool(self, context, id, pool):
with context.session.begin(subtransactions=True):
pool_db = self._get_resource(context, models.PoolV2, id)
hm_id = pool.get('healthmonitor_id')
if hm_id:
if not self._resource_exists(context, models.HealthMonitorV2,
hm_id):
raise loadbalancerv2.EntityNotFound(
name=models.HealthMonitorV2.NAME, id=hm_id)
filters = {'healthmonitor_id': [hm_id]}
hmpools = self._get_resources(context,
models.PoolV2,
filters=filters)
if hmpools:
raise loadbalancerv2.EntityInUse(
entity_using=models.PoolV2.NAME,
id=hmpools[0].id,
entity_in_use=models.HealthMonitorV2.NAME)
# Only update or delete session persistence if it was part
# of the API request.
if 'session_persistence' in pool.keys():
sp = pool.pop('session_persistence')
if sp is None or sp == {}:
self._delete_session_persistence(context, id)
else:
self._update_pool_session_persistence(context, id, sp)
# sqlalchemy cries if listeners is defined.
listeners = pool.get('listeners')
if listeners:
del pool['listeners']
pool_db.update(pool)
context.session.refresh(pool_db)
return data_models.Pool.from_sqlalchemy_model(pool_db)
def update_pool(self, context, id, pool):
with context.session.begin(subtransactions=True):
pool_db = self._get_resource(context, models.PoolV2, id)
hm_id = pool.get('healthmonitor_id')
if hm_id:
if not self._resource_exists(context, models.HealthMonitorV2,
hm_id):
raise loadbalancerv2.EntityNotFound(
name=models.HealthMonitorV2.NAME, id=hm_id)
filters = {'healthmonitor_id': [hm_id]}
hmpools = self._get_resources(context,
models.PoolV2,
filters=filters)
if hmpools:
raise loadbalancerv2.EntityInUse(
entity_using=models.PoolV2.NAME,
id=hmpools[0].id,
entity_in_use=models.HealthMonitorV2.NAME)
sp = pool.pop('session_persistence', None)
if sp:
self._update_pool_session_persistence(context, id, sp)
else:
self._delete_session_persistence(context, id)
pool_db.update(pool)
context.session.refresh(pool_db)
return data_models.Pool.from_sqlalchemy_model(pool_db)
def test_and_set_status(self, context, model, id, status):
with context.session.begin(subtransactions=True):
db_lb_child = None
if model == models.LoadBalancer:
db_lb = self._get_resource(context, model, id, for_update=True)
else:
if model == models.PoolV2:
pool = self._get_resource(context, model, id)
if pool.healthmonitor and\
status == constants.PENDING_DELETE:
raise loadbalancerv2.EntityInUse(
entity_using=models.HealthMonitorV2.NAME,
id=pool.healthmonitor.id,
entity_in_use=models.PoolV2.NAME)
db_lb_child = self._get_resource(context, model, id)
db_lb = self._get_resource(context, models.LoadBalancer,
db_lb_child.root_loadbalancer.id)
# This method will raise an exception if modification is not
# allowed.
self.assert_modification_allowed(db_lb)
# if the model passed in is not a load balancer then we will
# set its root load balancer's provisioning status to
# PENDING_UPDATE and the model's status to the status passed in
# Otherwise we are just setting the load balancer's provisioning
# status to the status passed in
if db_lb_child:
db_lb.provisioning_status = constants.PENDING_UPDATE
db_lb_child.provisioning_status = status
else:
db_lb.provisioning_status = status
def delete_loadbalancer(self, context, id):
old_lb = self.db.get_loadbalancer(context, id)
if old_lb.listeners:
raise loadbalancerv2.EntityInUse(
entity_using=models.Listener.NAME,
id=old_lb.listeners[0].id,
entity_in_use=models.LoadBalancer.NAME)
self.db.test_and_set_status(context, models.LoadBalancer, id,
constants.PENDING_DELETE)
driver = self._get_driver_for_provider(old_lb.provider.provider_name)
db_lb = self.db.get_loadbalancer(context, id)
self._call_driver_operation(
context, driver.load_balancer.delete, db_lb)
def delete_listener(self, context, id):
old_listener = self.db.get_listener(context, id)
if old_listener.default_pool:
raise loadbalancerv2.EntityInUse(
entity_using=models.PoolV2.NAME,
id=old_listener.default_pool.id,
entity_in_use=models.Listener.NAME)
self.db.test_and_set_status(context, models.Listener, id,
constants.PENDING_DELETE)
listener_db = self.db.get_listener(context, id)
driver = self._get_driver_for_loadbalancer(
context, listener_db.loadbalancer_id)
self._call_driver_operation(
context, driver.listener.delete, listener_db)
def _validate_listener_data(self, context, listener):
pool_id = listener.get('default_pool_id')
lb_id = listener.get('loadbalancer_id')
if lb_id:
if not self._resource_exists(context, models.LoadBalancer, lb_id):
raise loadbalancerv2.EntityNotFound(
name=models.LoadBalancer.NAME, id=lb_id)
if pool_id:
pool = self._get_resource(context, models.PoolV2, pool_id)
if ((pool.protocol, listener.get('protocol'))
not in lb_const.LISTENER_POOL_COMPATIBLE_PROTOCOLS):
raise loadbalancerv2.ListenerPoolProtocolMismatch(
listener_proto=listener['protocol'],
pool_proto=pool.protocol)
filters = {'default_pool_id': [pool_id]}
listenerpools = self._get_resources(context,
models.Listener,
filters=filters)
if listenerpools:
raise loadbalancerv2.EntityInUse(
entity_using=models.Listener.NAME,
id=listenerpools[0].id,
entity_in_use=models.PoolV2.NAME)
