def execute(self):
deploy_running = db().query(Task).filter_by(
cluster=self.cluster,
name=consts.TASK_NAMES.deploy,
status='running').first()
if deploy_running:
raise errors.DeploymentAlreadyStarted(
u"Can't reset environment '{0}' when "
u"deployment is running".format(self.cluster.id))
obsolete_tasks = db().query(Task).filter_by(
cluster_id=self.cluster.id, ).filter(
Task.name.in_([
consts.TASK_NAMES.deploy, consts.TASK_NAMES.deployment,
consts.TASK_NAMES.stop_deployment
]))
for task in obsolete_tasks:
db().delete(task)
db().commit()
task = Task(name=consts.TASK_NAMES.reset_environment,
cluster=self.cluster)
db().add(task)
db.commit()
self._call_silently(task, tasks.ResetEnvironmentTask)
return task
def execute(self):
logger.info(u"Trying to start deployment at cluster '{0}'".format(
self.cluster.name or self.cluster.id, ))
current_tasks = orm().query(Task).filter_by(cluster_id=self.cluster.id,
name="deploy")
for task in current_tasks:
if task.status == "running":
raise errors.DeploymentAlreadyStarted()
elif task.status in ("ready", "error"):
for subtask in task.subtasks:
orm().delete(subtask)
orm().delete(task)
orm().commit()
nodes_to_delete = TaskHelper.nodes_to_delete(self.cluster)
nodes_to_deploy = TaskHelper.nodes_to_deploy(self.cluster)
if not any([nodes_to_deploy, nodes_to_delete]):
raise errors.WrongNodeStatus("No changes to deploy")
self.cluster.status = 'deployment'
orm().add(self.cluster)
orm().commit()
supertask = Task(name="deploy", cluster=self.cluster)
orm().add(supertask)
orm().commit()
task_deletion, task_provision, task_deployment = None, None, None
if nodes_to_delete:
task_deletion = supertask.create_subtask("node_deletion")
self._call_silently(task_deletion, tasks.DeletionTask)
if nodes_to_deploy:
TaskHelper.update_slave_nodes_fqdn(nodes_to_deploy)
task_provision = supertask.create_subtask("provision")
# we assume here that task_provision just adds system to
# cobbler and reboots systems, so it has extreamly small weight
task_provision.weight = 0.05
provision_message = self._call_silently(task_provision,
tasks.ProvisionTask,
method_name='message')
task_provision.cache = provision_message
orm().add(task_provision)
orm().commit()
task_deployment = supertask.create_subtask("deployment")
deployment_message = self._call_silently(task_deployment,
tasks.DeploymentTask,
method_name='message')
task_deployment.cache = deployment_message
orm().add(task_deployment)
orm().commit()
rpc.cast('naily', [provision_message, deployment_message])
logger.debug(u"Deployment: task to deploy cluster '{0}' is {1}".format(
self.cluster.name or self.cluster.id, supertask.uuid))
return supertask
def _remove_obsolete_tasks(self):
locked_tasks = self._lock_required_tasks()
current_tasks = objects.TaskCollection.filter_by(
locked_tasks,
name=consts.TASK_NAMES.deploy
)
# locking cluster
objects.Cluster.get_by_uid(
self.cluster.id,
fail_if_not_found=True,
lock_for_update=True
)
for task in current_tasks:
if task.status == consts.TASK_STATUSES.running:
db().commit()
raise errors.DeploymentAlreadyStarted()
elif task.status in (consts.TASK_STATUSES.ready,
consts.TASK_STATUSES.error):
db().delete(task)
db().flush()
obsolete_tasks = objects.TaskCollection.filter_by_list(
locked_tasks,
'name',
(consts.TASK_NAMES.stop_deployment,
consts.TASK_NAMES.reset_environment)
)
for task in obsolete_tasks:
db().delete(task)
db().flush()
def check_no_running_deployment(cls, cluster):
tasks_q = objects.TaskCollection.get_by_name_and_cluster(
cluster, cls.deployment_tasks).filter_by(
status=consts.TASK_STATUSES.running)
tasks_exists = db.query(tasks_q.exists()).scalar()
if tasks_exists:
raise errors.DeploymentAlreadyStarted(
'Cannot perform the actions because there are '
'running tasks {0}'.format(tasks_q.all()))
def _remove_obsolete_tasks(self):
locked_tasks = self._lock_required_tasks()
current_tasks = objects.TaskCollection.filter_by(
locked_tasks, name=TASK_NAMES.deploy)
for task in current_tasks:
if task.status == TASK_STATUSES.running:
db().commit()
raise errors.DeploymentAlreadyStarted()
elif task.status in (TASK_STATUSES.ready, TASK_STATUSES.error):
db().delete(task)
db().flush()
obsolete_tasks = objects.TaskCollection.filter_by_list(
locked_tasks, 'name',
(TASK_NAMES.stop_deployment, TASK_NAMES.reset_environment))
for task in obsolete_tasks:
db().delete(task)
db().flush()
def execute(self):
deploy_running = db().query(Task).filter_by(
cluster=self.cluster,
name=consts.TASK_NAMES.deploy,
status='running').first()
if deploy_running:
raise errors.DeploymentAlreadyStarted(
u"Can't reset environment '{0}' when "
u"deployment is running".format(self.cluster.id))
obsolete_tasks = db().query(Task).filter_by(
cluster_id=self.cluster.id, ).filter(
Task.name.in_([
consts.TASK_NAMES.deploy, consts.TASK_NAMES.deployment,
consts.TASK_NAMES.stop_deployment
]))
for task in obsolete_tasks:
db().delete(task)
nodes = objects.Cluster.get_nodes_by_role(
self.cluster, consts.VIRTUAL_NODE_TYPES.virt)
for node in nodes:
objects.Node.reset_vms_created_state(node)
db().commit()
supertask = Task(name=consts.TASK_NAMES.reset_environment,
cluster=self.cluster)
db().add(supertask)
al = TaskHelper.create_action_log(supertask)
remove_keys_task = supertask.create_subtask(
consts.TASK_NAMES.reset_environment)
db.commit()
rpc.cast('naily', [
tasks.ResetEnvironmentTask.message(supertask),
tasks.RemoveClusterKeys.message(remove_keys_task)
])
TaskHelper.update_action_log(supertask, al)
return supertask
def execute(self):
logger.info(u"Trying to start deployment at cluster '{0}'".format(
self.cluster.name or self.cluster.id, ))
current_tasks = db().query(Task).filter_by(cluster_id=self.cluster.id,
name="deploy")
for task in current_tasks:
if task.status == "running":
raise errors.DeploymentAlreadyStarted()
elif task.status in ("ready", "error"):
for subtask in task.subtasks:
db().delete(subtask)
db().delete(task)
db().commit()
task_messages = []
nodes_to_delete = TaskHelper.nodes_to_delete(self.cluster)
nodes_to_deploy = TaskHelper.nodes_to_deploy(self.cluster)
nodes_to_provision = TaskHelper.nodes_to_provision(self.cluster)
if not any([nodes_to_provision, nodes_to_deploy, nodes_to_delete]):
raise errors.WrongNodeStatus("No changes to deploy")
self.cluster.status = 'deployment'
db().add(self.cluster)
db().commit()
supertask = Task(name="deploy", cluster=self.cluster)
db().add(supertask)
db().commit()
# checking admin intersection with untagged
network_info = NetworkConfigurationSerializer.serialize_for_cluster(
self.cluster)
check_networks = supertask.create_subtask('check_networks')
self._call_silently(check_networks,
tasks.CheckNetworksTask,
data=network_info,
check_admin_untagged=True)
db().refresh(check_networks)
if check_networks.status == 'error':
return supertask
db().delete(check_networks)
db().commit()
# checking prerequisites
check_before = supertask.create_subtask('check_before_deployment')
logger.debug("Checking prerequisites task: %s", check_before.uuid)
self._call_silently(check_before, tasks.CheckBeforeDeploymentTask)
db().refresh(check_before)
# if failed to check prerequisites
# then task is already set to error
if check_before.status == 'error':
logger.debug("Checking prerequisites failed: %s",
check_before.message)
return supertask
logger.debug(
"Checking prerequisites is successful, starting deployment...")
db().delete(check_before)
db().commit()
# in case of Red Hat
if self.cluster.release.operating_system == "RHEL":
try:
redhat_messages = self._redhat_messages(
supertask,
# provision only?
[{
"uid": n.id,
"platform_name": n.platform_name
} for n in nodes_to_provision])
except Exception as exc:
TaskHelper.update_task_status(supertask.uuid,
status='error',
progress=100,
msg=str(exc))
return supertask
task_messages.extend(redhat_messages)
# /in case of Red Hat
task_deletion, task_provision, task_deployment = None, None, None
if nodes_to_delete:
task_deletion = supertask.create_subtask("node_deletion")
logger.debug("Launching deletion task: %s", task_deletion.uuid)
self._call_silently(task_deletion, tasks.DeletionTask)
if nodes_to_provision:
TaskHelper.update_slave_nodes_fqdn(nodes_to_provision)
logger.debug("There are nodes to provision: %s",
" ".join([n.fqdn for n in nodes_to_provision]))
task_provision = supertask.create_subtask("provision")
# we assume here that task_provision just adds system to
# cobbler and reboots it, so it has extremely small weight
task_provision.weight = 0.05
provision_message = self._call_silently(task_provision,
tasks.ProvisionTask,
method_name='message')
db().refresh(task_provision)
# if failed to generate task message for orchestrator
# then task is already set to error
if task_provision.status == 'error':
return supertask
task_provision.cache = provision_message
db().add(task_provision)
db().commit()
task_messages.append(provision_message)
if nodes_to_deploy:
TaskHelper.update_slave_nodes_fqdn(nodes_to_deploy)
logger.debug("There are nodes to deploy: %s",
" ".join([n.fqdn for n in nodes_to_deploy]))
task_deployment = supertask.create_subtask("deployment")
deployment_message = self._call_silently(task_deployment,
tasks.DeploymentTask,
method_name='message')
# if failed to generate task message for orchestrator
# then task is already set to error
if task_deployment.status == 'error':
return supertask
task_deployment.cache = deployment_message
db().add(task_deployment)
db().commit()
task_messages.append(deployment_message)
if task_messages:
rpc.cast('naily', task_messages)
logger.debug(u"Deployment: task to deploy cluster '{0}' is {1}".format(
self.cluster.name or self.cluster.id, supertask.uuid))
return supertask
def execute(self):
logger.info(u"Trying to start deployment at cluster '{0}'".format(
self.cluster.name or self.cluster.id))
network_info = self.serialize_network_cfg(self.cluster)
logger.info(u"Network info:\n{0}".format(
json.dumps(network_info, indent=4)))
current_tasks = db().query(Task).filter_by(cluster_id=self.cluster.id,
name='deploy')
for task in current_tasks:
if task.status == "running":
raise errors.DeploymentAlreadyStarted()
elif task.status in ("ready", "error"):
db().delete(task)
db().commit()
obsolete_tasks = db().query(Task).filter_by(
cluster_id=self.cluster.id, ).filter(
Task.name.in_(['stop_deployment', 'reset_environment']))
for task in obsolete_tasks:
db().delete(task)
db().commit()
task_messages = []
nodes_to_delete = TaskHelper.nodes_to_delete(self.cluster)
nodes_to_deploy = TaskHelper.nodes_to_deploy(self.cluster)
nodes_to_provision = TaskHelper.nodes_to_provision(self.cluster)
if not any([nodes_to_provision, nodes_to_deploy, nodes_to_delete]):
raise errors.WrongNodeStatus("No changes to deploy")
supertask = Task(name='deploy', cluster=self.cluster)
db().add(supertask)
db().commit()
# Run validation if user didn't redefine
# provisioning and deployment information
if not self.cluster.replaced_provisioning_info \
and not self.cluster.replaced_deployment_info:
try:
self.check_before_deployment(supertask)
except errors.CheckBeforeDeploymentError:
return supertask
# in case of Red Hat
if self.cluster.release.operating_system == "RHEL":
try:
redhat_messages = self._redhat_messages(
supertask,
# provision only?
[{
"uid": n.id,
"platform_name": n.platform_name
} for n in nodes_to_provision])
except Exception as exc:
TaskHelper.update_task_status(supertask.uuid,
status='error',
progress=100,
msg=str(exc))
return supertask
task_messages.extend(redhat_messages)
# /in case of Red Hat
task_deletion, task_provision, task_deployment = None, None, None
if nodes_to_delete:
# For more accurate progress calulation
task_weight = 0.4
task_deletion = supertask.create_subtask("node_deletion",
weight=task_weight)
logger.debug("Launching deletion task: %s", task_deletion.uuid)
self._call_silently(task_deletion, tasks.DeletionTask)
if nodes_to_provision:
TaskHelper.update_slave_nodes_fqdn(nodes_to_provision)
logger.debug("There are nodes to provision: %s",
" ".join([n.fqdn for n in nodes_to_provision]))
# For more accurate progress calulation
task_weight = 0.4
task_provision = supertask.create_subtask("provision",
weight=task_weight)
provision_message = self._call_silently(task_provision,
tasks.ProvisionTask,
nodes_to_provision,
method_name='message')
db().refresh(task_provision)
# if failed to generate task message for orchestrator
# then task is already set to error
if task_provision.status == 'error':
return supertask
task_provision.cache = provision_message
db().add(task_provision)
db().commit()
task_messages.append(provision_message)
if nodes_to_deploy:
TaskHelper.update_slave_nodes_fqdn(nodes_to_deploy)
logger.debug("There are nodes to deploy: %s",
" ".join([n.fqdn for n in nodes_to_deploy]))
task_deployment = supertask.create_subtask("deployment")
deployment_message = self._call_silently(task_deployment,
tasks.DeploymentTask,
nodes_to_deploy,
method_name='message')
# if failed to generate task message for orchestrator
# then task is already set to error
if task_deployment.status == 'error':
return supertask
task_deployment.cache = deployment_message
db().add(task_deployment)
db().commit()
task_messages.append(deployment_message)
if nodes_to_provision:
for node in nodes_to_provision:
node.status = 'provisioning'
db().commit()
self.cluster.status = 'deployment'
db().add(self.cluster)
db().commit()
if task_messages:
rpc.cast('naily', task_messages)
logger.debug(u"Deployment: task to deploy cluster '{0}' is {1}".format(
self.cluster.name or self.cluster.id, supertask.uuid))
return supertask
