Example #1
0
def abandon_release(name):
    session = current_app.db.session
    try:
        release = session.query(Release).filter(Release.name == name).one()

        # we must require scope which depends on product
        required_permission = f"{SCOPE_PREFIX}/abandon_release/{release.product}"
        if not current_user.has_permissions(required_permission):
            user_permissions = ", ".join(current_user.get_permissions())
            abort(
                401,
                f"required permission: {required_permission}, user permissions: {user_permissions}"
            )

        # Cancel all submitted task groups first
        for phase in filter(lambda x: x.submitted and not x.skipped,
                            release.phases):
            try:
                actions = fetch_artifact(phase.task_id, "public/actions.json")
                parameters = fetch_artifact(phase.task_id,
                                            "public/parameters.yml")
            except ArtifactNotFound:
                logger.info("Ignoring not completed action task %s",
                            phase.task_id)
                continue

            hook = generate_action_hook(task_group_id=phase.task_id,
                                        action_name="cancel-all",
                                        actions=actions,
                                        parameters=parameters,
                                        input_={})
            hooks = get_service("hooks")
            client_id = hooks.options["credentials"]["clientId"].decode(
                "utf-8")
            hook["context"]["clientId"] = client_id
            hook_payload_rendered = render_action_hook(
                payload=hook["hook_payload"],
                context=hook["context"],
                delete_params=[
                    "existing_tasks", "release_history",
                    "release_partner_config"
                ])
            logger.info("Cancel phase %s by hook %s with payload: %s",
                        phase.name, hook["hook_id"], hook_payload_rendered)
            res = hooks.triggerHook(hook["hook_group_id"], hook["hook_id"],
                                    hook_payload_rendered)
            logger.debug("Done: %s", res)

        release.status = "aborted"
        session.commit()
        release_json = release.json
    except NoResultFound:
        abort(404)

    notify_via_irc(
        release.product,
        f"Release {release.product} {release.version} build{release.build_number} was just canceled."
    )

    return release_json
Example #2
0
def abandon_release(name):
    session = current_app.db.session
    try:
        release = session.query(Release).filter(Release.name == name).one()

        # we must require scope which depends on product
        required_permission = f'{SCOPE_PREFIX}/abandon_release/{release.product}'
        if not current_user.has_permissions(required_permission):
            user_permissions = ', '.join(current_user.get_permissions())
            abort(
                401,
                f'required permission: {required_permission}, user permissions: {user_permissions}'
            )

        # Cancel all submitted task groups first
        for phase in filter(lambda x: x.submitted, release.phases):
            try:
                actions = fetch_actions_json(phase.task_id)
            except ActionsJsonNotFound:
                logger.info('Ignoring not completed action task %s',
                            phase.task_id)
                continue

            hook = generate_action_hook(
                task_group_id=phase.task_id,
                action_name='cancel-all',
                actions=actions,
                input_={},
            )
            hooks = get_service('hooks')
            client_id = hooks.options['credentials']['clientId'].decode(
                'utf-8')
            hook['context']['clientId'] = client_id
            hook_payload_rendered = render_action_hook(
                payload=hook['hook_payload'],
                context=hook['context'],
                delete_params=[
                    'existing_tasks', 'release_history',
                    'release_partner_config'
                ],
            )
            logger.info('Cancel phase %s by hook %s with payload: %s',
                        phase.name, hook['hook_id'], hook_payload_rendered)
            res = hooks.triggerHook(hook['hook_group_id'], hook['hook_id'],
                                    hook_payload_rendered)
            logger.debug('Done: %s', res)

        release.status = 'aborted'
        session.commit()
        release_json = release.json
    except NoResultFound:
        abort(404)

    notify_via_irc(
        release.product,
        f'Release {release.product} {release.version} build{release.build_number} was just canceled.'
    )

    return release_json
Example #3
0
 def rendered_hook_payload(self):
     context = self.context_json
     previous_graph_ids = context['input']['previous_graph_ids']
     # The first ID is always the decision task ID. We need to update the
     # remaining tasks' IDs using their names.
     decision_task_id, remaining = previous_graph_ids[
         0], previous_graph_ids[1:]
     resolved_previous_graph_ids = [decision_task_id]
     other_phases = {p.name: p.task_id for p in self.release.phases}
     for phase_name in remaining:
         resolved_previous_graph_ids.append(other_phases[phase_name])
     context['input']['previous_graph_ids'] = resolved_previous_graph_ids
     return render_action_hook(self.task_json['hook_payload'], context)
Example #4
0
 def rendered_hook_payload(self, extra_context={}):
     context = self.context_json
     previous_graph_ids = context['input']['previous_graph_ids']
     # The first ID is always the decision task ID. We need to update the
     # remaining tasks' IDs using their names.
     decision_task_id, remaining = previous_graph_ids[0], previous_graph_ids[1:]
     resolved_previous_graph_ids = [decision_task_id]
     other_phases = {p.name: p.task_id for p in self.release.phases}
     for phase_name in remaining:
         resolved_previous_graph_ids.append(other_phases[phase_name])
     context['input']['previous_graph_ids'] = resolved_previous_graph_ids
     if extra_context:
         context.update(extra_context)
     return render_action_hook(self.task_json['hook_payload'], context)
Example #5
0
def abandon_release(name):
    session = g.db.session
    try:
        r = session.query(Release).filter(Release.name == name).one()
        # Cancel all submitted task groups first
        for phase in filter(lambda x: x.submitted, r.phases):
            try:
                actions = fetch_actions_json(phase.task_id)
            except ActionsJsonNotFound:
                logger.info('Ignoring not completed action task %s',
                            phase.task_id)
                continue

            hook = generate_action_hook(
                task_group_id=phase.task_id,
                action_name='cancel-all',
                actions=actions,
                input_={},
            )
            hooks = get_service('hooks')
            client_id = hooks.options['credentials']['clientId'].decode(
                'utf-8')
            hook['context']['clientId'] = client_id
            hook_payload_rendered = render_action_hook(
                payload=hook['hook_payload'],
                context=hook['context'],
                delete_params=[
                    'existing_tasks', 'release_history',
                    'release_partner_config'
                ],
            )
            logger.info('Cancel phase %s by hook %s with payload: %s',
                        phase.name, hook['hook_id'], hook_payload_rendered)
            res = hooks.triggerHook(hook['hook_group_id'], hook['hook_id'],
                                    hook_payload_rendered)
            logger.debug('Done: %s', res)

        r.status = 'aborted'
        session.commit()
        release = r.json
    except NoResultFound:
        abort(404)

    notify_via_irc(
        f'Release {r.product} {r.version} build{r.build_number} was just canceled.'
    )

    return release
Example #6
0
 def rendered_hook_payload(self, extra_context={}):
     context = self.context_json
     previous_graph_ids = context["input"]["previous_graph_ids"]
     # The first ID is always the decision task ID. We need to update the
     # remaining tasks' IDs using their names.
     decision_task_id, remaining = previous_graph_ids[0], previous_graph_ids[1:]
     resolved_previous_graph_ids = [decision_task_id]
     other_phases = {p.name: p.task_id for p in self.release.phases}
     for phase_name in remaining:
         resolved_previous_graph_ids.append(other_phases[phase_name])
     # in case we skip a phase, the task ID is not defined, we want to
     # filter it out
     resolved_previous_graph_ids = filter(None, resolved_previous_graph_ids)
     context["input"]["previous_graph_ids"] = list(resolved_previous_graph_ids)
     if extra_context:
         context.update(extra_context)
     return render_action_hook(self.task_json["hook_payload"], context)