def post(self, health_monitor_):
"""Creates a health monitor on a pool."""
context = pecan.request.context.get('octavia_context')
health_monitor = health_monitor_.healthmonitor
pool = self._get_db_pool(context.session, health_monitor.pool_id)
health_monitor.project_id = pool.project_id
self._auth_validate_action(context, health_monitor.project_id,
constants.RBAC_POST)
lock_session = db_api.get_session(autocommit=False)
if self.repositories.check_quota_met(
context.session,
lock_session,
data_models.HealthMonitor,
health_monitor.project_id):
lock_session.rollback()
raise exceptions.QuotaException
hm_dict = db_prepare.create_health_monitor(
health_monitor.to_dict(render_unsets=True))
try:
self._test_lb_and_listener_and_pool_statuses(
lock_session, health_monitor)
db_hm = self._validate_create_hm(lock_session, hm_dict)
lock_session.commit()
except odb_exceptions.DBError:
lock_session.rollback()
raise exceptions.InvalidOption(
value=hm_dict.get('type'), option='type')
except Exception:
with excutils.save_and_reraise_exception():
lock_session.rollback()
return self._send_hm_to_handler(context.session, db_hm)
def post(self, health_monitor_):
"""Creates a health monitor on a pool."""
context = pecan.request.context.get('octavia_context')
health_monitor = health_monitor_.healthmonitor
if (not CONF.api_settings.allow_ping_health_monitors
and health_monitor.type == consts.HEALTH_MONITOR_PING):
raise exceptions.DisabledOption(option='type',
value=consts.HEALTH_MONITOR_PING)
pool = self._get_db_pool(context.session, health_monitor.pool_id)
health_monitor.project_id, provider = self._get_lb_project_id_provider(
context.session, pool.load_balancer_id)
self._auth_validate_action(context, health_monitor.project_id,
consts.RBAC_POST)
# Load the driver early as it also provides validation
driver = driver_factory.get_driver(provider)
lock_session = db_api.get_session(autocommit=False)
try:
if self.repositories.check_quota_met(context.session, lock_session,
data_models.HealthMonitor,
health_monitor.project_id):
raise exceptions.QuotaException(
resource=data_models.HealthMonitor._name())
hm_dict = db_prepare.create_health_monitor(
health_monitor.to_dict(render_unsets=True))
self._test_lb_and_listener_and_pool_statuses(
lock_session, health_monitor)
db_hm = self._validate_create_hm(lock_session, hm_dict)
# Prepare the data for the driver data model
provider_healthmon = (driver_utils.db_HM_to_provider_HM(db_hm))
# Dispatch to the driver
LOG.info("Sending create Health Monitor %s to provider %s",
db_hm.id, driver.name)
driver_utils.call_provider(driver.name,
driver.health_monitor_create,
provider_healthmon)
lock_session.commit()
except odb_exceptions.DBError:
lock_session.rollback()
raise exceptions.InvalidOption(value=hm_dict.get('type'),
option='type')
except Exception:
with excutils.save_and_reraise_exception():
lock_session.rollback()
db_hm = self._get_db_hm(context.session, db_hm.id)
result = self._convert_db_to_type(db_hm,
hm_types.HealthMonitorResponse)
return hm_types.HealthMonitorRootResponse(healthmonitor=result)
def post(self, health_monitor):
"""Creates a health monitor on a pool."""
context = pecan.request.context.get('octavia_context')
health_monitor.project_id = self._get_lb_project_id(
context.session, self.load_balancer_id)
try:
db_hm = self.repositories.health_monitor.get(
context.session, pool_id=self.pool_id)
if db_hm:
raise exceptions.DuplicateHealthMonitor()
except exceptions.NotFound:
pass
lock_session = db_api.get_session(autocommit=False)
if self.repositories.check_quota_met(
context.session,
lock_session,
data_models.HealthMonitor,
health_monitor.project_id):
lock_session.rollback()
raise exceptions.QuotaException(
resource=data_models.HealthMonitor._name()
)
try:
hm_dict = db_prepare.create_health_monitor(
health_monitor.to_dict(render_unsets=True), self.pool_id)
self._test_lb_and_listener_statuses(lock_session)
db_hm = self.repositories.health_monitor.create(lock_session,
**hm_dict)
db_new_hm = self._get_db_hm(lock_session)
lock_session.commit()
except odb_exceptions.DBError:
lock_session.rollback()
raise exceptions.InvalidOption(value=hm_dict.get('type'),
option='type')
except Exception:
with excutils.save_and_reraise_exception():
lock_session.rollback()
try:
LOG.info("Sending Creation of Health Monitor for Pool %s to "
"handler", self.pool_id)
self.handler.create(db_hm)
except Exception:
for listener_id in self._get_affected_listener_ids(
context.session):
with excutils.save_and_reraise_exception(reraise=False):
self.repositories.listener.update(
context.session, listener_id,
operating_status=constants.ERROR)
return self._convert_db_to_type(db_new_hm,
hm_types.HealthMonitorResponse)
def post(self, health_monitor):
"""Creates a health monitor on a pool."""
context = pecan.request.context.get('octavia_context')
try:
db_hm = self.repositories.health_monitor.get(context.session,
pool_id=self.pool_id)
if db_hm:
raise exceptions.DuplicateHealthMonitor()
except exceptions.NotFound:
pass
hm_dict = db_prepare.create_health_monitor(
health_monitor.to_dict(render_unsets=True), self.pool_id)
self._test_lb_and_listener_statuses(context.session)
try:
db_hm = self.repositories.health_monitor.create(
context.session, **hm_dict)
except odb_exceptions.DBError:
# Setting LB and Listener back to active because this is just a
# validation failure
self.repositories.load_balancer.update(
context.session,
self.load_balancer_id,
provisioning_status=constants.ACTIVE)
for listener_id in self._get_affected_listener_ids(
context.session):
self.repositories.listener.update(
context.session,
listener_id,
provisioning_status=constants.ACTIVE)
raise exceptions.InvalidOption(value=hm_dict.get('type'),
option='type')
try:
LOG.info(
_LI("Sending Creation of Health Monitor for Pool %s to "
"handler"), self.pool_id)
self.handler.create(db_hm)
except Exception:
for listener_id in self._get_affected_listener_ids(
context.session):
with excutils.save_and_reraise_exception(reraise=False):
self.repositories.listener.update(
context.session,
listener_id,
operating_status=constants.ERROR)
db_hm = self._get_db_hm(context.session)
return self._convert_db_to_type(db_hm, hm_types.HealthMonitorResponse)
def post(self, health_monitor):
"""Creates a health monitor on a pool."""
context = pecan.request.context.get('octavia_context')
try:
db_hm = self.repositories.health_monitor.get(
context.session, pool_id=self.pool_id)
if db_hm:
raise exceptions.DuplicateHealthMonitor()
except exceptions.NotFound:
pass
hm_dict = db_prepare.create_health_monitor(
health_monitor.to_dict(), self.pool_id)
self._test_lb_and_listener_statuses(context.session)
try:
db_hm = self.repositories.health_monitor.create(context.session,
**hm_dict)
except odb_exceptions.DBError:
# Setting LB and Listener back to active because this is just a
# validation failure
self.repositories.load_balancer.update(
context.session, self.load_balancer_id,
provisioning_status=constants.ACTIVE)
for listener_id in self._get_affected_listener_ids(
context.session):
self.repositories.listener.update(
context.session, listener_id,
provisioning_status=constants.ACTIVE)
raise exceptions.InvalidOption(value=hm_dict.get('type'),
option='type')
try:
LOG.info(_LI("Sending Creation of Health Monitor for Pool %s to "
"handler"), self.pool_id)
self.handler.create(db_hm)
except Exception:
for listener_id in self._get_affected_listener_ids(
context.session):
with excutils.save_and_reraise_exception(reraise=False):
self.repositories.listener.update(
context.session, listener_id,
operating_status=constants.ERROR)
db_hm = self._get_db_hm(context.session)
return self._convert_db_to_type(db_hm, hm_types.HealthMonitorResponse)
def post(self, health_monitor_):
"""Creates a health monitor on a pool."""
context = pecan.request.context.get('octavia_context')
health_monitor = health_monitor_.healthmonitor
pool = self._get_db_pool(context.session, health_monitor.pool_id)
health_monitor.project_id = pool.project_id
lock_session = db_api.get_session(autocommit=False)
hm_dict = db_prepare.create_health_monitor(
health_monitor.to_dict(render_unsets=True))
try:
self._test_lb_and_listener_and_pool_statuses(
lock_session, health_monitor)
db_hm = self._validate_create_hm(lock_session, hm_dict)
lock_session.commit()
except Exception:
with excutils.save_and_reraise_exception():
lock_session.rollback()
return self._send_hm_to_handler(context.session, db_hm)
def _graph_create(self, lock_session, hm_dict):
hm_dict = db_prepare.create_health_monitor(hm_dict)
db_hm = self._validate_create_hm(lock_session, hm_dict)
return db_hm
