def delete_server(self, context, server):
"""Delete a server."""
LOG.debug("Deleting server...")
fsm = utils.get_state_machine(start_state=server.status,
target_state=states.DELETED)
@utils.synchronized(server.uuid)
def do_delete_server(server):
try:
self._delete_server(context, server)
except exception.ServerNotFound:
LOG.info("Server disappeared during terminate",
server=server)
except Exception:
# As we're trying to delete always go to Error if something
# goes wrong that _delete_server can't handle.
with excutils.save_and_reraise_exception():
LOG.exception('Setting server status to ERROR',
server=server)
server.power_state = states.NOSTATE
utils.process_event(fsm, server, event='error')
self._rollback_servers_quota(context, 1)
# Issue delete request to driver only if server is associated with
# a underlying node.
if server.node_uuid:
do_delete_server(server)
server.power_state = states.NOSTATE
utils.process_event(fsm, server, event='done')
server.destroy()
def schedule_and_create_servers(self, context, servers,
requested_networks,
user_data,
injected_files,
key_pair,
request_spec=None,
filter_properties=None):
if filter_properties is None:
filter_properties = {}
retry = filter_properties.pop('retry', {})
# update attempt count:
if retry:
retry['num_attempts'] += 1
else:
retry = {
'num_attempts': 1,
'nodes': [] # list of tried nodes
}
filter_properties['retry'] = retry
request_spec['num_servers'] = len(servers)
request_spec['server_ids'] = [s.uuid for s in servers]
try:
nodes = self.scheduler_client.select_destinations(
context, request_spec, filter_properties)
except exception.NoValidNode as e:
# Here should reset the state of building servers to Error
# state. And rollback the quotas.
# TODO(litao) rollback the quotas
with excutils.save_and_reraise_exception():
for server in servers:
fsm = utils.get_state_machine(
start_state=server.status,
target_state=states.ACTIVE)
utils.process_event(fsm, server, event='error')
utils.add_server_fault_from_exc(
context, server, e, sys.exc_info())
LOG.info("The selected nodes %(nodes)s for servers",
{"nodes": nodes})
for (server, node) in six.moves.zip(servers, nodes):
server.node_uuid = node
server.save()
# Add a retry entry for the selected node
retry_nodes = retry['nodes']
retry_nodes.append(node)
for server in servers:
utils.spawn_n(self._create_server,
context, server,
requested_networks,
user_data,
injected_files,
key_pair,
request_spec,
filter_properties)
def rebuild_server(self, context, server):
"""Destroy and re-make this server.
:param context: mogan request context
:param server: server object
"""
LOG.debug('Rebuilding server', server=server)
fsm = utils.get_state_machine(start_state=server.status)
try:
self._rebuild_server(context, server)
except Exception as e:
with excutils.save_and_reraise_exception():
utils.process_event(fsm, server, event='error')
LOG.error(
"Rebuild server %(uuid)s failed."
"Exception: %(exception)s", {
"uuid": server.uuid,
"exception": e
})
utils.process_event(fsm, server, event='done')
LOG.info('Server was successfully rebuilt', server=server)
def rebuild(self, context, server):
"""Rebuild a server."""
fsm = utils.get_state_machine(start_state=server.status)
try:
utils.process_event(fsm, server, event='rebuild')
except exception.ServerNotFound:
LOG.debug("Server is not found while rebuilding", server=server)
return
self.engine_rpcapi.rebuild_server(context, server)
def _delete_server(self, context, server):
fsm = utils.get_state_machine(start_state=server.status)
try:
utils.process_event(fsm, server, event='delete')
except exception.ServerNotFound:
LOG.debug("Server is not found while deleting", server=server)
return
reserve_opts = {'servers': -1}
reservations = self.quota.reserve(context, **reserve_opts)
if reservations:
self.quota.commit(context, reservations)
self.engine_rpcapi.delete_server(context, server)
def power(self, context, server, target):
"""Set power state of a server."""
LOG.debug("Going to try to set server power state to %s",
target, server=server)
fsm = utils.get_state_machine(start_state=server.status)
try:
utils.process_event(fsm, server,
event=states.POWER_ACTION_MAP[target])
except exception.ServerNotFound:
LOG.debug("Server is not found while setting power state",
server=server)
return
self.engine_rpcapi.set_power_state(context, server, target)
def do_delete_server(server):
try:
self._delete_server(context, server)
except exception.ServerNotFound:
LOG.info("Server disappeared during terminate", server=server)
except Exception:
# As we're trying to delete always go to Error if something
# goes wrong that _delete_server can't handle.
with excutils.save_and_reraise_exception():
LOG.exception('Setting server status to ERROR',
server=server)
server.power_state = states.NOSTATE
utils.process_event(fsm, server, event='error')
self._rollback_servers_quota(context, 1)
def set_power_state(self, context, server, state):
"""Set power state for the specified server."""
fsm = utils.get_state_machine(start_state=server.status)
@utils.synchronized(server.uuid)
def do_set_power_state():
LOG.debug('Power %(state)s called for server %(server)s', {
'state': state,
'server': server
})
self.driver.set_power_state(context, server, state)
do_set_power_state()
server.power_state = self.driver.get_power_state(context, server.uuid)
utils.process_event(fsm, server, event='done')
LOG.info('Successfully set node power state: %s', state, server=server)
def rebuild_server(self, context, server, preserve_ephemeral):
"""Destroy and re-make this server.
:param context: mogan request context
:param server: server object
:param preserve_ephemeral: whether preserve ephemeral partition
"""
LOG.debug('Rebuilding server: %s', server)
notifications.notify_about_server_action(
context,
server,
self.host,
action=fields.NotificationAction.REBUILD,
phase=fields.NotificationPhase.START)
fsm = utils.get_state_machine(start_state=server.status)
try:
self._rebuild_server(context, server, preserve_ephemeral)
except Exception as e:
with excutils.save_and_reraise_exception():
utils.process_event(fsm, server, event='error')
LOG.error(
"Rebuild server %(uuid)s failed."
"Exception: %(exception)s", {
"uuid": server.uuid,
"exception": e
})
notifications.notify_about_server_action(
context,
server,
self.host,
action=fields.NotificationAction.REBUILD,
phase=fields.NotificationPhase.ERROR,
exception=e)
utils.process_event(fsm, server, event='done')
notifications.notify_about_server_action(
context,
server,
self.host,
action=fields.NotificationAction.REBUILD,
phase=fields.NotificationPhase.END)
LOG.info('Server was successfully rebuilt')
def rebuild(self, context, server, image_uuid=None):
"""Rebuild a server."""
if not image_uuid:
image_uuid = server.image_uuid
# check if the image exists
self._get_image(context, image_uuid)
if image_uuid != server.image_uuid:
# replace original image with the new one
server.image_uuid = image_uuid
server.save()
fsm = utils.get_state_machine(start_state=server.status)
try:
utils.process_event(fsm, server, event='rebuild')
except exception.ServerNotFound:
LOG.debug("Server is not found while rebuilding", server=server)
return
self.engine_rpcapi.rebuild_server(context, server)
def _create_server(self, context, server, requested_networks,
user_data, injected_files, key_pair, request_spec=None,
filter_properties=None):
"""Perform a deployment."""
LOG.debug("Starting server...", server=server)
notifications.notify_about_server_action(
context, server, self.host,
action=fields.NotificationAction.CREATE,
phase=fields.NotificationPhase.START)
fsm = utils.get_state_machine(start_state=server.status,
target_state=states.ACTIVE)
try:
flow_engine = create_server.get_flow(
context,
self,
server,
requested_networks,
user_data,
injected_files,
key_pair,
request_spec,
filter_properties,
)
except Exception:
with excutils.save_and_reraise_exception():
utils.process_event(fsm, server, event='error')
self._rollback_servers_quota(context, -1)
msg = _("Create manager server flow failed.")
LOG.exception(msg)
def _run_flow():
# This code executes create server flow. If something goes wrong,
# flow reverts all job that was done and reraises an exception.
# Otherwise, all data that was generated by flow becomes available
# in flow engine's storage.
with flow_utils.DynamicLogListener(flow_engine, logger=LOG):
flow_engine.run()
try:
_run_flow()
except Exception as e:
with excutils.save_and_reraise_exception():
server.power_state = states.NOSTATE
utils.process_event(fsm, server, event='error')
self._rollback_servers_quota(context, -1)
LOG.error("Created server %(uuid)s failed."
"Exception: %(exception)s",
{"uuid": server.uuid,
"exception": e})
else:
# Advance the state model for the given event. Note that this
# doesn't alter the server in any way. This may raise
# InvalidState, if this event is not allowed in the current state.
server.power_state = self.driver.get_power_state(context,
server.uuid)
server.launched_at = timeutils.utcnow()
utils.process_event(fsm, server, event='done')
LOG.info("Created server %s successfully.", server.uuid)
def set_power_state(self, context, server, state):
"""Set power state for the specified server."""
fsm = utils.get_state_machine(start_state=server.status)
@utils.synchronized(server.uuid)
def do_set_power_state():
LOG.debug('Power %(state)s called for server %(server)s', {
'state': state,
'server': server
})
self.driver.set_power_state(context, server, state)
try:
do_set_power_state()
server.power_state = self.driver.get_power_state(
context, server.uuid)
except Exception as e:
with excutils.save_and_reraise_exception():
LOG.exception(
"Set server power state to %(state)s failed, "
"the reason: %(reason)s", {
"state": state,
"reason": six.text_type(e)
})
server.power_state = self.driver.get_power_state(
context, server.uuid)
if state in ['reboot', 'soft_reboot'] \
and server.power_state != states.POWER_ON:
utils.process_event(fsm, server, event='error')
else:
utils.process_event(fsm, server, event='fail')
action = POWER_NOTIFICATION_MAP[state]
notifications.notify_about_server_action(
context,
server,
self.host,
action=action,
phase=fields.NotificationPhase.ERROR,
exception=e)
utils.process_event(fsm, server, event='done')
LOG.info('Successfully set node power state: %s', state, server=server)
