Python utils.broadcast函数代码示例

def broadcast_remove_orphan_symlinks():
    """
    Broadcast the task ``remove_orphan_symlinks`` to all our web servers.

    This task is executed by CELERY BEAT.
    """
    broadcast(type='web', task=remove_orphan_symlinks, args=[])

def finish_build(version_pk, build_pk, hostname=None, html=False,
                 localmedia=False, search=False, pdf=False, epub=False):
    """Build Finished, do house keeping bits"""
    version = Version.objects.get(pk=version_pk)
    build = Build.objects.get(pk=build_pk)

    if html:
        version.active = True
        version.built = True
        version.save()

    if not pdf:
        clear_pdf_artifacts(version)
    if not epub:
        clear_epub_artifacts(version)

    move_files(
        version_pk=version_pk,
        hostname=hostname,
        html=html,
        localmedia=localmedia,
        search=search,
        pdf=pdf,
        epub=epub,
    )

    # Symlink project on every web
    broadcast(type='app', task=symlink_project, args=[version.project.pk])

    # Delayed tasks
    update_static_metadata.delay(version.project.pk)
    fileify.delay(version.pk, commit=build.commit)
    update_search.delay(version.pk, commit=build.commit)

 def delete(self, *args, **kwargs):  # pylint: disable=arguments-differ
     from readthedocs.projects import tasks
     log.info('Removing files for version %s', self.slug)
     broadcast(type='app', task=tasks.clear_artifacts, args=[self.pk])
     broadcast(
         type='app', task=tasks.symlink_project, args=[self.project.pk])
     super(Version, self).delete(*args, **kwargs)

def project_subprojects(request, project_slug):
    """Project subprojects view and form view"""
    project = get_object_or_404(Project.objects.for_admin_user(request.user),
                                slug=project_slug)

    form_kwargs = {
        'parent': project,
        'user': request.user,
    }
    if request.method == 'POST':
        form = SubprojectForm(request.POST, **form_kwargs)
        if form.is_valid():
            form.save()
            broadcast(type='app', task=tasks.symlink_subproject, args=[project.pk])
            project_dashboard = reverse(
                'projects_subprojects', args=[project.slug])
            return HttpResponseRedirect(project_dashboard)
    else:
        form = SubprojectForm(**form_kwargs)

    subprojects = project.subprojects.all()

    return render_to_response(
        'projects/project_subprojects.html',
        {'form': form, 'project': project, 'subprojects': subprojects},
        context_instance=RequestContext(request)
    )

def project_subprojects_delete(request, project_slug, child_slug):
    parent = get_object_or_404(Project.objects.for_admin_user(request.user), slug=project_slug)
    child = get_object_or_404(Project.objects.all(), slug=child_slug)
    parent.remove_subproject(child)
    broadcast(type='app', task=tasks.symlink_subproject, args=[parent.pk])
    return HttpResponseRedirect(reverse('projects_subprojects',
                                        args=[parent.slug]))

 def form_valid(self, form):
     broadcast(
         type='app',
         task=tasks.symlink_subproject,
         args=[self.get_project().pk],
     )
     return super(ProjectRelationshipMixin, self).form_valid(form)

def project_version_detail(request, project_slug, version_slug):
    """Project version detail page"""
    project = get_object_or_404(Project.objects.for_admin_user(request.user), slug=project_slug)
    version = get_object_or_404(
        Version.objects.public(user=request.user, project=project, only_active=False),
        slug=version_slug)

    form = VersionForm(request.POST or None, instance=version)

    if request.method == 'POST' and form.is_valid():
        version = form.save()
        if form.has_changed():
            if 'active' in form.changed_data and version.active is False:
                log.info('Removing files for version %s' % version.slug)
                broadcast(type='app', task=tasks.clear_artifacts, args=[version.pk])
                version.built = False
                version.save()
        url = reverse('project_version_list', args=[project.slug])
        return HttpResponseRedirect(url)

    return render_to_response(
        'projects/project_version_detail.html',
        {'form': form, 'project': project, 'version': version},
        context_instance=RequestContext(request)
    )

 def delete(self, *args, **kwargs):  # pylint: disable=arguments-differ
     from readthedocs.projects import tasks
     broadcast(
         type='app',
         task=tasks.symlink_domain,
         args=[self.project.pk, self.domain, True],
     )
     super().delete(*args, **kwargs)

 def handle(self, *args, **options):
     queryset = Project.objects.all()
     for p in queryset:
         log.info("Generating metadata for %s", p)
         try:
             broadcast(type='app', task=tasks.update_static_metadata, args=[p.pk])
         except Exception:
             log.exception('Build failed for %s', p)

    def delete_selected_and_artifacts(self, request, queryset):
        """Remove HTML/etc artifacts from application instances

        Prior to the query delete, broadcast tasks to delete HTML artifacts from
        application instances.
        """
        if request.POST.get('post'):
            for project in queryset:
                broadcast(type='app', task=remove_dir, args=[project.doc_path])
        return delete_selected(self, request, queryset)

 def save(self, *args, **kwargs):  # pylint: disable=arguments-differ
     """Add permissions to the Version for all owners on save."""
     from readthedocs.projects import tasks
     obj = super().save(*args, **kwargs)
     for owner in self.project.users.all():
         assign('view_version', owner, self)
     broadcast(
         type='app',
         task=tasks.symlink_project,
         args=[self.project.pk],
     )
     return obj

 def save(self, *args, **kwargs):  # pylint: disable=arguments-differ
     """Add permissions to the Version for all owners on save."""
     from readthedocs.projects import tasks
     obj = super(Version, self).save(*args, **kwargs)
     for owner in self.project.users.all():
         assign('view_version', owner, self)
     try:
         self.project.sync_supported_versions()
     except Exception:
         log.error('failed to sync supported versions', exc_info=True)
     broadcast(type='app', task=tasks.symlink_project, args=[self.project.pk])
     return obj

 def save(self, *args, **kwargs):  # pylint: disable=arguments-differ
     from readthedocs.projects import tasks
     parsed = urlparse(self.domain)
     if parsed.scheme or parsed.netloc:
         self.domain = parsed.netloc
     else:
         self.domain = parsed.path
     super().save(*args, **kwargs)
     broadcast(
         type='app',
         task=tasks.symlink_domain,
         args=[self.project.pk, self.domain],
     )

def wipe_version_via_slugs(version_slug, project_slug):
    """Wipes the given version of a given project."""
    version = get_object_or_404(
        Version,
        slug=version_slug,
        project__slug=project_slug,
    )
    del_dirs = [
        os.path.join(version.project.doc_path, 'checkouts', version.slug),
        os.path.join(version.project.doc_path, 'envs', version.slug),
        os.path.join(version.project.doc_path, 'conda', version.slug),
    ]
    for del_dir in del_dirs:
        broadcast(type='build', task=remove_dirs, args=[(del_dir,)])

 def delete(self, *args, **kwargs):  # pylint: disable=arguments-differ
     from readthedocs.projects import tasks
     log.info('Removing files for version %s', self.slug)
     broadcast(
         type='app',
         task=tasks.remove_dirs,
         args=[self.get_artifact_paths()],
     )
     project_pk = self.project.pk
     super().delete(*args, **kwargs)
     broadcast(
         type='app',
         task=tasks.symlink_project,
         args=[project_pk],
     )