Definition¶

In computing, a virtual machine (VM) is an emulation of a particular computer system. Virtual machines operate based on the computer architecture and functions of a real or hypothetical computer, and their implementations may involve specialized hardware, software, or a combination of both [1].

Software¶

• VirtualBox
• VMware
• LinuxKVM
• etc...

We will focus entirely on VirtualBox.

Exercises¶

1. Download and install the VirtualBox
2. Download an image of an operating system. We will use Ubuntu in this course. Download the ISO image
3. In VirtualBox Create a Virtual Machine
4. Configure the RAM to be allocated
5. Configure a hard drive for the image

Important commands¶

As you might expect, anything that you can do in the GUI you can do in the command line. CLI has many Shells e.g. Bourne Shell, Korn SHell, Bourne_Again_SHell ...etc. Shells are program that help you execute commands on the computer. They have a special language, and they provide basic programming capabilities. Below are a list of important commands that you should be comfortable with.

• pwd

  Stands for Print Working Directory:

  pwd prints the current working directory from / or root directory

  
  
• mkdir

  Make Directory:

  mkdir foo creates a directory called foo

  mkdir -p foo/bar/baz creates baz and all the missing directories in the path to it

  Exercise:

  • Make a directory called temp
  • Make a directory at the path temp/stuff
  • Make a directory at the path temp/stuff/things
  • Can you create a directory at temp/stuff/things/frank/joe/alex/john using a single command?

• cd

  Change Directory.

  Once invoked it will change your working directory to a new one:

  cd temp to change to the temp directory you created in the last exercise

  Exercise:

  • Change to the temp directory. Check where you are using pwd.
  • Change to the stuff directory. Check where you are.
  • Change directly to the john directory in one command.
  • Use the command cd ... Where did you end up?
  • Where does cd ../../.. take you?
  • What about cd .?
  • Just cd?

• ls

  Lists the contents of the current directory:

  ls -a to list all files and directory including hidden directory or dotfiles

  ls -l to list the files and directory with more information about their permissions, owner, group that owns it, disk size and creation date

  Exercise:

  • Navigate back to your home directory ~.
  • Go to temp and use ls to see what is in it.
  • While in temp try ls -lR. What did it do?
  • Use a combination of cd, ls and pwd to explore the files on your machine.

• touch

  Creates an empty file in the current directory:

  touch CaptainAwesomesauce.txt creates a blank text file called CaptainAwesomesauce.txt

  
  
• cp

  Copy file or directory from one location to another:

  cp file1 file2 copies the contents of file1 into file2

  cp file1 Documents/ copies file1 into the Documents directory

  cp -r /tmp Documents/tmp copies the contents of /tmp into Documents/tmp

  Exercise:

  • Inside temp create a file called iamcool.txt.
  • Make a copy of it called awesome.txt.
  • Make a directory called stuff and copy awesome.txt into it.
  • Without leaving temp check the contents of stuff
  • Copy stuff and all its contents into a new directory called things.
  • Without leaving temp check the contents of things.

• mv

  Moves files or directories to different location (path). Also it can be used

  to rename files or directories:

  mv file file.txt renames file to file.txt

  mv Downloads/file.zip Documents/ moves file.zip from Downloads/ to Documents/

  Exercise:

  • Change the name of the file awesome.txt to notawesome.txt
  • Change the name of the directory stuff to foo
  • Move the file iamcool.txt from temp into foo

• nano

  Nano is an easy to use terminal text editor:

  nano file1 opens file1 for editing

  
  
• less

  Less is a file viewer, and it has search features. The name came from the

  Unix philosophy “Less is more, more is less”[1]:

  less foo.txt page through foo.txt

  
  
• cat

  Concatenate files and prints them to stdout:

  cat file1 spits the content of file1 to stdout

  cat file1 file2 concatenates file1 to file2 then spits the contents to stdout

  Exercise:

  • Create a file called zen.txt with the following content:

    Beautiful is better than ugly.
    Explicit is better than implicit.
    Simple is better than complex.
    Complex is better than complicated.
    Flat is better than nested.
    Sparse is better than dense.
    Readability counts.
    Special cases aren't special enough to break the rules.
    Although practicality beats purity.
    Errors should never pass silently.
    Unless explicitly silenced.
    In the face of ambiguity, refuse the temptation to guess.
    There should be one-- and preferably only one --obvious way to do it.
    Although that way may not be obvious at first unless you're Dutch.
    Now is better than never.
    Although never is often better than *right* now.
    If the implementation is hard to explain, it's a bad idea.
    If the implementation is easy to explain, it may be a good idea.
    Namespaces are one honking great idea -- let's do more of those!
    

  • View it using less and cat. What’s the difference?

• rm

  Removes a file or directory:

  rm /path/to/file1 to delete file1

  rm -r /path/to/dir1 to recursively delete dir1 and all its contents

  Exercise:

  • Go to the temp directory
  • Remove the file notawesome.txt.
  • Remove the directory things and all its content.

• echo

  Takes a string of text and prints it to stdout

  echo Hello world

  
  
• |

  The Pipe character which takes the output of the left command and inputs it to the right command

  ls | grep ""

  
  
• >

  Redirect to character; it redirect the output of the command to a file

  echo Hello > foo.txt

  
  
• >>

  Append character; it appends the output to a file

  echo Hello >> foo.txt

  
  
• <

  Input in character; it inputs the text of a file to the command

  cat < foo.txt

  
  
• man

  Return the help manual for any command in the system:

  man shell-command

  
  
• find

  Find is a powerful command. Take a look at the manual of find to see all

  the options that you can use with it:

  find . -type f -name foo looks for a file that’s named foo

  
  
• diff

  Differences between two files. The command diff prints out the difference

  between two files:

  diff v1/foo1 v2/foo1

  
  
• comm

  Common is a command that compares two files and print the common bytes

  between them:

  comm v1/foo1 v2/foo1

  
  
• head

  Head prints out first lines of a file:

  head foo.txt

  
  
• tail

  Tail is simliar to head but it prints out the last lines of a file:

  tail foo.txt

  
  
• sort

  Sort sorts text:

  sort foo

  
  
• * - The Wildcard

  * is known as the wildcard because it matches everything.

  It’s great when you want to do a command on a set of files all at once:

  ls *.py lists all the files in the current directory ending in .py

  rm -r h* removes all files and directories beginning with h

  rm h*.* removes only files beginning with h

  Exercise:

  • Create the following files in temp:

    • ex12.txt
    • ex13.txt
    • ex14.py
    • stupid.vb
    • useless.vb
    • wasteoftime.vb

  • List all the .txt files in temp.

  • List all the files that begin with ex.

  • Delete all the vb files!

  • Use find and less to see all the .txt files under your home directory.

• grep

  Grep is a pattern search that uses regular expressions to look for a pattern

  in text. It’s powerful if you know regular expressions:

  grep this words.txt looks for the word this inside a file named words.txt

  Exercise:

  • Create a file in temp called newfile.txt with the following text:

    This is a new file.
    This is a new file.
    This is a new file.
    

  • Create another file called oldfile.txt but with:

    This is an old file.
    This is an old file.
    This is an old file.
    

  • Search for all occurences of the word new in all the .txt files in temp.

  • Search for all occurences of old.

  • Search for all occurences of file.

  • How would you search for the words This is?

• env

  Prints out all the environments variables

  env

  Exercise:

  • Print all your environment variables.
  • Use | and grep to print only the variables that have your username in them.

• export

  Export a local varialble to become an environment variable

  export VAR

  Exercises:

  • Create an environment variable called TESTING and set it to "1 2 3".
  • echo your new varialble.

• ssh

  SecureShell is a program that connects you to remote computers and execute

  commands on them:

  ssh alice@foo.com

  
  
• scp

  Secure copy like FTP but uses SSH protocol to transmit data:

  scp words.txt alice@foo.com:Desktop/store

  
  
• sudo

  Super User DO is a command that escalates and runs the given command as root

  
  
• `` or ${}

  Backticks command; which executes the command inside it and returns the output:

  cat `ls *txt`

  
  
• ifconfig

  To check the network cards and the ip address

  
  
• alias

  To alias command and modify them

  alias l="ls -al"

  
  

Dot files/directories¶

Dot files and directories play a big role in the Unix/Linux operating system. Once a file or directory starts with a . it will be hidden from the regular ls command, and to display it you need to run ls with -a flag. The flag display the all the files in the current directory. There are many special dotfiles that you need to be aware of. The list below lists couple of them.

1. ~/.bashrc
2. ~/.vimrc
3. ~/.emacs
4. ~/.bash_history

Exercises¶

run ls -a ~ to display the files and try to get familiar with them

Exercises¶

1. Read the Aptitude man page
2. Install PIP, python3, nginx using Aptitude
3. Read the PIP help file pip help
4. Install django, selenium, uwsgi using PIP

More Information:¶

There are many more package managers than we mentioned in this section depending on what kind of web development you are doing. We would recomment looking at:

• npm (node.js)
• yum (Linux)
• rpm (Linux)
• homebrew (Mac OSX)
• macports (Mac OSX)

Exercises¶

1. Navigate to foo directory again

2. Launch one of the text editors and create hello.txt

3. Write the following in it:

   Lorem ipsum dolor sit amet, consectetur adipiscing elit.
   Cras fermentum dolor purus, quis lobortis arcu volutpat ac.
   Nullam consequat dapibus bibendum. Donec at libero at mi pulvinar sagittis.
   Mauris et risus molestie, porta justo vel, suscipit erat.
   Maecenas sed diam a nisi finibus ultrices eu et felis.
   Nulla ornare elementum mi, vel dignissim tellus bibendum sed.
   Vivamus diam nulla, hendrerit non dapibus at, pharetra non arcu.
   Mauris posuere erat nibh, volutpat venenatis mi ultricies quis.
   Duis hendrerit lacus lacus, eget viverra justo rhoncus ac.
   Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.
   Vestibulum id orci ut tortor fringilla imperdiet volutpat id orci.
   Sed bibendum mauris ac dolor efficitur, ut pharetra neque lobortis.
   Fusce malesuada ultricies feugiat. Interdum et malesuada fames ac ante ipsum primis in faucibus.
   Praesent facilisis ultricies accumsan.
   Quisque lectus neque, faucibus in egestas interdum, euismod at lacus.
   Sed imperdiet nisl justo, eget porta tortor molestie sed.
   Aenean consectetur varius ante, nec malesuada lorem pretium in.
   Donec feugiat sapien non justo scelerisque vestibulum sed vel libero.
   Suspendisse lobortis arcu nec ultrices vehicula.
   Phasellus gravida nulla sed nunc sollicitudin, a vehicula enim commodo.
   Sed eu convallis augue. Donec in eros malesuada, pretium sapien quis, eleifend est.
   Ut vel venenatis turpis.
   

4. Save and Exit from the text editor.

Vim Exercise¶

1. Launch your terminal and follow and the instructions.
2. Finish all the 7 chapters.

Step One: Setup Your Virtual Machine¶

At this point you should already have a virtual machine up and running but if you don’t, set one up using the image you created on the first day of this course.

Step Two: Install and Create Virtualenv¶

In Phase II we will go into more details about how to install, configure and use python virtual environments but for now just use the following commands.

Install virtualenv:

sudo apt-get install python-virtualenv

Create a virtualenv for our python packages:

virtualenv ~/myenv

Step Three: Install and Configure PostgreSQL¶

Most Django users prefer to use PostgreSQL as their database server. It is much more robust than MySQL and the Django ORM works much better with PostgreSQL than MySQL, MSSQL, or others.

sudo apt-get install libpq-dev python-dev

sudo apt-get install postgresql postgresql-contrib

sudo su - postgres

createdb mydb

createuser -P {{username}}

psql

GRANT ALL PRIVILEGES ON DATABASE mydb TO myuser;

Step Four: Install Django and Create a Project¶

source ~/myenv/bin/activate

pip install django

cd ~

djang-admin.py startproject myproject

pip install psycopg2

cd ~/myproject/myproject
vim settings.py

DATABASES = {
        'default': {
                    'ENGINE': 'django.db.backends.postgresql_psycopg2', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
                    'NAME': 'mydb',                      # Or path to database file if using sqlite3.
                    # The following settings are not used with sqlite3:
                    'USER': 'myuser',
                    'PASSWORD': 'password',
                    'HOST': 'localhost',                      # Empty for localhost through domain sockets or           '127.0.0.1' for localhost through TCP.
                    'PORT': '',                      # Set to empty string for default.
        }
}

cd ~/myproject/
python manage.py syncdb

Step Five: Install and Configure Gunicorn¶

Gunicorn is a very powerful Python WSGI HTTP server.

source ~/myenv/bin/activate
pip install gunicorn

gunicorn --bind localhost:8001 myproject.wsgi:application

Step Six: Install and Configure NGINX¶

NGINX is an incredibly fast and light-weight web server. We will use it to serve up our static files for our Django app.

sudo apt-get install nginx

STATIC_ROOT = '/home/{{ user }}/static/'

sudo vim /etc/nginx/sites-available/myproject

server {
        listen 80; # to listen on the default HTTP port but you need to be root ;)
        server_name {{your ip}};

        access_log off;

        location /static/ {
                alias /home/{{user}}/static/;
        }

        location / {
                proxy_pass http://127.0.0.1:8001;
                proxy_set_header Host $host;
        }
}

cd /etc/nginx/sites-enabled
sudo ln -s ../sites-available/myproject

sudo service nginx restart

What you need to know¶

The tutorial assumes some basic familiarity with the commandline prompt in a terminal.

You’ll need to know how to install software. Some of the examples given refer to Debian/Ubuntu’s apt-get; you ought to know what the equivalent is on whatever operating system you’re using.

You’ll also need to know how to edit plain text or source files of various kinds.

It will be very useful to have some understanding of Python, but it’s not strictly necessary. However, if you’ve never done any programming, that will probably be an obstacle.

Software¶

The tutorial assumes that you’re using a Unix-like system, but there should be no reason why (for example) it would not work for Windows users.

You’ll need a suitable text editor, that you’re comfortable using.

Other software will be used, but the tutorial will discuss its installation.

However, your environment does need to be set up appropriately, and you will need to know how to use it effectively.

If your system already has Django and/or Python packages running that you’ve installed, you probably already have what you need and know what you need to know. All the same:

sudo apt-get install git # for Debian/Ubuntu users

brew install git # for Mac OS X users with Homebrew installed

What is virtualenv?¶

Virtualenv lets you create and manage virtual Python environments.

If you’re running a Python project for deployment or development, the chances are that you’ll need more than one version of it, or the numerous other Python applications it depends upon, at any one time.

For example, when a new version of Django is released, you might want to check your project is still compatible. You don’t want to have to set up a whole new server with a different version of Django to find out.

With virtualenv, you can quickly set up a a brand new Python environment, and install your components into it - along with the new version of Django, without touching or affecting what you already have running.

You can have literally dozens of virtualenvs on the same machine, all running different versions of your Python software, all independently of each other, and can safely make changes to one without affecting anything else.

pip goes hand-in-hand with virtualenv; in fact, it comes with virtualenv (as well as separately). It’s an installer, and is the easiest way to install things into a virtualenv.

Install virtualenv¶

Try:

virtualenv --version

Do you have a version lower than 1.9? Upgrade it:

sudo pip install --upgrade virtualenv
hash -r # purge shell's PATH, though this may not be necessary for you

If you got a “Command not found” when you tried to use virtualenv, try:

sudo pip install virtualenv

or:

sudo apt-get install python-virtualenv # for a Debian-based system - but
it may not be up-to-date

If that fails or you’re using a different system, you might need more help:

Virtualenv installation documentation

Create and activate a virtual environment¶

virtualenv my-first-virtualenv
cd my-first-virtualenv
source bin/activate

Notice how your command prompt tells you that the virtualenv is active (and it remains active even while you’re not in its directory):

(my-first-virtualenv)~/my-first-virtualenv$

Using pip¶

(my-first-virtualenv)daniele@v029:~/my-first-virtualenv$ pip freeze
argparse==1.2.1
distribute==0.6.24
pyasn1==0.1.7
virtualenv==1.9.1
wsgiref==0.1.2

pip install rsa

(my-first-virtualenv)~/my-first-virtualenv$ python
Python 2.7.2+ (default, Jul 20 2012, 22:15:08)
[GCC 4.6.1] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import rsa

pip uninstall rsa

pip install rsa==3.0

pip install --upgrade rsa

~/my-first-virtualenv/lib/python2.7/site-packages/rsa

Managing virtualenvs¶

cd ~/ # let's not create it inside the other...
virtualenv my-second-virtualenv

cd my-second-virtualenv
source bin/activate

deactivate

virtualenv --system-site-packages my-third-virtualenv

cd ~/
rm -r  my-first-virtualenv my-second-virtualenv my-third-virtualenv

Get the code set up¶

$ virtualenv testingtutorial
New python executable in testingtutorial/bin/python
Installing setuptools............done.
Installing pip...............done.
$ cd testingtutorial/
$ source bin/activate

(testingtutorial)$ pip install django==1.5.1
Downloading/unpacking django
[...]

(testingtutorial)$ git clone git@github.com:<your git name>/django-tutorials-project.git
Cloning into 'django-tutorials-project'...
[...]

(testingtutorial)$ cd django-tutorials-project/
(testingtutorial)$ git checkout tutorial-four
Branch tutorial-four set up to track remote branch tutorial-four from origin.
Switched to a new branch 'tutorial-four'

python manage.py syncdb # set up the database

pip install django # install Django into your virtualenv

python manage.py runserver 0.0.0.0:8000 # start the runserver

Developing tests¶

git checkout -b test-for-published-recently

git checkout -b improve-list-view tutorial-four

git checkout -b improve-list-view

Following the tutorial¶

The Django testing tutorial covers a number of key ideas and approaches. It’s worth following the whole thing, and making sure you understand the points its making.

Set up your working environment¶

virtualenv documentation-tutorial
[...]
cd documentation-tutorial/
source bin/activate

git checkout -b first-docs

mkdir my-first-docs
cd my-first-docs/
# Converts the directory into a git repository
git init
# Point this repo at the GitHub repo you just created
git remote add origin git@github.com:<your git username>/my-first-docs.git
# Create a new branch in which to do your work
git checkout -b first-docs

mkdir docs

Sphinx¶

pip install sphinx

sphinx-quickstart

Using Sphinx & reStructuredText¶

############
All about me
############

I'm Daniele Procida, a Django user and developer.

I've contributed to:

*   django CMS
*   Arkestra
*   Django

.. toctree::
   :maxdepth: 2

   all-about-me

make html

WARNING: toctree contains reference to nonexisting document u'all-about-me'
...
checking consistency...
<your repository>/my-first-docs/docs/all-about-me.rst::
WARNING: document isn't included in any toctree

Publishing your documentation¶

_build
_static
_templates

git push origin master

git push origin first-docs # or whatever you called this branch

Talk to somebody about it¶

You may have been eating, sleeping, dreaming and otherwise living your idea for days, but until you discuss it, no-one else knows anything about it. To them, your patch will come flying out of the blue.

You need - usually - to introduce your idea, and - particularly if you’re new to the community - yourself.

In the case of Django, this will typically mean posting to the Django Developers email list, django-developers@googlegroups.com (sign up at http://groups.google.com/group/django-developers), or raising it on #django-dev on irc.freenode.net.

Quite apart from letting people know about what you have to offer, it’s an opportunity to get some feedback on your proposal.

Don’t automatically expect your proposal to be considered a great idea. Be prepared to explain the need it meets and why you think your solution is a good one. Be prepared to do some more work.

Above all, you will need to be patient, polite and persistent.

File it¶

If one doesn’t exist already, lay down a formal public marker raising the issue your contribution addresses. In Django’s case, this will be a ticket on https://code.djangoproject.com/. For others, it’s likely to be an issue on GitHub or whatever system they use. Mention your earlier discussion!

Do your homework¶

Every project has its standards for things like code and documentation, and its ways of working. They tend to follow a general pattern, but they often have their own little quirks or preferences - so learn them.

If you think that sounds tedious, it’s nothing compared to the potential pain of having to manage or use code and documentation written according to the individual preferences of all its different contributors.

• https://docs.djangoproject.com/en/1.7/internals/contributing/
• https://docs.djangoproject.com/en/1.7/internals/contributing/writing-code/working-with-git/

Note that the Django Project’s Git guidelines ask contributors to use rebase - which is firstly a little unusual, and secondly explained in the documentation above better than I can here - so read that.

And be prepared to get it wrong the first few times, and even the subsequent ones. It happens to everyone.

Submit it¶

Now you can make your pull request. Having prepared the way for it, and having provided the accompaniments - tests and documentation - that might be required, it has a good chance of enjoying a smooth passage into the project.

What to start with?¶

Documentation! It’s the easy way in.

Everyone loves documentation, and unlike code where incompleteness or vagueness can make it worse than useless, documentation has to be really quite bad to be worse than no documentation.

What’s more, writing documentation will help you better understand the things you’re writing about, and if you’re new to all this, that’s going to put you in a better position to understand and improve code.

virtualenv¶

create

virtualenv [name-of-virtualenv]

include system’s Python packages

virtualenv [name-of-virtualenv] --install-site-packages

activate

source bin/activate

deactivate

deactivate

pip¶

install

pip install [name-of-package]

install a particular version

pip install [name-of-package]==[version-number]

upgrade

pip install --upgrade [name-of-package]

uninstall

pip uninstall [name-of-package]

show what’s installed

pip freeze

git¶

tell git who you are

git config --global user.email "you@example.com"

git config --global user.name "Your Name"

clone a repository

git clone [repository URL]

checkout

git checkout [branch] switches to another branch

git checkout -b [new-branch] creates and switches to a new branch

git checkout -b [new-branch] [existing branch] creates and switches to a new branch based on an existing one

git checkout -b [new-branch] [remote/branch] creates and switches to a new branch based on remote/branch

git checkout [commit sha] checks out the state of the repository at a particular commit

current status of your local branches

git status

show the commit you’re on in the current working directory

git show

commit

git commit -m "[your commit message]"

add

git add [filename] adds a file to the staging areas

git add -u [filename] - the -u flag will also remove deleted files

remote

git remote add [name] [remote repository URL] sets up remote

git remote show lists remotes

git remote show -v lists remotes and their URLs

branch

git branch

git branch -a to show remote branches too

fetch

git fetch gets the latest information about the branches on the default remote

git fetch [remote] gets the latest information about the branches on the named remote

merge

git merge [branch] merges the named branch into the working directory

git merge [remote/branch] -m "[message]" merges the branch referred to into the working directory - don’t forget to fetch the remote before the merge

pull

fetch followed by merge is often safer than pull - don’t assume that pull will do what you expect it to

git pull fetches updates from the default remote and merges into the working directory

push

git push pushes committed changes to the default remote, in branches that exist at both ends

git push [remote] [branch] pushes the current branch to the named branch on remote

log

git log will show you a list of commits

Documentation¶

initialise Sphinx documentation

sphinx-quickstart

render documentation

make html

Workshops¶

I followed the tutorial online¶

• Daniel Quinn - 18th May 2013
• Paul C. Anagnostopoulos - 19 August 2013
• Ben Rowett - 27 August 2013
• Chris Miller, <chris@chrismiller.org> - 5th September 2013
• David Lewis - 7th September 2013
• Josh Chandler - 11th September 2013
• Richie Arnold - <richard@ambercouch.co.uk> - 22nd September 2013
• Padraic Stack - https://github.com/padraic7a
• Patrick Nsukami - <patrick@soon.pro> - lemeteore
• Can Ibanoglu - http://github.com/canibanoglu
• Pedro J. Lledó - http://github.com/pjlledo - 11th October 2013
• Ken Tam - 4th Jan 2014
• Óscar M. Lage - http://github.com/oscarmlage
• Bob Aalsma - https://github.com/BobAalsma/
• Andy Venet - https://github.com/avenet/
• Vathsala Achar - 22nd September, 2014
• Amine Zyad <amizya@gmail.com> http://github.com/amizya

Notes on running a workshop¶

To cover all the workshop material seems to take about four and a half hours.

Any of the following will make it take longer:

• attendees who aren’t already a little familiar with the terminal and using a text editor to edit source files
• attendees whose machines aren’t already suitably-configured for the workshop and need software installed
• attendees using operating systems you’re not familiar with

If you’re lucky, you’ll find that the majority of attendees have the same expertise and the same gaps in expertise. This makes it much easier to decide which parts to dwell upon and which ones you can skim over. If you’re not lucky, they will each have a completely different skillset.

You’ll do a lot of running around to look at people’s screens, so it helps to be able to get around the room easily.

The Git on the commandline section is the one where you will be in most demand - it helps great if at this stage you have one or two helpers who are familiar with Git.

Watch out for wireless network limitations - at one session the promised network turned out to block both github.com and ssh, and we had to rely on an access point created by someone’s mobile telephone.

Things that might look odd¶

If you’re experienced with things virtualenv and Git, some of the way things are done here might strike you as odd. For example:

Prerequisite¶

You need to install VirtualBox or any hypervisor you wish to use. The following instruction will focus on VirtualBox since it’s our presonal preference. After that Download and install Vagrant. After you done the previous two steps move to the next section.

Init¶

To initialize the vagrant you have to run the following command $vagrant init, and you should get the following out put.

A `Vagrantfile` has been placed in this directory. You are now
ready to `vagrant up` your first virtual environment! Please read
the comments in the Vagrantfile as well as documentation on
`vagrantup.com` for more information on using Vagrant.

Now, you should have a new file created in the same directory called Vagrantfile. This is a ruby file and it has the initial settup for the VM. Take a moment and open the file and be familair of the different configuration that you can do with your VM. If you open the file you should see the following.

# -*- mode: ruby -*-
# vi: set ft=ruby :

# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
VAGRANTFILE_API_VERSION = "2"

Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
  # All Vagrant configuration is done here. The most common configuration
  # options are documented and commented below. For a complete reference,
  # please see the online documentation at vagrantup.com.

  # Every Vagrant virtual environment requires a box to build off of.
  config.vm.box = "base"

  # Disable automatic box update checking. If you disable this, then
  # boxes will only be checked for updates when the user runs
  # `vagrant box outdated`. This is not recommended.
  # config.vm.box_check_update = false

  # Create a forwarded port mapping which allows access to a specific port
  # within the machine from a port on the host machine. In the example below,
  # accessing "localhost:8080" will access port 80 on the guest machine.
  # config.vm.network "forwarded_port", guest: 80, host: 8080

  # Create a private network, which allows host-only access to the machine
  # using a specific IP.
  # config.vm.network "private_network", ip: "192.168.33.10"

  # Create a public network, which generally matched to bridged network.
  # Bridged networks make the machine appear as another physical device on
  # your network.
  # config.vm.network "public_network"

  # If true, then any SSH connections made will enable agent forwarding.
  # Default value: false
  # config.ssh.forward_agent = true

  # Share an additional folder to the guest VM. The first argument is
  # the path on the host to the actual folder. The second argument is
  # the path on the guest to mount the folder. And the optional third
  # argument is a set of non-required options.
  # config.vm.synced_folder "../data", "/vagrant_data"

  # Provider-specific configuration so you can fine-tune various
  # backing providers for Vagrant. These expose provider-specific options.
  # Example for VirtualBox:
  #
  # config.vm.provider "virtualbox" do |vb|
  #   # Don't boot with headless mode
  #   vb.gui = true
  #
  #   # Use VBoxManage to customize the VM. For example to change memory:
  #   vb.customize ["modifyvm", :id, "--memory", "1024"]
  # end
  #
  # View the documentation for the provider you're using for more
  # information on available options.

  # Enable provisioning with CFEngine. CFEngine Community packages are
  # automatically installed. For example, configure the host as a
  # policy server and optionally a policy file to run:
  #
  # config.vm.provision "cfengine" do |cf|
  #   cf.am_policy_hub = true
  #   # cf.run_file = "motd.cf"
  # end
  #
  # You can also configure and bootstrap a client to an existing
  # policy server:
  #
  # config.vm.provision "cfengine" do |cf|
  #   cf.policy_server_address = "10.0.2.15"
  # end

  # Enable provisioning with Puppet stand alone.  Puppet manifests
  # are contained in a directory path relative to this Vagrantfile.
  # You will need to create the manifests directory and a manifest in
  # the file default.pp in the manifests_path directory.
  #
  # config.vm.provision "puppet" do |puppet|
  #   puppet.manifests_path = "manifests"
  #   puppet.manifest_file  = "site.pp"
  # end

  # Enable provisioning with chef solo, specifying a cookbooks path, roles
  # path, and data_bags path (all relative to this Vagrantfile), and adding
  # some recipes and/or roles.
  #
  # config.vm.provision "chef_solo" do |chef|
  #   chef.cookbooks_path = "../my-recipes/cookbooks"
  #   chef.roles_path = "../my-recipes/roles"
  #   chef.data_bags_path = "../my-recipes/data_bags"
  #   chef.add_recipe "mysql"
  #   chef.add_role "web"
  #
  #   # You may also specify custom JSON attributes:
  #   chef.json = { mysql_password: "foo" }
  # end

  # Enable provisioning with chef server, specifying the chef server URL,
  # and the path to the validation key (relative to this Vagrantfile).
  #
  # The Opscode Platform uses HTTPS. Substitute your organization for
  # ORGNAME in the URL and validation key.
  #
  # If you have your own Chef Server, use the appropriate URL, which may be
  # HTTP instead of HTTPS depending on your configuration. Also change the
  # validation key to validation.pem.
  #
  # config.vm.provision "chef_client" do |chef|
  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
  #   chef.validation_key_path = "ORGNAME-validator.pem"
  # end
  #
  # If you're using the Opscode platform, your validator client is
  # ORGNAME-validator, replacing ORGNAME with your organization name.
  #
  # If you have your own Chef Server, the default validation client name is
  # chef-validator, unless you changed the configuration.
  #
  #   chef.validation_client_name = "ORGNAME-validator"
end

After making your adjustments on the file move the next section.

Up¶

The VagrantFile has all the configuration for the VM, and once you fnish configuring run the following command $vagrant up. The command will aply the configuration to your VM and instantiate the machine. The output of the command should look like the following.

Bringing machine 'default' up with 'virtualbox' provider...
==> default: Importing base box 'base.box'...
==> default: Matching MAC address for NAT networking...
==> default: Setting the name of the VM: test_default_1416676086074_86409
==> default: Clearing any previously set forwarded ports...
==> default: Clearing any previously set network interfaces...
==> default: Preparing network interfaces based on configuration...
    default: Adapter 1: nat
==> default: Forwarding ports...
    default: 80 => 8080 (adapter 1)
    default: 22 => 2222 (adapter 1)
==> default: Booting VM...
==> default: Waiting for machine to boot. This may take a few minutes...
    default: SSH address: 127.0.0.1:2222
    default: SSH username: vagrant
    default: SSH auth method: private key
    default: Warning: Connection timeout. Retrying...
    default: Warning: Remote connection disconnect. Retrying...
==> default: Machine booted and ready!
==> default: Checking for guest additions in VM...
==> default: Mounting shared folders...
    default: /vagrant => /private/tmp/test

After completing the command, you should have a VM running in the background. The VM is running without GUI, and you should interact with it using vagrant commands. To check if there is a machine or not open up VirtualBox GUI and you should see a machine running.

SSH¶

$vagrant ssh is the command that you should use in order to log in to the machine and run your commands. After running the command, you will be logged in into the machine.

Provision¶

Provision is the way to set up your development environment. You can put your configuration inside VagrantFile and let Vagrant run and configure your machine the way you like. There are multiple options to accomplish that you could use Puppet, Chef, Ansible or Shell. In this section will talk about how you can provision using shell commands and then we will talk about Ansible provisioning later in this course. Follow the next instructions to provision using shell

1. Open VagrantFile
2. Append config.vm.provision "shell", path: "myscript.sh"
3. Create a file called myscript.sh
4. Copy the following into the file

#!/bin/sh
set -e

# installing Nginx
sudo apt-get install -y --force-yes nginx

# starting nginx
sudo service nginx start

Tutorial¶

We will be following the official vagrant tutorial.

Exercise¶

Let’s create a Vagrantfile to set up the box we will need for our toy project.

Integer Operations¶

>>> 3 + 7 # Addition
10
>>> 10 - 9 # Subtraction
1
>>> 9 - 100 # Handles negative numbers
-91
>>> 5 * 6 # Multiplications
30
>>> 15 / 5 # division
3
>>> 14 / 3 # integer division
4
>>> 14 // 3 # forcing integer division
4
>>> 5 ** 7 # Power operator
78125
>>> 10 % 4 # modules operations
2
>>> 1 << 4 # Left bitshift
16
>>> 16 >> 2 # Right bitshift
4
>>> 3 & 2 # Bit And operator
2
>>> 1 | 4 # Bit Or operator
5
>>> ~ 1 # 2's complement
-2
>>> 1 ^ 10 # XOr operator
11

Complex numbers¶

Python supports complex numbers by default. To use or create a complex number just append a j to a number.

>>> 4 + 6j
(4+6j)

Float point operations¶

Just like integers, Python supports float point operations

>>> 0.5 + 6.9
7.4
>>> 7 / 3.0
2.3333333333333335
>>> 7 / 2.0
3.5
>>> 4 * 8.4
33.6
>>> .5 - 8.4
-7.9

Boolean operations¶

>>> True
True
>>> False
False
>>> True or False
True
>>> True and True
True
>>> True and False
False
>>> False or False
False
>>> not False or False
True

Variables¶

To create a variable in Python, you have to use the assignment operator which is =. The has to start with latin alphabets or _

>>> x = 3
>>> _r = 100
>>> x
3
>>> _r
100
>>> y = x + _r
>>> y
103

Strings¶

Python would treat any thing inside ", ' or ''' as a valid string.

>>> "This is a string"
'This is a string'
>>> 'Single quotes can be used like "'
'Single quotes can be used like "'
>>> x = """
... This is a multiline string
... The idea behind it is that you don't
... have to escape charactors
... like ' or "
... or even a new line \n
... """
>>> x
'\nThis is a multiline string\nThe idea behind it is that you don\'t \nhave to escape charactors\nlike \' or "\nor even a new line \n\n'
>>> print x

This is a multiline string
The idea behind it is that you don't
have to escape charactors
like ' or "
or even a new line


>>>

Print¶

Python has a keyword to print to the screen just like printf or cout in different languages. Print is very easy to use and it appends \n at the end of the output unless you append , where that behavior will be over written.

>>> y = "This is a line"
>>> g = "This is another line"
>>> print y
This is a line
>>> print g
This is another line
>>> print y,g
This is a line This is another line
>>> print y,g,
This is a line This is another line

Functions¶

To define a function is Python, you have to use the keyword def and then the name of the function. The name of the function can be any valid identifier. After the name of the function you have to add () to denotes function can be called without arguments or (x,y,z) to denotes a function that takes three arguments. Then, to start implementing the body of the function you have to end the function declaration with :. The body of the function must be indented by four spaces.

>>> def main():
...    print "Hello world"
...
>>>
>>> main()
Hello world
>>> def another_main(x,y,z):
...    return (x/y)**z
...
>>>
>>>
>>> another_main(4,6,2)
0
>>> another_main(40,6,2)
36
>>> another_main(40,6.0,2)
44.44444444444445

Reservation Application¶