Setting up Your Class2Go Dev Environment

These instructions should help you get started setting up a dev environment. You should be able to do most of your development on your laptop by running a local database (mysqld) and storing files locally instead of in S3.

The majority of our dev team uses Macs, so the Mac instructions are generally the most up to date. But we do have some developers who have had windows or Ubuntu Linux as their day-to-day dev machines, so we know it works.

If you have suggestions how to improve these notes, please improve them and send us a pull request!

Mac OS X
Windows
Linux
Configuring Django
Generating Test Data

It is a big step to go from a dev instance to a full-on deployed cloud instance. Instructions for that are forthcoming.

For Mac

General Instructions:

Set-up Python
Set-up Python's virtual env
Set-up Django
Set-up Mysql

For MAC OS-X Lion: Instructions mainly taken from http://www.tlswebsolutions.com/mac-os-x-lion-setting-up-django-pip-virtualenv-and-homebrew/

Some people don't have their normal user set up with write permissions for all these commands that modify the environment (brew, easy_install, pip). For all of those you should plan on running your own sudo prefix for these.

Install XCode from the Apple App Store Version 4.5 or later
Within XCode, add the command line tools: Preferences -> Download -> "Command Line Tools" -> Install button

Install Homebrew:

 /usr/bin/ruby -e "$(curl -fsSkL http://raw.github.com/mxcl/homebrew/go)"

Install Python (we are expecting 2.7.x):

 brew install readline sqlite gdbm
 brew install python --universal --framework

Install mysql
```
 brew install mysql
```
(Optional but useful for looking at the database) Install phpmyadmin (?!) following the directions here: http://www.djangoapp.com/blog/2011/07/24/installing-phpmyadmin-on-mac-os-x-lion/
Install pip, a python package manager
```
 easy_install pip
```
Install python's virtual env
```
 pip install virtualenv
```
Create the class2go virtual env (if you want)
```
 virtualenv class2go-venv --no-site-packages
```
This should create the class2go-venv directory under the directory where this README is found. All our django stuff will happen in there now.
Start using the virtual environment that we just created.
```
 . ./class2go-venv/bin/activate
```
WARNING: You need to do this from whatever shell you're using. You can tell this because is puts an environment indicator at the beginning of your prompt.
Install django itself (this will be inside the virtualenv)
```
 pip install django
```
Install MySQL-python (this will be inside the virtualenv)
```
 pip install MySQL-python
```
Install python image library (this will be inside the virtualenv)
```
 pip install PIL
```
Install South, the database schema migration tool: (this will be inside the virtualenv)
```
pip install South
```

Install modules for Amazon S3

 pip install django-storages
 pip install boto

Install GData (2.0.17)
```
 pip install gdata
```

Install Celery ecosystem

 pip install django-celery django-celery-email pytz

Install test environment dependencies:

 pip install mock nose django_nose django_coverage lxml

Install test dependencies for Selenium based testing:
```
 pip install selenium selenose
```

Install chrome for Selenium testing

 # chromedriver - list of options available here:
 # https://code.google.com/p/chromedriver/downloads/list
 curl -O http://chromedriver.googlecode.com/files/chromedriver_mac_23.0.1240.0.zip
 unzip chromedriver_mac_23.0.1240.0.zip
 # move onto your path
 sudo mv ./chromedriver /usr/local/bin/
 # install Chrome -- download from https://www.google.com/intl/en/chrome/browser/

[Optional] Install dependenices to run selenium tests "headless"

 # TODO: Figure out how to run headless on Mac OSX (see Linux section for starters)

Setup the account and database in MySql

 create database class2go;
 grant all on class2go.* to class2go@'localhost' identified by 'class2gopw';
 grant all on class2go.* to class2go@'127.0.0.1' identified by 'class2gopw';

Set up some folders for logs and the celery database.

Put them somewhere writable. Make sure the django settings.py entry for LOGGING_DIR and the database.py entry for DATABASES.celery.NAME match these locations.
```
 mkdir /home/account/django-logs/
 mkdir /home/account/sqlite3/
```

In the main folder, make a copy of database_example.py to database.py and edit the DATABASES strings as follows substituting proper values for your system.

 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.mysql',
         'NAME': 'class2go',
         'USER': 'class2go',
         'PASSWORD': 'class2gopw',
         'HOST': '',
         'PORT': '',
     },
     'celery': {
         'ENGINE': 'django.db.backends.sqlite3',
         'NAME': '/Users/account/sqlite3/celerydb.sqlite',
     },
 }

Setup initial db from the main folder

 ./manage.py syncdb  ######## answer no to the superuser question for now
 ./manage.py migrate
 ./manage.py syncdb --database=celery
 ./manage.py migrate --database=celery

At this point you should be able to look at the django database in your local mysql and see a bunch of c2g_* tables. Now you should create the super user

 ./manage.py createsuperuser

Yay. :)

From the main folder, run server on whatever port you want:
```
 python manage.py runserver 8100
```
Visit localhost:8100 in your web browser and confirm that you get a C2G page.

For Windows

Eclipse Users and/or WAMP users:

The following versions seem to be compatible:

Python: 2.7.3
Eclipse for PHP: Helios (http://download.eclipse.org/releases/helios)
PyDev plugin for Eclipse: 2.5.0 (http://pydev.org/updates)
Egit plugin for Eclipse: (http://download.eclipse.org/egit/updates)
WAMPServer: 2.1

Steps:

Install Eclipse
Install Egit and configure it to the github repos (https://github.com/Stanford-Online/class2go) For this you would need Jason to set you up with access to this repos. Note, when configuring the Remote Push Url you'll need to add ".git" on the end: (git clone https://github.com/Stanford-Online/class2go.git)

Requirements

Prereqs: If you do not have the following, install them: python 2.7 django easy_install pip python image library (pip install PIL) django_storages boto
Install South, the database schema migration tool: (this will be inside the virtualenv) easy_install South
Create a database called c2g (for example).
Copy database.example.py to database.py.
In database.py, append 'mysql' to ENGINE, and enter the name of the database you created in step 1, and the credentials of an authorized user of the database (user 'root' and empty password may work on MySQL unless you specified otherwise during the MySQL setup)
Make sure you're in the src/class2go/main directory (wherever that is for you)
'python manage.py syncdb' followed by 'python manage.py migrate' to create the required database tables and make sure the schema is up to date.You will be asked to create your admin account on the way. Skip it. You will later be able to create a user and promote it to admin manually using your DBMS client.
```
 ./manage.py syncdb  ######## answer no to the superuser question for now
 ./manage.py migrate
 ./manage.py syncdb --database=celery
 ./manage.py migrate --database=celery
```

At this point you should be able to look at the django database in your local mysql and see a bunch of c2g_* tables. Now you should create the super user

./manage.py createsuperuser

Yay. :)

XX -- 'python manage.py collectstatic' to copy all static files to the directory specified in settings.py.
'python manage.py runserver xxxx' to run a dev server on port number xxxx. Example: xxxx = 8000
Visit localhost:xxxx in your web browser and confirm that you get a C2G page.

For Linux

This assumes you have mysql and python installed. These instructions also include info for virtualenvwrapper, which contains useful tools for virtualenv. virtualenvwrapper can also be installed for Mac (and probably Windows too).

Create the database (perhaps with different username and password):

 sudo mysql mysql
 create database c2g;
 CREATE USER 'c2g_username'@'localhost' IDENTIFIED BY 'c2g_passwd';
 GRANT ALL PRIVILEGES ON c2g . * TO 'c2g_username'@'localhost';
 FLUSH PRIVILEGES;

Install pip:
```
 sudo apt-get install python-pip
```
Install virtualenv:
```
 sudo pip install virtualenv
```
Install virtualenvwrapper:
```
 sudo pip install virtualenvwrapper
```
Verify installation location of virtualenv and virtualenvwrapper:
```
 ls /usr/local/bin/
```
Check out your PATH to see if /usr/local/bin comes before /usr/bin:
```
 echo $PATH
```
(If not, add export PATH=/usr/local/bin:$PATH to your .bashrc)
Edit login script:
```
 vim .bashrc
```

...and add the following:

 # virtualenv setup -- use Distribute by default
 export VIRTUALENV_DISTRIBUTE=true

 # virtualenvwrapper setup
 export WORKON_HOME=~/DevEnvs
 export PROJECT_HOME=~/DevProjects
 export VIRTUALENVWRAPPER_VIRTUALENV_ARGS='--no-site-packages'
 export VIRTUALENVWRAPPER_VIRTUALENV=`which virtualenv`
 source /usr/local/bin/virtualenvwrapper.sh

Source login script so env vars take effect:
```
 source ~/.bashrc
```
(Sourcing should auto-create your virtual environment base dir)
Check out new virtual base directory:
```
 ls DevEnvs/
```
Make sure PROJECT_HOME is defined
```
 echo $PROJECT_HOME
```
Make new project directory:
```
 mkdir -p $PROJECT_HOME
```
Issue command to set up new project subdirectory and link it to virtual env:
```
 mkproject class2go
```
Once inside virtual env/project directory, install django:
```
 pip install django
```

Clone class2go repo from github:

 git clone https://github.com/Stanford-Online/class2go.git .

Check out where your mysql is installed, make sure mysql_config exists in the dir:
```
 ls `which mysql`
```
Need to install mysql_config if it's not there:
```
 sudo apt-get install libmysqlclient-dev
```
Might need some extra python developer stuff:
```
 sudo apt-get install python-dev
```
Install python hooks for MySQL:
```
 pip install MySQL-python
```
Install Python Imaging Lib:
```
 pip install PIL
```
Install South db stuff:
```
 pip install South
```

Install modules for Amazon S3

 pip install django_storages
 pip install boto

Install GData (2.0.17)
```
 pip install gdata
```
Install numpy for video thumbnailer:
```
 pip install numpy
```

Install Celery ecosystem

 pip install django-celery django-celery-email pytz

Install test environment dependencies:

 pip install mock nose django_nose django_coverage lxml

Install test dependencies for Selenium based testing:
```
 pip install selenium selenose
```

Install chrome for Selenium testing

 # chromedriver - list of options available here:
 # https://code.google.com/p/chromedriver/downloads/list
 curl -O http://chromedriver.googlecode.com/files/chromedriver_linux32_23.0.1240.0.zip
 unzip chromedriver_linux32_23.0.1240.0.zip
 # move onto your path
 sudo mv ./chromedriver /usr/local/bin/
 # install Chrome -- download from https://www.google.com/intl/en/chrome/browser/

[Optional] Install dependenices to run selenium tests "headless"

 pip install pyvirtualdisplay
 sudo apt-get install xvfb xserver-xephyr

Go to "main" dir and copy over database settings file:
```
 cd main
 cp database_example.py database.py
```
Edit file and add db name, username and password (see mac instructions)
```
 vim database.py
```
Run syncdb to create database tables
```
 ./manage.py syncdb  ######## answer no to the superuser question for now
```
Might need to issue "syncdb" command a couple times if there are errors. The first time, it will ask you for username and password for the database
Migrate user stuff over:
```
 ./manage.py migrate
```

Now you should create the super user

    ./manage.py createsuperuser

Yay. :)

Update settings file and change STATIC_ROOT to "static/":
```
 vim settings.py
```
Make sure directory exists, or create it:
```
 mkdir static
```
Run collectstatic to copy stuff into your dir:
```
 ./manage.py collectstatic
```
Run server on whatever port you want:
```
 python manage.py runserver 8100
```

When you want to start working on your project, just do the following:

    # this should change to the correct virtualenv and cd you to project dir
    workon class2go
    python ./manage.py runserver 8100

Configuring Django

The "main" dir is where the django project lives. You will spend most of your time in there. All the runtime application source is under main, and the manage.py script is the interface to runtime command line tools.

We partition our django project settings into two settings files:

settings.py - Most of the project settings are in here. This should be familiar to any django dev.
database.py - Anything that should not be checked in, i.e. secret keys or local configuration, should be in the database.py file. Upon setting up your project one of the first things you have to do is create your own database.py. There is an example file to get you started, database_example.py.

Generating Test Data

Some schema mods were made so run: manage.py migrate
Take a look in c2g/views.py as there are some parameters that affect which data gets created. Note, if you choose the delete_current_data option it will delete your current django users so you'll have to recreate those users if you want.
To run the script that populates the data do "manage.py help db_populate" first. This will tell you where to setup the params for the test data.

A helper script for this exists at main/repave_dev_database.sh. It drops/recreates your dev database and then does the syncdb / migrate / db_populate steps so you end up with a clean database. It requires a ~/.my.cnf file to know what database to talk to.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

README_SETUP.md

README_SETUP.md

Setting up Your Class2Go Dev Environment

For Mac

For Windows

For Linux

Configuring Django

Generating Test Data

Files

README_SETUP.md

Latest commit

History

README_SETUP.md

File metadata and controls

Setting up Your Class2Go Dev Environment

For Mac

For Windows

For Linux

Configuring Django

Generating Test Data