Async github/bitbucket repository syncing.

gulpfile.js

@@ -17,7 +17,11 @@ var gulp = require('gulp'),
 // picking up dependencies of the primary entry points and putting any
 // limitations on directory structure for entry points.
 var sources = {
-    core: ['js/readthedocs-doc-embed.js', 'js/autocomplete.js'],
+    core: [
+        'js/readthedocs-doc-embed.js',
+        'js/autocomplete.js',
+        'js/projectimport.js',
+    ],
     projects: ['js/tools.js'],
     gold: ['js/gold.js'],
     donate: ['js/donate.js']

media/css/core.css

@@ -96,6 +96,8 @@ input[type="hidden"] { display: none; }
 input[type="checkbox"], input[type="radio"] { display: inline; }
 label { display: block; margin-bottom: 4px; font-weight: bold; color: #444; }
 
+input[type="submit"].inline, input[type="button"].inline, button.inline, .button.inline { display: inline; }
+
 h2 > span.link-help,
 h3 > span.link-help,
 label > span.link-help {

readthedocs/core/static-src/core/js/django-csrf.js

@@ -0,0 +1,30 @@
+function csrfSafeMethod(method) {
+    // these HTTP methods do not require CSRF protection
+    return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method));
+}
+
+
+$.ajaxSetup({
+    beforeSend: function(xhr, settings) {
+        if (!csrfSafeMethod(settings.type) && !this.crossDomain) {
+            function getCookie(name) {
+                var cookieValue = null;
+                if (document.cookie && document.cookie != '') {
+                    var cookies = document.cookie.split(';');
+                    for (var i = 0; i < cookies.length; i++) {
+                        var cookie = jQuery.trim(cookies[i]);
+                        // Does this cookie string begin with the name we want?
+                        if (cookie.substring(0, name.length + 1) == (name + '=')) {
+                            cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
+                            break;
+                        }
+                    }
+                }
+                return cookieValue;
+            }
+            var csrftoken = getCookie('csrftoken');
+
+            xhr.setRequestHeader("X-CSRFToken", csrftoken);
+        }
+    }
+});

readthedocs/core/static-src/core/js/projectimport.js

@@ -0,0 +1,100 @@
+require('./django-csrf.js');
+
+
+$(function() {
+  var input = $('#id_repo'),
+      repo = $('#id_repo_type');
+
+  input.blur(function () {
+    var val = input.val(),
+        type;
+
+    switch(true) {
+      case /^hg/.test(val):
+        type = 'hg';
+      break;
+
+      case /^bzr/.test(val):
+      case /launchpad/.test(val):
+        type = 'bzr';
+      break;
+
+      case /trunk/.test(val):
+      case /^svn/.test(val):
+        type = 'svn';
+      break;
+
+      default:
+      case /github/.test(val):
+      case /(^git|\.git$)/.test(val):
+        type = 'git';
+      break;
+    }
+
+    repo.val(type);
+  });
+
+  $('[data-sync-repositories]').each(function () {
+    var $button = $(this);
+    var target = $(this).attr('data-target');
+
+    $button.on('click', function () {
+      var url = $button.attr('data-sync-repositories');
+      $.ajax({
+        method: 'POST',
+        url: url,
+        success: function (data) {
+          $button.attr('disabled', true);
+          watchProgress(data.url);
+        },
+        error: function () {
+          onError();
+        }
+      });
+      $('.sync-repositories').addClass('hide');
+      $('.sync-repositories-progress').removeClass('hide');
+    });
+
+    function watchProgress(url) {
+      setTimeout(function () {
+        $.ajax({
+          method: 'GET',
+          url: url,
+          success: function (data) {
+            if (data.finished) {
+              if (data.success) {
+                onSuccess();
+              } else {
+                onError();
+              }
+            } else {
+              watchProgress(url);
+            }
+          },
+          error: onError
+        });
+      }, 2000);
+    }
+
+    function onSuccess(url) {
+      $.ajax({
+        method: 'GET',
+        url: window.location.href,
+        success: function (data) {
+          var $newContent = $(data).find(target);
+          $('body').find(target).replaceWith($newContent);
+          $('.sync-repositories').addClass('hide');
+          $('.sync-repositories-progress').addClass('hide');
+          $('.sync-repositories-success').removeClass('hide');
+        },
+        error: onError
+      });
+    }
+
+    function onError() {
+      $('.sync-repositories').addClass('hide');
+      $('.sync-repositories-progress').addClass('hide');
+      $('.sync-repositories-error').removeClass('hide');
+    }
+  });
+});

readthedocs/core/utils/tasks/__init__.py

@@ -0,0 +1,3 @@
+from .permission_checks import *
+from .public import *
+from .retrieve import *

readthedocs/core/utils/tasks/permission_checks.py

@@ -0,0 +1,9 @@
+__all__ = ('user_id_matches',)
+
+
+def user_id_matches(request, state, context):
+    user_id = context.get('user_id', None)
+    if user_id is not None and request.user.is_authenticated():
+        if request.user.id == user_id:
+            return True
+    return False

readthedocs/core/utils/tasks/public.py

@@ -0,0 +1,122 @@
+from celery import Task
+from django.conf import settings
+
+from .retrieve import TaskNotFound
+from .retrieve import get_task_data
+
+
+__all__ = (
+    'PublicTask', 'TaskNoPermission', 'permission_check',
+    'get_public_task_data')
+
+
+STATUS_UPDATES_ENABLED = not getattr(settings, 'CELERY_ALWAYS_EAGER', False)
+
+
+class PublicTask(Task):
+    """
+    See oauth.tasks for usage example.
+
+    Subclasses need to define a ``run_public`` method.
+    """
+    public_name = 'unknown'
+
+    @classmethod
+    def check_permission(cls, request, state, context):
+        """
+        Override this method to define who can monitor this task.
+        """
+        return False
+
+    def get_task_data(self):
+        """
+        Return a tuple with the state that should be set next and the results
+        task.
+        """
+        state = 'STARTED'
+        info = {
+            'task_name': self.name,
+            'context': self.request.get('permission_context', {}),
+            'public_data': self.request.get('public_data', {}),
+        }
+        return state, info
+
+    def update_progress_data(self):
+        state, info = self.get_task_data()
+        if STATUS_UPDATES_ENABLED:
+            self.update_state(state=state, meta=info)
+
+    def set_permission_context(self, context):
+        """
+        Set data that can be used by ``check_permission`` to authorize a
+        request for the this task. By default it will be the ``kwargs`` passed
+        into the task.
+        """
+        self.request.update(permission_context=context)
+        self.update_progress_data()
+
+    def set_public_data(self, data):
+        """
+        Set data that can be displayed in the frontend to authorized users.
+        This might include progress data about the task.
+        """
+        self.request.update(public_data=data)
+        self.update_progress_data()
+
+    def run(self, *args, **kwargs):
+        self.set_permission_context(kwargs)
+        result = self.run_public(*args, **kwargs)
+        if result is not None:
+            self.set_public_data(result)
+        state, info = self.get_task_data()
+        return info
+
+
+def permission_check(check):
+    """
+    Class decorator for subclasses of PublicTask to sprinkle in re-usable
+    permission checks::
+
+        @permission_check(user_id_matches)
+        class MyTask(PublicTask):
+            def run_public(self, user_id):
+                pass
+    """
+
+    def decorator(cls):
+        cls.check_permission = staticmethod(check)
+        return cls
+    return decorator
+
+
+class TaskNoPermission(Exception):
+    def __init__(self, task_id, *args, **kwargs):
+        message = 'No permission to access task with id {id}'.format(
+            id=task_id)
+        super(TaskNoPermission, self).__init__(message, *args, **kwargs)
+
+
+def get_public_task_data(request, task_id):
+    """
+    Return a 3-value tuple with the public name of the task, the current state
+    of the task and the data that can be displayed publicly about this task.
+
+    Will raise `TaskNoPermission` if `request` has no permission to access info
+    of the task with id `task_id`. This is also the case of no task with the
+    given id exists.
+    """
+    try:
+        task, state, info = get_task_data(task_id)
+    except TaskNotFound:
+        # No task info has been found act like we don't have permission to see
+        # the results.
+        raise TaskNoPermission(task_id)
+
+    if not hasattr(task, 'check_permission'):
+        raise TaskNoPermission(task_id)
+
+    context = info.get('context', {})
+    if not task.check_permission(request, state, context):
+        raise TaskNoPermission(task_id)
+    public_name = task.public_name
+    return public_name, state, info.get('public_data', {})

readthedocs/core/utils/tasks/retrieve.py

@@ -0,0 +1,30 @@
+from djcelery import celery as celery_app
+from celery.result import AsyncResult
+
+
+__all__ = ('TaskNotFound', 'get_task_data')
+
+
+class TaskNotFound(Exception):
+    def __init__(self, task_id, *args, **kwargs):
+        message = 'No public task found with id {id}'.format(id=task_id)
+        super(TaskNotFound, self).__init__(message, *args, **kwargs)
+
+
+def get_task_data(task_id):
+    """
+    Will raise `TaskNotFound` if the task is in state ``PENDING`` or the task
+    meta data has no ``'task_name'`` key set.
+    """
+
+    result = AsyncResult(task_id)
+    state, info = result.state, result.info
+    if state == 'PENDING':
+        raise TaskNotFound(task_id)
+    if 'task_name' not in info:
+        raise TaskNotFound(task_id)
+    try:
+        task = celery_app.tasks[info['task_name']]
+    except KeyError:
+        raise TaskNotFound(task_id)
+    return task, state, info