Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 12 Next »

Overview

This document describes the soup-to-nuts engineering process for creating and maintaining a "cspace_django_project" Project for your institution. This process is the culmination of some months of experimentation and development at UCB, and what you see here is really the tip of the iceberg. The many details of how this process came about, its motivations, and its justification, are here.

Below, however, please find the essential workflow for this process outlined; consult the outlinks for details, tips, troubleshooting, etc.  

It assumes you are familiar with Django, GitHub, and QA and Release Engineering practices.

Prerequisites to development

At UCB, development of Django webapps is done using Pycharm. Therefore, your first step in any case is to install Pycharm on your development system. (Unless of course all you are doing is deploying existing code from GitHub, in which case skip ahead to the deployment section.)

Once you have PyCharm installed and working, you can create new projects and webapps in this framework or maintain existing ones. Follow the steps below that are appropriate to where you are in the process.

Creating a new CSpace Django Project for an institution

The UCB practice for Django Webapps is to have one (or perhaps more) Django Projects per institution.  Each of these is forked from the parent project, called cspace_django_project and is maintained as a separate entity.

The "normal" workflow assumes you are the developer who will be creating the instituition's initial project and webapps, and further that you are a CollectionSpace committer who can add repos under http://github.com/cspace-deployment.  However, such permissions are not required.  Read up here for the distinction in roles

If no Django project exists for your institution, or you need to make another one, the following steps will create such an institution level project in GitHub:   

Checking out an existing institution's project for development

Once an institutional project exists (typically, it will be called something like myinstitution_project), you can check the code for it out from GitHub and do what you need to do on your local system. In general, we don't modify code directly on our VM deployments. The process of getting your code back into a GitHub repo and making deployments and releases is described further below.

  • From PyCharm checkout the project; from the command line: git clone http://github.com/cspace-deployment/myinstitution_project.git
  • Open this directory in PyCharm
  • Configure the project to run locally (i.e. created needed local infrastructure (directories, etc.), local configuration files, etc.)
  • Run the development server or debugger in PyCharm

Creating of a new webapp for an existing project

If the webapp you want to work on exists, go to the next step, otherwise:

  • Run startapp (link to Django docs) or copy an existing app directory to a new directory and customize from there.
  • Edit cspace_django_site/settings.py (INSTALLED_APPS)
  • Edit cspace_django_site/urls.py (urlpatterns)
  • Resolve any other site-level dependencies: logging, cacheing, configuration, other python or code dependencies
  • Create an example config file (if necessary) See: Use of the config directory and .cfg files

Maintaining an existing webapp

  • Check out latest code (details?)
  • Modify
  • Test on your local system
  • git add
  • git commit -m
  • git push (where exactly?)

Deploying an institution project to a "Linux Server"

The initial deployment of Django projects on any server entails a number of "devops" activities. It is assumed that deployers reading this have an understanding of the process for deploying software on the target servers; here we assume that the deployment target is a "type IS&T VM" like those in use for the existing UCB CollectionSpace deployments. Your experience may differ.

Basically the procedure is as follows: 

  • Resolve dependencies (Apache (i.e. mod_wsgi), Python, Django, virtenv, SELinux, python packages)
  • Clone project to /usr/local/share/django
  • Modify Apache configuration to accomodate new project
  • Copy example config file(s) to config/ and customize per deployment (if any)
  • Restart Apache
  • Verify webapp function

The myriad practical details that need to be considered at UCB may be found here

Pushing your spiffy revised project to Dev or Production Server

Your project is already deployed and running (see the step above). You have made some wonderful fixes and improvements and you need to update the code on the server to the latest version.

  • ssh in to the server
  • cd /usr/local/share/django/my_project
  • sudo git pull
  • update configuration file (if needed) ("sudo vi config/webapp.cfg")
  • sudo manage.py collectstatic
  • sudo service httpd graceful

Maintaining the parent CSpace Django Project

- defer

Souping up your webapps

Solr

PIL

...

  • No labels