1911285612

Build # 1911285612

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/5b161c564ae5d66e58c87651497c2624759a6257">5b161c564">&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/&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/5b161c564ae5d66e58c87651497c2624759a6257">5b161c564</a><a href="https://github.com/HewlettPackard/squest/commit/5b161c564ae5d66e58c87651497c2624759a6257">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/HewlettPackard/squest/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/HewlettPackard/squest/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/HewlettPackard/squest/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/HewlettPackard/squest/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/HewlettPackard/squest/commit/5b161c564ae5d66e58c87651497c2624759a6257&quot;&gt;5b161c564&lt;/a&gt;&lt;a href=&quot;https://github.com/HewlettPackard/squest/commit/5b161c564ae5d66e58c87651497c2624759a6257&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/HewlettPackard/squest/commit/5b161c564ae5d66e58c87651497c2624759a6257&amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;&amp;amp;amp;lt;a href=&amp;amp;amp;quot;https://gi... (continued)

Pull Request Pull Request #408: Release 1.5

Run Details

583 of 583 new or added lines in 50 files covered. (100.0%)

6350 of 6766 relevant lines covered (93.85%)

0.94 hits per line

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

98.61

/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 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 update_fill_in_surveys_accept_request(self, admin_provided_survey_fields):
        for key, value in admin_provided_survey_fields.items():
            if self.operation.tower_survey_fields.filter(enabled=True, name=key).exists():
                self.fill_in_survey[key] = value
            if self.operation.tower_survey_fields.filter(enabled=False, name=key).exists():
                self.admin_fill_in_survey[key] = value
        self.save()

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

HewlettPackard / squest / 1911285612

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