def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
url = obj['repository']['url']
ghetto_url = url.replace('http://', '').replace('https://', '')
branch = obj['ref'].replace('refs/heads/', '')
pc_log.info("(Incoming Github Build) %s [%s]" % (ghetto_url, branch))
try:
return _build_url(ghetto_url, [branch])
except NoProjectException:
try:
name = obj['repository']['name']
desc = obj['repository']['description']
homepage = obj['repository']['homepage']
repo = obj['repository']['url']
email = obj['repository']['owner']['email']
user = User.objects.get(email=email)
proj = Project.objects.create(
name=name,
description=desc,
project_url=homepage,
repo=repo,
)
proj.users.add(user)
# Version doesn't exist yet, so use classic build method
update_docs.delay(pk=proj.pk)
pc_log.info("Created new project %s" % (proj))
except Exception, e:
pc_log.error("Error creating new project %s: %s" % (name, e))
return HttpResponseNotFound('Repo not found')
def trigger_build(project, version=None, record=True, force=False, basic=False):
"""
An API to wrap the triggering of a build.
"""
# Avoid circular import
from projects.tasks import update_docs
if project.skip:
return None
if not version:
version = project.versions.get(slug='latest')
if record:
build = Build.objects.create(
project=project,
version=version,
type='html',
state='triggered',
success=True,
)
update_docs.delay(pk=project.pk, version_pk=version.pk, record=record, force=force, basic=basic, build_pk=build.pk)
else:
build = None
update_docs.delay(pk=project.pk, version_pk=version.pk, record=record, force=force, basic=basic)
return build
def trigger_build(project, version=None, record=True, force=False):
"""
An API to wrap the triggering of a build.
"""
# Avoid circular import
from projects.tasks import update_docs
if not version:
version = project.versions.get(slug='latest')
if record:
build = Build.objects.create(
project=project,
version=version,
type='html',
state='triggered',
success=True,
)
update_docs.delay(pk=project.pk,
version_pk=version.pk,
record=record,
force=force,
build_pk=build.pk)
else:
build = None
update_docs.delay(pk=project.pk,
version_pk=version.pk,
record=record,
force=force)
return build
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == "POST":
obj = json.loads(request.POST["payload"])
url = obj["repository"]["url"]
ghetto_url = url.replace("http://", "").replace("https://", "")
branch = obj["ref"].replace("refs/heads/", "")
pc_log.info("(Incoming Github Build) %s [%s]" % (ghetto_url, branch))
try:
return _build_url(ghetto_url, [branch])
except NoProjectException:
try:
name = obj["repository"]["name"]
desc = obj["repository"]["description"]
homepage = obj["repository"]["homepage"]
repo = obj["repository"]["url"]
email = obj["repository"]["owner"]["email"]
user = User.objects.get(email=email)
proj = Project.objects.create(name=name, description=desc, project_url=homepage, repo=repo)
proj.users.add(user)
# Version doesn't exist yet, so use classic build method
update_docs.delay(pk=proj.pk)
pc_log.info("Created new project %s" % (proj))
except Exception, e:
pc_log.error("Error creating new project %s: %s" % (name, e))
return HttpResponseNotFound("Repo not found")
def save(self, *args, **kwargs):
# save the project
project = super(ImportProjectForm, self).save(*args, **kwargs)
# kick off the celery job
update_docs.delay(pk=project.pk)
return project
def save_version(self, version):
new_value = self.cleaned_data.get('version-%s' % version.slug, None)
if new_value is None or new_value == version.active:
return
version.active = new_value
version.save()
if version.active and not version.built and not version.uploaded:
update_docs.delay(self.project.pk, record=True, version_pk=version.pk)
def save(self, *args, **kwargs):
# save the project
project = super(ImportProjectForm, self).save(*args, **kwargs)
# kick off the celery job
update_docs.delay(pk=project.pk)
return project
def generic_build(request, pk):
project = Project.objects.get(pk=pk)
context = {'built': False, 'project': project}
#This should be in the post, but for now it's always built for backwards compat
update_docs.delay(pk=pk, touch=True)
if request.method == 'POST':
context['built'] = True
return render_to_response('post_commit.html', context,
context_instance=RequestContext(request))
def save_version(self, version):
new_value = self.cleaned_data.get('version-%s' % version.slug, None)
if new_value is None or new_value == version.active:
return
version.active = new_value
version.save()
if version.active and not version.built and not version.uploaded:
update_docs.delay(self.project.pk,
record=True,
version_pk=version.pk)
def github_build(request):
"""
A post-commit hook for github.
"""
obj = json.loads(request.POST['payload'])
name = obj['repository']['name']
url = obj['repository']['url']
ghetto_url = url.replace('http://', '')
project = Project.objects.filter(repo__contains=ghetto_url)[0]
update_docs.delay(pk=project.pk)
return HttpResponse('Build Started')
def generic_build(request, pk):
project = Project.objects.get(pk=pk)
context = {"built": False, "project": project}
if request.method == "POST":
context["built"] = True
slug = request.POST.get("version_slug", None)
if slug:
version = project.versions.get(slug=slug)
update_docs.delay(pk=pk, version_pk=version.pk, touch=True)
else:
update_docs.delay(pk=pk, touch=True)
return render_to_response("post_commit.html", context, context_instance=RequestContext(request))
def save_version(self, version):
new_value = self.cleaned_data.get("version-%s" % version.slug, None)
privacy_level = self.cleaned_data.get("privacy-%s" % version.slug, None)
if (new_value is None or new_value == version.active) and (
privacy_level is None or privacy_level == version.privacy_level
):
return
version.active = new_value
version.privacy_level = privacy_level
version.save()
if version.active and not version.built and not version.uploaded:
update_docs.delay(self.project.pk, record=True, version_pk=version.pk)
def save(self, *args, **kwargs):
# grab the old content before saving
old_content = self.initial.get("content", "")
# save the file object
file_obj = super(FileForm, self).save(*args, **kwargs)
# create a new revision from the old content -> new
file_obj.create_revision(old_content, self.cleaned_data.get("revision_comment", ""))
update_docs.delay(file_obj.project.pk)
return file_obj
def save(self, *args, **kwargs):
# grab the old content before saving
old_content = self.initial.get('content', '')
# save the file object
file_obj = super(FileForm, self).save(*args, **kwargs)
# create a new revision from the old content -> new
file_obj.create_revision(old_content,
self.cleaned_data.get('revision_comment', ''))
update_docs.delay(file_obj.project.pk)
return file_obj
def generic_build(request, pk):
project = Project.objects.get(pk=pk)
context = {'built': False, 'project': project}
if request.method == 'POST':
context['built'] = True
slug = request.POST.get('version_slug', None)
if slug:
version = project.versions.get(slug=slug)
update_docs.delay(pk=pk, version_pk=version.pk, force=True)
else:
update_docs.delay(pk=pk, force=True)
# return HttpResponse('Build Started')
return redirect('builds_project_list', project.slug)
return redirect('builds_project_list', project.slug)
def generic_build(request, pk):
project = Project.objects.get(pk=pk)
context = {'built': False, 'project': project}
if request.method == 'POST':
context['built'] = True
slug = request.POST.get('version_slug', None)
if slug:
version = project.versions.get(slug=slug)
update_docs.delay(pk=pk, version_pk=version.pk, force=True)
else:
update_docs.delay(pk=pk, force=True)
# return HttpResponse('Build Started')
return redirect('builds_project_list', project.slug)
return redirect('builds_project_list', project.slug)
def bitbucket_build(request):
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
rep = obj['repository']
name = rep['name']
url = "%s%s" % ("bitbucket.org", rep['absolute_url'].rstrip('/'))
log.info("(Bitbucket Build) %s" % (url))
try:
project = Project.objects.filter(repo__contains=url)[0]
update_docs.delay(pk=project.pk, force=True)
return HttpResponse('Build Started')
except Exception, e:
log.error("(Github Build) Failed: %s:%s" % (name, e))
return HttpResponseNotFound('Build Failed')
def bitbucket_build(request):
if request.method == "POST":
obj = json.loads(request.POST["payload"])
rep = obj["repository"]
name = rep["name"]
url = "%s%s" % ("bitbucket.org", rep["absolute_url"].rstrip("/"))
log.info("(Bitbucket Build) %s" % (url))
try:
project = Project.objects.filter(repo__contains=url)[0]
update_docs.delay(pk=project.pk, force=True)
return HttpResponse("Build Started")
except Exception, e:
log.error("(Github Build) Failed: %s:%s" % (name, e))
return HttpResponseNotFound("Build Failed")
def generic_build(request, pk):
project = Project.objects.get(pk=pk)
context = {'built': False, 'project': project}
if request.method == 'POST':
context['built'] = True
slug = request.POST.get('version_slug', None)
if slug:
version = project.versions.get(slug=slug)
update_docs.delay(pk=pk, version_pk=version.pk, force=True)
else:
update_docs.delay(pk=pk, force=True)
return HttpResponse('Build Started')
return render_to_response('post_commit.html', context,
context_instance=RequestContext(request))
def generic_build(request, pk):
project = Project.objects.get(pk=pk)
context = {'built': False, 'project': project}
if request.method == 'POST':
context['built'] = True
slug = request.POST.get('version_slug', None)
if slug:
version = project.versions.get(slug=slug)
update_docs.delay(pk=pk, version_pk=version.pk, touch=True)
else:
update_docs.delay(pk=pk, touch=True)
return render_to_response('post_commit.html',
context,
context_instance=RequestContext(request))
def bitbucket_build(request):
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
rep = obj['repository']
name = rep['name']
url = "%s%s" % ("bitbucket.org", rep['absolute_url'].rstrip('/'))
log.info("(Bitbucket Build) %s" % (url))
try:
project = Project.objects.filter(repo__contains=url)[0]
update_docs.delay(pk=project.pk, force=True)
return HttpResponse('Build Started')
except Exception, e:
log.error("(Github Build) Failed: %s:%s" % (name, e))
return HttpResponseNotFound('Build Failed')
def bitbucket_build(request):
if request.method == "POST":
obj = json.loads(request.POST["payload"])
rep = obj["repository"]
name = rep["name"]
url = "%s%s" % ("bitbucket.org", rep["absolute_url"])
try:
project = Project.objects.filter(repo__contains=url)[0]
update_docs.delay(pk=project.pk, touch=True)
return HttpResponse("Build Started")
except:
mail_admins("Build Failure", "%s failed to build via github" % name)
return HttpResponse("Build Failed")
else:
return render_to_response("post_commit.html", {}, context_instance=RequestContext(request))
def generic_build(request, pk=None):
try:
project = Project.objects.get(pk=pk)
# Allow slugs too
except (Project.DoesNotExist, ValueError):
project = Project.objects.get(slug=pk)
if request.method == 'POST':
slug = request.POST.get('version_slug', None)
if slug:
pc_log.info("(Incoming Generic Build) %s [%s]" % (project.slug, slug))
_build_version(project, slug)
else:
pc_log.info("(Incoming Generic Build) %s [%s]" % (project.slug, 'latest'))
update_docs.delay(pk=pk, force=True)
return redirect('builds_project_list', project.slug)
def generic_build(request, pk=None):
try:
project = Project.objects.get(pk=pk)
# Allow slugs too
except (Project.DoesNotExist, ValueError):
project = Project.objects.get(slug=pk)
context = {'built': False, 'project': project}
if request.method == 'POST':
context['built'] = True
slug = request.POST.get('version_slug', None)
if slug:
_build_version(project, slug)
else:
update_docs.delay(pk=pk, force=True)
return redirect('builds_project_list', project.slug)
return redirect('builds_project_list', project.slug)
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
name = obj['repository']['name']
url = obj['repository']['url']
ghetto_url = url.replace('http://', '').replace('https://', '')
try:
project = Project.objects.filter(repo__contains=ghetto_url)[0]
update_docs.delay(pk=project.pk, force=True)
return HttpResponse('Build Started')
except Exception, e:
mail_admins('Build Failure', '%s failed to build via github.\n\n%s' % (name, e))
return HttpResponse('Build Failed')
def bitbucket_build(request):
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
rep = obj['repository']
name = rep['name']
url = "%s%s" % ("bitbucket.org", rep['absolute_url'])
try:
project = Project.objects.filter(repo__contains=url)[0]
update_docs.delay(pk=project.pk, touch=True)
return HttpResponse('Build Started')
except:
mail_admins('Build Failure', '%s failed to build via bitbucket' % name)
return HttpResponse('Build Failed')
else:
return render_to_response('post_commit.html', {},
context_instance=RequestContext(request))
def bitbucket_build(request):
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
rep = obj['repository']
name = rep['name']
url = "%s%s" % ("bitbucket.org", rep['absolute_url'])
try:
project = Project.objects.filter(repo__contains=url)[0]
update_docs.delay(pk=project.pk, force=True)
return HttpResponse('Build Started')
except:
mail_admins('Build Failure', '%s failed to build via bitbucket' % name)
return HttpResponse('Build Failed')
else:
return render_to_response('post_commit.html', {},
context_instance=RequestContext(request))
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
name = obj['repository']['name']
url = obj['repository']['url']
ghetto_url = url.replace('http://', '').replace('https://', '')
try:
project = Project.objects.filter(repo__contains=ghetto_url)[0]
update_docs.delay(pk=project.pk, force=True)
return HttpResponse('Build Started')
except Exception, e:
mail_admins('Build Failure', '%s failed to build via github.\n\n%s' % (name, e))
return HttpResponse('Build Failed')
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
name = obj['repository']['name']
url = obj['repository']['url']
ghetto_url = url.replace('http://', '').replace('https://', '')
branch = obj['ref'].replace('refs/heads/', '')
log.info("(Github Build) %s:%s" % (ghetto_url, branch))
version_pk = None
version_slug = branch
try:
project = Project.objects.filter(repo__contains=ghetto_url)[0]
version = project.version_from_branch_name(branch)
if version:
default = project.default_branch or project.vcs_repo(
).fallback_branch
if branch == default:
#Shortcircuit versions that are default
#These will build at "latest", and thus won't be active
version = project.versions.get(slug='latest')
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" %
(project.slug, version.slug))
elif version in project.versions.exclude(active=True):
log.info("(Github Build) Not building %s" % version.slug)
return HttpResponseNotFound('Not Building: %s' % branch)
else:
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" %
(project.slug, version.slug))
else:
version_slug = 'latest'
branch = 'latest'
log.info("(Github Build) Building %s:latest" % project.slug)
#version_pk being None means it will use "latest"
update_docs.delay(pk=project.pk, version_pk=version_pk, force=True)
return HttpResponse('Build Started: %s' % version_slug)
except Exception, e:
mail_admins('Build Failure',
'%s failed to build via github.\n\n%s' % (name, e))
return HttpResponseNotFound('Build Failed')
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == "POST":
obj = json.loads(request.POST["payload"])
name = obj["repository"]["name"]
url = obj["repository"]["url"]
ghetto_url = url.replace("http://", "").replace("https://", "")
try:
project = Project.objects.filter(repo__contains=ghetto_url)[0]
update_docs.delay(pk=project.pk, touch=True)
return HttpResponse("Build Started")
except:
mail_admins("Build Failure", "%s failed to build via github" % name)
return HttpResponse("Build Failed")
else:
return render_to_response("post_commit.html", {}, context_instance=RequestContext(request))
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
name = obj['repository']['name']
url = obj['repository']['url']
ghetto_url = url.replace('http://', '').replace('https://', '')
try:
project = Project.objects.filter(repo__contains=ghetto_url)[0]
update_docs.delay(pk=project.pk, touch=True)
return HttpResponse('Build Started')
except:
mail_admins('Build Failure', '%s failed to build via github' % name)
return HttpResponse('Build Failed')
else:
return render_to_response('post_commit.html', {},
context_instance=RequestContext(request))
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == "POST":
obj = json.loads(request.POST["payload"])
name = obj["repository"]["name"]
url = obj["repository"]["url"]
ghetto_url = url.replace("http://", "").replace("https://", "")
branch = obj["ref"].replace("refs/heads/", "")
log.info("(Github Build) %s:%s" % (ghetto_url, branch))
version_pk = None
version_slug = branch
try:
project = Project.objects.filter(repo__contains=ghetto_url)[0]
version = project.version_from_branch_name(branch)
if version:
default = project.default_branch or project.vcs_repo().fallback_branch
if branch == default:
# Shortcircuit versions that are default
# These will build at "latest", and thus won't be active
version = project.versions.get(slug="latest")
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" % (project.slug, version.slug))
elif version in project.versions.exclude(active=True):
log.info("(Github Build) Not building %s" % version.slug)
return HttpResponseNotFound("Not Building: %s" % branch)
else:
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" % (project.slug, version.slug))
else:
version_slug = "latest"
branch = "latest"
log.info("(Github Build) Building %s:latest" % project.slug)
# version_pk being None means it will use "latest"
update_docs.delay(pk=project.pk, version_pk=version_pk, force=True)
return HttpResponse("Build Started: %s" % version_slug)
except Exception, e:
log.error("(Github Build) Failed: %s:%s" % (name, e))
return HttpResponseNotFound("Build Failed")
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
name = obj['repository']['name']
url = obj['repository']['url']
ghetto_url = url.replace('http://', '').replace('https://', '')
branch = obj['ref'].replace('refs/heads/', '')
log.info("(Github Build) %s:%s" % (ghetto_url, branch))
version_pk = None
version_slug = branch
try:
project = Project.objects.filter(repo__contains=ghetto_url)[0]
version = project.version_from_branch_name(branch)
if version:
default = project.default_branch or project.vcs_repo().fallback_branch
if branch == default:
#Shortcircuit versions that are default
#These will build at "latest", and thus won't be active
version = project.versions.get(slug='latest')
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" % (project.slug, version.slug))
elif version in project.versions.exclude(active=True):
log.info("(Github Build) Not building %s" % version.slug)
return HttpResponseNotFound('Not Building: %s' % branch)
else:
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" % (project.slug, version.slug))
else:
version_slug = 'latest'
branch = 'latest'
log.info("(Github Build) Building %s:latest" % project.slug)
#version_pk being None means it will use "latest"
update_docs.delay(pk=project.pk, version_pk=version_pk, force=True)
return HttpResponse('Build Started: %s' % version_slug)
except Exception, e:
mail_admins('Build Failure', '%s failed to build via github.\n\n%s' % (name, e))
return HttpResponseNotFound('Build Failed')
def _build_version(project, slug):
default = project.default_branch or (project.vcs_repo().fallback_branch)
if slug == default:
# short circuit versions that are default
# these will build at "latest", and thus won't be
# active
version = project.versions.get(slug='latest')
update_docs.delay(pk=project.pk, version_pk=version.pk, force=True)
log.info(("(Version build) building %s:%s"
% (project.slug, version.slug)))
return "latest"
elif project.versions.exclude(active=True).filter(slug=slug).exists():
log.info(("(Version build) not building %s"% slug))
return None
else:
version = project.versions.get(slug=slug)
update_docs.delay(pk=project.pk, version_pk=version.pk, force=True)
log.info(("(Version build) building %s:%s"
% (project.slug, version.slug)))
return slug
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
name = obj['repository']['name']
url = obj['repository']['url']
ghetto_url = url.replace('http://', '').replace('https://', '')
try:
project = Project.objects.filter(repo__contains=ghetto_url)[0]
update_docs.delay(pk=project.pk, touch=True)
return HttpResponse('Build Started')
except:
mail_admins('Build Failure',
'%s failed to build via github' % name)
return HttpResponse('Build Failed')
else:
return render_to_response('post_commit.html', {},
context_instance=RequestContext(request))
def save(self, *args, **kwargs):
created = self.instance.pk is None
# save the project
project = super(CreateProjectForm, self).save(*args, **kwargs)
if created:
# create a couple sample files
for i, (sample_file, template) in enumerate(constants.SAMPLE_FILES):
file = File.objects.create(
project=project,
heading=sample_file,
content=render_to_string(template, {'project': project}),
ordering=i+1,
)
file.create_revision(old_content='', comment='')
# kick off the celery job
update_docs.delay(pk=project.pk)
return project
def _build_version(project, slug, already_built=()):
default = project.default_branch or (project.vcs_repo().fallback_branch)
if slug == default and slug not in already_built:
# short circuit versions that are default
# these will build at "latest", and thus won't be
# active
latest_version = project.versions.get(slug='latest')
update_docs.delay(
pk=project.pk, version_pk=latest_version.pk, force=True)
pc_log.info(("(Version build) Building %s:%s"
% (project.slug, latest_version.slug)))
if project.versions.exclude(active=False).filter(slug=slug).exists():
# Handle the case where we want to build the custom branch too
slug_version = project.versions.get(slug=slug)
update_docs.delay(
pk=project.pk, version_pk=slug_version.pk, force=True)
pc_log.info(("(Version build) Building %s:%s"
% (project.slug, slug_version.slug)))
return "latest"
elif project.versions.exclude(active=True).filter(slug=slug).exists():
pc_log.info(("(Version build) Not Building %s" % slug))
return None
elif slug not in already_built:
version = project.versions.get(slug=slug)
update_docs.delay(pk=project.pk, version_pk=version.pk, force=True)
pc_log.info(("(Version build) Building %s:%s"
% (project.slug, version.slug)))
return slug
else:
pc_log.info(("(Version build) Not Building %s" % slug))
return None
def _build_version(project, slug, already_built=()):
default = project.default_branch or (project.vcs_repo().fallback_branch)
if slug == default and slug not in already_built:
# short circuit versions that are default
# these will build at "latest", and thus won't be
# active
latest_version = project.versions.get(slug='latest')
update_docs.delay(pk=project.pk,
version_pk=latest_version.pk,
force=True)
pc_log.info(("(Version build) Building %s:%s" %
(project.slug, latest_version.slug)))
if project.versions.exclude(active=False).filter(slug=slug).exists():
# Handle the case where we want to build the custom branch too
slug_version = project.versions.get(slug=slug)
update_docs.delay(pk=project.pk,
version_pk=slug_version.pk,
force=True)
pc_log.info(("(Version build) Building %s:%s" %
(project.slug, slug_version.slug)))
return "latest"
elif project.versions.exclude(active=True).filter(slug=slug).exists():
pc_log.info(("(Version build) Not Building %s" % slug))
return None
elif slug not in already_built:
version = project.versions.get(slug=slug)
update_docs.delay(pk=project.pk, version_pk=version.pk, force=True)
pc_log.info(
("(Version build) Building %s:%s" % (project.slug, version.slug)))
return slug
else:
pc_log.info(("(Version build) Not Building %s" % slug))
return None
def save(self, *args, **kwargs):
created = self.instance.pk is None
# save the project
project = super(CreateProjectForm, self).save(*args, **kwargs)
if created:
# create a couple sample files
for i, (sample_file,
template) in enumerate(constants.SAMPLE_FILES):
file = File.objects.create(
project=project,
heading=unicode(sample_file),
content=render_to_string(template, {'project': project}),
ordering=i + 1,
)
file.create_revision(old_content='', comment='')
# kick off the celery job
update_docs.delay(pk=project.pk)
return project
def generic_build(request, pk):
update_docs.delay(pk=pk)
return HttpResponse('Build Started')
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
name = obj['repository']['name']
url = obj['repository']['url']
ghetto_url = url.replace('http://', '').replace('https://', '')
branch = obj['ref'].replace('refs/heads/', '')
log.info("(Github Build) %s:%s" % (ghetto_url, branch))
version_pk = None
version_slug = branch
try:
projects = Project.objects.filter(repo__contains=ghetto_url)
for project in projects:
version = project.version_from_branch_name(branch)
if version:
log.info("(Github Build) Processing %s:%s" %
(project.slug, version.slug))
default = project.default_branch or project.vcs_repo(
).fallback_branch
if branch == default:
#Shortcircuit versions that are default
#These will build at "latest", and thus won't be active
version = project.versions.get(slug='latest')
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" %
(project.slug, version.slug))
elif version in project.versions.exclude(active=True):
log.info("(Github Build) Not building %s" %
version.slug)
return HttpResponseNotFound('Not Building: %s' %
branch)
else:
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" %
(project.slug, version.slug))
else:
version_slug = 'latest'
branch = 'latest'
log.info("(Github Build) Building %s:latest" %
project.slug)
#version_pk being None means it will use "latest"
update_docs.delay(pk=project.pk,
version_pk=version_pk,
force=True)
return HttpResponse('Build Started: %s' % version_slug)
except Exception, e:
log.error("(Github Build) Failed: %s:%s" % (name, e))
#handle new repos
project = Project.objects.filter(repo__contains=ghetto_url)
if not len(project):
project = Project.objects.filter(name__icontains=name)
if len(project):
#Bail if we think this thing exists
return HttpResponseNotFound('Build Failed')
#create project
try:
email = obj['repository']['owner']['email']
desc = obj['repository']['description']
homepage = obj['repository']['homepage']
repo = obj['repository']['url']
user = User.objects.get(email=email)
proj = Project.objects.create(
name=name,
description=desc,
project_url=homepage,
repo=repo,
)
proj.users.add(user)
log.error("Created new project %s" % (proj))
except Exception, e:
log.error("Error creating new project %s: %s" % (name, e))
return HttpResponseNotFound('Build Failed')
return HttpResponseNotFound('Build Failed')
def github_build(request):
"""
A post-commit hook for github.
"""
if request.method == 'POST':
obj = json.loads(request.POST['payload'])
name = obj['repository']['name']
url = obj['repository']['url']
ghetto_url = url.replace('http://', '').replace('https://', '')
branch = obj['ref'].replace('refs/heads/', '')
log.info("(Github Build) %s:%s" % (ghetto_url, branch))
version_pk = None
version_slug = branch
try:
projects = Project.objects.filter(repo__contains=ghetto_url)
for project in projects:
version = project.version_from_branch_name(branch)
if version:
log.info("(Github Build) Processing %s:%s" % (project.slug, version.slug))
default = project.default_branch or project.vcs_repo().fallback_branch
if branch == default:
#Shortcircuit versions that are default
#These will build at "latest", and thus won't be active
version = project.versions.get(slug='latest')
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" % (project.slug, version.slug))
elif version in project.versions.exclude(active=True):
log.info("(Github Build) Not building %s" % version.slug)
return HttpResponseNotFound('Not Building: %s' % branch)
else:
version_pk = version.pk
version_slug = version.slug
log.info("(Github Build) Building %s:%s" % (project.slug, version.slug))
else:
version_slug = 'latest'
branch = 'latest'
log.info("(Github Build) Building %s:latest" % project.slug)
#version_pk being None means it will use "latest"
update_docs.delay(pk=project.pk, version_pk=version_pk, force=True)
return HttpResponse('Build Started: %s' % version_slug)
except Exception, e:
log.error("(Github Build) Failed: %s:%s" % (name, e))
#handle new repos
project = Project.objects.filter(repo__contains=ghetto_url)
if not len(project):
project = Project.objects.filter(name__icontains=name)
if len(project):
#Bail if we think this thing exists
return HttpResponseNotFound('Build Failed')
#create project
try:
email = obj['repository']['owner']['email']
desc = obj['repository']['description']
homepage = obj['repository']['homepage']
repo = obj['repository']['url']
user = User.objects.get(email=email)
proj = Project.objects.create(
name=name,
description=desc,
project_url=homepage,
repo=repo,
)
proj.users.add(user)
log.error("Created new project %s" % (proj))
except Exception, e:
log.error("Error creating new project %s: %s" % (name, e))
return HttpResponseNotFound('Build Failed')
return HttpResponseNotFound('Build Failed')
