1842492088

Build # 1842492088

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/HewlettPackard/squest/commit/<a class=hub.com/HewlettPackard/squest/commit/<a class="double-link" href="https://git"><a class=hub.com/HewlettPackard/squest/commit/<a class="double-link" href="https://git"><a class=hub.com/HewlettPackard/squest/commit/<a class="double-link" href="https://git"><a class=hub.com/HewlettPackard/squest/commit/<a class="double-link" href="https://git"><a class=hub.com/HewlettPackard/squest/commit/acc69312574ff02ad909f4139a2e566ceac375db">acc693125">&lt;a href=&quot;https://github.com/HewlettPackard/squest/commit/</a><a class="double-link" href="https://github.com/HewlettPackard/squest/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/HewlettPackard/squest/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/HewlettPackard/squest/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/HewlettPackard/squest/commit/acc69312574ff02ad909f4139a2e566ceac375db">acc693125</a><a href="https://github.com/HewlettPackard/squest/commit/acc69312574ff02ad909f4139a2e566ceac375db">&lt;a href=&quot;https://github.com/HewlettPackard/squest/commit/acc69312574ff02ad909f4139a2e566ceac375db&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/HewlettPackard/squest/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/HewlettPackard/squest/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/HewlettPackard/squest/commit/acc69312574ff02ad909f4139a2e566ceac375db&amp;quot;&amp;gt;acc693125&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/HewlettPackard/squest/commit/acc69312574ff02ad909f4139a2e566ceac375db&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/HewlettPackard/squest/commit/acc69312574ff02ad909f4139a2e566c&amp;lt;/a&amp;gt;eac375db&amp;</a>quot;&gt;&amp;quot;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/HewlettPackard/squest/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/HewlettPackard/squest/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/HewlettPackard/squ... (continued)

Pull Request Pull Request #383: [Enhancement] Catch all exceptions in processing request

Run Details

6 of 6 new or added lines in 2 files covered. (100.0%)

6209 of 6608 relevant lines covered (93.96%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.64

/service_catalog/models/request.py

import copy
import json
import logging
from datetime import datetime, timedelta
import requests
import towerlib
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType
from django.core.exceptions import ValidationError
from django.db import models
from django.db.models.signals import post_save, pre_delete
from django.dispatch import receiver
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _
from django_celery_beat.models import IntervalSchedule, PeriodicTask
from django_fsm import FSMField, transition, post_transition
from profiles.models.user_role_binding import UserRoleBinding
from profiles.models.team_role_binding import TeamRoleBinding
from profiles.models.role_manager import RoleManager
from service_catalog.models.operations import Operation, OperationType
from service_catalog.models.exceptions import ExceptionServiceCatalog
from service_catalog.models.request_state import RequestState
from service_catalog.models.instance import Instance, InstanceState
from service_catalog.models.state_hooks import HookManager

logger = logging.getLogger(__name__)


class Request(RoleManager):
    fill_in_survey = models.JSONField(default=dict, blank=True)
    admin_fill_in_survey = models.JSONField(default=dict, blank=True)
    instance = models.ForeignKey(Instance, on_delete=models.CASCADE, null=True)
    operation = models.ForeignKey(Operation, on_delete=models.CASCADE)
    user = models.ForeignKey(User, blank=True, null=True, on_delete=models.SET_NULL)
    date_submitted = models.DateTimeField(auto_now=True, blank=True, null=True)
    date_complete = models.DateTimeField(auto_now=False, blank=True, null=True)
    date_archived = models.DateTimeField(auto_now=False, blank=True, null=True)
    tower_job_id = models.IntegerField(blank=True, null=True)
    state = FSMField(default=RequestState.SUBMITTED, choices=RequestState.choices)
    periodic_task = models.ForeignKey(PeriodicTask, on_delete=models.SET_NULL, null=True, blank=True)
    periodic_task_date_expire = models.DateTimeField(auto_now=False, blank=True, null=True)
    failure_message = models.TextField(blank=True, null=True)

    def __str__(self):
        return f"{self.operation.name} - {self.instance.name} (#{self.id})"

    @property
    def full_survey(self):
        return {k: v for k, v in {**self.fill_in_survey, **self.admin_fill_in_survey}.items() if v is not None}

    def set_fill_in_survey(self, survey, enabled_fields=None):
        self.fill_in_survey = {}
        self.admin_fill_in_survey = {}
        if not isinstance(enabled_fields, dict):
            enabled_fields = self.operation.enabled_survey_fields
        for field_name, is_enabled in enabled_fields.items():
            if field_name in survey.keys():
                if is_enabled:
                    self.fill_in_survey[field_name] = survey[field_name]
                else:
                    self.admin_fill_in_survey[field_name] = survey[field_name]
        self.save()

    def clean(self):
        if self.fill_in_survey is None:
            raise ValidationError({'fill_in_survey': _("Please enter a valid JSON. Empty value is {} for JSON.")})

    def can_process(self):
        if self.instance.state in [InstanceState.AVAILABLE, InstanceState.PENDING, InstanceState.UPDATE_FAILED,
                                   InstanceState.PROVISION_FAILED, InstanceState.DELETE_FAILED]:
            return True
        logger.debug(f"Request][process] instance {self.id} is not available or pending")
        return False

    # TODO: add the job id (url of tower and axw are different)
    @property
    def tower_job_url(self):
        return f"{self.operation.job_template.tower_server.url}/#/jobs"

    @transition(field=state, source=RequestState.SUBMITTED, target=RequestState.NEED_INFO)
    def need_info(self):
        pass

    @transition(field=state, source=RequestState.NEED_INFO, target=RequestState.SUBMITTED)
    def re_submit(self):
        pass

    @transition(field=state, source=[RequestState.SUBMITTED,
                                     RequestState.NEED_INFO,
                                     RequestState.REJECTED,
                                     RequestState.ACCEPTED], target=RequestState.CANCELED)
    def cancel(self):
        # delete the related instance if the state was pending (we should have only one)
        if self.instance.state == InstanceState.PENDING:
            self.instance.delete()
            return False
        return True

    @transition(field=state, source=[RequestState.SUBMITTED, RequestState.ACCEPTED, RequestState.NEED_INFO],
                target=RequestState.REJECTED)
    def reject(self):
        pass

    @transition(field=state, source=[RequestState.ACCEPTED, RequestState.SUBMITTED, RequestState.FAILED],
                target=RequestState.ACCEPTED)
    def accept(self):
        pass

    @transition(field=state, source=[RequestState.ACCEPTED, RequestState.FAILED], target=RequestState.PROCESSING,
                conditions=[can_process])
    def process(self):
        logger.info(f"[Request][process] trying to start processing request '{self.id}'")
        # the instance now switch depending of the operation type
        if self.operation.type == OperationType.CREATE:
            self.instance.provisioning()
        elif self.operation.type == OperationType.UPDATE:
            self.instance.updating()
        elif self.operation.type == OperationType.DELETE:
            self.instance.deleting()
        self.instance.save()

    @transition(field=state, source=RequestState.PROCESSING)
    def perform_processing(self):
        # run Tower job
        tower_extra_vars = copy.copy(self.full_survey)
        # add the current instance to extra vars
        from service_catalog.api.serializers.request_serializers import AdminRequestSerializer
        from django.conf import settings
        tower_extra_vars["squest"] = {
            "squest_host": settings.SQUEST_HOST,
            "request": AdminRequestSerializer(self).data
        }
        tower_job_id = None
        try:
            tower_job_id = self.operation.job_template.execute(extra_vars=tower_extra_vars)
        except towerlib.towerlibexceptions.AuthFailed:
            self.has_failed(reason="towerlib.towerlibexceptions.AuthFailed")
        except requests.exceptions.SSLError:
            self.has_failed(reason="requests.exceptions.SSLError")
        except requests.exceptions.ConnectionError:
            self.has_failed(reason="requests.exceptions.ConnectionError")
        except ExceptionServiceCatalog.JobTemplateNotFound as e:
            self.has_failed(reason=e)
        except Exception as e:
            self.has_failed(reason=e)
        if isinstance(tower_job_id, int):
            self.tower_job_id = tower_job_id
            logger.info(f"[Request][process] process started on request '{self.id}'. Tower job id: {tower_job_id}")
            # create a periodic task to check the status until job is complete
            schedule, created = IntervalSchedule.objects.get_or_create(every=10,
                                                                       period=IntervalSchedule.SECONDS)
            self.periodic_task_date_expire = timezone.now() + timedelta(seconds=self.operation.process_timeout_second)
            self.periodic_task = PeriodicTask.objects.create(
                interval=schedule,
                name=f'job_status_check_request_{self.id}',
                task='service_catalog.tasks.check_tower_job_status_task',
                args=json.dumps([self.id]))
            logger.info(
                f'[Request][process] request \'{self.id}\': periodic task created. '
                f'Expire in {self.operation.process_timeout_second} seconds')

    @transition(field=state, source=RequestState.PROCESSING, target=RequestState.FAILED)
    def has_failed(self, reason=None):
        if reason is not None:
            self.failure_message = reason
        if self.operation.type == OperationType.CREATE:
            self.instance.provisioning_has_failed()
        elif self.operation.type == OperationType.UPDATE:
            self.instance.update_has_failed()
        elif self.operation.type == OperationType.DELETE:
            self.instance.delete_has_failed()
        self.instance.save()

    @transition(field=state, source=RequestState.PROCESSING, target=RequestState.COMPLETE)
    def complete(self):
        self.date_complete = datetime.now()

    @transition(field=state, source=RequestState.COMPLETE, target=RequestState.ARCHIVED)
    def archive(self):
        self.date_archived = datetime.now()

    @transition(field=state, source=RequestState.ARCHIVED, target=RequestState.COMPLETE)
    def unarchive(self):
        self.date_archived = None

    def delete(self, *args, **kwargs):
        if self.periodic_task is not None:
            self.periodic_task.delete()
        return super(self.__class__, self).delete(*args, **kwargs)

    def check_job_status(self):
        from ..mail_utils import send_mail_request_update
        if self.tower_job_id is None:
            logger.warning(
                f"[Request][check_job_status] no tower job id for request id {self.id}. Check job status skipped")
            return

        # if the task is expired we remove the periodic task
        date_worker_now = timezone.now()
        if self.periodic_task_date_expire < date_worker_now:
            logger.info("[check_tower_job_status_task] request now expired. deleting the periodic task")
            self.has_failed(reason="Operation execution timeout")
            self.save()
            self.periodic_task.delete()
            return

        tower = self.operation.job_template.tower_server.get_tower_instance()
        job_object = tower.get_unified_job_by_id(self.tower_job_id)

        if job_object.status == "successful":
            logger.info(f"[Request][check_job_status] tower job status successful for request id {self.id}")
            self.complete()
            self.save()
            self.periodic_task.delete()
            if self.operation.type in [OperationType.CREATE, OperationType.UPDATE]:
                if self.operation.type == OperationType.CREATE:
                    self.instance.date_available = timezone.now()
                self.instance.available()
                self.instance.save()
            elif self.operation.type == OperationType.DELETE:
                self.instance.deleted()
                self.instance.save()
            # notify owner and admins that the request is complete
            send_mail_request_update(target_request=self)

        if job_object.status in ["canceled", "failed"]:
            error_message = f"Tower job {self.tower_job_id} status is '{job_object.status}'"
            self.has_failed(error_message)
            self.save()
            self.periodic_task.delete()
            send_mail_request_update(target_request=self)

    @classmethod
    def add_permission(cls, sender, instance, created, *args, **kwargs):
        if created:
            if instance.user:
                instance.add_user_in_role(instance.user, "Admin")
            instance_content_type = ContentType.objects.get_for_model(Instance)
            user_bindings = UserRoleBinding.objects.filter(
                content_type=instance_content_type,
                object_id=instance.instance.id
            )
            team_bindings = TeamRoleBinding.objects.filter(
                content_type=instance_content_type,
                object_id=instance.instance.id
            )
            for user_binding in user_bindings:
                instance.add_user_in_role(user_binding.user, user_binding.role.name)
            for team_binding in team_bindings:
                instance.add_team_in_role(team_binding.team, team_binding.role.name)

    @classmethod
    def accept_if_auto_accept_on_operation(cls, sender, instance, created, *args, **kwargs):
        """
        Switch state to accept automatically if target operation auto_accept is true
        when creating the Request
        :param instance: the current Request
        :type instance: Request
        """
        if created:
            if instance.operation.auto_accept:
                instance.accept()
                instance.save()

    @classmethod
    def process_if_auto_auto_process_on_operation(cls, sender, instance, created, *args, **kwargs):
        """
        Switch state to processing automatically if target operation auto_process is true
        when creating the Request
        :param instance: the current Request
        :type instance: Request
        """
        if created:
            if instance.state == RequestState.ACCEPTED:
                if instance.operation.auto_process:
                    instance.process()
                    instance.save()
                    instance.perform_processing()
                    instance.save()

    @classmethod
    def trigger_hook_handler(cls, sender, instance, name, source, target, *args, **kwargs):
        """
        Proxy method. Cannot be mocked for testing
        """
        HookManager.trigger_hook(sender=sender, instance=instance, name=name, source=source, target=target,
                                 *args, **kwargs)

    @classmethod
    def on_create_call_hook_manager(cls, sender, instance, created, *args, **kwargs):
        if created:
            HookManager.trigger_hook(sender=sender, instance=instance, name="create", source="create",
                                     target=RequestState.SUBMITTED, *args, **kwargs)


@receiver(pre_delete, sender=Instance)
def pre_delete(sender, instance, **kwargs):
    instance.remove_all_bindings()


post_save.connect(Request.add_permission, sender=Request)
post_save.connect(Request.accept_if_auto_accept_on_operation, sender=Request)
post_save.connect(Request.process_if_auto_auto_process_on_operation, sender=Request)
post_transition.connect(Request.trigger_hook_handler, sender=Request)
post_save.connect(Request.on_create_call_hook_manager, sender=Request)

1	import copy	1✔
2	import json	1✔
3	import logging	1✔
4	from datetime import datetime, timedelta	1✔
5	import requests	1✔
6	import towerlib	1✔
7	from django.contrib.auth.models import User	1✔
8	from django.contrib.contenttypes.models import ContentType	1✔
9	from django.core.exceptions import ValidationError	1✔
10	from django.db import models	1✔
11	from django.db.models.signals import post_save, pre_delete	1✔
12	from django.dispatch import receiver	1✔
13	from django.utils import timezone	1✔
14	from django.utils.translation import ugettext_lazy as _	1✔
15	from django_celery_beat.models import IntervalSchedule, PeriodicTask	1✔
16	from django_fsm import FSMField, transition, post_transition	1✔
17	from profiles.models.user_role_binding import UserRoleBinding	1✔
18	from profiles.models.team_role_binding import TeamRoleBinding	1✔
19	from profiles.models.role_manager import RoleManager	1✔
20	from service_catalog.models.operations import Operation, OperationType	1✔
21	from service_catalog.models.exceptions import ExceptionServiceCatalog	1✔
22	from service_catalog.models.request_state import RequestState	1✔
23	from service_catalog.models.instance import Instance, InstanceState	1✔
24	from service_catalog.models.state_hooks import HookManager	1✔
25
26	logger = logging.getLogger(__name__)	1✔
27
28
29	class Request(RoleManager):	1✔
30	fill_in_survey = models.JSONField(default=dict, blank=True)	1✔
31	admin_fill_in_survey = models.JSONField(default=dict, blank=True)	1✔
32	instance = models.ForeignKey(Instance, on_delete=models.CASCADE, null=True)	1✔
33	operation = models.ForeignKey(Operation, on_delete=models.CASCADE)	1✔
34	user = models.ForeignKey(User, blank=True, null=True, on_delete=models.SET_NULL)	1✔
35	date_submitted = models.DateTimeField(auto_now=True, blank=True, null=True)	1✔
36	date_complete = models.DateTimeField(auto_now=False, blank=True, null=True)	1✔
37	date_archived = models.DateTimeField(auto_now=False, blank=True, null=True)	1✔
38	tower_job_id = models.IntegerField(blank=True, null=True)	1✔
39	state = FSMField(default=RequestState.SUBMITTED, choices=RequestState.choices)	1✔
40	periodic_task = models.ForeignKey(PeriodicTask, on_delete=models.SET_NULL, null=True, blank=True)	1✔
41	periodic_task_date_expire = models.DateTimeField(auto_now=False, blank=True, null=True)	1✔
42	failure_message = models.TextField(blank=True, null=True)	1✔
43
44	def __str__(self):	1✔
45	return f"{self.operation.name} - {self.instance.name} (#{self.id})"	1✔
46
47	@property	1✔
48	def full_survey(self):	1✔
49	return {k: v for k, v in {self.fill_in_survey, self.admin_fill_in_survey}.items() if v is not None}	1✔
50
51	def set_fill_in_survey(self, survey, enabled_fields=None):	1✔
52	self.fill_in_survey = {}	1✔
53	self.admin_fill_in_survey = {}	1✔
54	if not isinstance(enabled_fields, dict):	1✔
55	enabled_fields = self.operation.enabled_survey_fields	1✔
56	for field_name, is_enabled in enabled_fields.items():	1✔
57	if field_name in survey.keys():	1✔
58	if is_enabled:	1✔
59	self.fill_in_survey[field_name] = survey[field_name]	1✔
60	else:
61	self.admin_fill_in_survey[field_name] = survey[field_name]	1✔
62	self.save()	1✔
63
64	def clean(self):	1✔
65	if self.fill_in_survey is None:	1✔
66	raise ValidationError({'fill_in_survey': _("Please enter a valid JSON. Empty value is {} for JSON.")})	×
67
68	def can_process(self):	1✔
69	if self.instance.state in [InstanceState.AVAILABLE, InstanceState.PENDING, InstanceState.UPDATE_FAILED,	1✔
70	InstanceState.PROVISION_FAILED, InstanceState.DELETE_FAILED]:
71	return True	1✔
72	logger.debug(f"Request][process] instance {self.id} is not available or pending")	1✔
73	return False	1✔
74
75	# TODO: add the job id (url of tower and axw are different)
76	@property	1✔
77	def tower_job_url(self):	1✔
78	return f"{self.operation.job_template.tower_server.url}/#/jobs"	1✔
79
80	@transition(field=state, source=RequestState.SUBMITTED, target=RequestState.NEED_INFO)	1✔
81	def need_info(self):	1✔
82	pass	1✔
83
84	@transition(field=state, source=RequestState.NEED_INFO, target=RequestState.SUBMITTED)	1✔
85	def re_submit(self):	1✔
86	pass	1✔
87
88	@transition(field=state, source=[RequestState.SUBMITTED,	1✔
89	RequestState.NEED_INFO,
90	RequestState.REJECTED,
91	RequestState.ACCEPTED], target=RequestState.CANCELED)
92	def cancel(self):	1✔
93	# delete the related instance if the state was pending (we should have only one)
94	if self.instance.state == InstanceState.PENDING:	1✔
95	self.instance.delete()	1✔
96	return False	1✔
97	return True	1✔
98
99	@transition(field=state, source=[RequestState.SUBMITTED, RequestState.ACCEPTED, RequestState.NEED_INFO],	1✔
100	target=RequestState.REJECTED)
101	def reject(self):	1✔
102	pass	1✔
103
104	@transition(field=state, source=[RequestState.ACCEPTED, RequestState.SUBMITTED, RequestState.FAILED],	1✔
105	target=RequestState.ACCEPTED)
106	def accept(self):	1✔
107	pass	1✔
108
109	@transition(field=state, source=[RequestState.ACCEPTED, RequestState.FAILED], target=RequestState.PROCESSING,	1✔
110	conditions=[can_process])
111	def process(self):	1✔
112	logger.info(f"[Request][process] trying to start processing request '{self.id}'")	1✔
113	# the instance now switch depending of the operation type
114	if self.operation.type == OperationType.CREATE:	1✔
115	self.instance.provisioning()	1✔
116	elif self.operation.type == OperationType.UPDATE:	1✔
117	self.instance.updating()	1✔
118	elif self.operation.type == OperationType.DELETE:	1✔
119	self.instance.deleting()	1✔
120	self.instance.save()	1✔
121
122	@transition(field=state, source=RequestState.PROCESSING)	1✔
123	def perform_processing(self):	1✔
124	# run Tower job
125	tower_extra_vars = copy.copy(self.full_survey)	1✔
126	# add the current instance to extra vars
127	from service_catalog.api.serializers.request_serializers import AdminRequestSerializer	1✔
128	from django.conf import settings	1✔
129	tower_extra_vars["squest"] = {	1✔
130	"squest_host": settings.SQUEST_HOST,
131	"request": AdminRequestSerializer(self).data
132	}
133	tower_job_id = None	1✔
134	try:	1✔
135	tower_job_id = self.operation.job_template.execute(extra_vars=tower_extra_vars)	1✔
136	except towerlib.towerlibexceptions.AuthFailed:	1✔
137	self.has_failed(reason="towerlib.towerlibexceptions.AuthFailed")	1✔
138	except requests.exceptions.SSLError:	1✔
139	self.has_failed(reason="requests.exceptions.SSLError")	1✔
140	except requests.exceptions.ConnectionError:	1✔
141	self.has_failed(reason="requests.exceptions.ConnectionError")	1✔
142	except ExceptionServiceCatalog.JobTemplateNotFound as e:	1✔
143	self.has_failed(reason=e)	1✔
144	except Exception as e:	×
145	self.has_failed(reason=e)	×
146	if isinstance(tower_job_id, int):	1✔
147	self.tower_job_id = tower_job_id	1✔
148	logger.info(f"[Request][process] process started on request '{self.id}'. Tower job id: {tower_job_id}")	1✔
149	# create a periodic task to check the status until job is complete
150	schedule, created = IntervalSchedule.objects.get_or_create(every=10,	1✔
151	period=IntervalSchedule.SECONDS)
152	self.periodic_task_date_expire = timezone.now() + timedelta(seconds=self.operation.process_timeout_second)	1✔
153	self.periodic_task = PeriodicTask.objects.create(	1✔
154	interval=schedule,
155	name=f'job_status_check_request_{self.id}',
156	task='service_catalog.tasks.check_tower_job_status_task',
157	args=json.dumps([self.id]))
158	logger.info(	1✔
159	f'[Request][process] request \'{self.id}\': periodic task created. '
160	f'Expire in {self.operation.process_timeout_second} seconds')
161
162	@transition(field=state, source=RequestState.PROCESSING, target=RequestState.FAILED)	1✔
163	def has_failed(self, reason=None):	1✔
164	if reason is not None:	1✔
165	self.failure_message = reason	1✔
166	if self.operation.type == OperationType.CREATE:	1✔
167	self.instance.provisioning_has_failed()	1✔
168	elif self.operation.type == OperationType.UPDATE:	1✔
169	self.instance.update_has_failed()	1✔
170	elif self.operation.type == OperationType.DELETE:	1✔
171	self.instance.delete_has_failed()	1✔
172	self.instance.save()	1✔
173
174	@transition(field=state, source=RequestState.PROCESSING, target=RequestState.COMPLETE)	1✔
175	def complete(self):	1✔
176	self.date_complete = datetime.now()	1✔
177
178	@transition(field=state, source=RequestState.COMPLETE, target=RequestState.ARCHIVED)	1✔
179	def archive(self):	1✔
180	self.date_archived = datetime.now()	1✔
181
182	@transition(field=state, source=RequestState.ARCHIVED, target=RequestState.COMPLETE)	1✔
183	def unarchive(self):	1✔
184	self.date_archived = None	1✔
185
186	def delete(self, args, *kwargs):	1✔
187	if self.periodic_task is not None:	1✔
188	self.periodic_task.delete()	1✔
189	return super(self.__class__, self).delete(args, *kwargs)	1✔
190
191	def check_job_status(self):	1✔
192	from ..mail_utils import send_mail_request_update	1✔
193	if self.tower_job_id is None:	1✔
194	logger.warning(	1✔
195	f"[Request][check_job_status] no tower job id for request id {self.id}. Check job status skipped")
196	return	1✔
197
198	# if the task is expired we remove the periodic task
199	date_worker_now = timezone.now()	1✔
200	if self.periodic_task_date_expire < date_worker_now:	1✔
201	logger.info("[check_tower_job_status_task] request now expired. deleting the periodic task")	1✔
202	self.has_failed(reason="Operation execution timeout")	1✔
203	self.save()	1✔
204	self.periodic_task.delete()	1✔
205	return	1✔
206
207	tower = self.operation.job_template.tower_server.get_tower_instance()	1✔
208	job_object = tower.get_unified_job_by_id(self.tower_job_id)	1✔
209
210	if job_object.status == "successful":	1✔
211	logger.info(f"[Request][check_job_status] tower job status successful for request id {self.id}")	1✔
212	self.complete()	1✔
213	self.save()	1✔
214	self.periodic_task.delete()	1✔
215	if self.operation.type in [OperationType.CREATE, OperationType.UPDATE]:	1✔
216	if self.operation.type == OperationType.CREATE:	1✔
217	self.instance.date_available = timezone.now()	1✔
218	self.instance.available()	1✔
219	self.instance.save()	1✔
220	elif self.operation.type == OperationType.DELETE:	1✔
221	self.instance.deleted()	1✔
222	self.instance.save()	1✔
223	# notify owner and admins that the request is complete
224	send_mail_request_update(target_request=self)	1✔
225
226	if job_object.status in ["canceled", "failed"]:	1✔
227	error_message = f"Tower job {self.tower_job_id} status is '{job_object.status}'"	1✔
228	self.has_failed(error_message)	1✔
229	self.save()	1✔
230	self.periodic_task.delete()	1✔
231	send_mail_request_update(target_request=self)	1✔
232
233	@classmethod	1✔
234	def add_permission(cls, sender, instance, created, args, *kwargs):	1✔
235	if created:	1✔
236	if instance.user:	1✔
237	instance.add_user_in_role(instance.user, "Admin")	1✔
238	instance_content_type = ContentType.objects.get_for_model(Instance)	1✔
239	user_bindings = UserRoleBinding.objects.filter(	1✔
240	content_type=instance_content_type,
241	object_id=instance.instance.id
242	)
243	team_bindings = TeamRoleBinding.objects.filter(	1✔
244	content_type=instance_content_type,
245	object_id=instance.instance.id
246	)
247	for user_binding in user_bindings:	1✔
248	instance.add_user_in_role(user_binding.user, user_binding.role.name)	1✔
249	for team_binding in team_bindings:	1✔
250	instance.add_team_in_role(team_binding.team, team_binding.role.name)	1✔
251
252	@classmethod	1✔
253	def accept_if_auto_accept_on_operation(cls, sender, instance, created, args, *kwargs):	1✔
254	"""
255	Switch state to accept automatically if target operation auto_accept is true
256	when creating the Request
257	:param instance: the current Request
258	:type instance: Request
259	"""
260	if created:	1✔
261	if instance.operation.auto_accept:	1✔
262	instance.accept()	1✔
263	instance.save()	1✔
264
265	@classmethod	1✔
266	def process_if_auto_auto_process_on_operation(cls, sender, instance, created, args, *kwargs):	1✔
267	"""
268	Switch state to processing automatically if target operation auto_process is true
269	when creating the Request
270	:param instance: the current Request
271	:type instance: Request
272	"""
273	if created:	1✔
274	if instance.state == RequestState.ACCEPTED:	1✔
275	if instance.operation.auto_process:	1✔
276	instance.process()	1✔
277	instance.save()	1✔
278	instance.perform_processing()	1✔
279	instance.save()	1✔
280
281	@classmethod	1✔
282	def trigger_hook_handler(cls, sender, instance, name, source, target, args, *kwargs):	1✔
283	"""
284	Proxy method. Cannot be mocked for testing
285	"""
286	HookManager.trigger_hook(sender=sender, instance=instance, name=name, source=source, target=target,	1✔
287	args, *kwargs)
288
289	@classmethod	1✔
290	def on_create_call_hook_manager(cls, sender, instance, created, args, *kwargs):	1✔
291	if created:	1✔
292	HookManager.trigger_hook(sender=sender, instance=instance, name="create", source="create",	1✔
293	target=RequestState.SUBMITTED, args, *kwargs)
294
295
296	@receiver(pre_delete, sender=Instance)	1✔
297	def pre_delete(sender, instance, **kwargs):	1✔
298	instance.remove_all_bindings()	1✔
299
300
301	post_save.connect(Request.add_permission, sender=Request)	1✔
302	post_save.connect(Request.accept_if_auto_accept_on_operation, sender=Request)	1✔
303	post_save.connect(Request.process_if_auto_auto_process_on_operation, sender=Request)	1✔
304	post_transition.connect(Request.trigger_hook_handler, sender=Request)	1✔
305	post_save.connect(Request.on_create_call_hook_manager, sender=Request)	1✔

HewlettPackard / squest / 1842492088

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous